6. Design Patterns 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d5c0661d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Design Patterns 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9b924ae",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Bridge"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0110993",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Angenommen, wir wollen das Maze aus dem vorherigen Kapitel nun sowohl mit Java Swing als auch für Android implementieren. Hierzu muss die Funktionalität der `draw` Methode der `MapSite`s jeweils für Android und Swing implementiert werden, und das für jede Art von Maze-Komponente. Dies kann zu einer Grossen Anzahl an Unterklassen führen. Eine Alternative bietet das Bridge-Pattern: Die Maze-Komponenten interagieren mit einem abstrakten Implementor-Interface, das den Client von der konkreten Umsetzung (Android vs Swing) abstrahiert. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f8d80f5",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface MapRenderer {\n",
    "    void updateGUI(String element);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f836b168",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Von diesem Implementor-Interface gibt es nun verschiedene konkrete Umsetzungen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a819a74",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class PrintRenderer implements MapRenderer {\n",
    "    public void updateGUI(String element) {\n",
    "        System.out.println(element);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfbb725d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class SwingRenderer implements MapRenderer {\n",
    "    public void updateGUI(String element) {\n",
    "        // Code to handle Java Swing output\n",
    "        System.out.println(\"Java Swing: \"+element);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8b06a39",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class AndroidRenderer implements MapRenderer {\n",
    "    public void updateGUI(String element) {\n",
    "        // Code to handle Android output\n",
    "        System.out.println(\"Android: \"+element);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4d980ca",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Statt für jede Art von Output eine eigene Unterklasse von `MapSite` zu definieren, bekommt die `MapSite` eine Referenz auf ein Implementor-Objekt, und kann damit unabhängig von der Implementierung der GUI umgesetzt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72da35ae",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public abstract class MapSite {\n",
    "    protected MapRenderer impl;\n",
    "    \n",
    "    public MapSite(MapRenderer renderer) {\n",
    "        this.impl = renderer;\n",
    "    }\n",
    "\n",
    "    public MapSite() {\n",
    "        this(new PrintRenderer());\n",
    "    }\n",
    "\n",
    "    public abstract void draw();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a94cb658",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die konkreten Komponenten bedienen nun das `impl` Objekt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa25c4ff",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Door extends MapSite {\n",
    "\n",
    "    public Door() {\n",
    "        super();\n",
    "    }\n",
    "\n",
    "    public Door(MapRenderer renderer) {\n",
    "        super(renderer);\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Door\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fbf2445",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Wall extends MapSite {\n",
    "    \n",
    "    public Wall() {\n",
    "        super();\n",
    "    }\n",
    "\n",
    "    public Wall(MapRenderer renderer) {\n",
    "        super(renderer);\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Wall\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebd51225",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public abstract class Composite extends MapSite {\n",
    "    protected List<MapSite> elements = new ArrayList<>();\n",
    "\n",
    "        \n",
    "    protected Composite() {\n",
    "        super();\n",
    "    }\n",
    "\n",
    "    protected Composite(MapRenderer renderer) {\n",
    "        super(renderer);\n",
    "    }\n",
    "    \n",
    "    \n",
    "    public void add(MapSite x) {\n",
    "        elements.add(x);\n",
    "    }\n",
    "    \n",
    "    public List<MapSite> getChildren() {\n",
    "        return elements;\n",
    "    }\n",
    "  \n",
    "    @Override\n",
    "    public void draw() {\n",
    "        elements.forEach(e -> e.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c50575de",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Room extends Composite {\n",
    "    \n",
    "    public Room() {\n",
    "        super();\n",
    "    }\n",
    "\n",
    "    public Room(MapRenderer renderer) {\n",
    "        super(renderer);\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Room consisting of:\");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d3a5450",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Maze extends Composite {\n",
    "    \n",
    "    public Maze() {\n",
    "        super();\n",
    "    }\n",
    "\n",
    "    public Maze(MapRenderer renderer) {\n",
    "        super(renderer);\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Maze consisting of: \");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b419384d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nachdem wir `MapSite` so implementiert haben, dass per Default ein `PrintRenderer` verwendet wird, können wir wie gehabt unser Maze erzeugen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f6388a5",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "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();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ad8f44d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir können auch einfach den Renderer wechseln."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6efa9dbc",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "SwingRenderer renderer = new SwingRenderer();\n",
    "\n",
    "Maze maze = new Maze(renderer);\n",
    "Room room1 = new Room(renderer);\n",
    "Room room2 = new Room(renderer);\n",
    "room1.add(new Wall(renderer));\n",
    "room1.add(new Wall(renderer));\n",
    "room1.add(new Wall(renderer));\n",
    "room1.add(new Wall(renderer));\n",
    "room2.add(new Wall(renderer));\n",
    "room2.add(new Wall(renderer));\n",
    "room2.add(new Wall(renderer));\n",
    "room2.add(new Wall(renderer));\n",
    "room1.add(new Door(renderer));\n",
    "room2.add(new Door(renderer));\n",
    "\n",
    "maze.add(room1);\n",
    "maze.add(room2);\n",
    "\n",
    "maze.draw();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b7481d8",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Natürlich könnte man die Konfiguration des Renderers über die Creational Patterns noch schöner integrieren."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b414f94",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Facade"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba147b49",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir haben im obigen Beispiel keine tatsächliche Implementierung von `SwingRenderer` angegeben, und das mit gutem Grund: Um eine Swing-GUI zu verwenden muss eine Vielzahl an Klassen konfiguriert und verwendet werden. Das Facade-Entwurfsmuster versteckt diese Komplexität hinter einer Fassade, die ein einfacheres, abstrakteres Interface zur Verfügrung stellt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "977af8d2",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class SwingFacade {\n",
    "    public void drawWindow() {\n",
    "        // ...\n",
    "        // Actual Swing code\n",
    "        System.out.println(\"...simulating Swing code...\");\n",
    "    }\n",
    "    \n",
    "    public void renderText(String text) {\n",
    "        // ...\n",
    "        // Actual Swing code\n",
    "        System.out.println(\"...simulating Swing code...\");\n",
    "    }\n",
    "    \n",
    "    public void renderButtons() {\n",
    "        // ...\n",
    "        // Actual Swing code\n",
    "        System.out.println(\"...simulating Swing code...\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0db6564",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class SwingRenderer implements MapRenderer {\n",
    "    private SwingFacade facade = new SwingFacade();\n",
    "    \n",
    "    public void updateGUI(String element) {\n",
    "        facade.drawWindow();\n",
    "        facade.renderText(element);\n",
    "        facade.renderButtons();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfea1b2d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Door doorUsingFacade = new Door(new SwingRenderer());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d07b0838",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "doorUsingFacade.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59c3fab3",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Adapter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4811d1b9",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Angenommen es gibt bereits eine bestehende Komponente `WebRenderer`, die zwar genau die Funktionalität bietet, die wir in unserem Beispiel von Unterklassen des `MapRenderer` Interfaces erwarten, aber die Klasse `WebRenderer` implementiert dieses Interface nicht und hat anders benannte Methoden. Beispielsweise könnte diese Klasse aus einer verwendeten Bibliothek stammen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42bb7c20",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class WebRenderer {\n",
    "    void renderStuffOnTheWeb(String element) {\n",
    "        System.out.println(\"Web rendering of \" + element);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c69eabdf",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Das Adapter-Entwurfsmuster erlaubt uns, so eine Komponente in unsere Interfaces einzupassen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e414b3e1",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class WebRendererAdapter implements MapRenderer {\n",
    "    private WebRenderer adaptee = new WebRenderer();\n",
    "\n",
    "    @Override\n",
    "    public void updateGUI(String element) {\n",
    "        adaptee.renderStuffOnTheWeb(element);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "544456db",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Door door = new Door(new WebRendererAdapter());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b51be4cb",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "door.draw();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b19ef275",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Proxy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7311db6f",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Ein Proxy ist ein Wrapper-Objekt das vom Client wie das tatsächliche Objekt benutzt wird, und dabei den Zugriff auf das tatsächliche Objekt steuert. Als Beispiel verwenden wir einen Proxy um Lazy Initialisation durchzuführen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eefc5606",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class WebRendererProxy implements MapRenderer {\n",
    "    private MapRenderer realSubject = null;\n",
    "    \n",
    "    private void setupCostlyInitialisation() {\n",
    "        if (realSubject == null) {\n",
    "            System.out.println(\"Performing costly initialisation\");\n",
    "            realSubject = new WebRendererAdapter();\n",
    "        }\n",
    "    }\n",
    "   \n",
    "    public void updateGUI(String element) {\n",
    "        setupCostlyInitialisation();\n",
    "        realSubject.updateGUI(element);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "861cc938",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Der Proxy ist eine für den Client transparente Schicht zur tatsächlichen Implementierung; wir verwenden diese Schicht für Lazy Initialisation, andere Anwendungsbeispiele sind Remote Proxies, Logging Proxies, oder Zugriffskontrolle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6bde459",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Door door = new Door(new WebRendererProxy());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59a90084",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "door.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50c95c4c",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Visitor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0acc9613",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Angenommen wir wollen eine komplexe Objektstruktur um Funktionalität erweitern, ohne dabei die neue Funktionalität direkt in den Klassen der Objektstruktur zu implementieren. Beispielsweise könnten wir ein Maze als XML Code ausgeben lassen. Ein einfacher Ansatz wäre, die Funktionalität in eine eigene Klasse zu packen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b968f1fb",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class XMLConverter {\n",
    "    void visitDoor(Door door) {\n",
    "        // print out xml for door\n",
    "        System.out.println(\"Door\");\n",
    "    }\n",
    "    \n",
    "    void visitWall(Wall wall) {\n",
    "        // print out xml for wall\n",
    "        System.out.println(\"Wall\");\n",
    "    }\n",
    "\n",
    "    void visitRoom(Room room) {\n",
    "        // print out xml for room\n",
    "        System.out.println(\"Room\");\n",
    "\n",
    "    }\n",
    "\n",
    "    void visitMaze(Maze maze) {\n",
    "        // print out xml for maze\n",
    "        System.out.println(\"Maze\");\n",
    "    }  \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc498a7",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Das Problem dabei ist, wie wir entscheiden welche der Funktionen nun aufgerufen werden soll. Wenn wir in irgendeiner Form über unsere Objektstruktur iterieren, müssen wir dabei bei jedem Objekt aufgrund der Klasse entscheiden welche Funktion die passende ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cda8d28",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "XMLConverter converter = new XMLConverter();\n",
    "\n",
    "for (MapSite mapSite : Arrays.asList(maze, door)) {\n",
    "    if (mapSite instanceof Door) {\n",
    "        converter.visitDoor((Door) mapSite);\n",
    "    } else if (mapSite instanceof Wall) {\n",
    "        converter.visitWall((Wall) mapSite);\n",
    "    } else if (mapSite instanceof Room) {\n",
    "        converter.visitRoom((Room) mapSite);\n",
    "    } else if (mapSite instanceof Maze) {\n",
    "        converter.visitMaze((Maze) mapSite);\n",
    "    } \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "321c30be",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Das ist umständlich, und man fragt sich vielleicht warum man das nicht einfach mit dynamischem Typing löst:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7733bc71",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class XMLConverter {\n",
    "    void visit(Door door) {\n",
    "        // print out xml for door\n",
    "        System.out.println(\"Door\");\n",
    "    }\n",
    "    \n",
    "    void visit(Wall wall) {\n",
    "        // print out xml for wall\n",
    "        System.out.println(\"Wall\");\n",
    "\n",
    "    }\n",
    "\n",
    "    void visit(Room room) {\n",
    "        // print out xml for room\n",
    "        System.out.println(\"Room\");\n",
    "\n",
    "    }\n",
    "\n",
    "    void visit(Maze maze) {\n",
    "        // print out xml for maze\n",
    "        System.out.println(\"Maze\");\n",
    "    }  \n",
    "\n",
    "    void visit(MapSite mapsite) {\n",
    "        // fallback, we don't actually want this to be called\n",
    "        System.out.println(\"MapSite\");\n",
    "    }  \n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "928a0516",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "new XMLConverter().visit(maze)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c843c4ea",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "...scheint ja zu funktionieren. Allerdings funktioniert es nicht mehr, wenn der Code die Abstraktion benutzt, so wie es wohl der Fall wäre wenn man über mehrere Elemente iteriert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7112d681",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "XMLConverter converter = new XMLConverter();\n",
    "\n",
    "for (MapSite mapSite : Arrays.asList(maze, door)) {\n",
    "    converter.visit(mapSite);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e561535",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Im Visitor-Pattern wird dieses Problem mit Hilfe von _Double Dispatch_ gelöst. Leider habe ich noch keine gute Möglichkeit gefunden, die Visitor-Klassen/Interfaces in geeigneter Reihenfolge im Jupyter Notebook, sondern muss einen Umweg in den Definition gehen. Diese doppelten Definitionen wären normalerweise nicht notwendig, sondern sind nur ein Problem das hier im Notebook besteht!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07a34e43",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public interface Visitor {\n",
    "    // Jupyter-Hack: Wird weiter unten vervollständigt\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91eaf536",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir müssen unsere Klassenhierarchie um ein Interface erweitern, sodass alle Objekte eine `accept` Methode erhalten, die das Double Dispatch durchführen kann."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f32d3f6",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "public interface Visitable {\n",
    "    void accept(Visitor v);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90df819d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Eine `MapSite` soll `Visitable` sein, d.h. sie muss die Methode `accept` implementieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87371a98",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "public abstract class MapSite implements Visitable {\n",
    "    protected MapRenderer impl;\n",
    "    \n",
    "    public MapSite(MapRenderer renderer) {\n",
    "        this.impl = renderer;\n",
    "    }\n",
    "\n",
    "    public MapSite() {\n",
    "        this(new PrintRenderer());\n",
    "    }\n",
    "\n",
    "    public abstract void draw();\n",
    "    \n",
    "    public abstract void accept(Visitor v);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "653906b7",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nachdem sich das Interface verändert hat, müssen alle Klassen der Objektstruktur so erweitert werden, dass sie auch die neue `accept` Methode implementieren.\n",
    "\n",
    "An dieser Stelle nun der Jupyter-Hack: Die `accept` Methode bleibt vorerst noch leer, normalerweise würde hier gleich der Code folgen..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f6181fc",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Door extends MapSite {\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Door\");\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        // Jupyter-Hack: Wird weiter unten vervollständigt\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3f1f2d3",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Wall extends MapSite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Wall\");\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        // Jupyter-Hack: Wird weiter unten vervollständigt\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "193090f4",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public abstract class Composite extends MapSite {\n",
    "    protected List<MapSite> elements = new ArrayList<>();\n",
    "\n",
    "    public void add(MapSite x) {\n",
    "        elements.add(x);\n",
    "    }\n",
    "\n",
    "    public List<MapSite> getChildren() {\n",
    "        return elements;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        elements.forEach(e -> e.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd7facb1",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Room extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Room consisting of:\");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        // Jupyter-Hack: Wird weiter unten vervollständigt\n",
    "        elements.forEach(x -> x.accept(v));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1aec92c3",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Maze extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Maze consisting of: \");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        // Jupyter-Hack: Wird weiter unten vervollständigt\n",
    "        elements.forEach(x -> x.accept(v));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64a599dd",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nachdem wir das gemacht haben, ist nun auch Jupyter bereit die vollständige Definition zu akzeptieren. Unser Visitor benötigt eine eigene Methode für jedes Element der Objektstruktur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9edcfe0c",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public interface Visitor {\n",
    "    void visitDoor(Door d);\n",
    "    void visitRoom(Room r);\n",
    "    void visitMaze(Maze m);\n",
    "    void visitWall(Wall w);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "981756af",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Die jeweiligen `accept` Methoden der konkreten Klassen der Objektstruktur rufen dann die entsprechende Methode auf (das ist das Double Dispatch)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "959b252b",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Door extends MapSite {\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Door\");\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        v.visitDoor(this);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08012b64",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Wall extends MapSite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Wall\");\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "       v.visitWall(this);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a7c7264",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public abstract class Composite extends MapSite {\n",
    "    protected List<MapSite> elements = new ArrayList<>();\n",
    "\n",
    "    public void add(MapSite x) {\n",
    "        elements.add(x);\n",
    "    }\n",
    "\n",
    "    public List<MapSite> getChildren() {\n",
    "        return elements;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        elements.forEach(e -> e.draw());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b0064da",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Room extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Room consisting of:\");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        v.visitRoom(this);\n",
    "        elements.forEach(x -> x.accept(v));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24c422e5",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Maze extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Maze consisting of: \");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        v.visitMaze(this);\n",
    "        elements.forEach(x -> x.accept(v));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e85e136f",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class PrintVisitor implements Visitor {\n",
    "    @Override\n",
    "    public void visitDoor(Door d) {\n",
    "        System.out.println(\"Here's a door\");\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitWall(Wall w) {\n",
    "        System.out.println(\"Here's a wall\");\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitRoom(Room r) {\n",
    "        System.out.println(\"Here's a room\");\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitMaze(Maze m) {\n",
    "        System.out.println(\"Here's a maze\");\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfe84d70",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "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);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6355f6cf",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "PrintVisitor visitor = new PrintVisitor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed0b2bea",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "room1.accept(visitor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cec9f9b4",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "maze.accept(visitor)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44e198c0",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "In dieser Implementierung haben wir die Traversierung der Objektstruktur in der Objektstruktur selbst umgesetzt; d.h. Composite Objekte rufen innerhalb der `accept` Methode die `accept` Methode ihrer Kinder auf. Es ist auch Möglich dies im Visitor selbst umzusetzen. Dies machen wir in folgendem Beispiel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0fa8ea5",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class PrintXMLVisitor implements Visitor {\n",
    "    @Override\n",
    "    public void visitDoor(Door d) {\n",
    "        System.out.println(\"    <door></door>\");\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitWall(Wall w) {\n",
    "        System.out.println(\"    <wall></wall>\");\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitRoom(Room r) {\n",
    "        System.out.println(\"  <room>\");\n",
    "        for (MapSite mapSite : r.getChildren()) {\n",
    "            mapSite.accept(this);\n",
    "        }\n",
    "        System.out.println(\"  </room>\");\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitMaze(Maze m) {\n",
    "        System.out.println(\"<maze>\");\n",
    "        for (MapSite mapSite : m.getChildren()) {\n",
    "            mapSite.accept(this);\n",
    "        }\n",
    "        System.out.println(\"</maze>\");\n",
    "    }\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "668be2d6",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nachdem die Traversierung der Kinderelemente nun im Visitor passiert, müssen wir den gleichen Code aus der Objektstruktur selbst entfernen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f72e3537",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Room extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Room consisting of:\");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        v.visitRoom(this);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ece81061",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Maze extends Composite {\n",
    "    @Override\n",
    "    public void draw() {\n",
    "        impl.updateGUI(\"Maze consisting of: \");\n",
    "        elements.forEach(x -> x.draw());\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void accept(Visitor v) {\n",
    "        v.visitMaze(this);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22c6e1d5",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "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);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8063c4f",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "PrintXMLVisitor visitor = new PrintXMLVisitor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f994167d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "maze.accept(visitor)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced4b946",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Command"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88555867",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Das Command-Pattern erlaubt es uns, auszuführende Aktionen als Objekte darzustellen. Diese Objekte lassen sich herumreichen, und es ist möglich erst zu geeigneten Zeiten die Aktionen ausführen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb197115",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface Command {\n",
    "    void execute();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06520540",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Wir erzeugen ein Dummy-Command für die Maze-Objektstruktur, das einfach nur aus einer Ausgabe besteht."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de95368e",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "public class PrintCommand implements Command {\n",
    "    private MapSite site;\n",
    "    \n",
    "    public PrintCommand(MapSite site) {\n",
    "        this.site = site;\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public void execute() {\n",
    "        System.out.println(\"Executing command on \" + site.getClass().getSimpleName());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef5776c8",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class OtherCommand implements Command {\n",
    "    private MapSite site;\n",
    "    \n",
    "    public OtherCommand(MapSite site) {\n",
    "        this.site = site;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void execute() {\n",
    "        // site.otherStuff();\n",
    "        // do other stuff\n",
    "\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94526c56",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun möchten wir ein Command für jedes Objekt innerhalb einer Objektstruktur einsammeln. Dafür eignet das Visitor Pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "647acc7a",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class CommandVisitor implements Visitor {\n",
    "\n",
    "    private List<Command> commands = new ArrayList<>();\n",
    "\n",
    "    public List<Command> getCommands() {\n",
    "        return commands;\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitDoor(Door d) {\n",
    "        commands.add(new PrintCommand(d));\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitWall(Wall w) {\n",
    "        commands.add(new PrintCommand(w));\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitRoom(Room r) {\n",
    "        commands.add(new PrintCommand(r));\n",
    "        r.getChildren().forEach(m -> m.accept(this));\n",
    "    }\n",
    "\n",
    "    @Override\n",
    "    public void visitMaze(Maze m) {\n",
    "        commands.add(new PrintCommand(m));\n",
    "        m.getChildren().forEach(ms -> ms.accept(this));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b0296ee",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Nun können wir unsere Commands erzeugen, und nach belieben Ausführen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46b8b01c",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "CommandVisitor visitor = new CommandVisitor();\n",
    "maze.accept(visitor);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5ecb966",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "List<Command> commands = visitor.getCommands();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f39d8b30",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "commands.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea19990d",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for (Command command : visitor.getCommands()) {\n",
    "    command.execute();\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "657815d1",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strategy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41cc3029",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Das Strategy-Muster wird verwendet, wenn zahlreiche zusammenhängende Klassen sich nur im Verhalten unterscheiden, oder verschiedene Varianten eines Algorithmus benötigt werden. Ein Beispiel für unser Maze-Szenario wären unterschiedliche Traversierungsstrategien, z.B. Preorder/Postorder. Das Strategy-Pattern erlaubt es, diese Strategien nach Belieben (und zur Laufzeit) zu wechseln, und auch einfach neue Strategien einzubauen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18b110f2",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "interface TraversalStrategy {\n",
    "    List<MapSite> traverse(MapSite element);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ed17a70",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "public class PreorderTraversalStrategy implements TraversalStrategy {\n",
    "    public List<MapSite> traverse(MapSite element) {\n",
    "        List<MapSite> elements = new ArrayList<MapSite>();\n",
    "        elements.add(element);\n",
    "        if (element instanceof Composite) {\n",
    "            for (MapSite map : ((Composite)element).getChildren()) {\n",
    "                elements.addAll(traverse(map));\n",
    "            }\n",
    "        }\n",
    "        return elements;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d912f2b",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "public class PostorderTraversalStrategy implements TraversalStrategy {\n",
    "    public List<MapSite> traverse(MapSite element) {\n",
    "        List<MapSite> elements = new ArrayList<MapSite>();\n",
    "        if (element instanceof Composite) {\n",
    "            for (MapSite map : ((Composite)element).getChildren()) {\n",
    "                elements.addAll(traverse(map));\n",
    "            }\n",
    "        }\n",
    "        elements.add(element);\n",
    "\n",
    "        return elements;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57a6af31",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "TraversalStrategy strategy = new PreorderTraversalStrategy();\n",
    "List<MapSite> preorderElements = strategy.traverse(maze)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "205a5578",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for (MapSite element : preorderElements) {\n",
    "    new PrintCommand(element).execute();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8fd8cf3",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "TraversalStrategy strategy = new PostorderTraversalStrategy();\n",
    "List<MapSite> postorderElements = strategy.traverse(maze);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d881070",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for (MapSite element : postorderElements) {\n",
    "    new PrintCommand(element).execute();\n",
    "}"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "hide_code_all_hidden": false,
  "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
}