5. Design Patterns 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2c7f34e7",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Design Patterns (Teil 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87715655",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die folgenden Patterns stammen alle aus dem Buch \"Entwurfsmuster. Elemente wiederverwendbarer objektorientierter Software ist ein 1994 von Erich Gamma, Richard Helm, Ralph Johnson und John Vlissides\". Erklärungen und Beispiele finden sich auch hier: [https://refactoring.guru/design-patterns](https://refactoring.guru/design-patterns)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16cf1315",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Observer Pattern"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3390b771",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die `Subject` Klasse beschreibt jene Objekte, die beobachtet werden sollen. Ein `Subject` muss wissen, von wem es beobachtet wird; dies wird in einer Datenstruktur (z.B. Liste) gespeichert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b4a9203",
   "metadata": {},
   "outputs": [],
   "source": [
    "interface Subject {\n",
    "  void attach(Observer o);\n",
    "  void detach(Observer o);\n",
    "  void notifyObservers();\n",
    "  \n",
    "  String getName();\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eea060c3",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die `Subject`s müssen über die Beobachter nichts wissen, ausser wie man sie von einer Zustandsänderung informiert. Dies wird durch das `Observer`-Interface beschrieben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7ce02f1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface Observer {\n",
    "    void update(Subject s);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d0c6174",
   "metadata": {},
   "source": [
    "Dieses Interface kann nun von konkreten Beobachtern implementiert werden, die dann mit der Information dass sich das `Subject` geändert hat beliebig umgehen können. Als Beispiel wollen wir einfach nur ausgeben, dass sich der Zustand verändert hat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5036d63c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteObserver implements Observer {\n",
    "    @Override\n",
    "    public void update(Subject s) {\n",
    "        System.out.println(\"I have just been notified by \" + s.getName());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2f3bdf4",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Implementierung eines `Subject`s fügt Zustand und Verhalten hinzu; die Verwaltung der Observer ist bereits in unserer abstrakten Oberklasse implementiert. Unser Beispiel wird einfach nur den Namen als Zustand speichern. Wenn der Zustand sich ändert, werden die `Observer` informiert mit Hilfe der `notifyObservers` Methode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7b88e86",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteSubject implements Subject {\n",
    "    private List<Observer> observers = new ArrayList<>();\n",
    "\n",
    "    private String name;\n",
    "\n",
    "    public ConcreteSubject(String name) {\n",
    "        this.name = name;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public String getName() {\n",
    "        return name;\n",
    "    }\n",
    "\n",
    "    public void rename(String newName) {\n",
    "        name = newName;\n",
    "        notifyObservers();\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void attach(Observer o) {\n",
    "        observers.add(o);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void detach(Observer o) {\n",
    "        observers.remove(o);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void notifyObservers() {\n",
    "        for(Observer o : observers) {\n",
    "            o.update(this);\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6f0893f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "ConcreteSubject subjectA = new ConcreteSubject(\"A\");\n",
    "ConcreteSubject subjectB = new ConcreteSubject(\"B\");\n",
    "ConcreteObserver observer = new ConcreteObserver();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33f48a79",
   "metadata": {},
   "source": [
    "Observer müssen sich explizit bei Subjects anmelden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39b99a1b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "subjectA.attach(observer);\n",
    "subjectB.attach(observer);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8d05124",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Jedes Mal wenn wir ein `ConcreteSubject` umbenennen, wird unser Observer informiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b68769c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "subjectA.rename(\"C\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b49ed63",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "subjectB.rename(\"D\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7081396",
   "metadata": {},
   "source": [
    "Weitere Beispiele: [https://refactoring.guru/design-patterns/observer](https://refactoring.guru/design-patterns/observer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41f93277",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Composite"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee97f39",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein Composite beschreibt eine Hierarchie von Objekten, bei der wir alle Objekte, egal ob sie eigene Teile (Leafs) sind oder nur aus anderen bestehen (Composite) gleich verwenden können. Alle Klassen implementieren ein generelles Interface mit den Operationen, die auf den Bestandteilen des Composites ausführbar sein sollen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f255ad5b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface Component {\n",
    "    void doTheOperation();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e22ab00",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein Leaf implementiert nur die Funktionalität des `Component` Interfaces, aber hat keine eigenen Kinder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c60ddc3",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Leaf implements Component {\n",
    "    private String name;\n",
    "\n",
    "    public Leaf(String name) {\n",
    "        this.name = name;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void doTheOperation() {\n",
    "        System.out.println(\"Operation invoked on leaf \"+name);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaf23bf8",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein Composite verwaltet eine Sammlung von Kindern, und das Ausführen der Operation besteht daraus, die Operation auf allen Kindern durchzuführen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4ca77ac",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Composite implements Component {\n",
    "    private List<Component> components = new ArrayList<>();\n",
    "\n",
    "    public void add(Component c) {\n",
    "        components.add(c);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void doTheOperation() {\n",
    "        System.out.println(\"Invoked on composite\");\n",
    "        for(Component c : components) {\n",
    "            c.doTheOperation();\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f4ccb6d",
   "metadata": {},
   "source": [
    "Als Beispiel erstellen wir ein Composite (`comp1`), das aus zwei weiteren Composites besteht (`comp2`, `comp3`), die jeweils aus diversen Leaves bestehen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36810a6b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "Leaf leaf1 = new Leaf(\"A\");\n",
    "Leaf leaf2 = new Leaf(\"B\");\n",
    "Leaf leaf3 = new Leaf(\"C\");\n",
    "Leaf leaf4 = new Leaf(\"D\");\n",
    "Leaf leaf5 = new Leaf(\"E\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31d279e3",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Composite comp1 = new Composite();\n",
    "Composite comp2 = new Composite();\n",
    "Composite comp3 = new Composite();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a10c6eff",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "comp1.add(comp2);\n",
    "comp1.add(comp3);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "39401e69",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "comp2.add(leaf1);\n",
    "comp2.add(leaf2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbe48609",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "comp3.add(leaf3);\n",
    "comp3.add(leaf4);\n",
    "comp3.add(leaf5);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f77c95a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir können unsere Funktionalität, dargestellt durch `doTheOperation` auf allen Bestandteilen ausführen, egal ob sie Composites oder Leaves sind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cbb082a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "leaf1.doTheOperation()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b40e59a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nachdem `comp1` das äusserste Element unserer Hierarchie ist, wird die Operation auf allen Bestandteilen ausgeführt, wenn wir sie auf `comp1` ausführen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba0e9159",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "comp1.doTheOperation();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b2db9ac",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Composite Beispiel: Maze"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2bddd93",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Basierend auf dem Beispiel auf den Vorlesungs-Slides entwerfen wir ein Composite, das aus den Bestandteilen eines Mazes besteht."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a439a27",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public interface MapSite {\n",
    "    void draw();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a8e1db5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Door implements MapSite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Door\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfb79a60",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Wall implements MapSite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Wall\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76f3ebea",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "abstract class Composite implements MapSite {\n",
    "    protected List<MapSite> elements = new ArrayList<>();\n",
    "\n",
    "    public void add(MapSite x) {\n",
    "        elements.add(x);\n",
    "    }\n",
    "\n",
    "    public void remove(MapSite x) {\n",
    "        elements.remove(x);\n",
    "    }\n",
    "\n",
    "    public MapSite getChild(int x) {\n",
    "        return elements.get(x);\n",
    "    }\n",
    "\n",
    "    public int size() {\n",
    "        return elements.size();\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        elements.forEach(e -> e.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dc0f9f6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Room extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Room consisting of:\");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f86c5b69",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Maze extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Maze consisting of: \");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4c5a142",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Um ein `Maze` zu erzeugen, müssen wir alle Komponenten einzeln erzeugen und zusammenbauen (das ist umständlich, und deshalb schauen wir uns dann auch gleich Erzeugungsmuster an)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e678ba74",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public void demo() {\n",
    "    Maze maze = new Maze();\n",
    "    Room room1 = new Room();\n",
    "    Room room2 = new Room();\n",
    "    room1.add(new Wall());\n",
    "    room1.add(new Wall());\n",
    "    room1.add(new Wall());\n",
    "    room1.add(new Wall());\n",
    "    room2.add(new Wall());\n",
    "    room2.add(new Wall());\n",
    "    room2.add(new Wall());\n",
    "    room2.add(new Wall());\n",
    "    room1.add(new Door());\n",
    "    room2.add(new Door());\n",
    "\n",
    "    maze.add(room1);\n",
    "    maze.add(room2);\n",
    "\n",
    "    maze.draw();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0241be3",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Der Output ist natürlich nicht wirklich ein graphisches Labyrinth, aber wir können die hierarchische Struktur erkennen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11dd5bc7",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7131ac38",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Decorator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0660beed",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wenn wir neue Funktionalität auf mehrere Elemente unserer Klassenhierarchie anwenden wollen, kann es passieren dass die Hierarchie stark wachsen muss; statt eine neue Unterklasse zu erzeugen erlaubt es uns das Decorator Pattern auch, einfach eine generelle Klasse für die neue Funktionalität zu definieren, und damit beliebige Elemente der Hierarchie zu \"dekorieren\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99b4ffd9",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Gegeben sei zunächst das Interface der Art von Komponenten die wir dekorieren wollen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14d07197",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "interface Component {\n",
    "    public void doIt();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb924bda",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Konkrete Komponenten implementieren dieses Interface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbb7f8eb",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class A implements Component {\n",
    "    public void doIt() {\n",
    "        System.out.println(\"Doing A\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cbde62c",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Ein Decorator implementiert das gleiche Interface, und enthält eine Referenz auf das dekorierte Objekt. Abgesehen von der neuen Funktionalität (`X`) wird einfach an das dekorierte Objekt weitergeleitet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f2bf99e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class AWithX implements Component {\n",
    "    private Component anA;\n",
    "\n",
    "    public AWithX(Component anA) {\n",
    "        this.anA = anA;\n",
    "    }\n",
    "\n",
    "    public void doIt() {\n",
    "        System.out.println(\"Doing X\");\n",
    "        anA.doIt();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b86a6c3",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Unterschiedliche Funktionalität (`Y`) kann einfach in unterschiedlichen Decorators implementiert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4414e972",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class AWithY implements Component  {\n",
    "    private Component anA;\n",
    "\n",
    "    public AWithY(Component anA) {\n",
    "        this.anA = anA;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void doIt() {\n",
    "        System.out.println(\"Doing Y\");\n",
    "        anA.doIt();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90f64b85",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Hier zunächst die originale Komponente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccbd4964",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "Component a = new A()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d691309",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "...die wir nun dekorieren können:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c6fa116",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Component ax = new AWithX(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53329115",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Component ay = new AWithY(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f85d798a",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Je nachdem, ob wir die Komponente oder einen Decorator aufrufen, erhalten wir nur die Originalfunktionalität, oder die dekorierte Funktionalität."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d6b70d1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a.doIt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74154495",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ax.doIt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c14d6d64",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ay.doIt()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af18a618",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun wenden wir dieses Muster noch auf unser Maze-Beispiel an. Ein `Decorator` ist eine `MapSite`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7ff85ad",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "abstract class Decorator implements MapSite {\n",
    "\n",
    "    protected MapSite wrappedElement;\n",
    "\n",
    "    public Decorator(MapSite site) {\n",
    "        this.wrappedElement = site;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e093e90",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein konkreter Decorator muss nun die abstrakte Methode `draw` implementieren, und dabei die Weiterleitung an das Originalobjekt übernehmen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "414ae202",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MagicMapSite extends Decorator {\n",
    "    public MagicMapSite(MapSite site) {\n",
    "        super(site);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"****************\");\n",
    "        System.out.print(\"Magic: \");\n",
    "        wrappedElement.draw();\n",
    "        System.out.println(\"****************\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "716fec02",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Anwendung ist wieder gleich wie beim vorherigen Beispiel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c50380d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "Door door = new Door()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "964b8afd",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MagicMapSite magicDoor = new MagicMapSite(door)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "224e3ba1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "door.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff922c3c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "magicDoor.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cedf080d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Factory Method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1755e0c",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir betrachten nun Erzeugsungsmuster, um die Erzeugung unseres Labyrinths zu vereinfachen. Eine Factory Methode ist eine einfache Art, die Entscheidung welches konkrete Objekt erzeugt wird konfigurierbar zu machen. Angenommen wir haben eine Funktionalität `doOperation` in der ein Integer-Wert erzeugt werden soll. Statt diesen Wert direkt in der Methode zu erzeugen, können wir die Erzeugung in eine abstrakte Methode auslagern. Damit können wir für unterschiedliche Szenarien unterschiedliche Varianten (=Unterklassen) implementieren diesen Wert zu erzeugen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d0fbb42",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "abstract class Creator {\n",
    "    abstract protected int factoryMethod();\n",
    "\n",
    "    public void doOperation() {\n",
    "        int x = factoryMethod();\n",
    "        System.out.println(\"The value is: \"+x);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dfc121b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteCreatorA extends Creator {\n",
    "    @Override\n",
    "    protected int factoryMethod() {\n",
    "        return 0;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5832a51d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteCreatorB extends Creator {\n",
    "    @Override\n",
    "    protected int factoryMethod() {\n",
    "        return 100;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c927089",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die beiden Beispiel-Erzeuger implementieren die identische Funktionalität, und unterscheiden sich nur in der Factory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f0d2e9ec",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "ConcreteCreatorA ca = new ConcreteCreatorA();\n",
    "ConcreteCreatorB cb = new ConcreteCreatorB();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e5abe98",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ca.doOperation();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d9599e2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "cb.doOperation();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a12c3fc",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun übertragen wir das auf unser Maze-Beispiel: Angenommen, wir wollen das gleiche Maze mit unterschiedlichen Türen erzeugen können; wir lagern dazu die Erzeugung einer konkreten Door in eine Factory Methode aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33a8d503",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "MapSite createDoor() {\n",
    "    return new Door();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcd37034",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Unsere Methode zur Erzeugung des Labyrinths muss dann noch statt des Konstruktors diese Factory-Methode verwenden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d50a20c2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "public void demo() {\n",
    "    Maze maze = new Maze();\n",
    "    Room room1 = new Room();\n",
    "    Room room2 = new Room();\n",
    "    room1.add(new Wall());\n",
    "    room1.add(new Wall());\n",
    "    room1.add(new Wall());\n",
    "    room1.add(new Wall());\n",
    "    \n",
    "    room2.add(new Wall());\n",
    "    room2.add(new Wall());\n",
    "    room2.add(new Wall());\n",
    "    room2.add(new Wall());\n",
    "    \n",
    "    room1.add(createDoor());\n",
    "    room2.add(createDoor());\n",
    "\n",
    "    maze.add(room1);\n",
    "    maze.add(room2);\n",
    "\n",
    "    maze.draw();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d93f0b58",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Zunächst die Variante mit der normalen Door."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46a8d205",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9a03645",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun wechseln wir die Door aus gegen eine dekorierte, \"magische\" Tür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0347c049",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "MapSite createDoor() {\n",
    "    return new MagicMapSite(new Door());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3742b0e",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ohne Änderung des Codes zur Erzeugung des Labyrinths enthält das Resultat nun \"magische Türen\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab5afdbe",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "demo()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac9ac7f2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Abstract Factory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92cedeb2",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wenn wir nun von der Erzeugung der Door zu allen Elementen unserer Hierarchie verallgemeinern, erhalten wir eine Abstract Factory. Gegeben eine Element-Hierarchie bestehend aus 2 Arten von Komponenten, von denen es jeweils 2 konkrete Ausprägungen gibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49abfd54",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface AbstractProductA {\n",
    "    String getValue();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55865c79",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface AbstractProductB {\n",
    "    String getValue();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90e95d44",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteProductA1 implements AbstractProductA {\n",
    "    @Override\n",
    "    public String getValue() {\n",
    "        return \"Product A 1\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cb3f9a4",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteProductA2 implements AbstractProductA {\n",
    "    @Override\n",
    "    public String getValue() {\n",
    "        return \"Product A 2\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3006a92a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteProductB1 implements AbstractProductB {\n",
    "    @Override\n",
    "    public String getValue() {\n",
    "        return \"Product B 1\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a0c312d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteProductB2 implements AbstractProductB {\n",
    "    @Override\n",
    "    public String getValue() {\n",
    "        return \"Product B 2\";\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f638129b",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Eine Abstract Factory muss für jede Art von Komponente eine eigene Factory-Methode definieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8272ad54",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface AbstractFactory {\n",
    "    AbstractProductA createProductA();\n",
    "    AbstractProductB createProductB();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f01fb1ce",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun können unterschiedliche konkrete Implementierungen der Abstract Factory unterschiedliche konkrete Varianten der Komponenten erzeugen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d059df9",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteFactory1 implements AbstractFactory {\n",
    "    @Override\n",
    "    public AbstractProductA createProductA() {\n",
    "        return new ConcreteProductA1();\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public AbstractProductB createProductB() {\n",
    "        return new ConcreteProductB1();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c161d5bc",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteFactory2 implements AbstractFactory {\n",
    "    @Override\n",
    "    public AbstractProductA createProductA() {\n",
    "        return new ConcreteProductA2();\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public AbstractProductB createProductB() {\n",
    "        return new ConcreteProductB2();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8e7247f",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Gegeben ein Kontext in dem die Factory verwendet wird."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cf2e31b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public void printProducts(AbstractFactory factory) {\n",
    "    AbstractProductA a = factory.createProductA();\n",
    "    AbstractProductB b = factory.createProductB();\n",
    "    System.out.println(\"A: \"+a.getValue()+\", B: \"+b.getValue());\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "097888d6",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Je nach Factory ist die Ausgabe unterschiedlich."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69b18ce3",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ConcreteFactory1 factory1 = new ConcreteFactory1();\n",
    "ConcreteFactory2 factory2 = new ConcreteFactory2();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "979287b1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "printProducts(factory1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04ca9f7c",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "printProducts(factory2);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd94b2dd",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Übertragen auf unser Maze-Beispiel benötigen wir beispielsweise Methoden für Räume, Türen, Wände."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78aba672",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "interface MazeFactory {\n",
    "  Room createRoom();\n",
    "  MapSite createDoor();\n",
    "  MapSite createWall();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c765fafa",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Aus Anwendersicht werden nun die Aufrufe der Konstruktoren bzw. Factory-Methoden zu Aufrufen einer übergebenen Factory geändert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2a993e9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "public void demo(MazeFactory factory) {\n",
    "    Maze maze = new Maze();\n",
    "    Room room1 = factory.createRoom();\n",
    "    Room room2 = factory.createRoom();\n",
    "    room1.add(factory.createWall());\n",
    "    room1.add(factory.createWall());\n",
    "    room1.add(factory.createWall());\n",
    "    room1.add(factory.createWall());\n",
    "    \n",
    "    room2.add(factory.createWall());\n",
    "    room2.add(factory.createWall());\n",
    "    room2.add(factory.createWall());\n",
    "    room2.add(factory.createWall());\n",
    "    \n",
    "    room1.add(factory.createDoor());\n",
    "    room2.add(factory.createDoor());\n",
    "\n",
    "    maze.add(room1);\n",
    "    maze.add(room2);\n",
    "\n",
    "    maze.draw();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10a38701",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Hier eine Factory, die alle Komponenten in der Standardversion erzeugt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccee1e51",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class DefaultFactory implements MazeFactory {\n",
    "    public Room createRoom() {\n",
    "      return new Room();\n",
    "    }\n",
    "    \n",
    "    public MapSite createDoor() {\n",
    "      return new Door();\n",
    "    }\n",
    "    \n",
    "    public MapSite createWall() {\n",
    "      return new Wall();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19c633be",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "demo(new DefaultFactory())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fab25db8",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Und hier eine Version, die dekorierte Varianten erzeugt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eba01426",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class MagicFactory implements MazeFactory {\n",
    "    public Room createRoom() {\n",
    "      return new Room();\n",
    "    }\n",
    "    \n",
    "    public MapSite createDoor() {\n",
    "      return new MagicMapSite(new Door());\n",
    "    }\n",
    "    \n",
    "    public MapSite createWall() {\n",
    "      return new MagicMapSite(new Wall());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b21604ae",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "demo(new MagicFactory())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "795bb533",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Builder"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e873523",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Auch wenn uns der Factory-Ansatz erlaubt die Arten der Komponenten auszutauschen, fehlt uns noch die Flexibilität die Struktur des Labyrinths zu verändern. Hierbei hilft das Builder-Pattern. Zunächst ein einfaches Beispiel, das die Konstruktion einer Liste an Integers vereinfachen soll."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cc9da2d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface Builder {\n",
    "    Builder addNumber(int x);\n",
    "    List<Integer> getProduct();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e078ade5",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein konkreter Builder besteht aus Methoden um das Konstrukt zu erweitern (`addNumber`), und einer Methode um das finale Produkt abzufragen (`getProduct`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48ae030e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class ConcreteBuilder implements Builder {\n",
    "    private List<Integer> theList = new ArrayList<>();\n",
    "\n",
    "    @Override\n",
    "    public Builder addNumber(int x) {\n",
    "        theList.add(x);\n",
    "        return this;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public List<Integer> getProduct() {\n",
    "        return theList;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a7fdc55",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Dadurch, dass die Methoden des `Builder`s den `Builder` selbst zurückgeben, kann die Erzeugung in Ketten von Methodenaufrufen erfolgen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7438f9b0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "ConcreteBuilder builder = new ConcreteBuilder();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e509ade9",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "builder.addNumber(5).addNumber(10).addNumber(100);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44405e6a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " System.out.println(builder.getProduct());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8778f82b",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "ConcreteBuilder builder = new ConcreteBuilder();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b4bd271",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "builder.addNumber(10).addNumber(20).addNumber(30);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30c561bf",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " System.out.println(builder.getProduct());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74df5753",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir wenden das Pattern nun wieder auf unser Maze-Beispiel an."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c692a54",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "interface Builder {\n",
    "    Builder withWall();\n",
    "    Builder withDoor();\n",
    "    Builder buildRoom();\n",
    "    \n",
    "    Maze getMaze();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "add7a195",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MazeBuilder implements Builder {\n",
    "    private Maze maze = new Maze();\n",
    "    private Room currentRoom = null;\n",
    "    \n",
    "    public Maze getMaze() {\n",
    "        return maze;\n",
    "    }\n",
    "    \n",
    "    public Builder buildRoom() {\n",
    "        currentRoom = new Room();\n",
    "        maze.add(currentRoom);        \n",
    "        return this;\n",
    "    }\n",
    "    \n",
    "    public Builder withDoor() {\n",
    "        currentRoom.add(new Door());\n",
    "        return this;\n",
    "    }\n",
    "\n",
    "    public Builder withWall() {\n",
    "        currentRoom.add(new Wall());\n",
    "        return this;\n",
    "    }    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e39a360",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die Erzeugung kann nun als Verkettung von Builder-Aufrufen geschehen. Dies gibt uns prinzipiell auch die Flexibilität, die Konstruktur zur Laufzeit erst zu entscheiden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64ee804f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public void demo(Builder builder) {\n",
    "    builder.buildRoom().withDoor().withWall().withWall().withWall().withWall();\n",
    "    builder.buildRoom().withDoor().withWall().withWall().withWall().withWall();\n",
    "    Maze maze = builder.getMaze();\n",
    "    maze.draw();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4372046",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "Builder builder = new MazeBuilder();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d69e2488",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "demo(builder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65dd61f8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Prototype"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72c02b55",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein alternativer Ansatz zur Erzeugung komplexer Objektstrukturen liegt darin, ein bestehendes komplexes Objekt zu kopieren, und die Kopie dann anzupassen. Im Prototype-Pattern wird von einem Prototyp-Objekt also eine tiefe Kopie erzeugt. Wir erweitern dazu das `MapSite` Interface um eine `clone` Methode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "218e8e7e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface MapSite<T extends MapSite> {\n",
    "    void draw();\n",
    "    T clone();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c08afbcd",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Für Leaf-Objekte in unserer Hierarchie wird diese Methode einfach so implementiert, dass wir ein neues (und damit identisches) Objekt erzeugen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f8d550c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "public class TheDoor implements MapSite<TheDoor> {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Door\");\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public TheDoor clone() {\n",
    "        return new TheDoor();        \n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6638c9c8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class TheWall implements MapSite<TheWall> {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Wall\");\n",
    "    }\n",
    "    \n",
    "    public TheWall clone() {\n",
    "        return new TheWall();\n",
    "    }    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b5ecf4d",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Schwieriger ist der Fall eines Composites: Hier müssen Kopien aller Kinder-Objekte erzeugt werden. Wir definieren uns dazu eine neue abstrakte Klasse `MazeComposite`, die zur bestehenden Funktionalität des bisherigen Composites noch die `clone` Methode verlangt. (Wir müssen die neuen `Composite` und `Maze` Klassen leider umbenennen damit das Jupyter Notebook damit glücklich wird)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03cd48fc",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public abstract class MazeComposite<T extends MazeComposite> implements MapSite<T> {\n",
    "    protected List<MapSite> elements = new ArrayList<>();\n",
    "\n",
    "    public void add(MapSite x) {\n",
    "        elements.add(x);\n",
    "    }\n",
    "\n",
    "    public void remove(MapSite x) {\n",
    "        elements.remove(x);\n",
    "    }\n",
    "\n",
    "    public MapSite getChild(int x) {\n",
    "        return elements.get(x);\n",
    "    }\n",
    "\n",
    "    public int size() {\n",
    "        return elements.size();\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        elements.forEach(e -> e.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public abstract T clone();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37ea0900",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein `Maze` ist ein Composite; das Klonen besteht einfach daraus, eine neue Liste zu erzeugen, und darin Kopien hinzuzufügen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b7f6723",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class TheMaze extends MazeComposite<TheMaze> {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Maze consisting of: \");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public TheMaze clone() {\n",
    "        TheMaze copy = new TheMaze();\n",
    "        for (MapSite element : elements) {\n",
    "            copy.add(element.clone());\n",
    "        }\n",
    "        return copy;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89152225",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Auch ein Raum ist ein Composite und muss die neue abstrakte Klasse erweitern (und wir müssen die Klasse daher anders benennen, damit Jupyter glücklich ist)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e880616",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class TheRoom extends MazeComposite<TheRoom> {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        System.out.println(\"Room consisting of:\");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    @Override\n",
    "    public TheRoom clone() {\n",
    "        TheRoom copy = new TheRoom();\n",
    "        for (MapSite element : elements) {\n",
    "            copy.add(element.clone());\n",
    "        }\n",
    "        return copy;\n",
    "    }    \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbc6b1b5",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nachdem wir die Klassen umbenannt haben muss sich auch das Builder-Interface anpassen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "939575a6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "interface Builder {\n",
    "    Builder withWall();\n",
    "    Builder withDoor();\n",
    "    Builder buildRoom();\n",
    "    \n",
    "    TheMaze getMaze();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deafaaf3",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "...wie auch die Implementierung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b084895",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MazeBuilder implements Builder {\n",
    "    private TheMaze maze = new TheMaze();\n",
    "    private TheRoom currentRoom = null;\n",
    "    \n",
    "    public TheMaze getMaze() {\n",
    "        return maze;\n",
    "    }\n",
    "    \n",
    "    public Builder buildRoom() {\n",
    "        currentRoom = new TheRoom();\n",
    "        maze.add(currentRoom);        \n",
    "        return this;\n",
    "    }\n",
    "    \n",
    "    public Builder withDoor() {\n",
    "        currentRoom.add(new TheDoor());\n",
    "        return this;\n",
    "    }\n",
    "\n",
    "    public Builder withWall() {\n",
    "        currentRoom.add(new TheWall());\n",
    "        return this;\n",
    "    }    \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3a0c690",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "MazeBuilder builder = new MazeBuilder();\n",
    "builder.buildRoom().withDoor().withWall().withWall().withWall().withWall();\n",
    "builder.buildRoom().withDoor().withWall().withWall().withWall().withWall();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3252c347",
   "metadata": {},
   "source": [
    "`thisMaze` sei nun das Prototyp-Objekt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40ab3ae5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "TheMaze thisMaze = builder.getMaze()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "808c4b46",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "`otherMaze` ist der Klon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04e76454",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "TheMaze otherMaze = builder.getMaze().clone()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e64a1266",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun ist es einfach, dem Klon einen weiteren Raum hinzuzufügen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6dae055",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "otherMaze.add(new TheRoom())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97bc360c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "thisMaze.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4405ab5",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "otherMaze.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4454002d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Singleton"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d34f97",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Angenommen wir wollen die Verteilung von magischen Items im Labyrinth zentral kontrollieren. Es darf also aus Konsistenzgründen nur eine `MazeFactory` geben. Wie kann man sicherstellen, dass die Klasse nur einmal instanziiert wird? Die Antwort ist das Singleton-Muster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "420343b2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class TheMazeFactory {\n",
    "    private TheMazeFactory() {}\n",
    "    \n",
    "    private static TheMazeFactory instance = null;\n",
    "  \n",
    "    public static TheMazeFactory getInstance() {\n",
    "        if (instance == null) {\n",
    "            instance = new TheMazeFactory();\n",
    "        }\n",
    "        return instance;\n",
    "    }\n",
    "\n",
    "  \n",
    "    public TheRoom createRoom() {\n",
    "        return new TheRoom();\n",
    "    }\n",
    "    \n",
    "    public MapSite createDoor() {\n",
    "        return new TheDoor();\n",
    "    }\n",
    "    \n",
    "    public MapSite createWall() {\n",
    "        return new TheWall();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64854e54",
   "metadata": {},
   "outputs": [],
   "source": [
    "TheMazeFactory factory = TheMazeFactory.getInstance();\n",
    "TheMaze newMaze = new TheMaze();\n",
    "TheRoom roomA = factory.createRoom();\n",
    "TheRoom roomB = factory.createRoom();\n",
    "roomA.add(factory.createWall());\n",
    "roomA.add(factory.createWall());\n",
    "roomA.add(factory.createWall());\n",
    "roomA.add(factory.createWall());\n",
    "    \n",
    "roomB.add(factory.createWall());\n",
    "roomB.add(factory.createWall());\n",
    "roomB.add(factory.createWall());\n",
    "roomB.add(factory.createWall());\n",
    "    \n",
    "roomA.add(factory.createDoor());\n",
    "roomB.add(factory.createDoor());\n",
    "\n",
    "newMaze.add(roomA);\n",
    "newMaze.add(roomB);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f7c032",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir können die Variante unserer `demo` Funktion anpassen, der wir bisher eine `MazeFactory` übergeben haben. Da es global nur mehr eine einzige Factory gibt, benötigen wir diesen Parameter nicht mehr."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b022faf5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "newMaze.draw();"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "22.0.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}