From 9d6a1ce2c4f94e4c7f7f6e6257594045570eef32 Mon Sep 17 00:00:00 2001
From: "Burau, Henri" <henri.burau@haw-hamburg.de>
Date: Wed, 5 May 2021 17:24:24 +0200
Subject: [PATCH] Started work on termin2

---
 02-termin.md   |  34 ++++++++++++++
 generics2.md   | 118 +++++++++++++++++++++++++++++++++++++++++++++++++
 polymorphie.md |  22 ++++++++-
 reflections.md |  13 ++++++
 4 files changed, 186 insertions(+), 1 deletion(-)
 create mode 100644 02-termin.md
 create mode 100644 generics2.md
 create mode 100644 reflections.md

diff --git a/02-termin.md b/02-termin.md
new file mode 100644
index 0000000..bed427c
--- /dev/null
+++ b/02-termin.md
@@ -0,0 +1,34 @@
+<!--
+title: Termin 2
+description: Folien für den ersten Termin in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+-->
+
+# Termin 2
+
+---
+
+# Fragen
+
+---
+
+# Links
+[https://git.haw-hamburg.de/pm2-tutorium](https://git.haw-hamburg.de/pm2-tutorium)
+- Aufgaben
+- Tutoriumsfolien
+
+---
+
+# Plan für heute
+
+Themen:
+
+- Testen und Asserts
+- Polymorphie und Vererbung *Nachtrag*
+- **Generizität**
+- **Reflections**
+- Implementationsvererbung
+- Exceptions
+- Module
diff --git a/generics2.md b/generics2.md
new file mode 100644
index 0000000..b1507a7
--- /dev/null
+++ b/generics2.md
@@ -0,0 +1,118 @@
+<!--
+title: Generizität
+description: Folien für Generizität in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+--> 
+
+# Generizität
+
+---
+
+# Grundlagen
+
+Durch Generizität können wir Typen, Klasse und Methode parametrisieren. Der
+genutzte Typ wird dann zur Laufzeit übergeben. 
+
+Genutzt wird dieses Sprachkonzept z.B. im Collection Framework.
+
+```java
+// Deklaration
+class Test<T> {
+    public T gibHer(T type) { return type; }
+}
+```
+
+```java
+// Benutzung
+Test<String> test;
+String result = test.gibHer(test);
+```
+
+---
+
+# Raw Types
+
+Der Java-Compiler entfernt alle generischen Parameter und arbeitet dann auf den
+**Raw Types**. Dieser Vorgang wird **Type Erasure** genannt. Das führt zu
+Beschränkungen zur Laufzeit:
+
+* Generische Klassen können keine statischen Felder haben
+* Es können keine Instanzen aus generischen Typen erzeugt werden
+* Es kann kein ``instanceof`` für generische Typen genutzt werden
+* ... (vollständige Liste auf der [Java-Website](https://docs.oracle.com/javase/tutorial/java/generics/restrictions.html))
+
+--- 
+
+# Subtyping und Vererbung
+
+Stehen zwei Typen in einer Subtyp-Beziehung (``class Dreieck extends Form``) bedeutet das **nicht**, dass auch die parametrisierten Typen in einer Verbindung stehen. 
+
+```java
+// Deklaration
+class FlaechenVerarbeiter {
+    public void verarbeiteFlaechen(List<Form> liste) {
+}
+```
+```java
+// Benutzung
+Dreieck dreieck = new Dreieck();
+Verarbeiter verarbeiter = new Verarbeiter();
+verarbeiter.verarbeiteFlaechen(dreieck); // Geht das?
+```
+
+--- 
+
+# Wildcards
+
+Werden genutzt um beliebige generische Type als Parameter, Feld, lokale Variable oder Rückgabetypen zu deklarieren. 
+
+Benutzt wird dieses Sprachkonzept wenn man z.B. auf Collections arbeiten will:
+
+```java
+class ListenSchreiber {
+    public void schreib(List<?> liste) {
+      for (Object elem: list) {
+           System.out.println(elem);
+      } 
+    }
+}
+```
+
+--- 
+
+## Lower Bounds
+
+Beschränkt den Wildcard Typen nach unten. Dafür wird das Schlüsselwort ``super`` verwendet.
+
+```java
+// Hierarchie Object -> Number -> Integer
+class IntegerSammler {
+    public void schreib(List<? super Integer> liste) {
+      for (int i = 0; i <= 10; i++) {
+           System.out.println(i);
+      } 
+    }
+}
+```
+---
+
+## Upper Bounds
+
+Beschränkt den Wildcard Typen nach oben. Dafür wird das Schlüsselwort ``extends`` verwendet.
+
+```java
+// Hierarchie Object -> Number -> Integer
+//                             -> Double
+class Sortierer {
+  public void sortiere(List<? extends Number> liste) {
+    // Ein cleverer Sortieralgorithmus,
+    // der mit Vergleichoperatoren funktioniert.
+  }
+}
+```
+
+---
+
+# Aufgaben
diff --git a/polymorphie.md b/polymorphie.md
index 6abf602..754d3f6 100644
--- a/polymorphie.md
+++ b/polymorphie.md
@@ -31,9 +31,12 @@ Die **Implementation** ist die Innenansicht auf einen Dienstleister.
 Weitergeben von bereits geschriebenen Code an Subklassen. Sinnvoll
 auch zum Aufstellen einer Vererbungshierarchie. 
 
+ - Eine Klasse kann erben von: Klassen und abstrakten Klasse
+ - Ein Interface kann erben von: Interfaces
+
 ---
 
-## Deklaration
+## Deklaration - Klassen
 
 ```java
 class Shape {
@@ -57,6 +60,22 @@ class Circle extends Shape {
 
 ---
 
+## Deklaration - Interfaces
+
+```java
+// Repräsentiert eine 2D Form
+interface Form {
+    double gibFlaeche();
+}
+
+// Repräsentiert ein 2D Dreieck
+interface Dreieck extends Shape {
+	double gibHoehe();
+}
+
+```
+
+---
 ## Benutzung
 
 ```java
@@ -69,6 +88,7 @@ shape = rectangle;
 shape.toString();
 ```
 
+
 ---
 
 # Aufgaben
diff --git a/reflections.md b/reflections.md
new file mode 100644
index 0000000..8c816ca
--- /dev/null
+++ b/reflections.md
@@ -0,0 +1,13 @@
+<!--
+title: Reflections
+description: Folien für Reflections in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+--> 
+
+# Reflections
+
+---
+
+