diff --git a/localization/de/README.md b/localization/de/README.md
index b727e6ba47e1..4442d9682921 100644
--- a/localization/de/README.md
+++ b/localization/de/README.md
@@ -1,7 +1,7 @@
-# In Java implementierte Entwurfsmuster
+# Design Patterns (Entwurfsmuster) in Java
-[](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md)
+[](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md)
[](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)
[](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)
[](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
@@ -11,38 +11,43 @@
-In anderen Sprachen lesen: [**zh**](localization/zh/README.md), [**ko**](localization/ko/README.md), [**fr**](localization/fr/README.md), [**tr**](localization/tr/README.md), [**ar**](localization/ar/README.md), [**es**](localization/es/README.md), [**pt**](localization/pt/README.md), [**id**](localization/id/README.md), [**ru**](localization/ru/README.md), [**de**](localization/de/README.md), [**ja**](localization/ja/README.md)
-
+In anderen Sprachen lesen: [**zh**](localization/zh/README.md), [**ko**](localization/ko/README.md), [**fr**](localization/fr/README.md), [**tr**](localization/tr/README.md), [**ar**](localization/ar/README.md), [**es**](localization/es/README.md), [**pt**](localization/pt/README.md), [**id**](localization/id/README.md), [**ru**](localization/ru/README.md), [**de**](localization/de/README.md), [**ja**](localization/ja/README.md), [**vi**](localization/vi/README.md), [**bn**](localization/bn/README.md), [**np**](localization/ne/README.md), [**it**](localization/it/README.md), [**da**](localization/da/README.md)
# Einführung
-Entwurfsmuster sind bewährte Lösungen, die Entwickler nutzen können, um häufige Probleme beim Entwurf von Anwendungen oder Systemen zu lösen.
+Design Patterns (auch Entwurfsmuster genannt) sind allgemein anerkannte Vorgehensweisen für den Entwurf von Anwendungen und Systemen, mit denen sich regelmäßig auftauchende Probleme lösen lassen.
-Sie helfen dabei, den Entwicklungsprozess zu beschleunigen, indem sie erprobte und zuverlässige Ansätze bereitstellen.
+Mit ihnen lässt sich der Entwicklungsprozess beschleunigen, indem erprobte und bewährte Vorlagen zur Verfügung gestellt werden.
-Die Wiederverwendung von Entwurfsmustern verhindert subtile Fehler, die zu größeren Problemen führen können, und verbessert die Lesbarkeit des Codes – besonders für Entwickler und Architekten, die mit diesen Mustern vertraut sind.
+Die Nutzung von Entwurfsmustern beugt versteckten Fehlern vor, die zu größeren Problemen führen können. Auch verbessert sich die Lesbarkeit des Codes, besonders für Entwickler und Architekten, die mit diesen Mustern vertraut sind.
# Erste Schritte
-Diese Seite stellt Java-Entwurfsmuster vor. Die Lösungen wurden von erfahrenen Entwicklern und Architekten aus der Open-Source-Community erstellt. Die Muster können entweder durch ihre Beschreibungen oder durch den Quellcode erkundet werden. Die Codebeispiele sind gut kommentiert und eignen sich als Tutorials, um die Muster zu verstehen und umzusetzen. Wir verwenden dabei bekannte und bewährte Open-Source-Java-Technologien.
+Diese Seite präsentiert Entwurfsmuster für Java. Die Lösungen wurden von erfahrenen Programmierern und Architekten aus der Open-Source-Community entwickelt. Die Muster können entweder anhand ihrer Beschreibungen oder durch den Quellcode erkundet werden. Die Codebeispiele sind gut kommentiert und eignen sich als Tutorials, wie das jeweilige Muster zu implementieren ist. Wir verwenden dabei bekannte und bewährte Open-Source-Java-Technologien.
-Bevor Sie sich mit den Entwurfsmustern beschäftigen, sollten Sie sich mit den grundlegenden [Software-Entwurfsprinzipien](https://java-design-patterns.com/principles/) vertraut machen.
+Ehe Sie tiefer in den Stoff eindringen, sollten Sie sich mit den grundlegenden [Software-Entwurfsprinzipien](https://java-design-patterns.com/principles/) vertraut machen.
-Entwürfe sollten immer so einfach wie möglich gehalten werden. Beginnen Sie mit den Prinzipien KISS (Keep It Simple, Stupid), YAGNI (You Aren’t Gonna Need It) und "Do The Simplest Thing That Could Possibly Work". Komplexe Muster sollten nur dann verwendet werden, wenn sie wirklich notwendig sind.
+Entwürfe sollten immer so einfach wie möglich gehalten werden. Beginnen Sie mit den Prinzipien KISS (Keep It Simple, Stupid), YAGNI (You Aren’t Gonna Need It) und "Do The Simplest Thing That Could Possibly Work". Komplexere Strukturen und Muster sollten erst dann verwendet werden, wenn sie wirklich notwendig sind.
Sobald Sie mit diesen Konzepten vertraut sind, können Sie sich die [verfügbaren Entwurfsmuster](https://java-design-patterns.com/patterns/) ansehen. Dafür gibt es verschiedene Ansätze:
- Suchen Sie nach einem bestimmten Muster anhand des Namens. Fehlt ein Muster? Melden Sie es gerne [hier](https://github.com/iluwatar/java-design-patterns/issues).
- Nutzen Sie Tags wie `Performance`, `Gang of Four` oder `Data access`.
-- Durchsuchen Sie die Muster nach Kategorien wie `Creational`, `Behavioral` und anderen.
+- Verwenden Sie Kategorien von Patterns wie `Creational`, `Behavioral` usw.
Wir hoffen, dass Sie die hier vorgestellten Lösungen für Ihre Projekte nützlich finden und genauso viel Spaß beim Lernen haben, wie wir bei der Entwicklung hatten.
-# Mitwirken
+# Mitarbeit
+
+Wenn Sie zum Projekt beitragen möchten, finden Sie alle notwendigen Informationen in unserem [Entwickler-Wiki](https://github.com/iluwatar/java-design-patterns/wiki). Bei Fragen helfen wir Ihnen gerne im [Gitter-Chat](https://gitter.im/iluwatar/java-design-patterns) weiter.
+
+# Das Buch
+
+Die Design Patterns sind jetzt als eBook verfügbar. Hier ist es erhältlich: https://payhip.com/b/bNQFX
-Wenn Sie zum Projekt beitragen möchten, finden Sie alle notwendigen Informationen in unserem [Entwickler-Wiki](https://github.com/iluwatar/java-design-patterns/wiki). Bei Fragen helfen wir Ihnen gerne im [Gitter-Chatraum](https://gitter.im/iluwatar/java-design-patterns) weiter.
+Mitwirkende am Projekt können das Buch kostenlos erhalten. Kontaktieren Sie mich via [Gitter-Chat](https://gitter.im/iluwatar/java-design-patterns) or E-Mail (iluwatar (at) gmail (dot) com ). Die Nachricht sollte enthalten: Ihre Mailadresse, den Usernamen bei Github, and einen Link zu einem akzeptierten Pull Request.
# Lizenz
-Dieses Projekt steht unter der MIT-Lizenz.
\ No newline at end of file
+Dieses Projekt unterliegt den Regelungen der MIT-Lizenz.
diff --git a/localization/de/abstract-document/README.md b/localization/de/abstract-document/README.md
index 13f8d26fbbbf..1210c45e1330 100644
--- a/localization/de/abstract-document/README.md
+++ b/localization/de/abstract-document/README.md
@@ -1,43 +1,48 @@
---
-title: "Abstract Document Pattern in Java: Vereinfachung der Datenverwaltung mit Flexibilität"
shortTitle: Abstract Document
-description: "Erkunden Sie das Abstract Document Design Pattern in Java. Lernen Sie seine Absicht, Erklärung, Anwendbarkeit, Vorteile kennen und sehen Sie reale Beispiele zur Implementierung flexibler und dynamischer Datenstrukturen."
-category: Strukturell
+category: Structural
language: de
tag:
- - Abstraktion
- - Entkopplung
- - Dynamische Typisierung
- - Kapselung
- - Erweiterbarkeit
- - Polymorphismus
+ - Abstraction
+ - Decoupling
+ - Dynamic typing
+ - Encapsulation
+ - Extensibility
+ - Polymorphism
---
-## Absicht des Abstract Document Design Patterns
+## Zweck
-Das Abstract Document Design Pattern in Java ist ein wichtiges strukturelles Design Pattern, das eine konsistente Möglichkeit bietet, hierarchische und baumartige Datenstrukturen zu handhaben, indem es eine gemeinsame Schnittstelle für verschiedene Dokumenttypen definiert. Es trennt die Kernstruktur des Dokuments von spezifischen Datenformaten und ermöglicht dynamische Aktualisierungen und vereinfachte Wartung.
+Abstract Document ist ein wichtiges Struktur-Pattern, das ein einheitliches Handling von hierarchischen baumartige Datenstrukturen ermöglicht, indem es eine gemeinsame Schnittstelle für verschiedene Dokumenttypen definiert. Es trennt die Kernstruktur des Dokuments von spezifischen Datenformaten und ermöglicht so dynamische Aktualisierungen und einfachere Wartung.
-## Detaillierte Erklärung des Abstract Document Patterns mit realen Beispielen
+## Detaillierte Erklärung
-Das Abstract Document Design Pattern in Java ermöglicht die dynamische Handhabung nicht-statischer Eigenschaften. Dieses Pattern verwendet das Konzept der Traits, um Typsicherheit zu gewährleisten und Eigenschaften verschiedener Klassen in eine Menge von Schnittstellen zu trennen.
+Abstract Document erlaubt die dynamische Behandlung nicht-statischer Eigenschaften. Dieses Pattern verwendet das Konzept der Traits, um Typsicherheit zu gewährleisten und Eigenschaften verschiedener Klassen in verschiedene Schnittstellen abzuspalten.
Reales Beispiel
-> Betrachten Sie ein Bibliothekssystem, das das Abstract Document Design Pattern in Java implementiert, wo Bücher verschiedene Formate und Attribute haben können: physische Bücher, eBooks und Hörbücher. Jedes Format hat einzigartige Eigenschaften, wie Seitenzahl für physische Bücher, Dateigröße für eBooks und Dauer für Hörbücher. Das Abstract Document Design Pattern ermöglicht es dem Bibliothekssystem, diese verschiedenen Formate flexibel zu verwalten. Durch die Verwendung dieses Patterns kann das System Eigenschaften dynamisch speichern und abrufen, ohne dass eine starre Struktur für jeden Buchtyp erforderlich ist, was es einfacher macht, neue Formate oder Attribute in der Zukunft hinzuzufügen, ohne dass wesentliche Änderungen am Codebase erforderlich sind.
+> Denken Sie an ein Bibliothekssystem, wo Bücher verschiedene Formate und Attribute haben können: physische Bücher, eBooks und Hörbücher. Jedes Format hat spezielle Eigenschaften, wie die Seitenzahl bei physischen Büchern, die Dateigröße bei eBooks oder die Spielzeit bei Hörbüchern. Das Abstract Document Design Pattern ermöglicht es dem Bibliothekssystem, diese verschiedenen Formate flexibel zu verwalten. Durch die Verwendung dieses Patterns kann das System Eigenschaften dynamisch speichern und abrufen, ohne dass eine starre Struktur für jeden Buchtyp erforderlich ist. Damit wird es einfacher, in der Zukunft neue Formate oder Attribute hinzuzufügen, ohne erhebliche Änderungen am Code vornehmen zu müssen.
In einfachen Worten
-> Das Abstract Document Pattern ermöglicht das Anhängen von Eigenschaften an Objekte, ohne dass diese davon wissen.
+> Abstract Document erlaubt das Anhängen von Eigenschaften an Objekte, ohne dass diese davon wissen.
Wikipedia sagt
-> Ein objektorientiertes strukturelles Design Pattern zur Organisation von Objekten in schwach typisierten Schlüssel-Wert-Speichern und zur Bereitstellung der Daten über typisierte Ansichten. Der Zweck des Patterns besteht darin, einen hohen Grad an Flexibilität zwischen Komponenten in einer stark typisierten Sprache zu erreichen, in der neue Eigenschaften zur Objektstruktur dynamisch hinzugefügt werden können, ohne die Unterstützung der Typsicherheit zu verlieren. Das Pattern verwendet Traits, um verschiedene Eigenschaften einer Klasse in verschiedene Schnittstellen zu trennen.
+> Ein objektorientiertes strukturelles Design Pattern zur Organisation von Objekten in schwach typisierten Schlüssel-Wert-Speichern mit Darstellung der Daten über typisierte Ansichten. Der Zweck des Patterns besteht darin, einen hohen Grad an Flexibilität zwischen Komponenten in einer stark typisierten Sprache zu erreichen, in der neue Eigenschaften zur Objektstruktur dynamisch hinzugefügt werden können, ohne die Unterstützung der Typsicherheit zu verlieren. Das Pattern verwendet Traits, um verschiedene Klasseneigenschaften in verschiedene Schnittstellen abzutrennen.
-## Programmatisches Beispiel des Abstract Document Patterns in Java
+## Klassendiagramm
-Betrachten Sie ein Auto, das aus mehreren Teilen besteht. Wir wissen jedoch nicht, ob das spezifische Auto wirklich alle Teile hat oder nur einige davon. Unsere Autos sind dynamisch und extrem flexibel.
+
+
+## Beispielprogramm in Java
-Lassen Sie uns zunächst die Basisklassen `Document` und `AbstractDocument` definieren. Sie sorgen im Wesentlichen dafür, dass das Objekt eine Eigenschaftsmap und eine beliebige Anzahl von Kindobjekten enthält.
+Betrachten Sie ein Auto, das aus mehreren Teilen besteht. Wir wissen jedoch nicht,
+ob das spezifische Auto wirklich alle Teile hat oder nur einige davon.
+Unsere Autos sind dynamisch und extrem flexibel.
+
+Zunächst definieren wir die Basisklassen `Document` und `AbstractDocument`.
+Sie sorgen im Wesentlichen dafür, dass jedes Objekt eine Map von Eigenschaften und eine beliebige Anzahl von Kindobjekten enthält.
```java
public interface Document {
@@ -80,10 +85,11 @@ public abstract class AbstractDocument implements Document {
.map(constructor);
}
- // Andere Eigenschaften und Methoden...
+ // Weitere Eigenschaften und Methoden...
}
```
-Als nächstes definieren wir ein Enum Property und eine Menge von Schnittstellen für Typ, Preis, Modell und Teile. Dies ermöglicht es uns, eine statisch aussehende Schnittstelle für unsere Car-Klasse zu erstellen.
+
+Als nächstes definieren wir ein Enum `Property` und je eine Schnittstelle für Typ, Preis, Modell und Teile. So können wir eine statisch aussehende Schnittstelle für unsere Klasse `Car` erstellen.
```java
public enum Property {
@@ -120,33 +126,43 @@ public interface HasParts extends Document {
}
```
-Jetzt sind wir bereit, das `Car` einzuführen.
+Nun können wir das `Car` einführen.
```java
- public static void main(String[] args) {
- LOGGER.info("Konstruktion von Teilen und Auto");
-
- var wheelProperties = Map.of(
- Property.TYPE.toString(), "wheel",
- Property.MODEL.toString(), "15C",
- Property.PRICE.toString(), 100L);
-
- var doorProperties = Map.of(
- Property.TYPE.toString(), "door",
- Property.MODEL.toString(), "Lambo",
- Property.PRICE.toString(), 300L);
-
- var carProperties = Map.of(
- Property.MODEL.toString(), "300SL",
- Property.PRICE.toString(), 10000L,
- Property.PARTS.toString(), List.of(wheelProperties, doorProperties));
-
- var car = new Car(carProperties);
-
- LOGGER.info("Hier ist unser Auto:");
- LOGGER.info("-> Modell: {}", car.getModel().orElseThrow());
- LOGGER.info("-> Preis: {}", car.getPrice().orElseThrow());
- LOGGER.info("-> Teile: ");
+public class Car extends AbstractDocument implements HasModel, HasPrice, HasParts {
+
+ public Car(Map properties) {
+ super(properties);
+ }
+}
+```
+Und schließlich konstruieren und verwenden wir ein solches `Car`.
+
+```java
+public static void main(String[] args) {
+ LOGGER.info("Constructing parts and car");
+
+var wheelProperties = Map.of(
+ Property.TYPE.toString(), "wheel",
+ Property.MODEL.toString(), "15C",
+ Property.PRICE.toString(), 100L);
+
+var doorProperties = Map.of(
+ Property.TYPE.toString(), "door",
+ Property.MODEL.toString(), "Lambo",
+ Property.PRICE.toString(), 300L);
+
+var carProperties = Map.of(
+ Property.MODEL.toString(), "300SL",
+ Property.PRICE.toString(), 10000L,
+ Property.PARTS.toString(), List.of(wheelProperties, doorProperties));
+
+var car = new Car(carProperties);
+
+ LOGGER.info("Here is our car:");
+ LOGGER.info("-> model: {}", car.getModel().orElseThrow());
+ LOGGER.info("-> price: {}", car.getPrice().orElseThrow());
+ LOGGER.info("-> parts: ");
car.getParts().forEach(p -> LOGGER.info("\t{}/{}/{}",
p.getType().orElse(null),
p.getModel().orElse(null),
@@ -154,50 +170,67 @@ Jetzt sind wir bereit, das `Car` einzuführen.
);
}
```
-Die Programmausgabe:
+Programmausgabe:
```
-07:21:57.391 [main] INFO com.iluwatar.abstractdocument.App -- Konstruktion von Teilen und Auto
-07:21:57.393 [main] INFO com.iluwatar.abstractdocument.App -- Hier ist unser Auto:
-07:21:57.393 [main] INFO com.iluwatar.abstractdocument.App -- -> Modell: 300SL
-07:21:57.394 [main] INFO com.iluwatar.abstractdocument.App -- -> Preis: 10000
-07:21:57.394 [main] INFO com.iluwatar.abstractdocument.App -- -> Teile:
-07:21:57.395 [main] INFO com.iluwatar.abstractdocument.App -- Rad/15C/100
-07:21:57.395 [main] INFO com.iluwatar.abstractdocument.App -- Tür/Lambo/300
+07:21:57.391 [main] INFO com.iluwatar.abstractdocument.App -- Constructing parts and car
+07:21:57.393 [main] INFO com.iluwatar.abstractdocument.App -- Here is our car:
+07:21:57.393 [main] INFO com.iluwatar.abstractdocument.App -- -> model: 300SL
+07:21:57.394 [main] INFO com.iluwatar.abstractdocument.App -- -> price: 10000
+07:21:57.394 [main] INFO com.iluwatar.abstractdocument.App -- -> parts:
+07:21:57.395 [main] INFO com.iluwatar.abstractdocument.App -- wheel/15C/100
+07:21:57.395 [main] INFO com.iluwatar.abstractdocument.App -- door/Lambo/300
```
-## Abstract Document Pattern Klassendiagramm
-
-
-## Wann sollte das Abstract Document Pattern in Java verwendet werden?
+## Verwendung
-Das Abstract Document Design Pattern ist besonders vorteilhaft in Szenarien, die eine Verwaltung unterschiedlicher Dokumenttypen in Java erfordern, die einige gemeinsame Attribute oder Verhaltensweisen teilen, aber auch einzigartige Attribute oder Verhaltensweisen haben, die spezifisch für ihren Typ sind. Hier sind einige Szenarien, in denen das Abstract Document Design Pattern anwendbar ist:
+Abstract Document ist besonders vorteilhaft in Szenarien, die eine Verwaltung unterschiedlicher
+Dokumenttypen erfordern, die zwar einige gemeinsame Attribute oder Verhaltensweisen teilen,
+aber auch typspezifische Eigenschaften haben. Hier sind einige Beispiele:
* **Content-Management-Systeme (CMS)**: In einem CMS könnten verschiedene Arten von Inhalten wie Artikel, Bilder, Videos usw. vorkommen. Jede Inhaltsart könnte gemeinsame Attribute wie Erstellungsdatum, Autor und Tags haben, aber auch spezifische Attribute wie Bildabmessungen für Bilder oder Videodauer für Videos.
-* **Dateisysteme**: Wenn Sie ein Dateisystem entwerfen, in dem unterschiedliche Dateitypen verwaltet werden müssen, wie Dokumente, Bilder, Audiodateien und Verzeichnisse, kann das Abstract Document Pattern helfen, eine konsistente Möglichkeit zum Zugriff auf Attribute wie Dateigröße, Erstellungsdatum usw. zu bieten, während spezifische Attribute wie Bildauflösung oder Audiodauer berücksichtigt werden.
+* **Dateisysteme**: Wenn Sie ein Dateisystem entwerfen, in dem unterschiedliche Dateitypen verwaltet werden müssen, wie Dokumente, Bilder, Audiodateien und Verzeichnisse, kann das Pattern helfen, einen einheitlichen Zugriff auf Attribute wie Dateigröße, Erstellungsdatum usw. zu bieten, aber zugleich spezifische Attribute wie Bildauflösung oder Audiodauer zu berücksichtigen.
-* **E-Commerce-Systeme**: Eine E-Commerce-Plattform könnte verschiedene Produkttypen haben, wie physische Produkte, digitale Downloads und Abonnements. Jeder Typ könnte gemeinsame Attribute wie Name, Preis und Beschreibung haben, aber auch einzigartige Attribute wie Versandgewicht für physische Produkte oder Download-Link für digitale Produkte.
+* **E-Commerce-Systeme**: Eine E-Commerce-Plattform kann verschiedene Produkttypen haben,
+wie physische Produkte, digitale Downloads und Abonnements.
+Alle Typen haben gemeinsame Attribute wie Name, Preis und Beschreibung,
+aber auch einzigartige Attribute wie Versandgewicht für physische Produkte
+oder Download-Link für digitale Produkte.
-* **Medizinische Aufzeichnungssysteme**: Im Gesundheitswesen könnten Patientenakten verschiedene Datentypen enthalten, wie demografische Daten, medizinische Vorgeschichte, Testergebnisse und Rezepte. Das Abstract Document Pattern kann helfen, gemeinsame Attribute wie Patienten-ID und Geburtsdatum zu verwalten, während spezialisierte Attribute wie Testergebnisse oder verschriebene Medikamente berücksichtigt werden.
+* **Medizindatensysteme**: Im Gesundheitswesen enthalten Patientenakten verschiedene
+Datentypen wie demografische Daten, medizinische Vorgeschichte, Testergebnisse und Rezepte.
+Das Abstract Document Pattern kann helfen, gemeinsame Attribute wie Patienten-ID und Geburtsdatum zu
+verwalten und zusätzlich spezielle Attribute wie Testergebnisse oder verschriebene Medikamente zu berücksichtigt werden.
-* **Konfigurationsmanagement**: Bei der Verwaltung von Konfigurationseinstellungen für Softwareanwendungen gibt es möglicherweise verschiedene Arten von Konfigurationselementen, jedes mit einer eigenen Reihe von Attributen. Das Abstract Document Pattern kann verwendet werden, um diese Konfigurationselemente zu verwalten, während eine konsistente Möglichkeit zum Zugriff auf und Bearbeiten der Attribute sichergestellt wird.
+* **Konfigurationsmanagement**: Bei der Verwaltung von Konfigurationseinstellungen für
+Software gibt es verschiedene Arten von Konfigurationselementen, jedes mit einer eigenen Reihe
+von Attributen. Mit dem Abstract Document Pattern können diese Konfigurationselemente
+konsistent verwaltet werden.
-* **Bildungsplattformen**: Bildungssysteme könnten verschiedene Arten von Lernmaterialien wie textbasierte Inhalte, Videos, Quizze und Aufgaben haben. Gemeinsame Attribute wie Titel, Autor und Veröffentlichungsdatum können geteilt werden, während spezifische Attribute wie Videodauer oder Aufgabenfälligkeit für jeden Typ einzigartig sind.
+* **Bildungsplattformen**: Bildungssysteme nutzen verschiedene Arten von Lernmaterialien wie textbasierte Inhalte,
+Videos, Quiz und Übungsaufgaben. Gemeinsame Attribute können Titel, Autor und Veröffentlichungsdatum sein,
+während spezifische Attribute wie Videodauer oder Aufgabenfälligkeit typabhängig sind.
-* **Projektmanagement-Tools**: In Projektmanagement-Anwendungen könnten unterschiedliche Aufgabenarten wie To-Do-Items, Meilensteine und Probleme vorliegen. Das Abstract Document Pattern könnte verwendet werden, um allgemeine Attribute wie Aufgabenname und Zuweisung zu handhaben, während spezifische Attribute wie Meilensteindaten oder Problemprioritäten zugelassen werden.
+* **Projektmanagement-Tools**: In Projektmanagement-Anwendungen können unterschiedliche Aufgabenarten
+wie To-Dos, Meilensteine und Probleme vorliegen. Das Abstract Document Pattern kann verwendet werden, um allgemeine
+Attribute wie Aufgabenname und Zuständigkeit zu handhaben, während spezifische Attribute wie Meilensteindaten oder
+Aufgabenprioritäten zugelassen sind.
-* **Dokumente haben vielfältige und sich entwickelnde Attributstrukturen.**
+* **Dokumente haben vielfältige und sich verändernde Attributstrukturen.**
-* **Dynamisches Hinzufügen neuer Eigenschaften ist eine häufige Anforderung.**
+* **Häufig ist es erforderlich, neue Eigenschaften dynamisch hinzuzufügen.**
-* **Entkopplung des Datenzugriffs von spezifischen Formaten ist entscheidend.**
+* **Entscheidend ist die Entkopplung des Datenzugriffs von spezifischen Formaten.**
-* **Wartbarkeit und Flexibilität sind entscheidend für die Codebasis.**
+* **Wartbarkeit und Flexibilität sind wesentlich für die Codebasis.**
-Die Hauptidee hinter dem Abstract Document Design Pattern ist es, eine flexible und erweiterbare Möglichkeit zur Verwaltung unterschiedlicher Dokumenttypen oder Entitäten mit gemeinsamen und spezifischen Attributen bereitzustellen. Durch die Definition einer gemeinsamen Schnittstelle und deren Implementierung über verschiedene Dokumenttypen hinweg können Sie einen besser organisierten und konsistenteren Ansatz zur Handhabung komplexer Datenstrukturen erreichen.
+Die Kernidee des Abstract Document Pattern ist es, eine flexible und erweiterbare Möglichkeit zur Verwaltung
+unterschiedlicher Dokumenttypen oder Entitäten mit gemeinsamen und spezifischen Attributen bereitzustellen.
+Durch die Definition einer gemeinsamen Schnittstelle und deren Implementierung über verschiedene Dokumenttypen
+hinweg können Sie komplexe Datenstrukturen besser organisiert und einheitlich verarbeiten.
-## Vorteile und Abwägungen des Abstract Document Patterns
+## Vor- und Nachteile
**Vorteile:**
@@ -206,12 +239,12 @@ Die Hauptidee hinter dem Abstract Document Design Pattern ist es, eine flexible
* **Wartbarkeit**: Fördert sauberen und anpassungsfähigen Code durch Trennung der Verantwortlichkeiten.
* **Wiederverwendbarkeit**: Typspezifische Ansichten ermöglichen eine Wiederverwendung des Codes zum Zugriff auf bestimmte Attributtypen.
-**Abwägungen:**
+**Nachteile:**
-* **Komplexität**: Erfordert die Definition von Schnittstellen und Ansichten, was zu zusätzlichem Implementierungsaufwand führt.
-* **Leistung**: Kann im Vergleich zum direkten Datenzugriff zu leichtem Leistungsaufwand führen.
+* **Komplexität**: Die Definition von Schnittstellen und spezifischen Ansichten erfordert zusätzlichen Implementierungsaufwand.
+* **Performance**: Leicht verringerte Performance im Vergleich zum direkten Datenzugriff möglich.
-## Quellen und Danksagungen
+## Quellen
* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)
diff --git a/localization/de/abstract-factory/README.md b/localization/de/abstract-factory/README.md
new file mode 100644
index 000000000000..3e48dffd8fe7
--- /dev/null
+++ b/localization/de/abstract-factory/README.md
@@ -0,0 +1,225 @@
+---
+shortTitle: Abstract Factory
+category: Creational
+language: de
+tag:
+ - Abstraction
+ - Decoupling
+ - Gang of Four
+ - Instantiation
+ - Polymorphism
+---
+
+## Alternativbezeichnung
+
+* Kit
+
+## Zweck
+
+Das Abstract-Factory-Pattern stellt ein Interface zum Erzeugen von Instanzen einer Familie
+ähnlicher oder voneinander abhängiger Objekte zur Verfügung, ohne dass dabei deren konkrete Klasse
+festgelegt ist. Damit werden Modularität und Flexibilität im Softwaredesign verbessert.
+
+## Detaillierte Erklärung
+Reales Beispiel
+
+> Stellen Sie sich einen Möbelhersteller vor, der Möbelstücke in verschiedenen Stilen anbietet, z.B. modern, viktorianisch, rustikal. Zu jedem Stil gibt es Produkte wie Stühle, Tische und Sessel. Um Produkte unabhängig vom Stil einheitlich verwalten zu können, wird das Abstract-Factory-Pattern eingesetzt.
+>
+> Dabei ist die Abstract Factory ein Interface, mit dem mehrere Familien zusammengehöriger Möbelstücke (Stühle, Tische, Sessel) erzeugt werden. Jede einzelne konkrete Factory (ModernFurnitureFactory, VictorianFurnitureFactory, RusticFurnitureFactory) implementiert dieses Interface und erzeugt Möbelstücke des jeweiligen Stils. Auf diese Weise können ganze Einrichtungen in einem bestimmten Stil produziert werden, ohne dass man sich um die Details der Instantiierung kümmern muss. Das erlaubt eine einheitliche Bearbeitung und einen einfachen Wechsel des Einrichtungsstils.
+
+In einfachen Worten
+
+> Eine Factory für Factories - eine Factory, die mehrere zusammengehörende Factories vereinigt, ohne die konkrete Klasse der Objekte festzulegen.
+
+Wikipedia sagt
+
+> Das Abstract-Factory-Pattern dient zur Kapselung einer Gruppe einzelner Factories mit gemeinsamem Thema, wobei deren konkrete Klasse variabel bleibt.
+
+Klassendiagramm
+
+
+
+## Programmbeispiel
+
+Um ein Königreich mit dem Abstract-Factory-Pattern zu erzeugen, brauchen wir ein gemeinsames Thema. Das Elben-Königreich hat einen Elbenkönig, ein Elbenschlos und eine Elbenarmee, das Ork-Königreich dagegen einen Orkkönig, ein Orkschloss und eine Orkarmee. Die Objekte des jeweiligen Königreichs hängen voneinander ab.
+
+Zunächst definieren wir die Interfaces und implementieren sie für die einzelnen Königreiche.
+
+```java
+public interface Castle {
+ String getDescription();
+}
+
+public interface King {
+ String getDescription();
+}
+
+public interface Army {
+ String getDescription();
+}
+
+// Elben-Implementationen ->
+public class ElfCastle implements Castle {
+ static final String DESCRIPTION = "This is the elven castle!";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+
+public class ElfKing implements King {
+ static final String DESCRIPTION = "This is the elven king!";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+
+public class ElfArmy implements Army {
+ static final String DESCRIPTION = "This is the elven Army!";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+
+// Ork-Implementations analog -> ...
+```
+
+Nun kommt das Interface für die Königreich-Factory und seine Implementationen.
+
+```java
+public interface KingdomFactory {
+ Castle createCastle();
+
+ King createKing();
+
+ Army createArmy();
+}
+
+public class ElfKingdomFactory implements KingdomFactory {
+
+ @Override
+ public Castle createCastle() {
+ return new ElfCastle();
+ }
+
+ @Override
+ public King createKing() {
+ return new ElfKing();
+ }
+
+ @Override
+ public Army createArmy() {
+ return new ElfArmy();
+ }
+}
+
+// Ork-Implementationen analog -> ...
+```
+
+Jetzt können wir eine Factory bauen, die eine Instanz von entweder `ElfKingdomFactory` oder `OrcKingdomFactory` erstellt. Diese nennen wir `FactoryMaker`. Der Client kann `FactoryMaker` verwenden, um die gewünschte Factory zu erzeugen, mit der dann wiederum konkrete Objekte (abgeleitet von `Army`, `King`, `Castle`) erzeugt werden können. In diesem Beispiel nutzen wir ein Enum als Parameter für die gewünschte Art der Factory.
+
+```java
+public static class FactoryMaker {
+
+ public enum KingdomType {
+ ELF, ORC
+ }
+
+ public static KingdomFactory makeFactory(KingdomType type) {
+ return switch (type) {
+ case ELF -> new ElfKingdomFactory();
+ case ORC -> new OrcKingdomFactory();
+ };
+ }
+}
+```
+
+Hier die main-Methode der Beispielanwendung:
+
+```java
+LOGGER.info("elf kingdom");
+createKingdom(Kingdom.FactoryMaker.KingdomType.ELF);
+LOGGER.info(kingdom.getArmy().getDescription());
+LOGGER.info(kingdom.getCastle().getDescription());
+LOGGER.info(kingdom.getKing().getDescription());
+
+LOGGER.info("orc kingdom");
+createKingdom(Kingdom.FactoryMaker.KingdomType.ORC);
+LOGGER.info(kingdom.getArmy().getDescription());
+LOGGER.info(kingdom.getCastle().getDescription());
+LOGGER.info(kingdom.getKing().getDescription());
+```
+
+Ausgabe:
+
+```
+07:35:46.340 [main] INFO com.iluwatar.abstractfactory.App -- elf kingdom
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the elven army!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the elven castle!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the elven king!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- orc kingdom
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the orc army!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the orc castle!
+07:35:46.343 [main] INFO com.iluwatar.abstractfactory.App -- This is the orc king!
+```
+
+## Verwendung
+
+Einsatzkriterien für Abstract Factory:
+* Das System sollte nicht davon abhängig sein, wie die Produkte erzeugt, zusammengesetzt und dargestellt werden.
+* Nötige Konfiguration für eine oder mehrere Produktfamilien.
+* Eine Familie ähnlicher Produkte muss gemeinsam auf gleiche Art genutzt werden.
+* Die Klassenbibliothek der Produkte zeigt dem Anwender nur ihre Interfaces, nicht ihre Implementation.
+* Abhängigkeiten zwischen den Produkten existieren kürzer als die Verwendung dauert.
+* Abhängigkeiten müssen zur Laufzeit durch Parameter konstruiert werden.
+* Zur Laufzeit wird ein Produkt aus einer Familie ausgewählt.
+* Keine Code-Änderungen bei Hinzufügen weiterer Familien oder Produkte.
+
+## Tutorials
+
+* [Abstract Factory Design Pattern in Java (DigitalOcean)](https://www.digitalocean.com/community/tutorials/abstract-factory-design-pattern-in-java)
+* [Abstract Factory(Refactoring Guru)](https://refactoring.guru/design-patterns/abstract-factory)
+
+## Vor- und Nachteile
+
+Vorteile:
+
+* Flexibilität: Einfacher Wechsel zwischen Produktfamilien ohne Codeänderung.
+
+* Entkopplung: Der Verwender sieht nur abstrakte Interfaces, wodurch sich Portabilität und Wartbarkeit verbessern.
+
+* Wiederverwendbarkeit: Objekte aus einer Abstract Factory können projektübergreifend eingesetzt werden.
+
+* Wartbarkeit: Änderungen an einer einzelnen Produktfamilie sind nur lokal in deren Implementation nötig, was Updates erleichtert.
+*
+Nachteile:
+
+* Komplexität: Anfänglicher Zusatzaufwand für die Definition von Interfaces und konkreten Factories.
+*
+* Intransparenz: Die Transparenz könnte leiden, weil der Client-Code mit den Produkten nur indirekt über den Umweg der Factories interagiert.
+
+## Reale Anwendungen
+
+* Die `LookAndFeel` Klassen von Java Swing stellen mittels Abstract Factory verschiedene optische Darstellungen zur Verfügung.
+* Verschiedene Implementationen im Java Abstract Window Toolkit (AWT) verwenden das Pattern zur Erzeugung diverser GUI-Komponenten.
+* [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)
+* [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--)
+* [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--)
+
+## Verwandte Patterns
+
+* [Factory-Methoden](https://java-design-patterns.com/patterns/factory-method/): Abstract Factory verwendet Factory-Methoden zur Erzeugung von Produkten.
+* [Singleton](https://java-design-patterns.com/patterns/singleton/): Abstract-Factory-Klassen sind häufig als Singletons implementiert.
+* [Factory Kit](https://java-design-patterns.com/patterns/factory-kit/): Ähnlich wie Abstract Factory, aber mit Schwerpunkt auf flexibler Konfiguration und Verwaltung verwandter Objekte .
+
+## Quellen
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+* [Design Patterns in Java](https://amzn.to/3Syw0vC)
+* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
+* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3HWNf4U)
diff --git a/localization/de/abstract-factory/etc/abstract-factory.urm.png b/localization/de/abstract-factory/etc/abstract-factory.urm.png
new file mode 100644
index 000000000000..836858a2c652
Binary files /dev/null and b/localization/de/abstract-factory/etc/abstract-factory.urm.png differ
diff --git a/localization/de/active-object/README.md b/localization/de/active-object/README.md
new file mode 100644
index 000000000000..aaacdc69364e
--- /dev/null
+++ b/localization/de/active-object/README.md
@@ -0,0 +1,232 @@
+---
+shortTitle: Active Object
+category: Concurrency
+language: de
+tag:
+ - Asynchronous
+ - Decoupling
+ - Messaging
+ - Synchronization
+ - Thread management
+---
+
+## Zweck
+
+Active Object bietet eine zuverlässige Methode zur Behandlung asynchroner Prozesse, mit der reaktionsfähige Anwendungen
+und effizientes Thread-Management gesichert werden.
+Dies wird dadurch erreicht, dass die einzelnen Aufgaben in Objekte gekapselt werden, die in eigenen Threads (Steuerungsflüssen)
+mit eigener Nachrichtenwarteschlange aktiv sind. Durch diese Trennung bleibt der Hauptthread
+reaktionsfähig und Probleme wie direkte Threadmanipulation oder gemeinsamer Zugriff auf Zustände werden vermieden.
+
+## Detaillierte Erklärung
+
+Reales Beispiel
+
+> Stellen Sie sich ein gut besuchtes Restaurant vor, in dem die Gäste Bestellungen bei den
+> Kellner aufgeben. Die Kellner gehen nicht selbst in die Küche, um die Essen selbst zuzubereiten,
+> sondern sie schreiben die Bestellungen auf Zettel und geben diese dem Küchenmanager.
+> Der Manager organisiert eine Gruppe von Köchen, die die verschiedenen Mahlzeiten parallel zubereiten.
+> Wenn ein Koch frei ist, nimmt er eine Bestellung aus der Warteschlange, bereitet das Essen zu
+> und benachrichtigt den Kellner, sobald es fertig zum Servieren ist.
+>
+> In dieser Analogie stehen die Kellner für die Client-Threads,
+> der Küchenmanager für den Thread-Scheduler, und die Köche für die Methodenausführung
+> in verschiedenen Threads.
+> Die Organisation ermöglicht es, dass die Kellner immer weiter Bestellungen annehmen können,
+> ohne durch die Essenszubereitung aufgehalten zu werden; so wie das Active-Object-Pattern
+> den Methodenaufruf von der Ausführung trennt, um die Effizienz zu verbessern.
+
+In einfachen Worten
+
+> Das Active-Object-Pattern trennt Methodenausführung und Methodenaufruf,
+> um Parallelitätsgrad und Reaktionsfähigkeit in Multithread-Anwendungen zu verbessern.
+
+Wikipedia sagt
+
+> Das Design-Pattern Active Object entkoppelt die Methodenausführung vom Methodenaufruf
+> für Objekte, die in ihrem jeweils eigenen Thread arbeiten.
+> Ziel ist, Parallelität dadurch zu ermöglichen, dass Methoden asynchron aufgerufen werden und ein
+> Scheduler die Anfragen organisiert.
+>
+> Das Pattern besteht aus sechs Elementen.
+>
+> * Ein Proxy stellt für Clients ein Interface mit öffentlich zugänglichen Methoden zur Verfügung.
+> * Ein weiteres Interface definiert die Anfragen an ein aktives Objekt.
+> * Eine Liste offener Client-Anfragen.
+> * Ein Scheduler entscheidet, welche Anfrage als nächstes ausgeführt wird.
+> * Die Implementation der Methoden.
+> * Eine Callback-Variable zur Rückmeldung des Ergebnisses.
+
+Ablaufdiagramm
+
+
+
+
+## Programmbeispiel in Java
+
+Die Orcs sind wilde und nicht zu bändigende Kreaturen. Anscheinend haben sie ihre eigene Steuerung, die nur von ihrem vorherigen Verhalten bestimmt wird.
+Um eine derartige Kreatur zu implementieren, können wir das Active-Objekt-Pattern benutzen.
+
+```java
+public abstract class ActiveCreature {
+ private final Logger logger = LoggerFactory.getLogger(ActiveCreature.class.getName());
+
+ private BlockingQueue requests;
+
+ private String name;
+
+ private Thread thread;
+
+ public ActiveCreature(String name) {
+ this.name = name;
+ this.requests = new LinkedBlockingQueue();
+ thread = new Thread(new Runnable() {
+ @Override
+ public void run() {
+ while (true) {
+ try {
+ requests.take().run();
+ } catch (InterruptedException e) {
+ logger.error(e.getMessage());
+ }
+ }
+ }
+ }
+ );
+ thread.start();
+ }
+
+ public void eat() throws InterruptedException {
+ requests.put(new Runnable() {
+ @Override
+ public void run() {
+ logger.info("{} is eating!", name());
+ logger.info("{} has finished eating!", name());
+ }
+ }
+ );
+ }
+
+ public void roam() throws InterruptedException {
+ requests.put(new Runnable() {
+ @Override
+ public void run() {
+ logger.info("{} has started to roam the wastelands.", name());
+ }
+ }
+ );
+ }
+
+ public String name() {
+ return this.name;
+ }
+}
+```
+
+Man sieht, dass jede Klasse, die `ActiveCreature` erweitert, ihren eigenen Kontrollfluss für den Aufruf und die Ausführung der Methoden zum Herumstreifen und Essen hat.
+
+Beispielsweise die Klasse `Orc`:
+
+```java
+public class Orc extends ActiveCreature {
+
+ public Orc(String name) {
+ super(name);
+ }
+}
+```
+Nun können wir etliche Kreaturen dieser Art schaffen, sie zum Essen und Herumstreifen auffordern, aber jede von ihnen wird das in Eigenregie (eigener Thread) ausführen.
+
+```java
+public class App implements Runnable {
+
+ private static final Logger logger = LoggerFactory.getLogger(App.class.getName());
+
+ private static final int NUM_CREATURES = 3;
+
+ public static void main(String[] args) {
+ var app = new App();
+ app.run();
+ }
+
+ @Override
+ public void run() {
+ List creatures = new ArrayList<>();
+ try {
+ for (int i = 0; i < NUM_CREATURES; i++) {
+ creatures.add(new Orc(Orc.class.getSimpleName() + i));
+ creatures.get(i).eat();
+ creatures.get(i).roam();
+ }
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ logger.error(e.getMessage());
+ Thread.currentThread().interrupt();
+ } finally {
+ for (int i = 0; i < NUM_CREATURES; i++) {
+ creatures.get(i).kill(0);
+ }
+ }
+ }
+}
+```
+
+Programmausgabe:
+
+```
+09:00:02.501 [Thread-0] INFO com.iluwatar.activeobject.ActiveCreature -- Orc0 is eating!
+09:00:02.501 [Thread-2] INFO com.iluwatar.activeobject.ActiveCreature -- Orc2 is eating!
+09:00:02.501 [Thread-1] INFO com.iluwatar.activeobject.ActiveCreature -- Orc1 is eating!
+09:00:02.504 [Thread-0] INFO com.iluwatar.activeobject.ActiveCreature -- Orc0 has finished eating!
+09:00:02.504 [Thread-1] INFO com.iluwatar.activeobject.ActiveCreature -- Orc1 has finished eating!
+09:00:02.504 [Thread-0] INFO com.iluwatar.activeobject.ActiveCreature -- Orc0 has started to roam in the wastelands.
+09:00:02.504 [Thread-2] INFO com.iluwatar.activeobject.ActiveCreature -- Orc2 has finished eating!
+09:00:02.504 [Thread-1] INFO com.iluwatar.activeobject.ActiveCreature -- Orc1 has started to roam in the wastelands.
+09:00:02.504 [Thread-2] INFO com.iluwatar.activeobject.ActiveCreature -- Orc2 has started to roam in the wastelands.
+```
+
+## Verwendung
+
+* Wenn asynchrone Aufgaben behandelt werden sollen, ohne dass der Hauptthread blockiert wird, um bessere Performance und Reaktionsfähigkeit zu gewährleisten.
+* Bei asynchronen Interaktionen mit externen Ressourcen.
+* Zur Verbesserung der Reaktionsfähigkeit.
+* Zum Management parallel ablaufender Aufgaben in modularer und wartbarer Art und Weise.
+*
+## Tutorials
+
+* [Android and Java Concurrency: The Active Object Pattern(Douglas Schmidt)](https://www.youtube.com/watch?v=Cd8t2u5Qmvc)
+
+## Reale Anwendungen in Java
+
+* Echtzeit-Handelssysteme mit asynchroner Verarbeitung von Transaktionen.
+* GUIs, bei denen langwierige Arbeiten im Hintergrund ablaufen, ohne dass die Benutzeroberfläche einfriert.
+* Spiele, bei denen Aktualisierungen des Spielstatus oder KI-Berechnungen parallel abgearbeitet werden.
+
+## Vor- und Nachteile
+
+Vorteile
+
+* Reaktionsfähigkeit des Hauptthreads wird verbessert
+* Parallelitätsprobleme sind in den Objekten gekapselt
+* Ermöglicht bessere Codeorganisation und -wartbarkeit.
+* Sorgt für Threadsicherheit und vermeidet Probleme beim gemeinsamen Zugriff auf Zustände.
+
+Nachteile
+
+* Zusatzaufwand für die Übermittlung von Benachrichtigungen und das Threadmanagement.
+* Nicht für alle Arten von Nebenläufigkeitsproblemen geeignet.
+
+## Verwandte Patterns
+
+* [Command](https://java-design-patterns.com/patterns/command/): Kapselt Anfragen als Objekte, ähnlich wie Active Object es mit Methodenaufrufen macht.
+* [Promise](https://java-design-patterns.com/patterns/promise/): Bietet einen Weg zur Abfrage von Ergebnissen eines asynchronen Methodenaufrufs, oft mit Active Object kombiniert.
+* [Proxy](https://java-design-patterns.com/patterns/proxy/): Active Object kann einen Proxy verwenden, um asynchrone Methodenaufrufe zu behandeln.
+
+## Quellen
+
+* [Design Patterns: Elements of Reusable Object Software](https://amzn.to/3HYqrBE)
+* [Concurrent Programming in Java: Design Principles and Patterns](https://amzn.to/498SRVq)
+* [Java Concurrency in Practice](https://amzn.to/4aRMruW)
+* [Learning Concurrent Programming in Scala](https://amzn.to/3UE07nV)
+* [Pattern Languages of Program Design 3](https://amzn.to/3OI1j61)
+* [Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects](https://amzn.to/3UgC24V)
diff --git a/localization/de/active-object/etc/active-object.urm.png b/localization/de/active-object/etc/active-object.urm.png
new file mode 100644
index 000000000000..c14f66144ee2
Binary files /dev/null and b/localization/de/active-object/etc/active-object.urm.png differ
diff --git a/localization/de/actor-model/README.md b/localization/de/actor-model/README.md
new file mode 100644
index 000000000000..3c3cb436eb97
--- /dev/null
+++ b/localization/de/actor-model/README.md
@@ -0,0 +1,203 @@
+---
+shortTitle: Actor Model
+category: Concurrency
+language: de
+tag:
+ - Concurrency
+ - Messaging
+ - Isolation
+ - Asynchronous
+ - Distributed Systems
+ - Actor Model
+---
+
+## Alternativbezeichnungen
+
+- Message-passing concurrency
+- Actor-based concurrency
+
+---
+
+## Zweck
+
+Das Actor-Model-Pattern ermöglicht die Konstruktion von hochparallelen fehlertoleranten verteilten Systemen,
+indem es isolierte Komponenten (Akteure) verwendet, die ausschließlich über asynchronen Nachrichtenaustausch interagieren.
+
+## Detaillierte Erklärung
+
+---
+
+### 📦 Reales Beispiel
+
+Stellen Sie sich ein Kundendienstsystem vor.
+- Jeder **Kundendienstmitarbeiter** ist ein **Aktor**.
+- Kunden **senden Anfragen (Nachrichten)** an die Mitarbeiter.
+- Jeder Mitarbeiter behandelt zu einem bestimmten Zeitpunkt genau eine Anfrage und kann diese **asynchron beantworten**,
+ohne dabei anderen Mitarbeitern in die Quere zu kommen.
+
+---
+
+### 🧠 In einfachen Worten
+
+> "Aktoren sind wie unabhängige Arbeiter, die keine Ressourcen teilen und nur über Nachrichten kommunizieren."
+
+---
+
+### 📖 Wikipedia sagt
+
+> Das [Actor Model](https://en.wikipedia.org/wiki/Actor_model) ist ein mathematisches Modell
+> für parallele Informationsverarbeitung, das "Aktoren" als universelle Ausführer von Aufgaben betrachtet.
+
+---
+
+### 🧹 Klassendiagramm
+
+
+
+---
+
+## Programmbeispiel in Java
+
+### Actor.java
+
+```java
+public abstract class Actor implements Runnable {
+
+ @Setter
+ @Getter
+ private String actorId;
+ private final BlockingQueue mailbox = new LinkedBlockingQueue<>();
+ private volatile boolean active = true;
+
+
+ public void send(Message message) {
+ mailbox.add(message);
+ }
+
+ public void stop() {
+ active = false;
+ }
+
+ @Override
+ public void run() {
+
+ }
+
+ protected abstract void onReceive(Message message);
+}
+
+```
+
+### Message.java
+
+```java
+
+@AllArgsConstructor
+@Getter
+@Setter
+public class Message {
+ private final String content;
+ private final String senderId;
+}
+```
+
+### ActorSystem.java
+
+```java
+public class ActorSystem {
+ public void startActor(Actor actor) {
+ String actorId = "actor-" + idCounter.incrementAndGet(); // Generate a new and unique ID
+ actor.setActorId(actorId); // assign the actor it's ID
+ actorRegister.put(actorId, actor); // Register and save the actor with it's ID
+ executor.submit(actor); // Run the actor in a thread
+ }
+ public Actor getActorById(String actorId) {
+ return actorRegister.get(actorId); // Find by Id
+ }
+
+ public void shutdown() {
+ executor.shutdownNow(); // Stop all threads
+ }
+}
+```
+
+### App.java
+
+```java
+public class App {
+ public static void main(String[] args) {
+ ActorSystem system = new ActorSystem();
+ Actor srijan = new ExampleActor(system);
+ Actor ansh = new ExampleActor2(system);
+
+ system.startActor(srijan);
+ system.startActor(ansh);
+ ansh.send(new Message("Hello ansh", srijan.getActorId()));
+ srijan.send(new Message("Hello srijan!", ansh.getActorId()));
+
+ Thread.sleep(1000); // Give time for messages to process
+
+ srijan.stop(); // Stop the actor gracefully
+ ansh.stop();
+ system.shutdown(); // Stop the actor system
+ }
+}
+```
+
+---
+
+## Verwendung
+
+- Bei der Konstruktion **paralleler oder verteilter Systeme**
+- Wenn **keine veränderlichen Zustände geteilt** werden sollen
+- Wenn **asynchrone, nachrichtenbasierte Kommunikation** benötigt wird
+- Wenn die Komponenten **isoliert und lose gekoppelt** sein sollen.
+
+---
+
+## Tutorials
+
+- [Baeldung – Akka with Java](https://www.baeldung.com/java-akka)
+- [Vaughn Vernon – Reactive Messaging Patterns](https://vaughnvernon.co/?p=1143)
+
+---
+
+## Reale Anwendungen
+
+- [Akka Framework](https://akka.io/)
+- [Concurrency in Erlang und Elixir](https://www.erlang.org/)
+- [Microsoft Orleans](https://learn.microsoft.com/en-us/dotnet/orleans/)
+- JVM-basierte Spiel-Engines und Simulatoren
+
+---
+
+## Vor- und Nachteile
+
+### ✅ Vorteile
+- Unterstützt hohes Maß an Parallelität
+- Leichte Skalierbarkeit über Zahl der Threads oder Prozessoren.
+- Fehlerisolation und -behebbarkeit.
+- Geordnete Nachrichten in den Aktoren
+
+### ⚠️ Nachteile
+- Schwierigeres Debugging wegen asynchronen Verhaltens
+- Leichte Performance-Einbußen durch die Nachrichten-Warteschlangen
+- Komplexeres Design als bei einfachem Methodenaufruf
+---
+
+## Verwandte Patterns
+
+- [Command Pattern](../command)
+- [Mediator Pattern](../mediator)
+- [Event-Driven Architecture](../event-driven-architecture)
+- [Observer Pattern](../observer)
+
+---
+
+## Quellen
+
+- *Programming Erlang*, Joe Armstrong
+- *Reactive Design Patterns*, Roland Kuhn
+- *The Actor Model in 10 Minutes*, [InfoQ Article](https://www.infoq.com/articles/actor-model/)
+- [Akka Documentation](https://doc.akka.io/docs/akka/current/index.html)
+
diff --git a/localization/de/acyclic-visitor/README.md b/localization/de/acyclic-visitor/README.md
new file mode 100644
index 000000000000..864ef3f0ab3d
--- /dev/null
+++ b/localization/de/acyclic-visitor/README.md
@@ -0,0 +1,192 @@
+---
+shortTitle: Acyclic Visitor
+category: Behavioral
+language: de
+tag:
+ - Decoupling
+ - Extensibility
+ - Interface
+ - Object composition
+---
+
+## Zweck
+
+Das Acyclic-Visitor-Pattern entkoppelt Operationen von der Objekthierarchie und erlaubt so ein flexibles Design für verschiedenste Anwendungen.
+
+## Detailierte Erklärung
+
+Reales Beispiel
+
+> Als Vergleich aus der realen analogen Welt soll ein System von Museumsführern dienen.
+> Stellen Sie sich ein Museum mit verschiedensten Ausstellungsstücken (Bilder, Skulpturen, historische Artefakte, ...) vor.
+> Es gibt dort verschiedene Typen von Führern (Menschen, Audio-Guides, VR-Führer), die zu jedem Objekt Informationen geben.
+> Wenn nun eine neue Art der Führung eingeführt wird, muss nicht jedes Ausstellungsstück dafür angepasst werden.
+> Stattdessen implementiert jeder Führer eine Schnittstelle zu den jeweiligen Ausstellungstücken.
+> Auf diese Weise ist das System leicht erweiterbar.
+
+In einfachen Worten
+
+> Acyclic Visitor erlaubt das Hinzufügen von Funktionen, ohne die bestehende Hierarchie anpassen zu müssen.
+
+[WikiWikiWeb](https://wiki.c2.com/?AcyclicVisitor) sagt:
+
+> Das Acyclic-Visitor-Pattern erlaubt es, neue Funktionen zu einer bestehenden Klassenhierarchie
+> hinzuzufügen, ohne diese Hierarchie zu verändern und ohne Abhängigkeitszyklen (wie beim Visitor Pattern) zu schaffen.
+
+Ablaufdiagramm
+
+
+
+
+## Programmbeispiel
+
+Wir betrachten eine Hierarchie von Modem-Klassen. Die Modems werden besucht von einem externen Algorithmus,
+der auf Filterkritien (Unix- oder DOS-Kompatibilität) basiert.
+
+Here die `Modem` Hierarchie.
+
+```java
+public abstract class Modem {
+ public abstract void accept(ModemVisitor modemVisitor);
+}
+
+public class Zoom extends Modem {
+
+ // Weitere Eigenschaften und Methoden ...
+
+ @Override
+ public void accept(ModemVisitor modemVisitor) {
+ if (modemVisitor instanceof ZoomVisitor) {
+ ((ZoomVisitor) modemVisitor).visit(this);
+ } else {
+ LOGGER.info("Only ZoomVisitor is allowed to visit Zoom modem");
+ }
+ }
+}
+
+public class Hayes extends Modem {
+
+ // Weitere Eigenschaften und Methoden...
+
+ @Override
+ public void accept(ModemVisitor modemVisitor) {
+ if (modemVisitor instanceof HayesVisitor) {
+ ((HayesVisitor) modemVisitor).visit(this);
+ } else {
+ LOGGER.info("Only HayesVisitor is allowed to visit Hayes modem");
+ }
+ }
+}
+```
+
+Danach führen wir die `ModemVisitor` Hierarchie ein.
+
+```java
+public interface ModemVisitor {
+}
+
+public interface HayesVisitor extends ModemVisitor {
+ void visit(Hayes hayes);
+}
+
+public interface ZoomVisitor extends ModemVisitor {
+ void visit(Zoom zoom);
+}
+
+public interface AllModemVisitor extends ZoomVisitor, HayesVisitor {
+}
+
+public class ConfigureForDosVisitor implements AllModemVisitor {
+
+ // Weitere Eigenschaften und Methoden...
+
+ @Override
+ public void visit(Hayes hayes) {
+ LOGGER.info(hayes + " used with Dos configurator.");
+ }
+
+ @Override
+ public void visit(Zoom zoom) {
+ LOGGER.info(zoom + " used with Dos configurator.");
+ }
+}
+
+public class ConfigureForUnixVisitor implements ZoomVisitor {
+
+ // Weitere Eigenschaften und Methoden...
+
+ @Override
+ public void visit(Zoom zoom) {
+ LOGGER.info(zoom + " used with Unix configurator.");
+ }
+}
+```
+
+Schließlich die Visitors im Einsatz.
+
+```java
+public static void main(String[] args) {
+ var conUnix = new ConfigureForUnixVisitor();
+ var conDos = new ConfigureForDosVisitor();
+
+ var zoom = new Zoom();
+ var hayes = new Hayes();
+
+ hayes.accept(conDos); // Hayes modem with Dos configurator
+ zoom.accept(conDos); // Zoom modem with Dos configurator
+ hayes.accept(conUnix); // Hayes modem with Unix configurator
+ zoom.accept(conUnix); // Zoom modem with Unix configurator
+}
+```
+
+Programausgabe:
+
+```
+09:15:11.125 [main] INFO com.iluwatar.acyclicvisitor.ConfigureForDosVisitor -- Hayes modem used with Dos configurator.
+09:15:11.127 [main] INFO com.iluwatar.acyclicvisitor.ConfigureForDosVisitor -- Zoom modem used with Dos configurator.
+09:15:11.127 [main] INFO com.iluwatar.acyclicvisitor.Hayes -- Only HayesVisitor is allowed to visit Hayes modem
+09:15:11.127 [main] INFO com.iluwatar.acyclicvisitor.ConfigureForUnixVisitor -- Zoom modem used with Unix configurator.
+```
+
+## Verwendung
+
+* Wenn Sie zu einer bestehenden Hierarchie eine neue Funktion hinzufügen müssen, ohne die Hierarchie zu verändern.
+* Wenn es Funktionen gibt, die zwar auf einer Hierarchie arbeiten, aber nicht selbst dazu gehören (Wie die Configure-Funktionen im obigen Beispiel).
+* Wenn abhängig vom Objekttyp sehr unterschiedliche Funktionen auszuführen sind.
+* Wenn die zu besuchende Klassenhierarchie häufig um neue Kindklassen erweitert wird.
+* When the visited class hierarchy will be frequently extended with new derivatives of the Element class.
+* Wenn es sehr aufwendig ist, die neuen Kindklassen zu kompilieren, zu verlinken, zu testen oder zu verteilen.
+
+## Tutorials
+
+* [The Acyclic Visitor Pattern (Code Crafter)](https://codecrafter.blogspot.com/2012/12/the-acyclic-visitor-pattern.html)
+
+## Vor- und Nachteile
+
+Vorteile:
+
+* Erweiterbarkeit: Neue Funktionen können leicht hinzugefügt werden, ohne die Objektstruktur zu verändern.
+* Entkopplung: Kopplung zwischen Objekten und den auf ihnen stattfindenden Operationen wird reduziert.
+* Keine Abhängigkeitszyklen: Abhängigkeiten sind azyklisch, Wartbarkeit verbessert sich, Komplexität wird reduziert.
+
+Nachteile:
+
+* Komplexität: Viele erforderliche Visitor-Interfaces können die Komplexität erhöhen.
+* Wartbarkeit: Änderungen an der Objekthierarchie erfordern Updates aller Visitoren.
+
+## Verwandte Patterns
+
+* [Composite](https://java-design-patterns.com/patterns/composite/):
+Wird oft zusammen mit Acyclic Visitor verwendet, um einzelne Objekte und Zusammensetzungen aus ihnen einheitlich zu behandeln.
+* [Decorator](https://java-design-patterns.com/patterns/decorator/):
+Can als Ergänzung eingesetzt werden, um Objekten Verantwortlichkeiten dynamisch zuzuweisen.
+* [Visitor](https://java-design-patterns.com/patterns/visitor/): Acyclic Visitor ist eine Variante des Visitor Patterns, die zyklische Abhängigkeiten vermeidet.
+
+## Quellen
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
+* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)
+* [Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML](https://amzn.to/4bOtzwF)
+* [Acyclic Visitor (Robert C. Martin)](http://condor.depaul.edu/dmumaugh/OOT/Design-Principles/acv.pdf)
+* [Acyclic Visitor (WikiWikiWeb)](https://wiki.c2.com/?AcyclicVisitor)
diff --git a/localization/de/adapter/README.md b/localization/de/adapter/README.md
new file mode 100644
index 000000000000..cb4c17ab313e
--- /dev/null
+++ b/localization/de/adapter/README.md
@@ -0,0 +1,168 @@
+---
+shortTitle: Adapter
+category: Structural
+language: de
+tag:
+ - Compatibility
+ - Decoupling
+ - Gang of Four
+ - Interface
+ - Object composition
+ - Wrapping
+---
+
+## Alternativbezeichnung
+
+* Wrapper
+
+## Zweck
+
+Das Adapter-Pattern konvertiert die Schnittstelle einer Klasse in eine andere Schnittstelle, die zu den Bedürfnissen der Anwender passt, und sorgt so für Kompatibilität.
+
+## Detaillierte Erklärung
+Vergleich mit der analogen Welt
+
+> Stellen Sie sich vor, Sie haben einige Bilder auf Ihrer Speicherkarte und wollen diese auf
+> Ihren Computer übertragen. Dafür brauchen Sie einen Kartenleser, der mit den Anschlüssen des Rechners
+> kompatibel ist, sodass dieser auf die Daten auf der Karten zugreifen kann. Dieser Kartenleser
+> ist ein Beispiel für einen Adapter.
+> Ein anderes Beispiel sind die Adapter, mit denen man deutsche Netzstecker in ausländischen
+> Steckdosen verwenden kann, in die sie sonst nicht passen würden. Auch ein Übersetzer, der die
+> Worte eines Sprechers in die Sprache des ausländischen Publikums übersetzt, erfüllt die Funktion eines Adapters.
+
+In einfachen Worten
+
+> Das Adapter-Pattern verpackt ein normalerweise inkompatibles Objekt so, dass es mit einer
+> anderen Klasse kompatibel wird.
+
+Wikipedia sagt
+
+> Das Adapter-Pattern in der Softwareentwicklung ist ein Entwurfsmuster,
+> das die Schnittstelle einer bestehenden Klasse im Rahmen einer neuen Schnittstelle nutzbar macht.
+> Es wird oft verwendet, damit Klassen zusammenarbeiten können, ohne ihren Quellcode zu verändern.
+
+Ablaufdiagramm
+
+
+
+## Programmbeispiel
+
+Betrachten wir einen Möchtegern-Kapität, der zwar rudern kann, aber noch nie gesegelt ist.
+
+Wir beginnen mit dem Interface `RowingBoat` und der Klasse `FishingBoat`
+
+```java
+public interface RowingBoat {
+ void row();
+}
+
+public class FishingBoat {
+ public void sail() {
+ LOGGER.info("The fishing boat is sailing");
+ }
+}
+```
+
+Der Kapität erwartet, dass sich ein Schiff mit der `row`-Methode von `RowingBoat` steuern lässt.
+
+```java
+public class Captain {
+
+ private final RowingBoat rowingBoat;
+
+ public Captain(RowingBoat rowingBoat) {
+ this.rowingBoat = rowingBoat;
+ }
+
+ public void row() {
+ rowingBoat.row();
+ }
+}
+```
+
+Nun kommen Piraten und unser Kapitän muss fliehen, hat aber nur ein Fischerboot zur Verfügung.
+Wir brauchen einen Adapter, mit dem er auch dieses Boot durch Rudern steuern kann.
+
+```java
+public class FishingBoatAdapter implements RowingBoat {
+
+ private final FishingBoat boat;
+
+ public FishingBoatAdapter() {
+ boat = new FishingBoat();
+ }
+
+ @Override
+ public void row() {
+ boat.sail();
+ }
+}
+```
+
+Nun segelt das `FishingBoat`, indem der Kapitän rudert, und er kann fliehen.
+
+```java
+ public static void main(final String[] args) {
+ // The captain can only operate rowing boats but with adapter he is able to
+ // use fishing boats as well
+ var captain = new Captain(new FishingBoatAdapter());
+ captain.row();
+}
+```
+
+Programmausgabe:
+
+```
+10:25:08.074 [main] INFO com.iluwatar.adapter.FishingBoat -- The fishing boat is sailing
+```
+
+## Verwendung
+Das Adapter-Pattern ist geeignet für diese Fälle
+* Sie wollen eine bestehende Klasse benutzen, deren Schnittstelle anders als benötigt ist.
+* Sie wollen eine wiederverwendbare Klasse schreiben, die auch mit fremden Klassen zusammen
+ arbeiten kann, die nicht unbedingt kompatible Schnittstellen haben.
+* Sie müssen verschiedene Tochterklassen verwenden, bei denen es zu aufwendig wäre, zu jeder einzelnen eine Subklasse mit angepasster Schnittstelle zu erstellen.
+ Ein Adapter kann die Schnittstelle der Elternklasse bedarfsgerecht anpassen.
+* Die meisten Anwendungen, die Fremdbibliotheken verwenden, nutzen einen Adapter für die Fremdklassen,
+ um die eigenen Anwendung vom fremden zu entkoppeln.
+
+## Tutorials
+
+* [Using the Adapter Design Pattern in Java (Dzone)](https://dzone.com/articles/adapter-design-pattern-in-java)
+* [Adapter in Java (Refactoring Guru)](https://refactoring.guru/design-patterns/adapter/java/example)
+* [The Adapter Pattern in Java (Baeldung)](https://www.baeldung.com/java-adapter-pattern)
+* [Adapter Design Pattern (GeeksForGeeks)](https://www.geeksforgeeks.org/adapter-pattern/)
+
+## Vor- und Nachteile
+
+Die Vor- und Nachteile hängen davon ab, ob ein Klassen- oder ein Objektadapter implementiert wird.
+
+Ein Klassenadapter adaptiert durch Bindung an eine spezifische zu adaptierende Klasse.
+Er kann das Verhalten der zu adaptierenden Klasse überschreiben, weil er
+als deren Tochterklasse implementiert wird.
+Das hat allerdings zur Folge, dass mit einer Klasse nicht auch all ihre Subklassen adaptiert werden können.
+Bei diesem Adaptertyp wird lediglich ein neues Objekt eingeführt, ohne
+dass mit einem extra Zeiger der Zugriff darauf ermöglicht werden muss.
+
+Ein Objektadapter hingegen kann mit verschiedenen zu adaptierenden Klassen arbeiten, auch mit
+allen Subklassen. Er kann allen adaptierten Klassen zugleich Funktionalität hinzufügen.
+Allerdings wird es damit schwerer, das Verhalten zu überschreiben, weil man dafür eine
+Subklasse der adaptierten Klasse benötigt und der Adapter sich auf diese Subklasse statt
+auf die ursprünglich adaptierte Klasse beziehen muss.
+
+## Reale Java-Anwendungen
+
+* `java.io.InputStreamReader` and `java.io.OutputStreamWriter` in der Java-IO-Bibliothek.
+* GUI-Komponentenbibliotheken, die per Plugin oder Adapter zwischen verschiedenen Kompontentenschnittstellen konvertieren können.
+* [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
+* [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
+* [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
+* [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
+
+## Quellen
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+* [Effective Java](https://amzn.to/4cGk2Jz)
+* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
+* [J2EE Design Patterns](https://amzn.to/4dpzgmx)
+* [Refactoring to Patterns](https://amzn.to/3VOO4F5)
diff --git a/localization/de/adapter/etc/adapter.urm.png b/localization/de/adapter/etc/adapter.urm.png
new file mode 100644
index 000000000000..341ad67699d9
Binary files /dev/null and b/localization/de/adapter/etc/adapter.urm.png differ
diff --git a/localization/de/aggregator-microservices/aggregator-service/etc/aggregator-service.png b/localization/de/aggregator-microservices/aggregator-service/etc/aggregator-service.png
new file mode 100644
index 000000000000..75ee82328bbe
Binary files /dev/null and b/localization/de/aggregator-microservices/aggregator-service/etc/aggregator-service.png differ
diff --git a/localization/de/ambassador/etc/ambassador.urm.png b/localization/de/ambassador/etc/ambassador.urm.png
new file mode 100644
index 000000000000..9b50a02ad356
Binary files /dev/null and b/localization/de/ambassador/etc/ambassador.urm.png differ
diff --git a/localization/de/api-gateway/etc/api-gateway.png b/localization/de/api-gateway/etc/api-gateway.png
new file mode 100644
index 000000000000..bb3ec2e2e1a8
Binary files /dev/null and b/localization/de/api-gateway/etc/api-gateway.png differ
diff --git a/localization/de/async-method-invocation/etc/async-method-invocation.png b/localization/de/async-method-invocation/etc/async-method-invocation.png
new file mode 100644
index 000000000000..764895d7a217
Binary files /dev/null and b/localization/de/async-method-invocation/etc/async-method-invocation.png differ
diff --git a/localization/de/balking/etc/balking.png b/localization/de/balking/etc/balking.png
new file mode 100644
index 000000000000..f409eaacbb95
Binary files /dev/null and b/localization/de/balking/etc/balking.png differ
diff --git a/localization/de/bridge/README.md b/localization/de/bridge/README.md
new file mode 100644
index 000000000000..bdfc3a65925b
--- /dev/null
+++ b/localization/de/bridge/README.md
@@ -0,0 +1,282 @@
+---
+shortTitle: Bridge
+category: Structural
+language: de
+tag:
+ - Abstraction
+ - Decoupling
+ - Extensibility
+ - Gang of Four
+ - Object composition
+---
+
+## Alternativbezeichnung
+
+* Handle/Body
+
+## Zweck
+
+Das Bridge-Pattern ist ein Entwurfsmuster, das eine Abstraktion von ihrer Implementation
+entkoppelt, wodurch beide unabhängig voneinander variieren können.
+Es ist wesentlich, um flexible und erweiterbare Softwaresysteme zu bauen.
+
+## Detaillierte Erklärung
+
+Reales Beispiel
+
+> In Java wird das Bridge-Pattern oft verwendet für GUI-Frameworks, Datenbanktreiber und Gerätetreiber.
+>
+> Denken Sie an eine Universalfernbedienung (Abstraktion), die verschiedene Geräte diverser Marken
+> (Implementationen) schalten kann. Die Fernbedienung stellt eine einheitliche Schnittstelle bereit für
+> Aktionen wie Ein- und Ausschalten, Programmwechsel und Lautstärkeregelung. Diese Aktionen sind
+> bei jedem einzelnen Gerät unterschiedlich implementiert. Mit dem Bridge-Pattern werden diese
+> spezifischen Implementationen von der Fernbedienungsschnittstelle entkoppelt, sodass alle Geräte bedient
+> unabhängig von Marke und interner Funktionsweise bedient werden können. Diese Trennung erlaubt es,
+> dass neue Geräte mit der gleichen Fernbedienung ohne Änderung an deren Schnittstelle gesteuert werden können,
+> oder dass neue Fernbedienungen für den gleichen Gerätepool entwickelt werden können.
+
+In einfachen Worten
+
+> Beim Bridge-Pattern geht es um den Vorrang von Komposition vor Vererbung.
+> Details der Implementation werden aus einer Hierarchie in ein anderes Objekt mit separater Hierarchie verschoben.
+
+Wikipedia sagt
+
+> Das Bridge-Pattern ist ein Entwurfsmuster der Softwareentwicklung mit dem Zweck,
+> eine Abstraktion von ihrer Implementierung zu trennen, so dass beide unabhängig voneinander angepasst werden können.
+
+Ablaufdiagramm
+
+
+
+## Programmbeispiel
+
+Stellen Sie sich vor, eine Waffe kann diverse Verzauberungen haben und sie müssen
+verschiedene Waffen mit verschiedenen Verzauberungen kombinieren. Wie realisieren Sie das?
+Imagine you have a weapon that can have various enchantments, and you need to combine
+different weapons with different enchantments. How would you handle this?
+Durch viele Versionen einer Waffe mit jeweils einem anderen Zauber, oder würden Sie separate
+Verzauberungen definieren und diese nach Bedarf einer Waffe zuordnen? Das Bridge-Pattern macht letzteres möglich.
+
+Hier ist die `Weapon`-Hierarchie:
+
+```java
+public interface Weapon {
+ void wield();
+
+ void swing();
+
+ void unwield();
+
+ Enchantment getEnchantment();
+}
+
+public class Sword implements Weapon {
+
+ private final Enchantment enchantment;
+
+ public Sword(Enchantment enchantment) {
+ this.enchantment = enchantment;
+ }
+
+ @Override
+ public void wield() {
+ LOGGER.info("The sword is wielded.");
+ enchantment.onActivate();
+ }
+
+ @Override
+ public void swing() {
+ LOGGER.info("The sword is swung.");
+ enchantment.apply();
+ }
+
+ @Override
+ public void unwield() {
+ LOGGER.info("The sword is unwielded.");
+ enchantment.onDeactivate();
+ }
+
+ @Override
+ public Enchantment getEnchantment() {
+ return enchantment;
+ }
+}
+
+public class Hammer implements Weapon {
+
+ private final Enchantment enchantment;
+
+ public Hammer(Enchantment enchantment) {
+ this.enchantment = enchantment;
+ }
+
+ @Override
+ public void wield() {
+ LOGGER.info("The hammer is wielded.");
+ enchantment.onActivate();
+ }
+
+ @Override
+ public void swing() {
+ LOGGER.info("The hammer is swung.");
+ enchantment.apply();
+ }
+
+ @Override
+ public void unwield() {
+ LOGGER.info("The hammer is unwielded.");
+ enchantment.onDeactivate();
+ }
+
+ @Override
+ public Enchantment getEnchantment() {
+ return enchantment;
+ }
+}
+```
+
+Hier die separate `Enchantment`-Hierarchie:
+
+```java
+public interface Enchantment {
+ void onActivate();
+
+ void apply();
+
+ void onDeactivate();
+}
+
+public class FlyingEnchantment implements Enchantment {
+
+ @Override
+ public void onActivate() {
+ LOGGER.info("The item begins to glow faintly.");
+ }
+
+ @Override
+ public void apply() {
+ LOGGER.info("The item flies and strikes the enemies finally returning to owner's hand.");
+ }
+
+ @Override
+ public void onDeactivate() {
+ LOGGER.info("The item's glow fades.");
+ }
+}
+
+public class SoulEatingEnchantment implements Enchantment {
+
+ @Override
+ public void onActivate() {
+ LOGGER.info("The item spreads bloodlust.");
+ }
+
+ @Override
+ public void apply() {
+ LOGGER.info("The item eats the soul of enemies.");
+ }
+
+ @Override
+ public void onDeactivate() {
+ LOGGER.info("Bloodlust slowly disappears.");
+ }
+}
+```
+
+Hier werden beide Hierarchien aktiv:
+
+```java
+public static void main(String[] args) {
+ LOGGER.info("The knight receives an enchanted sword.");
+ var enchantedSword = new Sword(new SoulEatingEnchantment());
+ enchantedSword.wield();
+ enchantedSword.swing();
+ enchantedSword.unwield();
+
+ LOGGER.info("The valkyrie receives an enchanted hammer.");
+ var hammer = new Hammer(new FlyingEnchantment());
+ hammer.wield();
+ hammer.swing();
+ hammer.unwield();
+}
+```
+
+Dies ist die Ausgabe:
+
+```
+The knight receives an enchanted sword.
+The sword is wielded.
+The item spreads bloodlust.
+The sword is swung.
+The item eats the soul of enemies.
+The sword is unwielded.
+Bloodlust slowly disappears.
+The valkyrie receives an enchanted hammer.
+The hammer is wielded.
+The item begins to glow faintly.
+The hammer is swung.
+The item flies and strikes the enemies finally returning to owner's hand.
+The hammer is unwielded.
+The item's glow fades.
+```
+
+## Verwendung
+
+Das Bridge-Pattern kommt in diesen Fällen in Betracht:
+
+* Eine dauerhafte Bindung zwischen Abstration und Implementierung soll vermieden werden, etwa
+ wenn die Implementation zur Laufzeit ausgewählt oder ausgewechselt werden muss.
+* Sowohl Abstraktion als auch Implementationen sollen durch Vererbung erweitert werden können,
+ um unabhängige Erweiterungen jeder Komponente zu ermöglichen.
+* Änderungen an der Implementation einer Abstraktion sollen die Verwender nicht beeinflussen, d.h. sie sollen nicht neu kompiliert werden müssen.
+* Die Hierarchie enthält eine große Anzahl Klassen, was dafür spricht, Objekte in zwei Teile zu spalten.
+ Dieses Konzept wird von Rumbaugh als "verschachtelte Generalisierungen" bezeichnet.
+* Sie wollen eine Implementation mit mehreren Objekten teilen, eventuell unter Verwendung von
+ Referenzzählern, dabei aber dieses Detail aber vor den Verwendern verstecken. Beispiel dafür
+ ist die String-Klasse von Coplien, wo mehrere Objekte die gleiche Stringdarstellung haben.
+
+## Tutorials
+
+* [Bridge Pattern Tutorial (DigitalOcean)](https://www.digitalocean.com/community/tutorials/bridge-design-pattern-java)
+
+## Reale Anwendungen in Java
+
+* In GUI-Frameworks ist das Fenster die Abstraktion, die Implementation die Fensterkonstruktion des Betriebssystem.
+* Bei Datenbanktreibern ist die Abstraktion eine generische Datenbankschnittstelle, die Implementationen sind datenbankspezifische Treiber.
+* Bei Gerätetreibern ist der geräteunabhängige Code die Abstraktion, die Implementation betrifft das einzelne Gerät.
+
+## Vor- und Nachteile
+
+Vorteile:
+
+* Entkopplung von Schnittstelle und Implementation: Durch Trennung von Operationen der höheren (Schnittstelle) und der niedrigeren Ebene (Implementation) verbessert sich die Modularität.
+* Bessere Erweiterbarkeit: Abstraktions- und Implementationshierarchien können unabhängig voneinander erweitert werden.
+* Versteckte Implementationsdetails: Verwender sehen nur die Schnittstelle, nicht ihre Implementation.
+
+Nachteile:
+
+* Höhere Komplexität: Systemarchitektur und Code können sich verkomplizieren, vor allem wenn man nicht mit dem Pattern vertraut ist.
+* Laufzeitkosten: Die zusätzliche Abstraktionsschicht kann zu Performanceeinbußen führen, auch wenn das in der Praxis oft vernachlässigbar ist.
+
+
+## Verwandte Patterns
+
+* [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/):
+ Das Abstract-Factory-Pattern kann zusammen mit dem Bridge-Pattern verwendet werden, um Plattformen zu schaffen, die unabhängig von den konkreten Klassen zur Objekterzeugung sind.
+* [Adapter](https://java-design-patterns.com/patterns/adapter/):
+ Das Adapter-Pattern stellt eine neue Schnittstelle für ein Objekt zur Verfügung,
+ das Bridge-Pattern trennt die Schnittstelle des Objekts von der Implementation.
+* [Composite](https://java-design-patterns.com/patterns/composite/):
+ Das Bridge-Pattern wird häufig mit dem Composite-Pattern verwendet, um die Implementationsdetails
+ einer Komponente zu modellieren.
+* [Strategy](https://java-design-patterns.com/patterns/strategy/):
+ Beide Patterns verwenden Komposition: Strategy für Veränderungen am Verhalten einer Klasse, Bridge für die Trennung von Abstraktion und Implementation.
+
+## Quellen
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
+* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)
+* [Pattern-Oriented Software Architecture Volume 1: A System of Patterns](https://amzn.to/3TEnhtl)
+* [Patterns of Enterprise Application Architecture](https://amzn.to/3WfKBPR)
diff --git a/localization/de/bridge/etc/bridge.urm.png b/localization/de/bridge/etc/bridge.urm.png
new file mode 100644
index 000000000000..785585bf8163
Binary files /dev/null and b/localization/de/bridge/etc/bridge.urm.png differ
diff --git a/localization/de/builder/etc/builder.urm.png b/localization/de/builder/etc/builder.urm.png
new file mode 100644
index 000000000000..d77808d36097
Binary files /dev/null and b/localization/de/builder/etc/builder.urm.png differ
diff --git a/localization/de/business-delegate/etc/business-delegate.urm.png b/localization/de/business-delegate/etc/business-delegate.urm.png
new file mode 100644
index 000000000000..4dca6c263b99
Binary files /dev/null and b/localization/de/business-delegate/etc/business-delegate.urm.png differ
diff --git a/localization/de/bytecode/etc/bytecode.urm.png b/localization/de/bytecode/etc/bytecode.urm.png
new file mode 100644
index 000000000000..51335fa0a4b4
Binary files /dev/null and b/localization/de/bytecode/etc/bytecode.urm.png differ
diff --git a/localization/de/chain-of-responsibility/etc/chain-of-responsibility.urm.png b/localization/de/chain-of-responsibility/etc/chain-of-responsibility.urm.png
new file mode 100644
index 000000000000..af1bd105455b
Binary files /dev/null and b/localization/de/chain-of-responsibility/etc/chain-of-responsibility.urm.png differ
diff --git a/localization/de/client-session/etc/session_state_pattern.png b/localization/de/client-session/etc/session_state_pattern.png
new file mode 100644
index 000000000000..f1e23be95766
Binary files /dev/null and b/localization/de/client-session/etc/session_state_pattern.png differ
diff --git a/localization/de/collecting-parameter/etc/collecting-parameter.urm.png b/localization/de/collecting-parameter/etc/collecting-parameter.urm.png
new file mode 100644
index 000000000000..785d6ecc2da1
Binary files /dev/null and b/localization/de/collecting-parameter/etc/collecting-parameter.urm.png differ
diff --git a/localization/de/command/etc/command.png b/localization/de/command/etc/command.png
new file mode 100644
index 000000000000..0f026464ecc4
Binary files /dev/null and b/localization/de/command/etc/command.png differ
diff --git a/localization/de/commander/etc/commander.urm.png b/localization/de/commander/etc/commander.urm.png
new file mode 100644
index 000000000000..6b5ebba75bd6
Binary files /dev/null and b/localization/de/commander/etc/commander.urm.png differ
diff --git a/localization/de/composite-entity/etc/composite_entity.urm.png b/localization/de/composite-entity/etc/composite_entity.urm.png
new file mode 100644
index 000000000000..d6c29a718837
Binary files /dev/null and b/localization/de/composite-entity/etc/composite_entity.urm.png differ
diff --git a/localization/de/composite-view/etc/composite_view.png b/localization/de/composite-view/etc/composite_view.png
new file mode 100644
index 000000000000..66215d9416b8
Binary files /dev/null and b/localization/de/composite-view/etc/composite_view.png differ
diff --git a/localization/de/composite-view/etc/images/noparam.png b/localization/de/composite-view/etc/images/noparam.png
new file mode 100644
index 000000000000..2979cf2bc657
Binary files /dev/null and b/localization/de/composite-view/etc/images/noparam.png differ
diff --git a/localization/de/composite-view/etc/images/threeparams.png b/localization/de/composite-view/etc/images/threeparams.png
new file mode 100644
index 000000000000..9338dedb8885
Binary files /dev/null and b/localization/de/composite-view/etc/images/threeparams.png differ
diff --git a/localization/de/composite/etc/composite.urm.png b/localization/de/composite/etc/composite.urm.png
new file mode 100644
index 000000000000..93c160f6450a
Binary files /dev/null and b/localization/de/composite/etc/composite.urm.png differ
diff --git a/localization/de/context-object/etc/context-object.png b/localization/de/context-object/etc/context-object.png
new file mode 100644
index 000000000000..a1f670812f7b
Binary files /dev/null and b/localization/de/context-object/etc/context-object.png differ
diff --git a/localization/de/converter/etc/converter.png b/localization/de/converter/etc/converter.png
new file mode 100644
index 000000000000..01435ef5ae29
Binary files /dev/null and b/localization/de/converter/etc/converter.png differ
diff --git a/localization/de/crtp/etc/crtp.png b/localization/de/crtp/etc/crtp.png
new file mode 100644
index 000000000000..a348c8af6175
Binary files /dev/null and b/localization/de/crtp/etc/crtp.png differ
diff --git a/localization/de/data-locality/etc/data-locality.urm.png b/localization/de/data-locality/etc/data-locality.urm.png
new file mode 100644
index 000000000000..d19873739551
Binary files /dev/null and b/localization/de/data-locality/etc/data-locality.urm.png differ
diff --git a/localization/de/decorator/etc/decorator.urm.png b/localization/de/decorator/etc/decorator.urm.png
new file mode 100644
index 000000000000..141c0563f0c6
Binary files /dev/null and b/localization/de/decorator/etc/decorator.urm.png differ
diff --git a/localization/de/delegation/etc/delegation.png b/localization/de/delegation/etc/delegation.png
new file mode 100644
index 000000000000..375ef4d6b00f
Binary files /dev/null and b/localization/de/delegation/etc/delegation.png differ
diff --git a/localization/de/dependency-injection/README.md b/localization/de/dependency-injection/README.md
new file mode 100644
index 000000000000..a47f8fe5e1c3
--- /dev/null
+++ b/localization/de/dependency-injection/README.md
@@ -0,0 +1,169 @@
+---
+shortTitle: Dependency Injection
+category: Creational
+language: de
+tag:
+ - Decoupling
+ - Dependency management
+ - Inversion of control
+---
+
+## Alternativbezeichnungen
+
+* Inversion of Control (IoC)
+* Dependency Inversion
+
+## Zweck
+
+Die Erzeugung der in einem Objekt benötigten Abhängigkeiten soll von der Verwendung entkoppelt werden. So wird der Code flexibler und testbarer.
+
+## Detaillierte Erklärung
+
+Beispiel aus dem echten Leben
+
+> Stellen Sie sich edles Restaurant vor, in dem der Koch diverse Zutaten für das Essen braucht.
+> Er geht nicht für jede Zutat einzeln zu deren Hersteller, sondern bedient sich eines zuverlässigen
+> Lieferanten, der ihm jeden Tag die Produkte frisch vom jeweiligen Hersteller besorgt.
+> So kann er sich aufs Kochen konzentrieren und muss sich nicht mehr um den Einkauf kümmern.
+>
+> Im Dependency-Injection-Pattern fungiert der Lieferant als "Injektor", der die nötigen
+> Abhängigkeiten (Zutaten) dem "Objekt" Koch zur Verfügung stellt. Der Koch kann die Zutaten
+> verwenden, ohne deren Ursprung kennen zu müssen. Die Beschaffung und Verwendung der Abhängigkeiten
+> sind also klar getrennt. Mit diesem Ansatz werden Effizienz, Flexibilität und Wartungsfreundlichkeit in der Küche verbessert,
+> ebenso wie in einem Softwaresystem.
+
+In einfachen Worten
+
+> Dependency Injection trennt die Beschaffung der Abhängigkeiten vom eigenen Verhalten des Verwenders.
+
+Wikipedia sagt
+
+> In der Softwareentwicklung ist Dependency Injection eine Technik, mit der ein Objekt andere
+> Objekte zugewiesen bekommt, die es benötigt. Diese anderen Objekte nennt man Abhängigkeiten (Dependencies).
+
+Ablaufdiagramm
+
+
+
+## Programmbeispiel
+
+Der alte Hexenmeister möchte hin und wieder seine Pfeife stopfen und Tabak rauchen.
+Dabei will er aber nicht von einer einzigen Tabakmarke abhängig sein, sondern die Marke wechseln können.
+
+Definieren wir also zunächst die Schnittstelle `Tobacco` und konkrete Klassen für die Marken.
+
+```java
+
+public abstract class Tobacco {
+
+ public void smoke(Wizard wizard) {
+ LOGGER.info("{} smoking {}", wizard.getClass().getSimpleName(),
+ this.getClass().getSimpleName());
+ }
+}
+
+public class SecondBreakfastTobacco extends Tobacco {
+}
+
+public class RivendellTobacco extends Tobacco {
+}
+
+public class OldTobyTobacco extends Tobacco {
+}
+```
+
+Als nächstes die `Wizard`-Klassenhierarchie.
+
+```java
+public interface Wizard {
+
+ void smoke();
+}
+
+public class AdvancedWizard implements Wizard {
+
+ private final Tobacco tobacco;
+
+ public AdvancedWizard(Tobacco tobacco) {
+ this.tobacco = tobacco;
+ }
+
+ @Override
+ public void smoke() {
+ tobacco.smoke(this);
+ }
+}
+```
+
+Schließlich sehen wir, wie leicht es ist, dem Hexenmeister jede beliebige Tabakmarke zu geben.
+
+```java
+public static void main(String[] args) {
+ var simpleWizard = new SimpleWizard();
+ simpleWizard.smoke();
+
+ var advancedWizard = new AdvancedWizard(new SecondBreakfastTobacco());
+ advancedWizard.smoke();
+
+ var advancedSorceress = new AdvancedSorceress();
+ advancedSorceress.setTobacco(new SecondBreakfastTobacco());
+ advancedSorceress.smoke();
+
+ var injector = Guice.createInjector(new TobaccoModule());
+ var guiceWizard = injector.getInstance(GuiceWizard.class);
+ guiceWizard.smoke();
+}
+```
+
+Prorammausgabe:
+
+```
+11:54:05.205 [main] INFO com.iluwatar.dependency.injection.Tobacco -- SimpleWizard smoking OldTobyTobacco
+11:54:05.207 [main] INFO com.iluwatar.dependency.injection.Tobacco -- AdvancedWizard smoking SecondBreakfastTobacco
+11:54:05.207 [main] INFO com.iluwatar.dependency.injection.Tobacco -- AdvancedSorceress smoking SecondBreakfastTobacco
+11:54:05.308 [main] INFO com.iluwatar.dependency.injection.Tobacco -- GuiceWizard smoking RivendellTobacco
+```
+
+## Verwendung
+
+* Wenn die Kopplung zwischen den Klassen reduziert und die Modularität der Anwendung erhöht werden soll
+* In Szenarien, wo die Objekterzeugung komplex ist oder sonst von der Verwendung der Klasse getrennt werden soll.
+* In Anwendungen, die einfacheres Texten durch Mocks oder Stubs benötigen.
+* In Frameworks oder Bibliotheken, die den Lebenszyklus von Objekten managen, wie Spring oder Jakarta EE (früher Java EE).
+
+## Reale Anwendungen in Java
+
+* Frameworks wie Spring, Jakarta EE und Google Guice verwenden Dependency Injection (DI)
+ ausgiebig, um Lebenszyklen und Abhängigkeiten zu verwalten.
+* Desktop- und Webanwendungen, die eine flexible Architektur mit leicht austauschbaren Komponenten benötigen.
+
+## Vor- und Nachteile
+
+Vorteile:
+
+* Verbessert die Modularität und Trennung von Zuständigkeiten.
+* Vereinfacht Unit-Tests durch leichtes Mocken von Abhängigkeiten.
+* Verbessert Flexibilität und Wartbarkeit durch Förderung von loser Kopplung.
+
+Nachteile:
+
+* Kann Konfiguration verkomplizieren, vor allem in großen Projekten.
+* Entwickler, die mit dem Konzept nicht vertraut sind, müssen es erst erlernen.
+* Erfordert sorgfältiges Management von Lebenzyklen und Gültigkeitsbereich der Objekte.
+
+## Verwandte Patterns
+
+* [Factory-Methoden](https://java-design-patterns.com/patterns/factory-method/) und [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/): Werden zur Erzeugung von Instanzen genutzt, die per DI injiziert werden.
+* [Service Locator](https://java-design-patterns.com/patterns/service-locator/): Eine Alternative zu DI, um Dienste oder Komponenten zu finden, entkoppelt den Prozess aber nicht so effektiv.
+* [Singleton](https://java-design-patterns.com/patterns/singleton/): Häufig Ergänzung zu DI, um eine einzige Instanz zu liefern. eines Service für die gesamte Anwendung zu liefern.
+
+## Quellen
+
+* [Clean Code: A Handbook of Agile Software Craftsmanship](https://amzn.to/3wRnjp5)
+* [Dependency Injection: Design patterns using Spring and Guice](https://amzn.to/4aMyHkI)
+* [Dependency Injection Principles, Practices, and Patterns](https://amzn.to/4aupmxe)
+* [Google Guice: Agile Lightweight Dependency Injection Framework](https://amzn.to/4bTDbX0)
+* [Java 9 Dependency Injection: Write loosely coupled code with Spring 5 and Guice](https://amzn.to/4ayCtxp)
+* [Java Design Pattern Essentials](https://amzn.to/3xtPPxa)
+* [Pro Java EE Spring Patterns: Best Practices and Design Strategies Implementing Java EE Patterns with the Spring Framework](https://amzn.to/3J6Teoh)
+* [Spring in Action](https://amzn.to/4asnpSG)
diff --git a/localization/de/dependency-injection/etc/dependency-injection.png b/localization/de/dependency-injection/etc/dependency-injection.png
new file mode 100644
index 000000000000..2a92c9eb228b
Binary files /dev/null and b/localization/de/dependency-injection/etc/dependency-injection.png differ
diff --git a/localization/de/dirty-flag/etc/dirty-flag.png b/localization/de/dirty-flag/etc/dirty-flag.png
new file mode 100644
index 000000000000..98d4f679d17c
Binary files /dev/null and b/localization/de/dirty-flag/etc/dirty-flag.png differ
diff --git a/localization/de/double-buffer/etc/double-buffer.urm.png b/localization/de/double-buffer/etc/double-buffer.urm.png
new file mode 100644
index 000000000000..072ec4dad8be
Binary files /dev/null and b/localization/de/double-buffer/etc/double-buffer.urm.png differ
diff --git a/localization/de/embedded-value/etc/embedded-value.urm.png b/localization/de/embedded-value/etc/embedded-value.urm.png
new file mode 100644
index 000000000000..52d3ffb62352
Binary files /dev/null and b/localization/de/embedded-value/etc/embedded-value.urm.png differ
diff --git a/localization/de/event-aggregator/etc/classes.png b/localization/de/event-aggregator/etc/classes.png
new file mode 100644
index 000000000000..295719ea3712
Binary files /dev/null and b/localization/de/event-aggregator/etc/classes.png differ
diff --git a/localization/de/extension-objects/etc/extension_obj.png b/localization/de/extension-objects/etc/extension_obj.png
new file mode 100644
index 000000000000..a2b750e9dedd
Binary files /dev/null and b/localization/de/extension-objects/etc/extension_obj.png differ
diff --git a/localization/de/facade/etc/facade.urm.png b/localization/de/facade/etc/facade.urm.png
new file mode 100644
index 000000000000..8e3ec7aca45e
Binary files /dev/null and b/localization/de/facade/etc/facade.urm.png differ
diff --git a/localization/de/factory-kit/etc/factory-kit.png b/localization/de/factory-kit/etc/factory-kit.png
new file mode 100644
index 000000000000..7093193cb8d0
Binary files /dev/null and b/localization/de/factory-kit/etc/factory-kit.png differ
diff --git a/localization/de/factory-method/etc/factory-method.urm.png b/localization/de/factory-method/etc/factory-method.urm.png
new file mode 100644
index 000000000000..7c97aff91ee6
Binary files /dev/null and b/localization/de/factory-method/etc/factory-method.urm.png differ
diff --git a/localization/de/factory/etc/factory.urm.png b/localization/de/factory/etc/factory.urm.png
new file mode 100644
index 000000000000..4b3420792e06
Binary files /dev/null and b/localization/de/factory/etc/factory.urm.png differ
diff --git a/localization/de/feature-toggle/etc/feature-toggle.png b/localization/de/feature-toggle/etc/feature-toggle.png
new file mode 100644
index 000000000000..5c118e57e44e
Binary files /dev/null and b/localization/de/feature-toggle/etc/feature-toggle.png differ
diff --git a/localization/de/flux/etc/flux.png b/localization/de/flux/etc/flux.png
new file mode 100644
index 000000000000..9cb596eaf03d
Binary files /dev/null and b/localization/de/flux/etc/flux.png differ
diff --git a/localization/de/flyweight/etc/flyweight.urm.png b/localization/de/flyweight/etc/flyweight.urm.png
new file mode 100644
index 000000000000..299cdb7bdf86
Binary files /dev/null and b/localization/de/flyweight/etc/flyweight.urm.png differ
diff --git a/localization/de/front-controller/etc/front-controller.png b/localization/de/front-controller/etc/front-controller.png
new file mode 100644
index 000000000000..77c14ef019cc
Binary files /dev/null and b/localization/de/front-controller/etc/front-controller.png differ
diff --git a/localization/de/game-loop/etc/game-loop.urm.png b/localization/de/game-loop/etc/game-loop.urm.png
new file mode 100644
index 000000000000..b7ffc11d2659
Binary files /dev/null and b/localization/de/game-loop/etc/game-loop.urm.png differ
diff --git a/localization/de/gateway/etc/gateway.urm.png b/localization/de/gateway/etc/gateway.urm.png
new file mode 100644
index 000000000000..2d8ad6c9a8f8
Binary files /dev/null and b/localization/de/gateway/etc/gateway.urm.png differ
diff --git a/localization/de/health-check/etc/health-check.png b/localization/de/health-check/etc/health-check.png
new file mode 100644
index 000000000000..89966c464cb5
Binary files /dev/null and b/localization/de/health-check/etc/health-check.png differ
diff --git a/localization/de/identity-map/etc/IdentityMap.png b/localization/de/identity-map/etc/IdentityMap.png
new file mode 100644
index 000000000000..1bac10ebf294
Binary files /dev/null and b/localization/de/identity-map/etc/IdentityMap.png differ
diff --git a/localization/de/intercepting-filter/etc/intercepting-filter.png b/localization/de/intercepting-filter/etc/intercepting-filter.png
new file mode 100644
index 000000000000..ec792639eab5
Binary files /dev/null and b/localization/de/intercepting-filter/etc/intercepting-filter.png differ
diff --git a/localization/de/interpreter/etc/interpreter_1.png b/localization/de/interpreter/etc/interpreter_1.png
new file mode 100644
index 000000000000..f10342a1df90
Binary files /dev/null and b/localization/de/interpreter/etc/interpreter_1.png differ
diff --git a/localization/de/iterator/etc/iterator_1.png b/localization/de/iterator/etc/iterator_1.png
new file mode 100644
index 000000000000..d8313bc5881f
Binary files /dev/null and b/localization/de/iterator/etc/iterator_1.png differ
diff --git a/localization/de/layers/etc/layers.png b/localization/de/layers/etc/layers.png
new file mode 100644
index 000000000000..a4bd8b19ddad
Binary files /dev/null and b/localization/de/layers/etc/layers.png differ
diff --git a/localization/de/lazy-loading/etc/lazy-loading.png b/localization/de/lazy-loading/etc/lazy-loading.png
new file mode 100644
index 000000000000..bec0a7afbefe
Binary files /dev/null and b/localization/de/lazy-loading/etc/lazy-loading.png differ
diff --git a/localization/de/leader-election/etc/leader-election.urm.png b/localization/de/leader-election/etc/leader-election.urm.png
new file mode 100644
index 000000000000..85a90b75b636
Binary files /dev/null and b/localization/de/leader-election/etc/leader-election.urm.png differ
diff --git a/localization/de/marker/etc/MarkerDiagram.png b/localization/de/marker/etc/MarkerDiagram.png
new file mode 100644
index 000000000000..6ed4f9c56780
Binary files /dev/null and b/localization/de/marker/etc/MarkerDiagram.png differ
diff --git a/localization/de/mediator/etc/mediator_1.png b/localization/de/mediator/etc/mediator_1.png
new file mode 100644
index 000000000000..0b48ffdbaee7
Binary files /dev/null and b/localization/de/mediator/etc/mediator_1.png differ
diff --git a/localization/de/memento/etc/memento.png b/localization/de/memento/etc/memento.png
new file mode 100644
index 000000000000..dcfe7a749b04
Binary files /dev/null and b/localization/de/memento/etc/memento.png differ
diff --git a/localization/de/module/etc/module.png b/localization/de/module/etc/module.png
new file mode 100644
index 000000000000..a26807d290c0
Binary files /dev/null and b/localization/de/module/etc/module.png differ
diff --git a/localization/de/monostate/etc/monostate.png b/localization/de/monostate/etc/monostate.png
new file mode 100644
index 000000000000..273fa95459d4
Binary files /dev/null and b/localization/de/monostate/etc/monostate.png differ
diff --git a/localization/de/multiton/etc/multiton.png b/localization/de/multiton/etc/multiton.png
new file mode 100644
index 000000000000..91106463d2b2
Binary files /dev/null and b/localization/de/multiton/etc/multiton.png differ
diff --git a/localization/de/null-object/etc/null-object.png b/localization/de/null-object/etc/null-object.png
new file mode 100644
index 000000000000..cb0a5409c735
Binary files /dev/null and b/localization/de/null-object/etc/null-object.png differ
diff --git a/localization/de/object-mother/etc/object-mother.png b/localization/de/object-mother/etc/object-mother.png
new file mode 100644
index 000000000000..807343d9f9e4
Binary files /dev/null and b/localization/de/object-mother/etc/object-mother.png differ
diff --git a/localization/de/object-pool/etc/object-pool.png b/localization/de/object-pool/etc/object-pool.png
new file mode 100644
index 000000000000..b8ede36c5a47
Binary files /dev/null and b/localization/de/object-pool/etc/object-pool.png differ
diff --git a/localization/de/observer/etc/observer.png b/localization/de/observer/etc/observer.png
new file mode 100644
index 000000000000..f2ab0edfeb21
Binary files /dev/null and b/localization/de/observer/etc/observer.png differ
diff --git a/localization/de/page-controller/etc/page-controller.urm.png b/localization/de/page-controller/etc/page-controller.urm.png
new file mode 100644
index 000000000000..d46bb018755b
Binary files /dev/null and b/localization/de/page-controller/etc/page-controller.urm.png differ
diff --git a/localization/de/page-object/etc/page-object.png b/localization/de/page-object/etc/page-object.png
new file mode 100644
index 000000000000..4240b438efbb
Binary files /dev/null and b/localization/de/page-object/etc/page-object.png differ
diff --git a/localization/de/parameter-object/etc/parameter-object.png b/localization/de/parameter-object/etc/parameter-object.png
new file mode 100644
index 000000000000..661c3488ac49
Binary files /dev/null and b/localization/de/parameter-object/etc/parameter-object.png differ
diff --git a/localization/de/partial-response/etc/partial-response.urm.png b/localization/de/partial-response/etc/partial-response.urm.png
new file mode 100644
index 000000000000..17dbd5f1b60d
Binary files /dev/null and b/localization/de/partial-response/etc/partial-response.urm.png differ
diff --git a/localization/de/pipeline/etc/pipeline.urm.png b/localization/de/pipeline/etc/pipeline.urm.png
new file mode 100644
index 000000000000..4110f1624665
Binary files /dev/null and b/localization/de/pipeline/etc/pipeline.urm.png differ
diff --git a/localization/de/poison-pill/etc/poison-pill.png b/localization/de/poison-pill/etc/poison-pill.png
new file mode 100644
index 000000000000..bfca5848e082
Binary files /dev/null and b/localization/de/poison-pill/etc/poison-pill.png differ
diff --git a/localization/de/presentation-model/etc/presentation-model.urm.png b/localization/de/presentation-model/etc/presentation-model.urm.png
new file mode 100644
index 000000000000..46690641cb82
Binary files /dev/null and b/localization/de/presentation-model/etc/presentation-model.urm.png differ
diff --git a/localization/de/presentation-model/etc/result.png b/localization/de/presentation-model/etc/result.png
new file mode 100644
index 000000000000..6b104968f302
Binary files /dev/null and b/localization/de/presentation-model/etc/result.png differ
diff --git a/localization/de/priority-queue/etc/priority-queue.urm.png b/localization/de/priority-queue/etc/priority-queue.urm.png
new file mode 100644
index 000000000000..e0b4295a5986
Binary files /dev/null and b/localization/de/priority-queue/etc/priority-queue.urm.png differ
diff --git a/localization/de/property/etc/property.png b/localization/de/property/etc/property.png
new file mode 100644
index 000000000000..98c0cbe3720c
Binary files /dev/null and b/localization/de/property/etc/property.png differ
diff --git a/localization/de/prototype/README.md b/localization/de/prototype/README.md
new file mode 100644
index 000000000000..0603ab77d626
--- /dev/null
+++ b/localization/de/prototype/README.md
@@ -0,0 +1,203 @@
+---
+shortTitle: Prototype
+category: Creational
+language: de
+tag:
+ - Gang of Four
+ - Instantiation
+ - Object composition
+ - Polymorphism
+---
+
+## Alternativbezeichnung
+
+* Klon
+
+## Zweck
+
+Das Prototyp-Pattern spezifiziert die Art von Objekten, die erzeugt werden sollen,
+durch eine prototypische Instanz. Neue Instanzen werden durch Klonen des Objekts erzeugt.
+
+## Detaillierte Erklärung
+
+Reales Beispiel
+
+> Stellen Sie sich einen Hersteller von Designmöbeln vor. Wenn eine Bestellung eintrifft, wird
+> nicht von Grund auf ein ganz neues Design entwickelt. Stattdessen werden von den beliebtesten
+> Designs Prototypen vorgehalten. Bei einer Bestellung zu einem bestimmten Design wird der
+> zugehörige Prototyp kopiert, ggfs. mit speziellen Anpassungen gemäß Kundenwunsch.
+> Dieser Ansatz spart Zeit und Ressourcen, weil die Grundkonstruktion und die Designdetails
+> bereits vorhanden sind, sodass Bestellungen schnell und in gleichbleibender Qualität erledigt werden können.
+> quality.
+>
+> Wie bei den Möbelstücken dienen auch bei Java-Objekten die Prototypen als Vorlage, um effizient neue Objekte erzeugen zu können.
+
+In einfachen Worten
+
+> Erzeuge ein neues Objekt durch Klonen eines existierenden.
+
+Wikipedia sagt:
+
+> Prototype ist ein Erzeugungsmuster in der Softwareentwicklung.
+> Es wird verwendet, wenn der Typ eines zu erzeugenden Objekts durch eine prototypische Instanz vorgegeben ist,
+> die dann geklont wird.
+
+Ablaufdiagramm
+
+
+
+## Programmbeispiel
+
+Folgende Implementation in Java wird empfohlen.
+Zunächst schreibt man eine Schnittstelle mit einer Methode zum Klonen.
+In diesem Beispiel ist dies die abstrakte Klasse `Prototype` mit ihrer `copy`-Methode.
+
+```java
+public abstract class Prototype implements Cloneable {
+ public T copy() {
+ return (T) super.clone();
+ }
+}
+```
+
+Das Beispiel enthält eine Hierarchie verschiedener Kreaturen. Betrachten wir exemplarisch die Klassen
+`Beast` and `OrcBeast`.
+
+```java
+public abstract class Beast extends Prototype {
+ public Beast(Beast source) {}
+}
+
+public class OrcBeast extends Beast {
+
+ private final String weapon;
+
+ public OrcBeast(OrcBeast orcBeast) {
+ super(orcBeast);
+ this.weapon = orcBeast.weapon;
+ }
+
+ @Override
+ public String toString() {
+ return "Orcish wolf attacks with " + weapon;
+ }
+}
+```
+
+In dieser Erklärung beschränken wir uns auf die Grundlagen. Der komplette Beispielcode
+enthält auch die
+Basisklassen `Mage` und `Warlord` und es gibt spezielle Implementationen für Elfen and Orks.
+
+Um das Prototyp-Pattern voll auszunutzen, schreiben wir das Interface `HeroFactory` und die implementierende Klasse
+`HeroFactoryImpl` zur Erzeugung verschiedener Arten von Kreaturen.
+
+```java
+public interface HeroFactory {
+ Mage createMage();
+ Warlord createWarlord();
+ Beast createBeast();
+}
+```
+
+```java
+public class HeroFactoryImpl implements HeroFactory {
+
+ private final Mage mage;
+ private final Warlord warlord;
+ private final Beast beast;
+
+ public Mage createMage() {
+ return mage.copy();
+ }
+
+ public Warlord createWarlord() {
+ return warlord.copy();
+ }
+
+ public Beast createBeast() {
+ return beast.copy();
+ }
+}
+```
+
+Nun können wir sehen, wie mit dem Pattern neue Kreaturen durch das Klonen vorhandener Instanzen erschaffen werden.
+
+```java
+public static void main(String[] args) {
+ var factory = new HeroFactoryImpl(
+ new ElfMage("cooking"),
+ new ElfWarlord("cleaning"),
+ new ElfBeast("protecting")
+ );
+ var mage = factory.createMage();
+ var warlord = factory.createWarlord();
+ var beast = factory.createBeast();
+ LOGGER.info(mage.toString());
+ LOGGER.info(warlord.toString());
+ LOGGER.info(beast.toString());
+
+ factory = new HeroFactoryImpl(
+ new OrcMage("axe"),
+ new OrcWarlord("sword"),
+ new OrcBeast("laser")
+ );
+ mage = factory.createMage();
+ warlord = factory.createWarlord();
+ beast = factory.createBeast();
+ LOGGER.info(mage.toString());
+ LOGGER.info(warlord.toString());
+ LOGGER.info(beast.toString());
+}
+```
+
+Hier die Konsolenausgabe
+
+```
+08:36:19.012 [main] INFO com.iluwatar.prototype.App -- Elven mage helps in cooking
+08:36:19.013 [main] INFO com.iluwatar.prototype.App -- Elven warlord helps in cleaning
+08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Elven eagle helps in protecting
+08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Orcish mage attacks with axe
+08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Orcish warlord attacks with sword
+08:36:19.014 [main] INFO com.iluwatar.prototype.App -- Orcish wolf attacks with laser
+```
+
+## Verwendung
+* Wenn die zu instanziierenden Klassen erst zur Laufzeit festgelegt werden, etwa durch dynamisches Laden.
+* Zur vermeidung einer Klassenhierarchie von Fabriken parallel zur Klassenhierarchie von Produkten.
+* Wenn Instanzen einer Klasse nur wenige verschiedene Zustände haben, kann es bequemer sein, Prototypen
+zu klonen, als jedesmal die Klasse mit passendem Zustand zu instanziieren.
+* Wenn das Erzeugen von Objekten aufwendiger ist als Klonen.
+* Wenn erst zur Laufzeit bestimmt wird, welche konkreten Klassen instanziiert werden müssen.
+
+## Echte Java-Anwendungen
+* Die `Object.clone()`-Methode is eine klassische Implementation des Prototyp-Patterns.
+* GUI Libraries verwenden oft Prototypes für Buttons, Fenster, und andere Widgets.
+* In der Spieleentwicklung können viele Objekte (wie Gegner-Charaktere) mit ähnlichen Attributen erzeugt werden.
+
+## Vor- und Nachteile
+Vorteile:
+
+* Verbirgt die Komplexitäten der Objektinstanziierung
+* Reduziert die Zahl der Klassen
+* Erlaubt das Hinzufügen und Entfernen von Objekten zur Laufzeit
+
+Nachteile:
+
+* Implementation eines möglicherweise komplexen Klon-Mechanismus erforderlich
+* Requires implementing a cloning mechanism which might be complex.
+* Deep Cloning kann Schwierigkeiten bei der korrekten Implementation bereiten,
+ insbesondere bei komplexen Objektgraphen mit zirkulären Referenzen
+
+## Verwandte Patterns
+
+* [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/): Beide betreffen das Erzeugen von Objekten,
+* aber Abstract Factory verwendet dafür Factory-Methoden statt Klonen.
+* [Singleton](https://java-design-patterns.com/patterns/singleton/): Singleton kann Prototyp zur Objekterzeugung verwenden, wenn die einzige Instanz geklont werden darf.
+* [Composite](https://java-design-patterns.com/patterns/composite/): Prototypen werden oft innerhalb von Composites verwendet, um Komponentenbäume dynamisch kreieren zu können.
+
+## Quellen
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+* [Effective Java](https://amzn.to/4cGk2Jz)
+* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
+* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)
diff --git a/localization/de/prototype/etc/prototype.urm.png b/localization/de/prototype/etc/prototype.urm.png
new file mode 100644
index 000000000000..b23c6d1cfb85
Binary files /dev/null and b/localization/de/prototype/etc/prototype.urm.png differ
diff --git a/localization/de/proxy/etc/proxy.urm.png b/localization/de/proxy/etc/proxy.urm.png
new file mode 100644
index 000000000000..a0c94fc7c717
Binary files /dev/null and b/localization/de/proxy/etc/proxy.urm.png differ
diff --git a/localization/de/registry/etc/registry.png b/localization/de/registry/etc/registry.png
new file mode 100644
index 000000000000..6c1c5b986d72
Binary files /dev/null and b/localization/de/registry/etc/registry.png differ
diff --git a/localization/de/retry/etc/retry.png b/localization/de/retry/etc/retry.png
new file mode 100644
index 000000000000..3ef6d3800ee5
Binary files /dev/null and b/localization/de/retry/etc/retry.png differ
diff --git a/localization/de/role-object/etc/role-object.urm.png b/localization/de/role-object/etc/role-object.urm.png
new file mode 100644
index 000000000000..65201c68aff4
Binary files /dev/null and b/localization/de/role-object/etc/role-object.urm.png differ
diff --git a/localization/de/separated-interface/etc/class_diagram.png b/localization/de/separated-interface/etc/class_diagram.png
new file mode 100644
index 000000000000..10d509801f79
Binary files /dev/null and b/localization/de/separated-interface/etc/class_diagram.png differ
diff --git a/localization/de/servant/etc/servant-pattern.png b/localization/de/servant/etc/servant-pattern.png
new file mode 100644
index 000000000000..a8237775e332
Binary files /dev/null and b/localization/de/servant/etc/servant-pattern.png differ
diff --git a/localization/de/sharding/etc/sharding.urm.png b/localization/de/sharding/etc/sharding.urm.png
new file mode 100644
index 000000000000..e7f412af3f01
Binary files /dev/null and b/localization/de/sharding/etc/sharding.urm.png differ
diff --git a/localization/de/single-table-inheritance/etc/single-table-inheritance.urm.png b/localization/de/single-table-inheritance/etc/single-table-inheritance.urm.png
new file mode 100644
index 000000000000..f3abe8df6fec
Binary files /dev/null and b/localization/de/single-table-inheritance/etc/single-table-inheritance.urm.png differ
diff --git a/localization/de/singleton/README.md b/localization/de/singleton/README.md
new file mode 100644
index 000000000000..b5330a077894
--- /dev/null
+++ b/localization/de/singleton/README.md
@@ -0,0 +1,114 @@
+---
+shortTitle: Singleton
+category: Creational
+language: de
+tag:
+ - Gang of Four
+ - Instantiation
+ - Lazy initialization
+ - Resource management
+---
+
+## Alternativbezeichnung
+
+* Single Instance
+
+## Zweck
+
+Sicherstellen, dass es nur eine Instanz einer Klasse gibt, und einen globalen Zugriffspunkt auf diese Instanz bereitstellen.
+
+## Detaillierte Erklärung
+
+Analogie aus der Realität
+
+> Das Singleton-Pattern entspricht der Ausgabe von Pässen durch die Regierung.
+> Jeder Bürger darf zu jeder Zeit nur einen Pass besitzen. Die Meldebehörde stellt sicher,
+> dass niemandem ein zweiter Pass ausgestellt wird.
+> Wenn ein Bürger ins Ausland reist, benötigt er seinen Pass, der als einzigartiger weltweit anerkannter Nachweis
+> seiner Identität dient.
+
+In einfachen Worten
+
+> Es darf nur ein einziges Objekt dieser Klasse erzeugt werden.
+>
+Wikipedia sagt
+
+> In der Softwareentwicklung ist das Singleton ein Entwurfsmuster, das die Instanziierung einer
+> Klasse auf ein einziges Objekt beschränkt.
+> Dies ist sinnvoll, wenn genau ein Objekt benötigt wird, das Aktionen über das gesamte System
+> hinweg koordiniert.
+
+Ablaufdiagramm
+
+
+
+## Programmbeispiel
+
+vgl. Joshua Bloch, Effective Java 2nd Edition, Seite 18
+
+> Die beste Art der Implementation eines Singletons ist ein Enum mit nur einem Element.
+
+```java
+public enum EnumIvoryTower {
+ INSTANCE
+}
+```
+
+So wird es verwendet:
+
+```java
+ var enumIvoryTower1 = EnumIvoryTower.INSTANCE;
+ var enumIvoryTower2 = EnumIvoryTower.INSTANCE;
+ LOGGER.info("enumIvoryTower1={}", enumIvoryTower1);
+ LOGGER.info("enumIvoryTower2={}", enumIvoryTower2);
+```
+
+Ausgabe in der Konsole:
+
+```
+enumIvoryTower1=com.iluwatar.singleton.EnumIvoryTower@1221555852
+enumIvoryTower2=com.iluwatar.singleton.EnumIvoryTower@1221555852
+```
+
+## Verwendung
+
+Ein Singleton sollte verwendet werden, wenn
+* genau eine Instanz der Klasse benötigt wird, die für Nutzer über einen wohldefinierten Zugriffspunkt erreichbar ist.
+* es möglich sein soll, diese Klasse durch Vererbung zu erweitern, ohne dass bei Verwendung der erweiterten Instanz Codeänderungen nötig sind.
+
+## Reale Anwendungen in Java
+
+* Logging-Klassen
+* Konfigurationsklassen in vielen Anwendungen
+* Verbindungspools
+* Dateimanager
+* [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
+* [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
+* [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
+
+## Vor- und Nachteile
+Vorteile:
+* Kontrollierter Zugriff auf die einzige Instanz.
+* Namensraum wird nicht unnötig belastet.
+* Operationen und Darstellungen können durch Vererbung verfeinert werden.
+* Bei Bedarf auch mehrere Instanzen möglich.
+* Flexibler als Klassenoperationen
+
+Nachteile:
+* Schwierig zu testen wegen globalem Status.
+* Möglicherweise komplexeres Lebenszyklusmanagement.
+* Bei Parallelität sind ohne sorgfältige Synchronisierung Engpässe möglich.
+
+## Verwandte Patterns
+
+* [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/): Oft verwendet, um sicherzustellen, dass nur eine Instanz existiert.
+* [Factory Methoden](https://java-design-patterns.com/patterns/factory-method/): Das Singleton-Pattern kann implementiert werden, indem über eine Factory-Methode die Instanzerzeugung gekapselt wird.
+* [Prototyp](https://java-design-patterns.com/patterns/prototype/): Hier müssen keine Instanzen erzeugt werden. Das Pattern kann zusammen mit dem Singleton verwendet werden, um einzige Instanzen zu verwalten.
+
+## Quellen
+
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)
+* [Effective Java](https://amzn.to/4cGk2Jz)
+* [Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software](https://amzn.to/49NGldq)
+* [Java Design Patterns: A Hands-On Experience with Real-World Examples](https://amzn.to/3yhh525)
+* [Refactoring to Patterns](https://amzn.to/3VOO4F5)
diff --git a/localization/de/singleton/etc/singleton.urm.png b/localization/de/singleton/etc/singleton.urm.png
new file mode 100644
index 000000000000..46584af40039
Binary files /dev/null and b/localization/de/singleton/etc/singleton.urm.png differ
diff --git a/localization/de/spatial-partition/etc/spatial-partition.urm.png b/localization/de/spatial-partition/etc/spatial-partition.urm.png
new file mode 100644
index 000000000000..5172bdb36a79
Binary files /dev/null and b/localization/de/spatial-partition/etc/spatial-partition.urm.png differ
diff --git a/localization/de/special-case/etc/special_case_urm.png b/localization/de/special-case/etc/special_case_urm.png
new file mode 100644
index 000000000000..03ca646f3816
Binary files /dev/null and b/localization/de/special-case/etc/special_case_urm.png differ
diff --git a/localization/de/specification/etc/specification.png b/localization/de/specification/etc/specification.png
new file mode 100644
index 000000000000..60fb0402d8d3
Binary files /dev/null and b/localization/de/specification/etc/specification.png differ
diff --git a/localization/de/state/etc/state_urm.png b/localization/de/state/etc/state_urm.png
new file mode 100644
index 000000000000..c2cf9f562943
Binary files /dev/null and b/localization/de/state/etc/state_urm.png differ
diff --git a/localization/de/step-builder/etc/step-builder.png b/localization/de/step-builder/etc/step-builder.png
new file mode 100644
index 000000000000..b7b623657c58
Binary files /dev/null and b/localization/de/step-builder/etc/step-builder.png differ
diff --git a/localization/de/strangler/etc/strangler.png b/localization/de/strangler/etc/strangler.png
new file mode 100644
index 000000000000..c69305e5d510
Binary files /dev/null and b/localization/de/strangler/etc/strangler.png differ
diff --git a/localization/de/strategy/etc/strategy_urm.png b/localization/de/strategy/etc/strategy_urm.png
new file mode 100644
index 000000000000..67d19acae62d
Binary files /dev/null and b/localization/de/strategy/etc/strategy_urm.png differ
diff --git a/localization/de/subclass-sandbox/etc/subclass-sandbox.urm.png b/localization/de/subclass-sandbox/etc/subclass-sandbox.urm.png
new file mode 100644
index 000000000000..db81e12cc815
Binary files /dev/null and b/localization/de/subclass-sandbox/etc/subclass-sandbox.urm.png differ
diff --git a/localization/de/table-module/etc/table-module.urm.png b/localization/de/table-module/etc/table-module.urm.png
new file mode 100644
index 000000000000..9c4bc0b189db
Binary files /dev/null and b/localization/de/table-module/etc/table-module.urm.png differ
diff --git a/localization/de/template-method/etc/template_method_urm.png b/localization/de/template-method/etc/template_method_urm.png
new file mode 100644
index 000000000000..b7babccff96d
Binary files /dev/null and b/localization/de/template-method/etc/template_method_urm.png differ
diff --git a/localization/de/throttling/etc/throttling_urm.png b/localization/de/throttling/etc/throttling_urm.png
new file mode 100644
index 000000000000..a9824e24b5a4
Binary files /dev/null and b/localization/de/throttling/etc/throttling_urm.png differ
diff --git a/localization/de/trampoline/etc/trampoline.urm.png b/localization/de/trampoline/etc/trampoline.urm.png
new file mode 100644
index 000000000000..f2e9c7439a32
Binary files /dev/null and b/localization/de/trampoline/etc/trampoline.urm.png differ
diff --git a/localization/de/transaction-script/etc/transaction-script.png b/localization/de/transaction-script/etc/transaction-script.png
new file mode 100644
index 000000000000..6d0cffb6a551
Binary files /dev/null and b/localization/de/transaction-script/etc/transaction-script.png differ
diff --git a/localization/de/twin/etc/twin.png b/localization/de/twin/etc/twin.png
new file mode 100644
index 000000000000..724092525bd6
Binary files /dev/null and b/localization/de/twin/etc/twin.png differ
diff --git a/localization/de/typeobjectpattern/etc/typeobjectpattern.urm.png b/localization/de/typeobjectpattern/etc/typeobjectpattern.urm.png
new file mode 100644
index 000000000000..477dac5f2a2e
Binary files /dev/null and b/localization/de/typeobjectpattern/etc/typeobjectpattern.urm.png differ
diff --git a/localization/de/update-method/etc/update-method.urm.png b/localization/de/update-method/etc/update-method.urm.png
new file mode 100644
index 000000000000..ddc47b5fe145
Binary files /dev/null and b/localization/de/update-method/etc/update-method.urm.png differ
diff --git a/localization/de/value-object/etc/value-object.png b/localization/de/value-object/etc/value-object.png
new file mode 100644
index 000000000000..69a244c80691
Binary files /dev/null and b/localization/de/value-object/etc/value-object.png differ
diff --git a/localization/de/visitor/etc/visitor.png b/localization/de/visitor/etc/visitor.png
new file mode 100644
index 000000000000..5bbee60eeabf
Binary files /dev/null and b/localization/de/visitor/etc/visitor.png differ
diff --git a/localization/de/visitor/etc/visitor_1.png b/localization/de/visitor/etc/visitor_1.png
new file mode 100644
index 000000000000..de5285d7fdc3
Binary files /dev/null and b/localization/de/visitor/etc/visitor_1.png differ