04_praxis_filled.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8efd29b6",
   "metadata": {},
   "source": [
    "# Bedingungen und Rekursion\n",
    "#### Patrick Schnider, Marcel Lüthi<br/>Departement Mathematik und Informatik, Universität Basel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5997727",
   "metadata": {},
   "source": [
    "### Warm-up"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69e32aa4",
   "metadata": {},
   "source": [
    "- Geben Sie die ersten 100 ganzen Zahlen mit Hilfe von Rekursion aus.\n",
    "- Wie können Sie die Zahlen aufsteigend oder absteigend ausgeben?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f402710e",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Numbers {\n",
    "\n",
    "    public static void print(int n) {\n",
    "        if (n == 0) {\n",
    "           // Abbruch, tue nichts, 0 tut hier nichts\n",
    "        } else {\n",
    "            print(n - 1);\n",
    "            System.out.println(n);\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        print(10);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fea1eae",
   "metadata": {},
   "outputs": [],
   "source": [
    "Numbers.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01c16915",
   "metadata": {},
   "source": [
    "Wir können den `else` weglassen wenn wir ein \"early-`return`\" nutzen um im `if`-Zweig die Methode direkt zu verlassen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e27fa944",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Numbers {\n",
    "\n",
    "    public static void print(int n) {\n",
    "        if (n == 0) {\n",
    "           return; // kein Wert da void\n",
    "        }\n",
    "        \n",
    "        System.out.println(n);\n",
    "        print(n - 1);\n",
    "        // Das Vertauschen der Reihenfolge der Anweisungen kehrt hier die Reihenfolge der Ausgabe um\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        print(10);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88031ddd",
   "metadata": {},
   "outputs": [],
   "source": [
    "Numbers.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c28fc29",
   "metadata": {},
   "source": [
    "Überlegen Sie, welche Schreibweise Sie in welchem Fall bevorzugen."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de5e5e80",
   "metadata": {},
   "source": [
    "### Variablen, Methoden und if-Anweisungen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a4ac350",
   "metadata": {},
   "source": [
    "Wir kennen jetzt if-Anweisungen, Methoden und Variablen. Wir wollen nun einige Fragen klären, welche auftauchen können, wenn man beginnt zu Programmieren. Im folgenden sollen Sie immer beurteilen, ob der Code richtig ist oder nicht. Bitte führen Sie den Code zuerst einmal nicht aus.\n",
    "\n",
    ">*Hinweis: Im Jupyter-Notebook kann es sein, dass Sie die Klasse definieren können (Zelle mit der Klasse ausführen), so lange Sie diese nicht aufrufen. Manchmal kommt dann erst bei der Ausführung ein Fehler. Damit Sie dies nicht vergessen, sind in diesem Notebook die Klassenaufrufe mit in der Zelle.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b0176a6-db0d-423c-96ef-c7831ac93e8b",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        int i = 0;\n",
    "        if (Math.random() > 0.5) {\n",
    "            int i = 2;\n",
    "        } else {\n",
    "            int i = 4;\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b63334b1-d54a-4440-9325-c552a4b8648f",
   "metadata": {},
   "source": [
    "Der Code oben ist nicht richtig: die Variable `i`wird mehrmals definiert. Der folgende Code hingegen kompiliert:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76634b3b-3736-497c-8f00-6a42cb855f63",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        if (Math.random() > 0.5) {\n",
    "            int i = 2;\n",
    "        } else {\n",
    "            int i = 4;\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96973ad0-6f12-493b-b282-aac4141509b8",
   "metadata": {},
   "source": [
    "Der folgende Code funktioniert nicht, da die Variable `i` im `if`-Statement deklariert wird, aber ausserhalb davon darauf zugegriffen wird."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d1e804b-9582-4ee5-b727-5386815ed848",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        if (Math.random() > 0.5) {\n",
    "            int i = 2;\n",
    "        } else {\n",
    "            int i = 4;\n",
    "        }\n",
    "        System.out.println(\"i hat den Wert \" + i);\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e53b48b-6efd-43b6-8cf8-79a71dbbdc2e",
   "metadata": {},
   "source": [
    "Die folgenden zwei Programme funktionieren jedoch:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca801476-5972-408e-b323-08f044df8e40",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        if (Math.random() > 0.5) {\n",
    "            int i = 2;\n",
    "            System.out.println(\"i hat den Wert \" + i);\n",
    "        } else {\n",
    "            int i = 4;\n",
    "            System.out.println(\"i hat den Wert \" + i);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1665eda2-6e29-4791-a582-87c36aad51ac",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        int i;\n",
    "        if (Math.random() > 0.5) {\n",
    "            i = 2;\n",
    "        } else {\n",
    "            i = 4;\n",
    "        }\n",
    "        System.out.println(\"i hat den Wert \" + i);\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1687ea6d-a333-4aeb-8ef2-b3c8908a74d3",
   "metadata": {},
   "source": [
    "Das folgende Programm funktioniert. Die Ausgabe ist aber eventuell nicht die, die wir möchten."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "902cd10c-55ba-4789-ba7c-3855782a770e",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void print() {\n",
    "        int i = 7;\n",
    "        System.out.println(\"i hat den Wert \" + i);\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        int i = 4;\n",
    "        print();\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89a7931b-84f2-44d7-a401-e4c37e2b5ebc",
   "metadata": {},
   "source": [
    "Das folgende Programm funktioniert nicht, da der Methode kein Wert übergeben wird."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f17fbf4-e4d7-495c-903e-8db940f7887d",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void print() {\n",
    "        System.out.println(\"i hat den Wert \" + i);\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        int i = 4;\n",
    "        print();\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43a3197a-8079-467f-8d59-8ebb685f251f",
   "metadata": {},
   "source": [
    "Im folgenden Code wird zwar ein Wert übergeben, dieser wird jedoch von der Methode falsch aufgerufen."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd61ab84-1727-446a-b94e-381f71f95d73",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void print(int value) {\n",
    "        System.out.println(\"i hat den Wert \" + i);\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        int i = 4;\n",
    "        print(i);\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa28e72b-c413-493e-b7be-a6e45a93dab5",
   "metadata": {},
   "source": [
    "Das folgende Programm funktioniert korrekt."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a9d013-11d4-491b-a3f0-4431e0eb2d04",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void print(int value) {\n",
    "        System.out.println(\"i hat den Wert \" + value);\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        int i = 4;\n",
    "        print(i);\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ef750f-2653-4252-b854-56dec17a5701",
   "metadata": {},
   "source": [
    "Von den folgenden 3 Programmen funktioniert nur das dritte nicht. Wir können Variablen mit den selben Namen in verschiedenen deklarieren, diese werden lokal behandelt. Eine Variable, die in einer Methode deklariert wird, kann aber ausserhalb dieser Methode nicht aufgerufen werden."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26f86117-5331-4d0d-ac4f-4c7578a3d764",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void print2() {\n",
    "        int i = 2;\n",
    "    }\n",
    "\n",
    "    public static void print1() {\n",
    "        int i = 4;\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        if (Math.random() > 0.5) {\n",
    "            print1();\n",
    "        } else {\n",
    "            print2();\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceaf6a67-7339-4b02-91d7-da6c3a8c02a0",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void print2() {\n",
    "        int i = 2;\n",
    "    }\n",
    "\n",
    "    public static void print1() {\n",
    "        int i = 4;\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        print1();\n",
    "        print2();\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06786f23-a66c-4e6a-9dfb-2c25e598d3a8",
   "metadata": {},
   "source": [
    "```java\n",
    "public class Scope {\n",
    "\n",
    "    public static void define() {\n",
    "        int i = 4;\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        define();\n",
    "        System.out.println(\"i hat den Wert \" + i);\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76a1c6f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Ihre eigenen Tests\n",
    "public class Scope {\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "    }\n",
    "}\n",
    "\n",
    "Scope.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dfc9d52",
   "metadata": {},
   "source": [
    "### Programme Analysieren"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06efe2f3",
   "metadata": {},
   "source": [
    "Manchmal ist es schwierig, ein Programm zu lesen und genau zu sehen, was passiert. Für das folgende Programm wäre es wohl mit einigem Aufwand möglich. Oft ist es jedoch einfacher, Fragen über das Programm zu beantworten, indem man durch gezielt eingefügte Ausgaben im Programm den Ablauf sichtbar macht."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ed286e0",
   "metadata": {},
   "source": [
    "#### Miniübung"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6755d940",
   "metadata": {},
   "source": [
    "Versuchen Sie folgende Fragen zu beantowrten, indem Sie gezielt Text ausgeben lassen.\n",
    "\n",
    "- Wie oft wird die Methode `body` aufgerufen?\n",
    "- Was ist der Inhalt des Parameters `content` wenn die Methode `head` aufgerufen wird?\n",
    "- Wird die Methode `start` oder die Methode `end` öfters aufgerufen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ae8660b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Website {\n",
    "\n",
    "    static String start(String tag) {\n",
    "        System.out.println(\"start called\");\n",
    "        return \"<\" + tag + \">\";\n",
    "    }\n",
    "    \n",
    "    static String end(String tag) {\n",
    "        System.out.println(\"end called\");\n",
    "        return \"</\" + tag + \">\";\n",
    "    }\n",
    "    \n",
    "    static String group(String tag, String content) {\n",
    "        return start(tag) + content + end(tag);\n",
    "    }\n",
    "    \n",
    "    static String html(String content) {\n",
    "        String tag = \"html\";\n",
    "        return group(tag, content);\n",
    "    }\n",
    "    \n",
    "    static String head(String content) {\n",
    "        System.out.println(\"Value of content: \" + content);\n",
    "        String tag = \"head\";\n",
    "        return group(tag, content);\n",
    "    }\n",
    "    \n",
    "    static String title(String title) {\n",
    "        String tag = \"title\";\n",
    "        return group(tag, title);\n",
    "    }\n",
    "    \n",
    "    static String body(String content) {\n",
    "        System.out.println(\"body wird aufgerufen\");\n",
    "        String tag = \"body\";\n",
    "        return group(tag, content);\n",
    "    }\n",
    "    \n",
    "    static String h1(String title) {\n",
    "        String tag = \"h1\";\n",
    "        return group(tag, title);\n",
    "    }\n",
    "    \n",
    "    static String document() {\n",
    "        String webpage = html(\n",
    "            head(title(\"Meine erste eigene Homepage\")) +\n",
    "            body(\n",
    "                h1(\"Ein Titel\") + \"\\n\" +\n",
    "                \"Dies ist ein bischen Text\"\n",
    "            )\n",
    "        );\n",
    "        return webpage;\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(document());\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee178b48",
   "metadata": {},
   "outputs": [],
   "source": [
    "Website.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "397c5b18",
   "metadata": {},
   "source": [
    "### Test Driven Development"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dadb8b25",
   "metadata": {},
   "source": [
    "Wenn wir programmieren, machen wir Fehler. Deshalb ist das Testen von Programmen sehr wichtig. Wir wollen uns nun anschauen, was Test Driven Development (TDD) ist.\n",
    "\n",
    "Die Philosophie hinter TDD ist, dass man zuerst den Test schreibt und erst dann das Programm dazu. Dabei schreibt man nur so viel vom Programm um den Test zu erfüllen.\n",
    "\n",
    "Dies klingt sehr einfach. Wir wollen nun an einem Beispiel schauen, wie man das umsetzen kann. Nehmen wir zum Beispiel die Aufgabe arabische Zahlen in römische Zahlen umzuwandeln. Dazu soll eine Methode `toRoman` geschrieben werden. Diese soll die dem Wert des übergebenen Parameter entsprechende Zahl als Text zurückgegeben.\n",
    "\n",
    "Wir beginnen, indem wir zuerst einen Test für die Zahl `1` schreiben. Danach entwickeln wir unser Programm weiter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "593f1edb",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class RomanNumbers {\n",
    "    \n",
    "    public static String toRoman(int value) {\n",
    "        if(value == 4) {\n",
    "            return \"IV\";\n",
    "        }\n",
    "        if(value >= 1) {\n",
    "            return \"I\" + toRoman(value - 1);\n",
    "        }\n",
    "        return \"\";\n",
    "    }\n",
    "    \n",
    "    public static void test(int value, String expected) {\n",
    "        if (toRoman(value).equals(expected) ) {\n",
    "            System.out.println(\"Test successful for \" + value +\", result is \" + expected);\n",
    "        } else {\n",
    "            System.out.println(\"Test failed for \" + value + \" is not \" + expected);\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        test(1, \"I\");\n",
    "        test(2, \"II\");\n",
    "        test(3, \"III\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "473b8b0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "RomanNumbers.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1fb31af",
   "metadata": {},
   "source": [
    "Fortfahren durch schrittweises hinzufügen von Tests und Fällen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87697433",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class RomanNumbers {\n",
    "\n",
    "    public static void testNumber(int value, String expectedValue) {\n",
    "        String convertedValue = toRoman(value);\n",
    "        \n",
    "        System.out.print(String.format(\"%d is converted to \\\"%s\\\"\", value, convertedValue));\n",
    "        System.out.println(String.format(\" <-> \\\"%s\\\" expected\", expectedValue));\n",
    "        if (convertedValue.equals(expectedValue)) {\n",
    "            System.out.println(\"Test passed!\");\n",
    "        } else {\n",
    "            System.out.println(\"Test failed!\");\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    public static String toRoman(int i) {\n",
    "        if (i >= 1000) {\n",
    "            return \"M\" + toRoman(i - 1000);\n",
    "        }\n",
    "        if (i >= 900) {\n",
    "            return \"CM\" + toRoman(i - 900);\n",
    "        }\n",
    "        if (i >= 500) {\n",
    "            return \"D\" + toRoman(i - 500);\n",
    "        }\n",
    "        if (i >= 400) {\n",
    "            return \"CD\" + toRoman(i - 400);\n",
    "        }\n",
    "        if (i >= 100) {\n",
    "            return \"C\" + toRoman(i - 100);\n",
    "        }\n",
    "        if (i >= 90) {\n",
    "            return \"XC\" + toRoman(i - 90);\n",
    "        }\n",
    "        if (i >= 50) {\n",
    "            return \"L\" + toRoman(i - 50);\n",
    "        }\n",
    "        if (i >= 40) {\n",
    "            return \"XL\" + toRoman(i - 40);\n",
    "        }\n",
    "        if (i >= 10) {\n",
    "            return \"X\" + toRoman(i - 10);\n",
    "        }\n",
    "        if (i >= 9) {\n",
    "            return \"IX\" + toRoman(i - 9);\n",
    "        }\n",
    "        if (i >= 5) {\n",
    "            return \"V\" + toRoman(i - 5);\n",
    "        }\n",
    "        if (i >= 4) {\n",
    "            return \"IV\" + toRoman(i - 4);\n",
    "        }\n",
    "        if (i >= 1) {\n",
    "            return toRoman(i-1) + \"I\";\n",
    "        }\n",
    "        return \"\";\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        testNumber(0, \"\");\n",
    "        testNumber(1, \"I\");\n",
    "        testNumber(2, \"II\");\n",
    "        testNumber(3, \"III\");\n",
    "        testNumber(4, \"IV\");\n",
    "        testNumber(5, \"V\");\n",
    "        testNumber(7, \"VII\");\n",
    "        testNumber(9, \"IX\");\n",
    "        testNumber(10, \"X\");\n",
    "        testNumber(323, \"CCCXXIII\");\n",
    "        testNumber(1989, \"MCMLXXXIX\");\n",
    "        testNumber(1998, \"MCMXCVIII\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2507ea6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "RomanNumbers.main(new String[0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9bd63f41-609b-42de-b481-d2a36d2bfc31",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java [conda env:ijava]",
   "language": "java",
   "name": "conda-env-ijava-java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "17.0.3-internal+0-adhoc..src"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}