Schablonenmethode

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Klassendiagramm einer Schablonenmethoden-Implementierung

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

Funktionsweise[Bearbeiten]

Beim Schablonenmethoden-Entwurfsmuster 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 zu Grunde liegende Struktur des Algorithmus modifiziert werden muss. Die Schablonenmethode (engl. template method) 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 man an vordefinierten Stellen im Algorithmus zusätzliche Funktionalität einfügen.

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 in der I/O-Datenstrom-Programmierschnittstelle 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[Bearbeiten]

Policy-Based Design ist ein allgemeineres Entwurfsmuster, 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 C# oder Java realisierbar.

Beispiel[Bearbeiten]

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 Grundzü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. Hier ein Beispiel in C++.

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

Einzelnachweise[Bearbeiten]

  1.  Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides: Entwurfsmuster. 5 Auflage. Addison-Wesley, 1996, ISBN 3-8273-1862-9, S. 366.

Weblinks[Bearbeiten]