Merge branch 'master' of git.haw-hamburg.de:pm2-tutorium/slides

05-termin.md

@@ -0,0 +1,31 @@
+<!--
+title: Termin 5
+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 5
+
+---
+
+# Fragen
+
+---
+
+# Links
+[https://git.haw-hamburg.de/pm2-tutorium](https://git.haw-hamburg.de/pm2-tutorium)
+- Aufgaben
+- Tutoriumsfolien
+
+---
+
+# Plan für heute
+
+Level 6 Themen:
+
+- Werkzeug & Material-Ansatz
+- Entwurfsmuster
+- **Lambdas**
+- **Streams**

07-termin.md

@@ -0,0 +1,40 @@
+<!--
+title: Termin 7
+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 7
+
+---
+
+# Fragen
+
+---
+
+# Links
+[https://git.haw-hamburg.de/pm2-tutorium](https://git.haw-hamburg.de/pm2-tutorium)
+- Aufgaben
+- Tutoriumsfolien
+  * In Präsentationsansicht: [https://wi-pm2-tut.informatik.haw-hamburg.de](https://wi-pm2-tut.informatik.haw-hamburg.de/)
+
+---
+
+# Plan für heute
+
+Level 7 Themen:
+
+- *Organisatorisches*
+- **Objektorientierter Entwurf**
+
+---
+
+# Plan
+
+* Am 24.6. letzter Termin
+* 1.7. findet nicht statt, aber es gibt eine Aufzeichnung.
+* Prüfungsvorberreitung wird es auch in Form einer Aufzeichnung geben.
+    * Entweder Erklärung der Prüfung oder die ganze Prüfung aufgezeichnet.
+* Fragen gerne auf Teams stellen. Am Montag den 5.7. um 11 Uhr gibt es noch eine Fragestunde.

deploy.yml

@@ -1,23 +1,27 @@
-apiVersion: extensions/v1beta1
+apiVersion: networking.k8s.io/v1
 kind: Ingress
 metadata:
   annotations:
     kubernetes.io/tls-acme: "true"
     kubernetes.io/ingress.class: "nginx"
+    nginx.ingress.kubernetes.io/rewrite-target: /
   name: slides-ingress
 spec:
   tls:
   - hosts:
     - wi-pm2-tut.informatik.haw-hamburg.de
-    secretName: slides-secret-new
+    secretName: slides-secret
   rules:
   - host: wi-pm2-tut.informatik.haw-hamburg.de
     http:
       paths:
       - path: /
+        pathType: Prefix
         backend:
-          serviceName: slides
+          service:
-          servicePort: 80
+            name: slides
+            port: 
+              number: 80
 
 ---
 

lambdas.md

@@ -0,0 +1,73 @@
+<!--
+title: Lambdas
+description: Folien für Lambdas in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+-->
+
+# Lambdas
+
+---
+
+# Grundlagen
+
+Erlauben das Implementieren von Interfaces mit nur einer Methode. 
+
+Klassischerweise wurde dieses Problem mithilfe von anonymen inneren Klassen gelöst. Lambda-Ausdrücke sparen im Vergleich dazu deutlich an Code.
+
+---
+
+# Beispiel
+
+Lambda
+```java
+_zaehlerUI.gibErhoeheButton().setOnAction(event -> {
+    _zaehler.zaehleHoch();
+    informiereUeberAenderung();
+  });
+```
+
+Anonyme innere Klasse
+```java
+_zaehlerUI.gibErhoeheButton().setOnAction(new EventHandler<ActionEvent>() {	
+    @Override
+    public void handle(ActionEvent event) {
+        _zaehler.zaehleHoch();
+        informiereUeberAenderung();
+    }
+});
+```
+---
+
+# Beispiel
+
+```java
+// Lambda ohne explizite Typen und return (type inference)
+x -> x * 2
+
+// Lambda mit explitizen Typen der formalen Parameter
+(int x, int y) -> x + y
+
+// Lambda mit return
+(int x, int y) -> { return x * y + 2  }
+```
+
+---
+
+# Deklaration
+
+```java
+@FunctionalInterface
+public interface Filter<T> {
+    bool istGueltig(T obj);
+}
+```
+
+```java
+Filter<String> langGenug = (String text) -> text.length() > 10;
+```
+
+# Aufgabe
+
+1) Die Klasse `ZaehlerWerkzeug` nutzt das Interface `Observer` um Änderungen von Subwerkzeugen zu erhalten. `ZaehlerWerkzeug` registriert sich mithilfe von anonymen inneren Klassen. Baue das System der Observer um, sodass Lambdas genutzt werden.

oo_design.md

@@ -0,0 +1,93 @@
+<!--
+title: Object Orientated Design
+description: Folien für Object Orientated Design in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+-->
+
+# Objektorientierter Entwurf
+
+---
+
+# Grundlagen
+
+Software verändert sich regelmäßig. Diese Änderungen sollten sich so einfach wie möglich umsetzen lassen. Dabei hilft ein guter Objektorientierter Entwurf.  
+
+---
+
+# Zuständigkeiten
+
+Ein Objekt in der Objektorientierung soll immer für genau eine Aufgabe verantwortlich sein (engl. "Seperation of Concerns").
+
+--- 
+
+# Kopplung
+
+Die Abhängigkeiten zwischen den unterschiedlichen Objekten soll so gering wie möglich sein. Dabei helfen vor allem Interfaces. Es gibt zwei Arten von Kopplung auf die wir achten müssen:
+
+* Explizite Kopplung: Sind zur Übersetzungszeit klar (Methodenaufrufe etc.).
+* Implizite Kopplung: Es wird sich auf Interna verlassen die nirgendwo spezifiziert sind (z.B. Sortierung).
+
+---
+
+# Zyklenvermeidung
+
+Es sollte unter den Objekten keine zyklischen Abhängigkeiten geben. Stattdessen sollte eine klare Hierarchie der Klassen bestehen.
+
+--- 
+
+# Law of Demeter
+
+"Talk to friends not to strangers"
+
+Eine Methode `f` in Klasse `C` sollte nur Methoden aufrufen aus:
+* `C`
+* Objekte die von `f` erzeugt werden
+* Objekte die `f` als Paramter übergeben werden
+* Exemplarvariablen von `C`
+
+Vermieden werden sollen sind lange Aufrufketten wie man das in Java häufig sieht.
+
+---
+
+# Kohäsion
+
+Ergänzend zu den Zuständigkeiten. Die Kohäsion ist der Grad der Aufgaben die eine Softwareeinheit erfüllt. Bei hoher Kohäsion ist ein Objekt genau für eine Aufgabe zuständig.
+
+---
+
+# Geeignete Bezeichner
+
+Konkrete Klasse sollten durch ein Substantiv benennbar sein. Methoden sollten durch ein treffendes Verb benennbar sein. Die Bezeichner sollten konsistent im ganzen System sein.
+
+---
+
+# Don't repeat yoursef (DRY)
+
+Quelltext sollte nicht an mehreren Stellen eines Systems identisch vorhanden sein. Das ist ein Zeichen von schlechten Code.
+
+---
+
+# Gottklassen
+
+Beinhaltet eine Klasse plötzlich 90% des Quelltextes dann ist das ein Anti-Pattern (oder Code-Smell). Eine solche "Gottklasse" ist ein Zeichen für einen schlechten Softwareentwurf, da wir niedrige Kohäsion haben.
+
+---
+
+# SOLID
+
+* SRP: Single Responsibility Principle
+    * Hohe Kohäsion
+* OCP: Open Closed Principle
+    * Open for Extension/Closed for Modification -> Vertrauen in Code steigt
+* LSP: Liskov Substitution Principle
+    * Eine Subklasse soll immer Ersatz für ihre Superklasse sein
+* ISP: Interface Segregation Principle
+    * Ein Klient sollte nicht gezwungen sein von Methoden abzuhänge, die er nicht benutzt
+* DIP: Dependency Inversion Principle
+    * Reduzierte Kopplung: Man sollte niemals von etwas konkreten abhängen sondern immer von Interfaces
+
+---
+
+# Kein Code < Schlechter Code

streams.md

@@ -0,0 +1,51 @@
+<!--
+title: Streams
+description: Folien für Streams in Programmieren 2
+url: https://git.haw-hamburg.de/pm2-tutorium/slides
+header: Programmieren 2 **Tutorium**
+footer: Henri Burau
+-->
+
+# Streams
+
+Erleichtert das Verarbeiten von Sammlungen aus den Collection Framework. 
+
+---
+
+# Grundlagen
+
+Die [Stream-API](https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html) bietet Higher Order Functions (HOF) die auf Collections arbeiten. Dazu zählen:
+ * filter
+ * map
+ * fold
+
+Die Verarbeitung erfolgt in drei Schritten: Erzeugung des Streams, Verarbeitung des Streams und zum Schluss Terminieren des Streams.
+
+---
+
+# Beispiel
+
+```java
+List<String> liste = new ArrayList<String>();
+liste.addAll("was", "geht", "ab", "?");
+
+int laenge = liste.stream().map(text -> text.length()).reduce(0, Integer::sum);
+
+List<String> nurWoerter = liste.stream()
+                               .filter(s -> s.matches("[a-zA-Z]"))
+                               .collect(Collectors.toList());
+
+int nurLangeWoerterLaenge = liste.stream()
+                                 .filter(s -> s.matches("[a-zA-Z]"))
+                                 .filter(s -> s.length() >= 3)
+                                 .map(s -> s.length())
+                                 .reduce(0, Integer::sum)
+``` 
+
+[`Stream:reduce(Binary)`](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#reduce-T-java.util.function.BinaryOperator-)
+
+---
+
+# Aufgabe
+
+1) Berechne in `SummiererWerkzeug.setzeSumme()` die Summe der einzelnen Zähler mithilfe von Streams.