Prototyp (Entwurfsmuster)

Ein Prototyp (englisch prototype) ist ein Entwurfsmuster (engl. design pattern) aus dem Bereich der Softwareentwicklung und gehört zur Kategorie der Erzeugungsmuster (engl. creational patterns). Neue Instanzen werden auf Grundlage von prototypischen Instanzen („Vorlagen") erzeugt. Dabei wird die Vorlage kopiert und an neue Bedürfnisse angepasst.^[1] Das Muster ist eines der sogenannten GoF-Muster (Gang of Four, siehe Viererbande).

Ein Prototyp wird angewendet, wenn

• die Erzeugung weiterer Instanzen einer Klasse aufwendig (teuer) ist und sich die Objekte ähneln,
• die zu instanziierenden Klassen erst zur Laufzeit bekannt sind,
• eine Hierarchie von Fabriken parallel zu einer Hierarchie von Produkten vermieden werden soll, oder,
• die Objekte einer Klasse nur wenige Zustandskombinationen annehmen können; oder
• die Bearbeitung von Vorlagen sehr ähnlich oder gleich der von Objekten ist.

Das folgende Klassendiagramm zeigt die am Entwurfsmuster beteiligten Rollen. Ein Klient ruft die Methode klone() eines Objekts vom Typ Prototyp auf und bekommt entweder ein Objekt vom Typ KonkreterPrototyp1 oder vom Typ KonkreterPrototyp2 zurück, je nachdem, welcher der beiden Typen sich hinter der Schnittstelle Prototyp in dieser einfachen Assoziation (UML) verbirgt.

Der Typ Prototyp definiert eine Schnittstelle zur Kopie eines Objektes. Objekte vom Typ KonkreterPrototyp1 oder KonkreterPrototyp2 kopieren sich selbst durch Aufruf ihrer Implementierung der durch die Schnittstelle vorgeschriebenen klone()-Methode. Man unterscheidet zwischen flacher Kopie (shallow cloning) und tiefer Kopie (deep cloning). Erstere lässt Verweise auf andere Objekte bestehen, zweiteres kopiert zusätzlich die referenzierten Objekte. In der Regel wird eine tiefe Kopie eines Prototyps hergestellt (außer für nicht-modifizierbare Objekte), die genauen Details müssen aber von Fall zu Fall geklärt werden.

Der Klient erzeugt neue Objekte als Kopie bestehender Objekte und modifiziert sie.

Anmerkung: Die Verwendung einer clone()-Methode ist nicht gleichbedeutend mit der Anwendung eines Prototyp-Musters. Im Prototyp-Muster wird konzeptionell zwischen den Prototypen und den (Nutz-)Objekten unterschieden, es dient also nicht jedes Objekt (einer Klassenhierarchie) als Prototyp. Daher soll beim Kopieren des Prototyps zum Zwecke der Objekterzeugung auch zumindest das „Status=Prototyp"-Flag (o. ä.) verändert werden, und daher gilt nicht mehr, dass der Prototyp gleich dem erzeugten Objekt ist. Sinnvollerweise wird dafür eine eigene Instanzierungsmethode oder eine clone()-Methode mit Parameter verwendet.

Komplexe Objekte lassen sich schneller erzeugen. Neue Unterklassen können zur Laufzeit eingebunden werden. Neue Objekte können durch Variation der Struktur spezifiziert werden. Es gibt keine Erzeuger-Klassenhierarchie parallel zur Klassenhierarchie der Produkte.

Die Erstellung einer Kopie eines Objektes kann aufwendig sein. Jede Unterklasse muss die Kopie-Operation implementieren. Eventuelle Initialisierungen des kopierten Objekts müssen zusätzlich erfolgen.

In der Dokumentenverarbeitung (z. B. Microsoft Office, LibreOffice) ist das Prototyp-Muster Standard: Die Vorlagen werden mit denselben Tools wie die eigentlichen Dokumente bearbeitet; zum Erstellen eines Dokuments wird eine Vorlage kopiert und dann weiterbearbeitet. Oft gibt es eine Standard-Vorlage (z. B. „Normal.dot"), die als minimaler Prototyp für Objekte oder andere Vorlagen dienen kann.

Diese C++11 Implementierung basiert auf der vor C++98 Implementierung im Buch Entwurfsmuster.

#include<iostream>
enumRichtung{Norden,Sueden,Osten,Westen};
classKartenEintrag{
public:
virtualvoidbetrete()=0;
virtualKartenEintrag*klone()const=0;
virtual~KartenEintrag()=default;
};
classRaum:publicKartenEintrag{
public:
Raum():raumNr(0){}
Raum(intn):raumNr(n){}
voidsetSeite(Richtungd,KartenEintrag*ms){
std::cout<<"Raum::setSeite "<<d<<' '<<ms<<'\n';
}
virtualvoidbetrete(){}
virtualRaum*klone()const{
returnnewRaum(*this);
}
Raum&operator=(constRaum&)=delete;
private:
intraumNr;
};
classWand:publicKartenEintrag{
public:
Wand(){}
virtualvoidbetrete(){}
virtualWand*klone()const{
returnnewWand(*this);
}
};
classTuer:publicKartenEintrag{
public:
Tuer(Raum*r1=nullptr,Raum*r2=nullptr)
:raum1(r1),raum2(r2){}
Tuer(constTuer&andere)
:raum1(andere.raum1),raum2(andere.raum2){}
virtualvoidbetrete(){}
virtualTuer*klone()const{
returnnewTuer(*this);
}
virtualvoidinitialisiere(Raum*r1,Raum*r2){
raum1=r1;
raum2=r2;
}
Tuer&operator=(constTuer&)=delete;
private:
Raum*raum1;
Raum*raum2;
};
classLabyrinth{
public:
voidfuegeRaumHinzu(Raum*r){
std::cout<<"Labyrinth::fuegeRaumHinzu "<<r<<'\n';
}
Raum*raumNr(int)const{
returnnullptr;
}
virtualLabyrinth*klone()const{
returnnewLabyrinth(*this);
}
virtual~Labyrinth()=default;
};
classLabyrinthFabrik{
public:
LabyrinthFabrik()=default;
virtual~LabyrinthFabrik()=default;
virtualLabyrinth*erzeugeLabyrinth()const{
returnnewLabyrinth;
}
virtualWand*erzeugeWand()const{
returnnewWand;
}
virtualRaum*erzeugeRaum(intn)const{
returnnewRaum(n);
}
virtualTuer*erzeugeTuer(Raum*r1,Raum*r2)const{
returnnewTuer(r1,r2);
}
};
classLabyrinthPrototypFabrik:publicLabyrinthFabrik{
public:
LabyrinthPrototypFabrik(Labyrinth*m,Wand*w,Raum*r,Tuer*d)
:prototypLabyrinth(m),prototypRaum(r),
prototypWand(w),prototypTuer(d){}
virtualLabyrinth*erzeugeLabyrinth()const{
returnprototypLabyrinth->klone();
}
virtualRaum*erzeugeRaum(int)const{
returnprototypRaum->klone();
}
virtualWand*erzeugeWand()const{
returnprototypWand->klone();
}
virtualTuer*erzeugeTuer(Raum*r1,Raum*r2)const{
Tuer*door=prototypTuer->klone();
door->initialisiere(r1,r2);
returndoor;
}
LabyrinthPrototypFabrik(constLabyrinthPrototypFabrik&)=delete;
LabyrinthPrototypFabrik&operator=(constLabyrinthPrototypFabrik&)=delete;
private:
Labyrinth*prototypLabyrinth;
Raum*prototypRaum;
Wand*prototypWand;
Tuer*prototypTuer;
};
// Wenn baueLabyrinth mit verschiedenen prototypischen Raum-, Tür- und Wandobjekten parametrisiert wird, welche es kopieren und dem Labyrinth hinzufügen kann, dann können Sie den Aufbau des Labyrinths durch Ersetzen dieser prototypischen Objekte verändern. Dies ist ein Beispiel für das Prototypmuster (144).
classLabyrinthSpiel{
public:
Labyrinth*baueLabyrinth(LabyrinthPrototypFabrik&m){
Labyrinth*einLabyrinth=m.erzeugeLabyrinth();
Raum*r1=m.erzeugeRaum(1);
Raum*r2=m.erzeugeRaum(2);
Tuer*dieTuer=m.erzeugeTuer(r1,r2);
einLabyrinth->fuegeRaumHinzu(r1);
einLabyrinth->fuegeRaumHinzu(r2);
r1->setSeite(Norden,m.erzeugeWand());
r1->setSeite(Osten,dieTuer);
r1->setSeite(Sueden,m.erzeugeWand());
r1->setSeite(Westen,m.erzeugeWand());
r2->setSeite(Norden,m.erzeugeWand());
r2->setSeite(Osten,m.erzeugeWand());
r2->setSeite(Sueden,m.erzeugeWand());
r2->setSeite(Westen,dieTuer);
returneinLabyrinth;
}
};
intmain(){
LabyrinthSpielspiel;
LabyrinthPrototypFabrikeinfacheLabyrinthFabrik
(newLabyrinth,newWand,newRaum,newTuer);
spiel.baueLabyrinth(einfacheLabyrinthFabrik);
}

Die Programmausgabe ist ähnlich zu:

Labyrinth::fuegeRaumHinzu0x1353f50
Labyrinth::fuegeRaumHinzu0x1353f70
Raum::setSeite00x13543c0
Raum::setSeite20x1353f90
Raum::setSeite10x13543e0
Raum::setSeite30x1354400
Raum::setSeite00x1354420
Raum::setSeite20x1354440
Raum::setSeite10x1354460
Raum::setSeite30x1353f90

Im JDK wird das Prototyp-Muster nicht explizit verwendet; nur bei der Klasse javax.swing.text.EditorKit ist angeführt, dass neue Instanzen durch Klonen einer anderen Instanz erzeugt werden sollen. Viele Klassen im JDK implementieren allerdings eine öffentliche clone()-Methode, die prinzipiell als Grundlage eines Prototyp-Patterns verwendet werden kann.

Im .Net-Framework und in .NET bietet die Basisklasse System.Object die geschützte (protected) Methode MemberwiseClone(), die eine flache Kopie des Objekts erzeugt, d. h. wertbehaftete Typen (int, decimal etc.) werden byteweise 1 zu 1 kopiert, bei Referenzen wird nur der Referenzzeiger kopiert und nicht das Objekt selbst, auf das die neue Referenz zeigt. Um das Muster für einen Client nutzbar zu machen, muss der Prototyp noch die Schnittstelle ICloneable mit der Methode clone() implementieren (hier C#):

usingSystem;
usingSystem.Text;
namespacePrototype
{
abstractclassPrototype<T>whereT:Prototype<T>
{
publicTClone()
{
return(T)this.MemberwiseClone();
}
publicabstractvoidPrint();
publicabstractintX{get;set;}
}
classConcretePrototype:Prototype<ConcretePrototype>
{
publicConcretePrototype(intx){X=x;}
publicoverridevoidPrint()
{
Console.WriteLine(X);
}
publicoverrideintX{get;set;}
}
classClient
{
staticvoidMain(string[]args)
{
intnum=1000;
ConcretePrototypetempProt=null;
ConcretePrototypeprot=newConcretePrototype(num);
for(inti=0;i<10;i++)
{
tempProt=prot.Clone();
tempProt.X*=i;
tempProt.Print();
}
}
}
}

Einerseits konkurrieren abstrakte Fabrik und Prototyp miteinander, weil sie beide unterschiedliche Arten von Objekten erzeugen können. Andererseits lassen sie sich miteinander kombinieren, wenn eine abstrakte Fabrik Prototypen erzeugt, die dann anschließend ohne Zuhilfenahme einer Fabrik geklont werden können.

Kompositum und Decorator werden häufig gemeinsam mit Prototypen verwendet.

• .NET Design Patterns – Prototype

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

• Erzeugungsmuster
• Viererbande-Entwurfsmuster