From a062672e2fcf15c4013556dc610d27302b2bec19 Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 17 Jun 2021 11:02:45 +0200 Subject: [PATCH 1/7] Add termin5 --- 05-termin.md | 31 ++++++++++++++++++++++ lambdas.md | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++ streams.md | 51 ++++++++++++++++++++++++++++++++++++ 3 files changed, 155 insertions(+) create mode 100644 05-termin.md create mode 100644 lambdas.md create mode 100644 streams.md diff --git a/05-termin.md b/05-termin.md new file mode 100644 index 0000000..2911cb4 --- /dev/null +++ b/05-termin.md @@ -0,0 +1,31 @@ + + +# 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** diff --git a/lambdas.md b/lambdas.md new file mode 100644 index 0000000..04c9f9c --- /dev/null +++ b/lambdas.md @@ -0,0 +1,73 @@ + + +# 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() { + @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 { + bool istGueltig(T obj); +} +``` + +```java +Filter 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. diff --git a/streams.md b/streams.md new file mode 100644 index 0000000..f4f2a93 --- /dev/null +++ b/streams.md @@ -0,0 +1,51 @@ + + +# 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 liste = new ArrayList(); +liste.addAll("was", "geht", "ab", "?"); + +int laenge = liste.stream().map(text -> text.length()).reduce(0, Integer::sum); + +List 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. From f21087b7910564a3f581f013fba5059494b7e939 Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 17 Jun 2021 12:59:39 +0200 Subject: [PATCH 2/7] Update ingress to newer resource --- deploy.yml | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/deploy.yml b/deploy.yml index b65ddd7..92352cd 100644 --- a/deploy.yml +++ b/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 - servicePort: 80 + service: + name: slides + port: + number: 80 --- From 98314fc5ee870e5a11236bf26147f1f395a097cf Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 17 Jun 2021 13:00:30 +0200 Subject: [PATCH 3/7] Add termin slide --- 07-termin.md | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 07-termin.md diff --git a/07-termin.md b/07-termin.md new file mode 100644 index 0000000..bf8fe97 --- /dev/null +++ b/07-termin.md @@ -0,0 +1,40 @@ + + +# 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. From 3968c9f8c2cd70eda42d12fb5d6ef5e1a93d0f14 Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 17 Jun 2021 13:13:02 +0200 Subject: [PATCH 4/7] Start work on termin7 --- oo_design.md | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 oo_design.md diff --git a/oo_design.md b/oo_design.md new file mode 100644 index 0000000..04344dd --- /dev/null +++ b/oo_design.md @@ -0,0 +1,9 @@ + + +# Objektorientierter Entwurf From 71799703feeb502b3ca68c9f2670678d50826897 Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 17 Jun 2021 13:16:39 +0200 Subject: [PATCH 5/7] Add test --- test | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 test diff --git a/test b/test new file mode 100644 index 0000000..e69de29 From ade9c90265156ad171bf099d7000f88d4eb11cd7 Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 17 Jun 2021 15:27:32 +0200 Subject: [PATCH 6/7] Finish OO design --- oo_design.md | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/oo_design.md b/oo_design.md index 04344dd..c20dbbf 100644 --- a/oo_design.md +++ b/oo_design.md @@ -7,3 +7,78 @@ 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 +* OCP: Open Closed Principle +* LSP: Liskov Substitution Principle +* ISP: Interface Segregation Principle +* DIP: Dependency Inversion Principle From c63851ddb9b3b8a126fef954177ba2b9a921f821 Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 17 Jun 2021 15:58:56 +0200 Subject: [PATCH 7/7] Add content for SOLID principals --- oo_design.md | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/oo_design.md b/oo_design.md index c20dbbf..26743eb 100644 --- a/oo_design.md +++ b/oo_design.md @@ -12,7 +12,7 @@ footer: Henri Burau # Grundlagen -Software verändert sich regelmäßig. Diese Änderungen sollten sich so einfach wie möglich umsetzen lassen. Dabei hilft ein guter Objektorientierter Entwurf. +Software verändert sich regelmäßig. Diese Änderungen sollten sich so einfach wie möglich umsetzen lassen. Dabei hilft ein guter Objektorientierter Entwurf. --- @@ -78,7 +78,16 @@ Beinhaltet eine Klasse plötzlich 90% des Quelltextes dann ist das ein Anti-Patt # 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