From 9d6a1ce2c4f94e4c7f7f6e6257594045570eef32 Mon Sep 17 00:00:00 2001 From: "Burau, Henri" Date: Wed, 5 May 2021 17:24:24 +0200 Subject: [PATCH 1/2] 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 @@ + + +# 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 @@ + + +# 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 { + public T gibHer(T type) { return type; } +} +``` + +```java +// Benutzung +Test 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
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 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 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 @@ + + +# Reflections + +--- + + From 495c8b5229045ed2e2dd601b66d1416c88651ac2 Mon Sep 17 00:00:00 2001 From: Henri Burau Date: Thu, 6 May 2021 15:56:58 +0200 Subject: [PATCH 2/2] Finished termin2 --- generics2.md | 16 ++++++++++++++-- reflections.md | 49 ++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 62 insertions(+), 3 deletions(-) diff --git a/generics2.md b/generics2.md index b1507a7..8db33e5 100644 --- a/generics2.md +++ b/generics2.md @@ -12,7 +12,7 @@ footer: Henri Burau # Grundlagen -Durch Generizität können wir Typen, Klasse und Methode parametrisieren. Der +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. @@ -36,7 +36,7 @@ String result = test.gibHer(test); 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: +Einschränkungen zur Laufzeit: * Generische Klassen können keine statischen Felder haben * Es können keine Instanzen aus generischen Typen erzeugt werden @@ -80,6 +80,8 @@ class ListenSchreiber { } ``` +Warum wird hier nicht der Parameter-Typ ``List`` genutzt? + --- ## Lower Bounds @@ -96,6 +98,9 @@ class IntegerSammler { } } ``` + +Welche Typen akzeptiert der Compiler für den Parameter ``liste``? + --- ## Upper Bounds @@ -113,6 +118,13 @@ class Sortierer { } ``` +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 + diff --git a/reflections.md b/reflections.md index 8c816ca..23fd210 100644 --- a/reflections.md +++ b/reflections.md @@ -10,4 +10,51 @@ footer: Henri Burau --- - +# 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]()) + +--- + +# 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.