Add termin3

2021-05-18 18:17:49 +02:00 · 2021-05-18 18:17:49 +02:00 · 667e7fabda
parent a698803b82
commit 667e7fabda
4 changed files with 311 additions and 0 deletions
--- a/03-termin.md
+++ b/03-termin.md
@ -0,0 +1,34 @@
+<!--
+title: Termin 3
+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 3
+
+---
+
+# Fragen
+
+---
+
+# Links
+[https://git.haw-hamburg.de/pm2-tutorium](https://git.haw-hamburg.de/pm2-tutorium)
+- Aufgaben
+- Tutoriumsfolien
+
+---
+
+# Plan für heute
+
+Level 5 Themen:
+
+- Testen und Asserts
+- Polymorphie und Vererbung
+- Generizität
+- Reflections
+- **Implementationsvererbung**
+- **Exceptions**
+- **Module**
--- a/abstract.md
+++ b/abstract.md
@ -0,0 +1,99 @@
+<!--
+title: Abstrakte Klasse
+description: Folien für abstrakte Klassen in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+-->
+
+# Abstrakte Klassen
+
+
+---
+
+# Abstrakte Klassen
+
+In abstrakten Klassen können Operationen **ohne** eine Implementation deklariert werden.
+
+```java
+abstract double gibFlaeche();
+```
+
+---
+
+# Abstrakte Klassen
+
+Eine Klasse mit mindestens einer abstrakten Methode muss abstrakt sein.
+
+Es können keine Instanzen einer abstrakten Klasse erzeugt werden.
+
+```java
+abstract class Form 
+{
+    abstract double gibFlaeche();
+
+    String toString() 
+    {
+        return "Form";
+    }
+}
+```
+
+---
+
+# Benutzung
+
+Es können keine Instanzen einer abstrakten Klasse erzeugt werden. Trotzdem definieren die abstrakten Klassen einen Typ.
+
+```java
+// Deklaration
+class Kreis extends Form { 
+    private double _radius;
+    
+    Circle(double rad) {radius = rad;}
+    
+    double gibFlaeche(){
+        return  3.14 * radius * radius;
+    }
+}
+
+// Benutzung
+Form form1 = new Kreis(4.5);
+```
+
+---
+
+# Verwendung
+
+Abstrakte Klassen werden immer benutzt wenn Code wiederverwendet werden soll, aber nicht alle Details bekannt sind. Dabei wird häufig das Prinzip der Schablonen- und Einschubmethoden genutzt.
+
+```java
+abstract class DreidimensionaleForm {
+    private double _hoehe;
+
+    abstract double gibFlaeche();
+    
+    double gibVolumen() {
+        return gibFlaeche() * _hoehe;
+    }
+}
+```
+
+* Welche Methode ist die Einschubmethode und welche die Schablonenmethode?
+
+---
+
+# Übung
+
+1) Müssen alle abstrakten Methoden eine abstrakten Klasse in einer Subklasse implementiert werden?
+    * Ja, denn ansonsten fehlt für manche Operationen die Implementation.
+ 
+2) Sind alle Felder der abstrakten Klasse auch in der Subklasse enthalten?
+    * Ja
+ 
+3) Darf auf alle Felder der Superklasse aus der Subklasse zugegriffen werden?
+    * Nur solange die Modifier `private`, `protected` oder `package private` sind. 
+
+---
+
+4) Ändere die Klasse `Animal` zu einer abstrakten Klasse. Alle Methoden die bei `Sheep` und `Cow` gleich sind müssen nicht abstrakt sein. Füge aber eine abstrakte Methode `String makeNoise()` ein. Ändere den Code and den richtigen Stellen ab. 
--- a/exceptions.md
+++ b/exceptions.md
@ -0,0 +1,87 @@
+<!--
+title: Assertions
+description: Folien für Assertions in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+-->
+
+# Exceptions
+
+Erlauben es mit Fehlersituationen in einem Programm umzugehen. Es gibt zwei mögliche Fehlerarten:
+
+1) **Entwicklungsfehler**
+Vermeidbare Fehler die während der Entwicklung auftreten. Können gut durch Tests aufgedeckt werden und brauchen keine explizite Fehlerbehandlung.
+*Beispiel*: Ungültiger Arrayindex, Teilen durch 0
+    
+2) **Umgebungsfehler**
+Unvermeidbare Fehler die durch die Programmumgebung ausgelöst werden. Diese Fehlerart benötigt eine Fehlerbehandlung.
+*Beispiel*: Keine Internetverbindung, Zu wenig Festplattenspeicher
+
+---
+
+# Hierarchie
+
+Exceptions sind Objekte die von `Exception` oder `RuntimeException` erben. 
+
+[![width:300px](https://mermaid.ink/img/eyJjb2RlIjoiY2xhc3NEaWFncmFtXG4gICAgVGhyb3dhYmxlIDx8LS0gRXhjZXB0aW9uXG4gICAgVGhyb3dhYmxlIDx8LS0gRXJyb3JcbiAgICBFeGNlcHRpb24gPHwtLSBSdW50aW1lRXhjZXB0aW9uIiwibWVybWFpZCI6eyJ0aGVtZSI6ImRlZmF1bHQifSwidXBkYXRlRWRpdG9yIjpmYWxzZX0)](https://mermaid-js.github.io/mermaid-live-editor/#/edit/eyJjb2RlIjoiY2xhc3NEaWFncmFtXG4gICAgVGhyb3dhYmxlIDx8LS0gRXhjZXB0aW9uXG4gICAgVGhyb3dhYmxlIDx8LS0gRXJyb3JcbiAgICBFeGNlcHRpb24gPHwtLSBSdW50aW1lRXhjZXB0aW9uIiwibWVybWFpZCI6eyJ0aGVtZSI6ImRlZmF1bHQifSwidXBkYXRlRWRpdG9yIjpmYWxzZX0)
+
+---
+
+# Ungeprüfte Exceptions
+
+Erben von `RuntimeException` und müssen nicht explizit behandelt werden. 
+
+```java
+Dreieck dreieck = null;
+double flaeche = dreieck.gibFlaeche();
+// Programm wird beendet mit NullPointerException
+```
+---
+
+# Geprüfte Exceptions
+
+Erben von `Exception` und müssen explizit behandelt werden.
+
+```java
+public static void main(String[] args) {
+    System.out.print("Bitte Alter eingeben: ");
+    try {
+        Scanner sc = new Scanner(System.in);
+        String name = sc.nextLine();
+        int alter = Integer.parseInt(name); // Wirft ggf. NumberFormatException
+    } 
+    catch(NumberFormatException e) {
+        System.out.println("Das war kein gültiges Alter!");
+    } 
+    finally {
+        sc.close()
+    }
+}
+```
+---
+
+# Exceptions werfen
+
+Exceptions werden mit dem Schlüsselwort `throw` geworfen. Wird in einer Methode eine geprüfte Exception nicht behandelt, muss dies in dem Methodenkopf mithilfe von `throws` deklariert werden.
+
+```java
+public void pingServer(String serverUrl) throws ConnectException 
+{
+    Server server = connectToServer(serverUrl);
+    if(server == null)
+    {
+        throw new ConnectException("Can't connect to server");
+    }
+}
+
+```
+
+---
+# Übung
+
+1) Wann werden geprüfte Exceptions eingesetzt und wann ungeprüfte?
+    * Geprüfte Exceptions bei Umgebungsfehlern, Ungeprüfte Exceptions bei Entwicklungsfehlern
+
+2) Wie kann eine geprüfte Exception beim Auftreten an den Klienten weitergeleitet werden?
+    * In den Methodenkopf `throws` reinschreiben
--- a/packages.md
+++ b/packages.md
@ -0,0 +1,91 @@
+<!--
+title: Termin 3
+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
+-->
+
+# Module
+
+Grundlegendes Konzept in der Programmierung zur Organisation von Programmcode. 
+
+Module kapseln Implementationen und exportieren eine Schnittstelle mit Operationen, Typen und Konstanten. Dies kann explizit durch die Java 9 Modules geschehen oder implizit durch Zugriffsmodifikatoren.
+
+---
+
+# Geschachtelte Klassen
+
+Erlaubt das Verstecken von Hilfsklassen.
+
+```java
+class Dreieck {
+    private Koordinate _a;
+    private Koordinate _b;
+    private Koordinate _c;
+    
+    private class Koordinate
+    {
+        ...
+    }
+}
+```
+
+--- 
+
+# Pakete
+
+Ermöglichen Namensräume von zusammengehörigen Klassen. Klassen und Interfaces sind nur sichtbar wenn sie mit dem Schlüsselwort `public` deklariert wurden.
+
+```java
+// Dreieck.java
+package formen;
+public class Dreieck {
+    private Koordinate _a;
+    private Koordinate _b;
+    private Koordinate _c;
+    //...
+}
+// Koordinate.java
+package formen;
+class Koordinate
+{
+    //...
+}
+```
+
+---
+
+# Imports
+
+Möchte man Klassen und Interfaces aus einem anderen Paket nutzen dann müssen diese importiert werden. Um eine Grundfunktionalität von Java zu gewährleisten wird das Paket [`java.lang`](https://docs.oracle.com/javase/8/docs/api/java/lang/package-summary.html) immer importiert.
+
+```java
+import java.util.List; // Nur List
+import java.util.*;    // Alle Klassen und Interfaces aus java.util
+
+import static org.junit.Assert.*; // Statischer Import der Asserts
+
+import java.lang.*; // Default Import der immer gemacht wird
+```
+
+--- 
+
+# Sichtbarkeiten
+
+Sichtbarkeiten von Methoden, Konstruktoren und Feldern:
+
+* **public**: Sichtbar innerhalb und außerhalb des eigenen Pakets
+* **protected**: Sichtbar innerhalb des Pakets und für erbende Klassen
+* **package-private**: Sichtbar innerhalb des Pakets
+* **private**: Nur sichtbar innerhalb der Klasse
+
+---
+
+# Übung
+
+1) Durch welches Schlüsselwort wird der Modifikator `package-private` genutzt?
+    * Durch die Verwendung von keinem Schlüsselwort als Modifikator
+
+2) Wie sollten Pakete benannt werden? 
+    * Umgedrehte Domain: `de.henriburau.meineKlassen`