Add termin 2

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

generics2.md

@@ -0,0 +1,130 @@
+<!--
+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 Methoden 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
+Einschrä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);
+      } 
+    }
+}
+```
+
+Warum wird hier nicht der Parameter-Typ ``List<Object>`` genutzt?
+
+--- 
+
+## 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);
+      } 
+    }
+}
+```
+
+Welche Typen akzeptiert der Compiler für den Parameter ``liste``?
+
+---
+
+## 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.
+  }
+}
+```
+
+Welche Typen akzeptiert der Compiler für den Parameter ``liste``?
+
+---
+
+# Aufgaben
+
+1) Wann benutzt man ``super`` und wann ``extends`` ?
+    * "Producers Extend, Consumers Super". [Java Guidelines](https://docs.oracle.com/javase/tutorial/java/generics/wildcardGuidelines.html)
+    * ``extends`` erlaubt das Aufrufen von Gettern, ``super`` von Settern
+

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

reflections.md

@@ -0,0 +1,60 @@
+<!--
+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
+
+---
+
+# Grundlagen
+
+Ermöglichen das Abfragen von Metainformationen zur Laufzeit. Dazu gehört der
+dynamische Typ eines Objekts, dessen Felder (private und öffentliche) und
+Methoden. Benutzt werden Reflections vor allem beim Datenaustausch in
+verteilten Systemen.
+
+---
+
+# Java Reflection API
+Die wichtigsten Klassen aus den Java Reflections sind:
+
+* ``Class``
+* ``Field``
+* ``Constructor``
+* ``Method``
+* etc. (siehe [Reflection API](<!-- TODO -->))
+
+---
+
+# Anwendung
+
+```java
+Dreieck dreieck = new Dreieck();
+Class<?> dreieckKklasse = dreieck.getClass();
+
+System.out.println(dreieckKlasse.getSimpleName());
+// Konsole: Dreieck
+```
+
+---
+
+# Benutzung
+
+Reflections sollten nur genutzt werden wenn es gar nicht anders geht. Man kann
+sonst schnell die schönen Objektstrukturen zerstören die ein Software-Architekt
+entwickelt hat.
+
+---
+
+# Aufgaben
+
+1) Schreibe eine statische Methode ``schreibKonstruktoren(Object object)``
+    welche die Parameter aller Konstruktoren von ``object`` auf die Konsole
+    schreibt (``System.out.println(...)``).
+    
+2) Schreibe eine statische Methode `schreibPrivateFelder(Object object)` welche
+    die Namen und Typen aller **privaten** und **statischen** Felder von `object` auf die Konsole schreibt.