07_theorie_filled.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "02395950",
   "metadata": {},
   "source": [
    "# Objektorientierung\n",
    "\n",
    "#### Patrick Schnider, Marcel Lüthi</br>Departement Mathematik und Informatik, Universität Basel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e814204c",
   "metadata": {},
   "source": [
    "Dieses Arbeitsblatt besteht aus zwei Teilen.\n",
    "Im ersten Teil werden wir sehen, wie uns eigene Datentypen helfen, ein Vokabular aufzubauen, mit dem wir unsere Berechnungen strukturieren und beschreiben können.\n",
    "Im zweiten Teil werden wir eine Implementation eines Array-Datentyps schreiben, der dynamisch wachsen kann.\n",
    "Dieses Beispiel zeigt, wie wir mit Klassen Java um eigene, nützliche Datentypen erweitern können. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51098e8",
   "metadata": {},
   "source": [
    "### Teil 1: Konzepte aus der Geometrie"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7afe7c5",
   "metadata": {},
   "source": [
    "Das Ziel dieser ersten Aufgabe ist es, Polygone repräsentieren. Polygone sind geschlossene Vielecke, die durch eine Folge von Punkten definiert sind. Beispiele von Polygonen sind Dreiecke, Vierecke, 6-Ecke, etc. Wir wollen das Polygon auch um einen angegebenen Vektor verschieben können. \n",
    "\n",
    "#### Miniübung\n",
    "\n",
    "* Welche Klassen würden Sie definieren um das Problem zu strukturieren?\n",
    "* Welche Methoden sollen auf diesen Klassen definiert sein?\n",
    "* Implementieren Sie diese Klassen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "edfa59a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector {\n",
    "    double x;\n",
    "    double y;\n",
    "\n",
    "    public Vector(double x, double y) {\n",
    "        this.x = x;\n",
    "        this.y = y;\n",
    "    }\n",
    "    \n",
    "    public Vector add(Vector v) {\n",
    "        return new Vector(x + v.x, y + v.y);\n",
    "    }\n",
    "    \n",
    "    public void print() {\n",
    "        System.out.print(\"(\" + x + \", \" + y + \")\");\n",
    "    }\n",
    "}\n",
    "\n",
    "class Point {\n",
    "    double x;\n",
    "    double y;\n",
    "\n",
    "    public Point(double x, double y) {\n",
    "        this.x = x;\n",
    "        this.y = y;\n",
    "    }\n",
    "    \n",
    "    public Point add(Vector v) {\n",
    "        return new Point (x + v.x, y + v.y);\n",
    "    }\n",
    "    \n",
    "    public Vector minus(Point p) {\n",
    "        return new Vector (x - p.x, y - p.y);\n",
    "    }\n",
    "    \n",
    "    public void print() {\n",
    "        System.out.print(\"(\" + x + \", \" + y + \")\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1de7233",
   "metadata": {},
   "source": [
    "Wir können nun eine Klasse für Polygone schreiben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c14476cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Polygon {\n",
    "\n",
    "    Point[] points;\n",
    "    \n",
    "    Polygon(Point[] points) {\n",
    "        this.points = points;\n",
    "    }\n",
    "    \n",
    "    public Polygon translate(Vector v) {\n",
    "        Point[] newPoints = new Point[this.points.length];\n",
    "        for (int i = 0; i < this.points.length; i = i + 1) {\n",
    "            newPoints[i] = this.points[i].add(v);\n",
    "        }\n",
    "        return new Polygon(newPoints);\n",
    "    }\n",
    "    \n",
    "    public void print() {\n",
    "        for (Point p : this.points) {\n",
    "            p.print();\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e21c18ba",
   "metadata": {},
   "source": [
    "Wir schreiben eine Klasse `PolygonApp`, die eine Main-Methode enthält, um unsere Konzepte zu testen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b0c48de",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PolygonApp {\n",
    "\n",
    "    \n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        Point p1 = new Point(1, 3);\n",
    "        Point p2 = new Point(3, 4);\n",
    "        Point p3 = new Point(7, 1);\n",
    "        \n",
    "        Polygon poly = new Polygon(new Point[]{p1, p2, p3});\n",
    "        poly.print();\n",
    "        System.out.println(\"\");\n",
    "\n",
    "        Polygon poly2 = poly.translate(new Vector(1, 7));\n",
    "        poly2.print();\n",
    "    }\n",
    "}\n",
    "\n",
    "PolygonApp.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "766c6901",
   "metadata": {},
   "source": [
    "#### Miniübung\n",
    "\n",
    "* Erzeugen Sie ein Polygon und verschieben Sie dieses um einen gewissen Verschiebevektor. \n",
    "* Können Sie die Punkte im Polygon ausgeben? Ergänzen Sie die Klasse um eine print-Methode. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea85a956",
   "metadata": {},
   "source": [
    "### Teil 2: ArrayList"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa8f3923",
   "metadata": {},
   "source": [
    "Die Array-Klasse in Java hat grosse Limitierungen:\n",
    "\n",
    "* Die Grösse des Arrays ist fix. \n",
    "* Das Array kann nicht einfach ausgegeben werden. \n",
    "* Vergleiche von Arrays sind schwierig. \n",
    "\n",
    "In dieser Aufgabe werden wir eine eigene Klasse `ArrayList` schreiben, die diese Probleme behebt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8dcbd621",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ArrayList {\n",
    "    \n",
    "    // Hält die Daten \n",
    "    double[] data;\n",
    "    \n",
    "    // Die Anzahl der in der ArrayList gespeicherten Elemente\n",
    "    int size = 0;\n",
    "    \n",
    "    // Erzeugt eine ArrayList mit gegebener Kapazität\n",
    "    public ArrayList(int capacity) {\n",
    "        this.data = new double[capacity];\n",
    "        this.size = 0;\n",
    "    }\n",
    "    \n",
    "    // Erzeugt eine ArrayList mit n Elementen, die alle auf den in element gegebene\n",
    "    // Wert gesetzt wird. \n",
    "    public static ArrayList fill(int n, double element) {\n",
    "        ArrayList newList = new ArrayList(n);\n",
    "        for (int i = 0; i < n; i = i + 1) {\n",
    "            newList.append(element);\n",
    "        }\n",
    "        return newList;\n",
    "        \n",
    "    }\n",
    "    \n",
    "    // Setzt das Element an der Stelle index\n",
    "    public void set(int index, double element) {\n",
    "        data[index] = element;\n",
    "    }\n",
    "    \n",
    "    // Fügt ein neues Element am Ende der Liste an. Wenn die Liste nicht gross\n",
    "    // genug ist, wird die Liste vergrössert\n",
    "    public void append(double element) {\n",
    "        if (size >= data.length) {\n",
    "            resize(2 * data.length);\n",
    "        }\n",
    "        data[size] = element;\n",
    "        size += 1;\n",
    "    }\n",
    "    \n",
    "    // Gibt die Liste aus\n",
    "    public void print() { \n",
    "        if (size == 0) {\n",
    "            System.out.println(\"[]\");\n",
    "        } else {\n",
    "            System.out.print(\"[\");\n",
    "            for (int i = 0; i < size -1 ; i = i + 1) {\n",
    "                System.out.print(data[i] + \", \"); \n",
    "            }\n",
    "            System.out.print(data[size - 1]);\n",
    "            System.out.println(\"]\");\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    // Vergleicht dieses Array mit dem übergebenen Array other\n",
    "    public boolean equals(ArrayList other) {\n",
    "        if (other.size != this.size) { \n",
    "            return false;\n",
    "        }\n",
    "        for (int i = 0; i < size; i = i + 1) {\n",
    "            if (this.data[i] != other.data[i]) {\n",
    "                return false;\n",
    "            }\n",
    "        }\n",
    "        \n",
    "        return true;\n",
    "        \n",
    "    }\n",
    "    \n",
    "    // Verändert die Grösse des Arrays. Die im array gespeicherten \n",
    "    // Elemente bleiben erhalten. \n",
    "    void resize(int numberOfElements) {\n",
    "        double[] newArray = new double[numberOfElements];\n",
    "        for (int i = 0; i < size; i = i + 1) {\n",
    "            newArray[i] = data[i];\n",
    "        }\n",
    "        this.data = newArray;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "774b1971",
   "metadata": {},
   "source": [
    "Die Klasse `ArrayListTests` wird verwendet um unsere Klasse `ArrayList` zu testen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6010a62",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ArrayListTests {\n",
    "    public static void main(String[] args) {\n",
    "        ArrayList a = ArrayList.fill(10, 0);\n",
    "        a.append(7);\n",
    "        a.set(3, 99);\n",
    "        a.print();\n",
    "    }\n",
    "}\n",
    "ArrayListTests.main(new String[0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b81d001",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "160f5578",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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": "17.0.3-internal+0-adhoc..src"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}