Skip to content

Commit 0816c93

Browse files
siebersssieberss
authored
docs: Translate Prototype into German
#2295
1 parent 12fd4e0 commit 0816c93

1 file changed

Lines changed: 203 additions & 0 deletions

File tree

‎localization/de/prototype/README.md‎

Lines changed: 203 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,203 @@
1+
---
2+
shortTitle: Prototype
3+
category: Creational
4+
language: de
5+
tag:
6+
- Gang of Four
7+
- Instantiation
8+
- Object composition
9+
- Polymorphism
10+
---
11+
12+
## Alternativbezeichnung
13+
14+
* Klon
15+
16+
## Zweck
17+
18+
Das Prototyp-Pattern spezifiziert die Art von Objekten, die erzeugt werden sollen,
19+
durch eine prototypische Instanz. Neue Instanzen werden durch Klonen des Objekts erzeugt.
20+
21+
## Detaillierte Erklärung
22+
23+
Reales Beispiel
24+
25+
> Stellen Sie sich einen Hersteller von Designmöbeln vor. Wenn eine Bestellung eintrifft, wird
26+
> nicht von Grund auf ein ganz neues Design entwickelt. Stattdessen werden von den beliebtesten
27+
> Designs Prototypen vorgehalten. Bei einer Bestellung zu einem bestimmten Design wird der
28+
> zugehörige Prototyp kopiert, ggfs. mit speziellen Anpassungen gemäß Kundenwunsch.
29+
> Dieser Ansatz spart Zeit und Ressourcen, weil die Grundkonstruktion und die Designdetails
30+
> bereits vorhanden sind, sodass Bestellungen schnell und in gleichbleibender Qualität erledigt werden können.
31+
> quality.
32+
>
33+
> Wie bei den Möbelstücken dienen auch bei Java-Objekten die Prototypen als Vorlage, um effizient neue Objekte erzeugen zu können.
34+
35+
In einfachen Worten
36+
37+
> Erzeuge ein neues Objekt durch Klonen eines existierenden.
38+
39+
Wikipedia sagt:
40+
41+
> Prototype ist ein Erzeugungsmuster in der Softwareentwicklung.
42+
> Es wird verwendet, wenn der Typ eines zu erzeugenden Objekts durch eine prototypische Instanz vorgegeben ist,
43+
> die dann geklont wird.
44+
45+
Ablaufdiagramm
46+
47+
![Prototype sequence diagram](./etc/prototype-sequence-diagram.png)
48+
49+
## Programmbeispiel
50+
51+
Folgende Implementation in Java wird empfohlen.
52+
Zunächst schreibt man eine Schnittstelle mit einer Methode zum Klonen.
53+
In diesem Beispiel ist dies die abstrakte Klasse `Prototype` mit ihrer `copy`-Methode.
54+
55+
```java
56+
public abstract class Prototype<T> implements Cloneable {
57+
public T copy() {
58+
return (T) super.clone();
59+
}
60+
}
61+
```
62+
63+
Das Beispiel enthält eine Hierarchie verschiedener Kreaturen. Betrachten wir exemplarisch die Klassen
64+
`Beast` and `OrcBeast`.
65+
66+
```java
67+
public abstract class Beast extends Prototype<Beast> {
68+
public Beast(Beast source) {}
69+
}
70+
71+
public class OrcBeast extends Beast {
72+
73+
private final String weapon;
74+
75+
public OrcBeast(OrcBeast orcBeast) {
76+
super(orcBeast);
77+
this.weapon = orcBeast.weapon;
78+
}
79+
80+
@Override
81+
public String toString() {
82+
return "Orcish wolf attacks with " + weapon;
83+
}
84+
}
85+
```
86+
87+
In dieser Erklärung beschränken wir uns auf die Grundlagen. Der komplette Beispielcode
88+
enthält auch die
89+
Basisklassen `Mage` und `Warlord` und es gibt spezielle Implementationen für Elfen and Orks.
90+
91+
Um das Prototyp-Pattern voll auszunutzen, schreiben wir das Interface `HeroFactory` und die implementierende Klasse
92+
`HeroFactoryImpl` zur Erzeugung verschiedener Arten von Kreaturen.
93+
94+
```java
95+
public interface HeroFactory {
96+
Mage createMage();
97+
Warlord createWarlord();
98+
Beast createBeast();
99+
}
100+
```
101+
102+
```java
103+
public class HeroFactoryImpl implements HeroFactory {
104+
105+
private final Mage mage;
106+
private final Warlord warlord;
107+
private final Beast beast;
108+
109+
public Mage createMage() {
110+
return mage.copy();
111+
}
112+
113+
public Warlord createWarlord() {
114+
return warlord.copy();
115+
}
116+
117+
public Beast createBeast() {
118+
return beast.copy();
119+
}
120+
}
121+
```
122+
123+
Nun können wir sehen, wie mit dem Pattern neue Kreaturen durch das Klonen vorhandener Instanzen erschaffen werden.
124+
125+
```java
126+
public static void main(String[] args) {
127+
var factory = new HeroFactoryImpl(
128+
new ElfMage("cooking"),
129+
new ElfWarlord("cleaning"),
130+
new ElfBeast("protecting")
131+
);
132+
var mage = factory.createMage();
133+
var warlord = factory.createWarlord();
134+
var beast = factory.createBeast();
135+
LOGGER.info(mage.toString());
136+
LOGGER.info(warlord.toString());
137+
LOGGER.info(beast.toString());
138+
139+
factory = new HeroFactoryImpl(
140+
new OrcMage("axe"),
141+
new OrcWarlord("sword"),
142+
new OrcBeast("laser")
143+
);
144+
mage = factory.createMage();
145+
warlord = factory.createWarlord();
146+
beast = factory.createBeast();
147+
LOGGER.info(mage.toString());
148+
LOGGER.info(warlord.toString());
149+
LOGGER.info(beast.toString());
150+
}
151+
```
152+
153+
Hier die Konsolenausgabe
154+
155+
```
156+
08:36:19.012 [main] INFO com.iluwatar.prototype.App -- Elven mage helps in cooking
157+
08:36:19.013 [main] INFO com.iluwatar.prototype.App -- Elven warlord helps in cleaning
158+
08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Elven eagle helps in protecting
159+
08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Orcish mage attacks with axe
160+
08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Orcish warlord attacks with sword
161+
08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Orcish wolf attacks with laser
162+
```
163+
164+
## Verwendung
165+
* Wenn die zu instanziierenden Klassen erst zur Laufzeit festgelegt werden, etwa durch dynamisches Laden.
166+
* Zur vermeidung einer Klassenhierarchie von Fabriken parallel zur Klassenhierarchie von Produkten.
167+
* Wenn Instanzen einer Klasse nur wenige verschiedene Zustände haben, kann es bequemer sein, Prototypen
168+
zu klonen, als jedesmal die Klasse mit passendem Zustand zu instanziieren.
169+
* Wenn das Erzeugen von Objekten aufwendiger ist als Klonen.
170+
* Wenn erst zur Laufzeit bestimmt wird, welche konkreten Klassen instanziiert werden müssen.
171+
172+
## Echte Java-Anwendungen
173+
* Die `Object.clone()`-Methode is eine klassische Implementation des Prototyp-Patterns.
174+
* GUI Libraries verwenden oft Prototypes für Buttons, Fenster, und andere Widgets.
175+
* In der Spieleentwicklung können viele Objekte (wie Gegner-Charaktere) mit ähnlichen Attributen erzeugt werden.
176+
177+
## Vor- und Nachteile
178+
Vorteile:
179+
180+
* Verbirgt die Komplexitäten der Objektinstanziierung
181+
* Reduziert die Zahl der Klassen
182+
* Erlaubt das Hinzufügen und Entfernen von Objekten zur Laufzeit
183+
184+
Nachteile:
185+
186+
* Implementation eines möglicherweise komplexen Klon-Mechanismus erforderlich
187+
* Requires implementing a cloning mechanism which might be complex.
188+
* Deep Cloning kann Schwierigkeiten bei der korrekten Implementation bereiten,
189+
insbesondere bei komplexen Objektgraphen mit zirkulären Referenzen
190+
191+
## Verwandte Patterns
192+
193+
* [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/): Beide betreffen das Erzeugen von Objekten,
194+
* aber Abstract Factory verwendet dafür Factory-Methoden statt Klonen.
195+
* [Singleton](https://java-design-patterns.com/patterns/singleton/): Singleton kann Prototyp zur Objekterzeugung verwenden, wenn die einzige Instanz geklont werden darf.
196+
* [Composite](https://java-design-patterns.com/patterns/composite/): Prototypen werden oft innerhalb von Composites verwendet, um Komponentenbäume dynamisch kreieren zu können.
197+
198+
## Quellen
199+
200+
* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
201+
* [Effective Java](https://amzn.to/4cGk2Jz)
202+
* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
203+
* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)

0 commit comments

Comments
 (0)