Schablonenmethode

Die Schablonenmethode (engl. template method) ist ein in der Softwareentwicklung eingesetztes Entwurfsmuster, mit dem Teilschritte eines Algorithmus variabel gehalten werden können. Es gehört zur Kategorie der Verhaltensmuster (engl. behavioral patterns). Das Muster ist eines der sogenannten GoF-Muster (siehe Viererbande).

Dabei wird in einer abstrakten Klasse das Skelett eines Algorithmus definiert. Die konkrete Ausformung der einzelnen Schritte wird an Unterklassen delegiert. Dadurch besteht die Möglichkeit, einzelne Schritte des Algorithmus zu verändern oder zu überschreiben, ohne dass die zugrundeliegende Struktur des Algorithmus modifiziert werden muss. Die Schablonenmethode ruft abstrakte Methoden auf, die erst in den Unterklassen definiert werden. Diese Methoden werden auch als Einschubmethoden bezeichnet.

Zusätzlich können in der Schablonenmethode an bestimmten Stellen Hook-Operationen aufgerufen werden, deren Standardimplementierung in der abstrakten Klasse nichts tut. Auf diese Weise kann an vordefinierten Stellen im Algorithmus zusätzliche Funktionalität eingefügt werden.

Als Variante können die Einschubmethoden oder Hook-Operationen auch eine Standard-Implementierung besitzen, die von den konkreten Klassen genutzt werden können, aber nicht müssen.

Ein Beispiel dazu findet sich im Stream I/O API von Java. Dort implementiert ein OutputStream eine konkrete Methode zum Schreiben eines Byte-Arrays. Diese Methode benutzt eine Methode zum Schreiben eines einzelnen Bytes, um das ganze Array nach und nach zu schreiben. Die Methode für das einzelne Byte ist jedoch noch abstrakt, da ein OutputStream selbst noch nicht spezifisch ist. Klassen wie FileOutputStream können diese Methode implementieren. Sie erben dann eine bereits implementierte Methode zum Schreiben eines Byte-Arrays.

Policy-Based Design ist ein allgemeineres Design-Pattern, bei dem nicht nur Algorithmen sondern ganze Klassen schablonenhaft aufgebaut sind. Sowohl Methoden bzw. Algorithmen als auch gespeicherte Datensätze, Basisklassen und Schnittstellen sind dann innerhalb der Skelettstruktur austauschbar. Dies erfordert in aller Regel Templatemetaprogrammierung, wie es sie in C++ und D gibt, ist jedoch theoretisch auch über Konstrukte einiger Skriptsprachen (eval, Makros, Autoloading von Quellcode o.ä.), allerdings kaum in Sprachen wie Java oder C# realisierbar.

Klassendiagramm

Beispiel

Der grobe Ablauf eines Brettspiels wie Schach oder Monopoly sieht immer gleich aus: Es wird eine Begrüßung ausgesprochen und das Brett wird aufgestellt. Danach sind die Spieler reihum so lange am Zug, bis das Spiel beendet ist. Zum Schluss wird der Gewinner festgestellt.

Das Skelett dieses immer gleichen Algorithmus lässt sich in seinen Grobzügen in einer Schablonenmethode einer abstrakten Klasse Game implementieren. Um nun ein konkretes Spiel zu implementieren, müssen die abstrakten Methoden der Schablonenmethode (die sich für jedes Brettspiel unterscheiden) in einer konkreten Kindklasse implementiert werden.

#include <iostream>
#include <cstring>
 
using std::cout;
using std::endl;
 
class Game {
 
protected:
  int playersCount;
 
  Game(const int playersCount) {
    this->playersCount = playersCount;
  }
 
  virtual void printGreeting() {
    cout << "Welcome to our wonderful game!" << endl;
  }
 
  // Einschub-Methode:
  virtual void initializeBoard() = 0; 
  virtual void makeMove(const int player) = 0;
  virtual bool gameFinished() = 0;
  virtual void printWinner() = 0;
 
  // Hook-Methode:
  virtual void takeADrink(const int player) { }
 
public:
  // Schablonen-Methode
  void playOneGame() {
    printGreeting();
    initializeBoard();
    int j = 0;
    while (! gameFinished()) {
      takeADrink(j); // Aufruf des Hook (standardmäßig leer)
      makeMove(j);
      j = (j + 1) % playersCount;
    }
    printWinner();
  }
};
 
class Chess : public Game {
protected:
  void initializeBoard() {
    // ...
  }
  void makeMove(const int player) {
    cout << "Player " << player << "'s turn in chess game" << endl;
    // ...
  }
  bool gameFinished() {
    // ...
  }
  void printWinner() {
    // ...
  }
public:
  Chess() : Game (2) {
  }
};
 
class Monopoly : public Game {
protected:
  void printGreeting() {
    cout << "Welcome to Monopoly!" << endl;;
  }
  void initializeBoard() {
    // ...
  }
  void makeMove(const int player) {
    cout << "Player " << player << "'s turn in Monopoly game" << endl;
    // ...
  }
  bool gameFinished() {
    // ...
  }
  void printWinner() {
    // ...
  }
public:
  Monopoly(const int playersCount) : Game (playersCount) {
  }
};
 
class DrinkersMonopoly : public Monopoly {
protected:
  void printGreeting() {
    Monopoly::printGreeting();
    cout << "(The drinkers' version)" << endl;
  }
  void takeADrink(const int player) {
    cout << "Player " << player << " drinks a glass of whiskey" << endl;
  }
 
public:
  DrinkersMonopoly(const int playersCount) : Monopoly(playersCount) {
  }
};
 
int main(int argc, char* argv[]) {        
  Game *myGame; 
 
  if( argc <= 1  || strcmp( argv[1], "Chess") == 0 ) {
    myGame = new Chess();
  }
  else if( strcmp( argv[1], "Monopoly") == 0 ) {
    myGame = new Monopoly(4);
  }
  else if( strcmp( argv[1], "DrinkersMonopoly") == 0 ) {
    myGame = new DrinkersMonopoly(4);
  }
   else {
    cout << "Unknown game." << endl;
    return 1;
  }
 
  myGame->playOneGame();
 
  delete myGame;
}

Weblinks

• Die Schablonenmethode in PHP (deutsch)

Entwurfsmuster der Viererbande

Erzeugungsmuster:  Abstrakte Fabrik | Singleton | Builder | Fabrikmethode | Prototyp

Strukturmuster:  Adapter | Brücke | Decorator | Fassade | Flyweight | Kompositum | Stellvertreter

Verhaltensmuster:  Observer | Visitor | Interpreter | Iterator | Kommando | Memento | Schablonenmethode | Strategie | Vermittler | Zustand | Zuständigkeitskette

(Klassenmuster sind kursiv dargestellt)