12_theorie_filled.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "90963962",
   "metadata": {},
   "source": [
    "\n",
    "# Fehlerbehandlung\n",
    "\n",
    "#### Patrick Schnider, Marcel Lüthi</br>Departement Mathematik und Informatik, Universität Basel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea503ce3",
   "metadata": {},
   "source": [
    "Bisher haben wir einen Aspekt des Programmierens bewusst ausgelassen.\n",
    "Unser Interface lässt auch Befehle für eine Liste zu, welche zu Fehlern führen können.\n",
    "Eine Fehlerbehandlung haben wir noch nicht eingeführt.\n",
    "\n",
    "Wir schauen uns dies wieder an einer Teilmenge der Operationen unserer Listenklasse an.\n",
    "Insbesondere interessiert uns die `get` Methode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fb0ea6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "interface List<E> {\n",
    "    \n",
    "    /**\n",
    "      * Appends an element to the end of the list\n",
    "      */\n",
    "    void add(E element);\n",
    "    \n",
    "    /**\n",
    "      * returns the number of elements in the list\n",
    "      */\n",
    "    int size();\n",
    "    \n",
    "    /**\n",
    "      * gets the element at position i\n",
    "      */\n",
    "    E get(int index);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd1015eb",
   "metadata": {},
   "source": [
    "Wir können uns fragen: Was passiert, wenn wir einen Index übergeben, der grösser ist als die Anzahl Elemente?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97a9917f",
   "metadata": {},
   "source": [
    "#### Aufgabe: \n",
    "\n",
    "* Schauen Sie sich die Implementation `get()` (unten) an. Was macht die Methode im Fehlerfall? Probieren Sie es auch aus.\n",
    "* Diskutieren Sie Folgendes: \n",
    "    * Was sollte die Methode `get()` machen, wenn ein negativer oder zu grosser Index angegeben wird?\n",
    "    * Manche Methoden können fehlschlagen (wie `get()`) und manche nicht (wie `size()`). Wie kann ein Benutzer dies unterscheiden? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d85ed06c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node<E> {\n",
    "    E value;\n",
    "    Node<E> next;\n",
    "    \n",
    "    Node(E value) {\n",
    "        this.value = value;\n",
    "        this.next = null;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "887b9edd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinkedList<E> implements List<E> {\n",
    "    \n",
    "    Node<E> first;\n",
    "    Node<E> last;\n",
    "    \n",
    "    int size;\n",
    "    \n",
    "    // Erzeugt eine ArrayList mit gegebener Kapazität\n",
    "    public LinkedList() {\n",
    "        this.first = null;\n",
    "        this.last = null;\n",
    "        this.size = 0;\n",
    "    }\n",
    "    \n",
    "    \n",
    "    // Fügt ein neues Element am Ende der Liste an. \n",
    "    public void add(E element) {\n",
    "        Node<E> newNode = new Node<E>(element);\n",
    "        if (first == null) {\n",
    "            first = newNode;\n",
    "            last = newNode;\n",
    "        } else {\n",
    "            last.next = newNode;\n",
    "            last = newNode;\n",
    "        }        \n",
    "        size = size + 1;\n",
    "    }\n",
    "    \n",
    "    public int size() { \n",
    "        return size;\n",
    "    }\n",
    "    \n",
    "    public E get(int index) {\n",
    "        Node<E> curr = first;\n",
    "        for (int i = 0; i < index; i = i + 1) {\n",
    "            curr = curr.next;\n",
    "        }\n",
    "        return curr.value;\n",
    "        \n",
    "    }   \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e3af019",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinkedListTest {\n",
    "    public static void main(String[] args) {\n",
    "        LinkedList<String> ll = new LinkedList();\n",
    "        ll.add(\"foobar\");\n",
    "        ll.get(3);\n",
    "    }\n",
    "}\n",
    "\n",
    "LinkedListTest.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aec937a7",
   "metadata": {},
   "source": [
    "# Teil 1: Die Klasse Optional"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8058f1",
   "metadata": {},
   "source": [
    "Eine Möglichkeit, dem Benutzer mitzuteilen, dass eine Methode eventuell kein Resultat zurückgeben wird ist, dies durch einen Datentyp, eine Klasse zu repräsentieren. Java bietet dafür die Klasse `Optional` an."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b42db74e",
   "metadata": {},
   "outputs": [],
   "source": [
    "interface List<E> {\n",
    "    \n",
    "    /**\n",
    "      * Appends an element to the end of the list\n",
    "      */\n",
    "    void add(E element);\n",
    "    \n",
    "    /**\n",
    "      * returns the number of elements in the list\n",
    "      */\n",
    "    int size();\n",
    "    \n",
    "    /**\n",
    "      * gets the element at position i\n",
    "      */\n",
    "    Optional<E> get(int index);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9828adf",
   "metadata": {},
   "source": [
    "Diese Klasse `Optional` kann wie folgt implementiert werden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3280442b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Optional<T> {\n",
    "    T value = null;\n",
    "\n",
    "    private Optional(T value) {\n",
    "        this.value = value;\n",
    "    }\n",
    "    \n",
    "    static <T> Optional<T> of(T value) { \n",
    "        return new Optional<T>(value);\n",
    "    }\n",
    "\n",
    "    static <T> Optional<T> empty() { \n",
    "        return new Optional<T>(null);\n",
    "    }\n",
    "\n",
    "    boolean isPresent() { \n",
    "        return this.value != null;\n",
    "    }\n",
    "\n",
    "     public T get() {\n",
    "        return value;\n",
    "    }\n",
    "    \n",
    "    @Override\n",
    "    public String toString() { \n",
    "        if (value == null) {\n",
    "            return \"empty\";\n",
    "        } else { \n",
    "            return value.toString();\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "983c4f1b",
   "metadata": {},
   "source": [
    "Nun können wir die Implementation der Listenklasse anpassen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "829f6d3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinkedList<E> implements List<E> {\n",
    "    \n",
    "    Node<E> first;\n",
    "    Node<E> last;\n",
    "    \n",
    "    int size;\n",
    "    \n",
    "    // Erzeugt eine ArrayList mit gegebener Kapazität\n",
    "    public LinkedList() {\n",
    "        this.first = null;\n",
    "        this.last = null;\n",
    "        this.size = 0;\n",
    "    }\n",
    "    \n",
    "    \n",
    "    // Fügt ein neues Element am Ende der Liste an. \n",
    "    public void add(E element) {\n",
    "        Node<E> newNode = new Node<E>(element);\n",
    "        if (first == null) {\n",
    "            first = newNode;\n",
    "            last = newNode;\n",
    "        } else {\n",
    "            last.next = newNode;\n",
    "            last = newNode;\n",
    "        }        \n",
    "        size = size + 1;\n",
    "    }\n",
    "    \n",
    "    public int size() { \n",
    "        return size;\n",
    "    }\n",
    "        \n",
    "    public Optional<E> get(int index) {\n",
    "        if ((index < 0) || (index >= size)) {\n",
    "            return Optional.empty();\n",
    "        }\n",
    "        Node<E> curr = first;\n",
    "        for (int i = 0; i < index; i = i + 1) {\n",
    "            curr = curr.next;\n",
    "        }\n",
    "        return Optional.of(curr.value);\n",
    "        \n",
    "    }   \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e89cdbf6",
   "metadata": {},
   "source": [
    "Bei der Verwendung der Liste können wir auf den Fehlerfall testen und reagieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be1758e1",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class LinkedListTest {\n",
    "    public static void main(String[] args) {\n",
    "        LinkedList<Double> l = new LinkedList<Double>();\n",
    "        l.add(3.0);\n",
    "        Optional<Double> maybe = l.get(0);\n",
    "        \n",
    "        if (maybe.isPresent()) {\n",
    "            Double value = maybe.get();\n",
    "            System.out.println(value);\n",
    "        } else {\n",
    "            System.out.println(\"Value was not in list.\");\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "LinkedListTest.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae4034c2",
   "metadata": {},
   "source": [
    "# Teil 2: Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "928da663",
   "metadata": {},
   "source": [
    "Die Nutzung von Optional ist eine Möglichkeit der Fehlerbehandlung.\n",
    "Eine weitere Möglichkeit, die in Java oft verwendet wird, ist die Nutzung von Exceptions. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c83624ad",
   "metadata": {},
   "source": [
    "Wir wollen uns als erstes die Verwendung in Java ansehen.\n",
    "Dazu importieren wir die ArrayList Klasse von der Java Bibliothek `java.util`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "366a50aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import java.util.ArrayList;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6e1a3dd",
   "metadata": {},
   "source": [
    "Der folgende Aufruf führt zu einem Fehler:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec8aafe7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExceptionTest {\n",
    "    public static void main(String[] args) {\n",
    "        ArrayList<String> list = new ArrayList<String>();\n",
    "        list.add(\"abc\");\n",
    "        String value = list.get(3); // <-- hier wird die Exception geworfen\n",
    "        \n",
    "        System.out.println(\"after get().\");\n",
    "    }\n",
    "}\n",
    "\n",
    "ExceptionTest.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ebef371",
   "metadata": {},
   "source": [
    "Hier wurde eine *Exception* geworfen um den Fehler anzuzeigen. Exceptions sind einfache Objekte, die im Fehlerfall anstatt eines normalen Rückgabewerts einer Methode zurückgegeben werden. Dies werden aber nicht einer Variable zugewiesen, sondern werden von einem speziellen *Exceptionhandler* gefangen. Dies geschieht wie folgt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2bbcdba",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExceptionTest {\n",
    "    public static void main(String[] args) {\n",
    "        ArrayList<String> list = new ArrayList<String>();\n",
    "        list.add(\"abc\");\n",
    "        \n",
    "        // Fehlerbehandlung\n",
    "        try {\n",
    "            String value = list.get(3);\n",
    "        } catch (IndexOutOfBoundsException e) {  // <-- fangen der Exception\n",
    "            System.out.println(e.getMessage());\n",
    "        }\n",
    "        \n",
    "        System.out.println(\"after get().\");\n",
    "    }\n",
    "}\n",
    "\n",
    "ExceptionTest.main(new String[0]);\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c33220e",
   "metadata": {},
   "source": [
    "Eine Exception ist einfach eine Klasse. \n",
    "\n",
    "##### Übung: \n",
    "\n",
    "* Schauen Sie sich die [API-Dokumentation](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Exception.html) an. \n",
    "    * Wie erzeugen Sie eine Exception?\n",
    "    * Welche Methoden gibt es?\n",
    "    * Welche Klassen erben von Exceptions?\n",
    "* Versuchen Sie eine Instanz einer Exception zu erstellen. \n",
    "* Experimentieren Sie mit den Methoden. Was machen diese?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "668aaf7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExceptionExperiments {\n",
    "    public static void main(String[] args) {\n",
    "        Exception e = new Exception(\"foobar\");\n",
    "        System.out.println(e.getMessage());\n",
    "        System.out.println(e.toString());\n",
    "        e.printStackTrace();\n",
    "    }\n",
    "}\n",
    "\n",
    "ExceptionExperiments.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80f190f2",
   "metadata": {},
   "source": [
    "Der folgende Code illustriert, wie man einen Fehler mit Exceptions anzeigt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "319ed968",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExceptionTest {\n",
    "    static double  divide(int a, int b) throws Exception {\n",
    "        if (b == 0) {\n",
    "            throw new Exception(\"cannot divide by 0\");\n",
    "        } else { \n",
    "            return a / (double) b;\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b667a98",
   "metadata": {},
   "source": [
    "Beachten Sie Folgendes: \n",
    "\n",
    "* Die `throws`-Klausel in der Methodensignatur. \n",
    "* Im Fehlerfall wird mit `throw` ein neues Objekt der Klasse Exception geworfen. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8444054f",
   "metadata": {},
   "source": [
    "#### Aufgaben\n",
    "\n",
    "* Rufen Sie die Methode `divide()` auf und Fangen Sie die Exception (wie oben mit List gezeigt). \n",
    "* Können Sie die LinkedList Klasse so anpassen, dass diese einen Fehler in der `get` Methode mittels einer `IndexOutOfBoundsException` anzeigt?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "176fc371",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExceptionTest {\n",
    "    \n",
    "    static double  divide(int a, int b) throws Exception {\n",
    "        if (b == 0) {\n",
    "            throw new Exception(\"cannot divide by 0\");\n",
    "        } else { \n",
    "            return a / (double) b;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        try {\n",
    "            System.out.println(divide(4,0));\n",
    "        } catch (Exception e) {\n",
    "            System.out.println(e.getMessage());\n",
    "        }\n",
    "    }\n",
    "}\n",
    "ExceptionTest.main(new String[0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "919f9eed",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinkedList<E> {\n",
    "    \n",
    "    Node<E> first;\n",
    "    Node<E> last;\n",
    "    \n",
    "    int size;\n",
    "    \n",
    "    // Erzeugt eine ArrayList mit gegebener Kapazität\n",
    "    public LinkedList() {\n",
    "        this.first = null;\n",
    "        this.last = null;\n",
    "        this.size = 0;\n",
    "    }\n",
    "    \n",
    "    \n",
    "    // Fügt ein neues Element am Ende der Liste an. \n",
    "    public void add(E element) {\n",
    "        Node<E> newNode = new Node<E>(element);\n",
    "        if (first == null) {\n",
    "            first = newNode;\n",
    "            last = newNode;\n",
    "        } else {\n",
    "            last.next = newNode;\n",
    "            last = newNode;\n",
    "        }        \n",
    "        size = size + 1;\n",
    "    }\n",
    "    \n",
    "    public int size() { \n",
    "        return size;\n",
    "    }\n",
    "        \n",
    "    public E get(int index) throws IndexOutOfBoundsException {\n",
    "        if ((index < 0) || (index >= size)) {\n",
    "            throw new IndexOutOfBoundsException(\"index \" +index + \" is not in a list with size \" + size);\n",
    "        }\n",
    "        \n",
    "        Node<E> curr = first;\n",
    "        for (int i = 0; i < index; i = i + 1) {\n",
    "            curr = curr.next;\n",
    "        }\n",
    "        \n",
    "        return curr.value;\n",
    "    }   \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5aebf0d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinkedListTest {\n",
    "    public static void main(String[] args) {\n",
    "        LinkedList<String> ll = new LinkedList();\n",
    "        \n",
    "        ll.add(\"foo\");\n",
    "        ll.add(\"bar\");\n",
    "        \n",
    "        ll.get(2); // löst Exception aus\n",
    "    }\n",
    "}\n",
    "\n",
    "LinkedListTest.main(new String[0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e067063f-05f0-4c76-8222-b35f15bd820d",
   "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
}