diff --git a/localization/de/README.md b/localization/de/README.md
index 0e33ffbfa712..b727e6ba47e1 100644
--- a/localization/de/README.md
+++ b/localization/de/README.md
@@ -1,69 +1,48 @@
-
-
# In Java implementierte Entwurfsmuster
-[](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)
+[](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)
[](#contributors-)
-In einer anderen Sprache 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)
# Einführung
-Entwurfschemas sind die besten formalisierten Praktiken, die ein Programmierer verwenden kann,
-um allgemeine Probleme beim Entwurf einer Anwendung oder eines Systems zu lösen.
+Entwurfsmuster sind bewährte Lösungen, die Entwickler nutzen können, um häufige Probleme beim Entwurf von Anwendungen oder Systemen zu lösen.
-Entwurfschemas können den Entwicklungsprozess beschleunigen, indem sie getestete und bewährte
-Entwicklungsparadigmen bereitstellen.
+Sie helfen dabei, den Entwicklungsprozess zu beschleunigen, indem sie erprobte und zuverlässige Ansätze bereitstellen.
-Die Wiederverwendung von Entwurfschemas hilft, subtile Fehler zu vermeiden, die größere
-Probleme verursachen können, sowie die Lesbarkeit des Codes für Programmierer und Architekten zu verbessern,
-welche mit den Prinzipien der Entwurfsmuster vertraut sind.
+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.
# Erste Schritte
-Auf dieser Seite werden Java Entwurfschemas vorgestellt. Die Lösungen wurden entwickelt von
-erfahrenen Programmierern und Architekten aus der Open-Source-Gemeinschaft. Die
-Schemas können anhand ihrer übergeordneten Beschreibungen oder anhand ihres
-Quellcodes durchsucht werden. Die Quellcode-Beispiele sind gut kommentiert und können als
-Programmiertutorials zur Implementierung eines bestimmten Schemas angesehen werden. Wir verwenden die am besten
-bekannten und erprobtesten Open-Source Java-Technologien.
+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.
-Bevor Sie in die Materie der Entwurfschemas eintauchen, sollten sie sich mit den verschiednen
-[Software-Entwurfsprinzipien](https://java-design-patterns.com/principles/) auseinandersetzen.
+Bevor Sie sich mit den Entwurfsmustern beschäftigen, sollten Sie sich mit den grundlegenden [Software-Entwurfsprinzipien](https://java-design-patterns.com/principles/) vertraut machen.
-Alle Entwürfe sollten so einfach wie möglich gehalten werden. Sie sollten mit KISS, YAGNI,
-und Do The Simplest Thing That Could Possibly Work prinzipen anfangen. Komplexe Entwurfschemas sollen nur eingesetzt werden, wenn diese für sinnvolle Erweiterungen benötigt werden.
+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.
-Sobald sie mit diesen Konzepten vertraut sind, können sie beginnen, sich mit den [verfügbaren Entwurfschemas](https://java-design-patterns.com/patterns/) auseinanderzusetzen, durch einen
-der folgenden Ansätze
+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:
- - Nach einem bestimmten Schema anhand des Namens suchen.
- Sie können keins finden? Bitte melden sie ein neues Schema [hier](https://github.com/iluwatar/java-design-patterns/issues).
- - Verwendung von Tags wie `Performance`, `Gang of Four` oder `Data access`.
- - Verwendung von Entwurfschema-Kategorien wie `Creational`, `Behavioral` und andere.
+- 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.
-Hoffentlich finden sie die auf dieser Website vorgestellten objektorientierten Lösungen
-für ihre Architekturen nützlich und dass sie genauso viel Spaß beim Lernen haben, wie wir bei ihrer Entwicklung hatten.
+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.
-# Wie man bei diesem Projekt mitwirken kann
+# Mitwirken
-Wenn sie zu dem Projekt beitragen wollen, finden sie die entsprechenden Informationen in
-unserem [Entwickler-Wiki](https://github.com/iluwatar/java-design-patterns/wiki).mWir helfen Ihnen
-gerne und beantworten ihre Fragen im [Gitter chatroom](https://gitter.im/iluwatar/java-design-patterns).
+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.
# Lizenz
-Dieses Projekt steht unter den Bedingungen der MIT-Lizenz.
-
+Dieses Projekt steht unter der MIT-Lizenz.
\ No newline at end of file
diff --git a/localization/de/abstract-document/README.md b/localization/de/abstract-document/README.md
new file mode 100644
index 000000000000..13f8d26fbbbf
--- /dev/null
+++ b/localization/de/abstract-document/README.md
@@ -0,0 +1,226 @@
+---
+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
+language: de
+tag:
+ - Abstraktion
+ - Entkopplung
+ - Dynamische Typisierung
+ - Kapselung
+ - Erweiterbarkeit
+ - Polymorphismus
+---
+
+## Absicht des Abstract Document Design Patterns
+
+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.
+
+## Detaillierte Erklärung des Abstract Document Patterns mit realen Beispielen
+
+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.
+
+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.
+
+In einfachen Worten
+
+> Das Abstract Document Pattern ermöglicht 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.
+
+## Programmatisches Beispiel des Abstract Document Patterns in Java
+
+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.
+
+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.
+
+```java
+public interface Document {
+
+ Void put(String key, Object value);
+
+ Object get(String key);
+
+ Stream children(String key, Function, T> constructor);
+}
+
+public abstract class AbstractDocument implements Document {
+
+ private final Map properties;
+
+ protected AbstractDocument(Map properties) {
+ Objects.requireNonNull(properties, "properties map is required");
+ this.properties = properties;
+ }
+
+ @Override
+ public Void put(String key, Object value) {
+ properties.put(key, value);
+ return null;
+ }
+
+ @Override
+ public Object get(String key) {
+ return properties.get(key);
+ }
+
+ @Override
+ public Stream children(String key, Function, T> constructor) {
+ return Stream.ofNullable(get(key))
+ .filter(Objects::nonNull)
+ .map(el -> (List>) el)
+ .findAny()
+ .stream()
+ .flatMap(Collection::stream)
+ .map(constructor);
+ }
+
+ // Andere 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.
+
+```java
+public enum Property {
+
+ PARTS, TYPE, PRICE, MODEL
+}
+
+public interface HasType extends Document {
+
+ default Optional getType() {
+ return Optional.ofNullable((String) get(Property.TYPE.toString()));
+ }
+}
+
+public interface HasPrice extends Document {
+
+ default Optional getPrice() {
+ return Optional.ofNullable((Number) get(Property.PRICE.toString()));
+ }
+}
+
+public interface HasModel extends Document {
+
+ default Optional getModel() {
+ return Optional.ofNullable((String) get(Property.MODEL.toString()));
+ }
+}
+
+public interface HasParts extends Document {
+
+ default Stream getParts() {
+ return children(Property.PARTS.toString(), Part::new);
+ }
+}
+```
+
+Jetzt sind wir bereit, das `Car` einzufü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: ");
+ car.getParts().forEach(p -> LOGGER.info("\t{}/{}/{}",
+ p.getType().orElse(null),
+ p.getModel().orElse(null),
+ p.getPrice().orElse(null))
+ );
+}
+```
+Die 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
+```
+## Abstract Document Pattern Klassendiagramm
+
+
+
+## Wann sollte das Abstract Document Pattern in Java verwendet werden?
+
+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:
+
+* **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.
+
+* **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.
+
+* **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.
+
+* **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.
+
+* **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.
+
+* **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.
+
+* **Dokumente haben vielfältige und sich entwickelnde Attributstrukturen.**
+
+* **Dynamisches Hinzufügen neuer Eigenschaften ist eine häufige Anforderung.**
+
+* **Entkopplung des Datenzugriffs von spezifischen Formaten ist entscheidend.**
+
+* **Wartbarkeit und Flexibilität sind entscheidend 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.
+
+## Vorteile und Abwägungen des Abstract Document Patterns
+
+**Vorteile:**
+
+* **Flexibilität**: Ermöglicht die Handhabung unterschiedlicher Dokumentstrukturen und -eigenschaften.
+* **Erweiterbarkeit**: Neue Attribute können dynamisch hinzugefügt werden, ohne bestehenden Code zu brechen.
+* **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:**
+
+* **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.
+
+## Quellen und Danksagungen
+
+* [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)
+* [Pattern-Oriented Software Architecture Volume 4: A Pattern Language for Distributed Computing (v. 4)](https://amzn.to/49zRP4R)
+* [Patterns of Enterprise Application Architecture](https://amzn.to/3WfKBPR)
+* [Abstract Document Pattern (Wikipedia)](https://en.wikipedia.org/wiki/Abstract_Document_Pattern)
+* [Dealing with Properties (Martin Fowler)](http://martinfowler.com/apsupp/properties.pdf)
+
+
+
+
+
diff --git a/localization/de/abstract-document/etc/abstract-document.png b/localization/de/abstract-document/etc/abstract-document.png
new file mode 100644
index 000000000000..6bc0b29a4e77
Binary files /dev/null and b/localization/de/abstract-document/etc/abstract-document.png differ