Create README.md

docs: Translate Step Builder into German
#2275

Author: sieberss

localization/de/step-builder/README.md

@@ -0,0 +1,218 @@
+---
+shortTitle: Step Builder
+category: Creational
+language: de
+tag:
+  - Code simplification
+  - Domain
+  - Encapsulation
+  - Extensibility
+  - Instantiation
+  - Interface
+---
+
+## Alternativbezeichnung
+
+* Fluent Builder
+
+## Zweck
+
+Das Step-Builder-Pattern ist eine erweiterte Technik, um komplexe Objekte übersichtlich und flexibel
+zu erzeugen. Es ist ideal für Szenarien, in denen die Objekterzeugung schrittweise und äußerst genau zu erfolgen hat.
+
+## Detaillierte Erklärung
+
+Vergleichsbeispiel:
+
+> Betrachten wir den Zusammenbau eines individuell konfigurierten Computers.
+Dafür sind mehrere Schritte nötig: Die CPU muss ausgewählt werden, ein Motherboard, dazu kommen
+Arbeitsspeicher, Grafikkarte und Festplatte, die nach und nach ins Gehäuse eingebaut werden müssen.
+Jeder Schritt folgt auf den anderen, bis schließlich ein funktionsfähiger Rechner entsteht.
+Dieser schrittweise Konstruktionsprozess entspricht dem Step-Builder-Pattern und sorgt dafür,
+dass alle nötigen Komponenten richtig zusammengebaut werden und anforderungsgemäß funktionieren.
+
+In einfachen Worten
+
+> Das Step-Builder-Pattern konstruiert komplexe Objekte nach und nach durch eine Reihe 
+definierter Schritte. Das macht den Vorgang übersichtlich und flexibel.
+
+Wikipedia sagt
+
+> Step Builder ist eine Variante des Builder-Patterns mit dem Ziel, eine flexible Lösung
+zur schrittweisen Konstruktion komplexer Objekte anzubieten. Sie ist besonders hilfreich,
+wenn ein Objekt viele Initialisierungsschritte benötigt, die der Klarheit und Flexibilität wegen
+einzeln abgearbeitet werden können.
+
+Ablaufdiagramm
+
+![Step Builder Ablaufdiagramm](/step-builder/etc/step-builder-sequence-diagram.png)
+
+## Programmbeispiel
+
+Als Erweiterung des Builder-Patterns führt Step Builder den Nutzer Schritt für Schritt durch
+den Erzeugungsprozess eines Objekts. Es werden immer nur die nächsten verfügbaren Schritte
+angezeigt, und die build-Methode ist erst dann verfügbar, wenn das Objekt tatsächlich bereit
+zum Bau ist.
+
+Betrachten wir eine Klasse `Character` mit vielen Attributen wie `name`, `fighterClass`, 
+`wizardClass`, `weapon`, `spell`, und `abilities`.
+
+```java
+public class Character {
+
+  private String name;
+  private String fighterClass;
+  private String wizardClass;
+  private String weapon;
+  private String spell;
+  private List<String> abilities;
+
+  public Character(String name) {
+    this.name = name;
+  }
+
+}
+```
+
+Die Konstruktion ist wegen der vielen Attribute komplex. Darum verwenden wir Step Builder.
+
+Wir schreiben eine Klasse `CharacterStepBuilder`, um den Benutzer durch den Konstruktionsprozess zu führen. 
+
+```java
+public class CharacterStepBuilder {
+
+  // neuer Builder startet mit dem Schritt Namensvergabe
+  public static NameStep newBuilder() {
+    return new CharacterSteps();
+  }
+
+}
+```
+
+Die Klasse `CharacterStepBuilder` enthält eine Reihe von Interfaces,
+die jeweils einen Schritt des Konstruktionsprozesses repräsentieren. Indem jedes Interface
+eine Methode für den folgenden Schritt deklariert, wird der Benutzer durch den Prozess geführt.
+
+```java
+// nach der Namensvergabe kommt die Auswahl der wizardClass oder fighterClass
+public interface NameStep {
+  ClassStep name(String name);
+}
+```
+
+```java
+// nach der Klassenwahl wird entweder eine Waffe oder ein Zauberspruch zugewiesen
+public interface ClassStep {
+  WeaponStep fighterClass(String fighterClass);
+  SpellStep wizardClass(String wizardClass);
+}
+
+// Weitere Schritte weggelassen
+```
+
+Die Klasse `Steps` implementiert all diese Interfaces und baut schließlich das `Character`-Object.
+
+```java
+private static class Steps implements NameStep, ClassStep, WeaponStep, SpellStep, BuildStep {
+
+  private String name;
+  private String fighterClass;
+  private String wizardClass;
+  private String weapon;
+  private String spell;
+  private List<String> abilities;
+
+  // Die Implementationen der Methoden für die einzelnen Schritte sind hier weggelassen
+
+  @Override
+  public Character build() {
+    return new Character(name, fighterClass, wizardClass, weapon, spell, abilities);
+  }
+}
+```
+
+Jetzt ist die Erzeugung eines `Character`-Objekts ein geführter Prozess.
+
+```java
+public static void main(String[] args) {
+
+    var warrior = CharacterStepBuilder
+            .newBuilder()
+            .name("Amberjill")
+            .fighterClass("Paladin")
+            .withWeapon("Sword")
+            .noAbilities()
+            .build();
+
+    LOGGER.info(warrior.toString());
+
+    var mage = CharacterStepBuilder
+            .newBuilder()
+            .name("Riobard")
+            .wizardClass("Sorcerer")
+            .withSpell("Fireball")
+            .withAbility("Fire Aura")
+            .withAbility("Teleport")
+            .noMoreAbilities()
+            .build();
+
+    LOGGER.info(mage.toString());
+
+    var thief = CharacterStepBuilder
+            .newBuilder()
+            .name("Desmond")
+            .fighterClass("Rogue")
+            .noWeapon()
+            .build();
+
+    LOGGER.info(thief.toString());
+}
+```
+
+Konsolenausgabe:
+
+```
+12:58:13.887 [main] INFO com.iluwatar.stepbuilder.App -- This is a Paladin named Amberjill armed with a Sword.
+12:58:13.889 [main] INFO com.iluwatar.stepbuilder.App -- This is a Sorcerer named Riobard armed with a Fireball and wielding [Fire Aura, Teleport] abilities.
+12:58:13.889 [main] INFO com.iluwatar.stepbuilder.App -- This is a Rogue named Desmond armed with a with nothing.
+```
+
+## Verwendung
+
+* Wenn die Konstruktion eines Objekts viele Initialisierungsschritte benötigt.
+* Wenn die Objektkonstruktion komplex ist und viele Parameter enthält.
+* Um einen übersichtlichen, lesbaren und wartbaren Objekterzeugungsprozess bereitzustellen.
+
+## Tutorials
+
+* [Step Builder (Marco Castigliego)](http://rdafbn.blogspot.co.uk/2012/07/step-builder-pattern_28.html)
+
+## Reale Anwendungen in Java
+* Komplexe Konfigurationseinstellungen in Java-Anwendungen.
+* Konstruktion von Objekten für Datenbankeinträge mit vielen Feldern.
+* Konstruktion von GUI-Elementen, wo jeder Schritt einen anderen Teil der Schnittstelle festlegt.
+
+## Vor- und Nachteile
+
+Vorteile
+
+* Code wird lesbarer und wartbarer durch übersichtliche und prägnante Objektkonstruktion.
+* Erhöhte Flexibilität bei der Objekterzeugung durch Varianten im Konstruktionsprozess.
+* Unterstützt unveränderbare Objekte durch Abtrennung ihrer Erzeugung.ntation.
+
+Nachteile
+
+* Code kann durch zusätzliche Klassen und Interfaces komplexer werden.
+* Langatmiger Code bei vielen Konstruktionsschritten.
+
+## Verwandte Patterns
+
+* [Builder](https://java-design-patterns.com/patterns/builder/): Beide Patterns dienen der Konstruktion komplexer Objekte. Step Builder ist eine Variante mit Betonung auf schrittweisem Vorgehen.
+* [Fluent Interface](https://java-design-patterns.com/patterns/fluentinterface/): Wird oft zusammen mit Step Builder verwendet, um eine sprechende API mit Methodenverkettung zur Konstruktion bereitzustellen.
+* [Factory Method](https://java-design-patterns.com/patterns/factory-method/): Wird manchmal im Step-Builder-Pattern genutzt, um die Konstruktion des Builders selbst zu kapseln.
+
+## Quellen
+
+* [Clean Code: A Handbook of Agile Software Craftsmanship](https://amzn.to/3wRnjp5)
+* [Effective Java](https://amzn.to/4cGk2Jz)
+* [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)