Tutorium 15.04¶

Wiederholung¶

Interface vs. Abstrakte Klassen¶

 interface Flyable {
   void fly();
 }

 abstract class Animal {
   String name;

   Animal(String name) {
      this.name = name;
   }

   void eat() {
      System.out.println(name + " eats");
   }
 }

 class Bird extends Animal implements Flyable {
   Bird(String name) {
      super(name);
   }

   @Override
   public void fly() {
      System.out.println(name + " flies");
   }
 }

Aufgabe 1¶

Abstrakte Klasse oder Interface¶

??? class DatabaseConnection {
   void connect() { ... }
}

Aufgabe 2¶

Es gibt 3 Java-Objekte

Nutzer
Rechnung
Bild

Alle sollten speicherbar sein - interface oder abstrakte Klasse?

Aufgabe 3¶

Wir haben Hunde-, Katzen- und Vogel-Objekte. Alle Tiere haben eine Namen, sowie ein Alter, des Weiteren können sie essen und lauteMachen.

Wie sollte man das am besten abbilden - Abstrakte Klasse oder Interface?

Aufgabe 4¶

Wir wollen einen einfachen Rechner mit methoden wie addieren() und subtrahieren() bauen. Wie würden wir das am besten Umsetzen?

Aufgabe 5¶

Wir haben 3 Objekte Bericht, Bild und Ticket, alle sollen über die Funktionalität drucken verfügen.

Aufgabe 6¶

Wir haben eine Firma mit drei verschiedenen Angestellten: Vollzeitangestellter, Halbtagsangestellter und Freelancer. Alle haben einen Namen und eine AngestelltenID - aber eine unterschiedliche Berechnung bezüglich des Lohns.

Aufgabe 7¶

Wir haben eine Ente, eine FliegendeFischDrone und einen Rettungsroboter - ein paar können fliegen, ein paar schwimmen und manche können auch beides.

Aufgabe 8¶

Wir haben ein Auto, einen Truck und ein Motorrad. Alle haben eine maximale Geschwindigkeit sowie eine Tankgröße sowie die Funktionalität einer Beschleunigung, die für alle Gefährte gleich ist.

Aufgabe 9¶

Wir haben drei Objekte: EmailNotification, SmsNotification, PushNotification, und alle sollten die Funktionalität send(String message) verfügen.

Aufgabe 10¶

Wir haben einen Kreis, ein Rechteck und ein Dreieck. Alle haben eine Farbe und optional die Funktion sich in x oder y Richtung zu verschieben. Die Flächenberechnung unterscheidet sich natürlich je nach Form.

Array-Sortierung¶

Arrays können in Java ganz schnell wie z.B.

java.util.Arrays.sort(zahlen);

java.util.Arrays.sort(stringListe);

sortiert werden.

Comparable-Interface¶

Im Hintergrund funktioniert das über das Interface Comparable. Implementiert man dieses

 public class Ring implements Comparable <Ring> {

     private double durchmesser;

     public Ring(double durchmesser) {
         this durchmesser = durchmesser;
     }

     public int compareTo(Ring o) {
         double durchmesser_tmp = o.durchmesser
         if (durchmesser < durchmesser_tmp) return -1;
         if (durchmesser > durchmesser_tmp return 1;
         else return 0;
     }

     public String toString() {
         return "Ring der Größe " + durchmesser;
     }

 }

Generizität (Generics)¶

In dem Beispiel haben wir zwei Objekte: Ohrring und Socke.

 public class Ohrring {
     public String toString() {
         return "Ohrring";
     }
 }

 public class Socke {
     public String toString() {
         return "Socke";
     }
 }

Jetzt wollen wir die Socken zusammenlagen, bzw. Paare bilden damit alles zusammenpasst. Da wir nicht Klassen für OhrringPaar und für SockenPaar schreiben wollen müssen wir generalisieren und verwenden als Paar-Typ ein Object.

 public class Paar {

     private Object links, rechts;

     public Paar(Object links, Object rechts) {
         this.links = links;
         this.rechts = rechts;
     }

     public Object getLinks() {
         return this.links;
     }

     public String toString() {
         return "Paar: " + "(" + links + " und " + rechts + ")";
     }

 }

Damit haben wir eine allgemeine Generizität, die jedoch bei der Kompilierung unbekannt ist und zu Fehlern führen kann, da…

public static void main(String[] args) {
    Socke socke = new Socke();
    Ohrring ohrring = new Ohrring();

    Paar paar = new Paar(socke, ohrring);

    print(paar);
}

Type-Parameter (Platzhaltervariablen)¶

 public class Paar<T> {

     private T links, rechts;

     public Paar(T links, T rechts) {
         this.links = links;
         this.rechts = rechts;
     }

     public T getLinks() {
         return this.links;
     }

     public String toString() {
         return "Paar: " + "(" + links + " und " + rechts + ")";
     }
 }

 public static void main(String[] args) {
     Socke s1 = new Socke();
     Socke s2 = new Socke();

     Paar<Socke> sockenPaar = new Paar<Socke>(s1, s2);
 }

Untergruppen¶

image shows inheritance example for visual understanding

extends¶

public class Paar<T extends Schuhe> { ... }

wildcards¶

List<?> dinge;

Bound wildcards¶

List<? extends Schuhe>;

List<? super Schuhe>;

image shows inheritance example for visual understanding with super Type-Parameter.

Methoden¶

Wieder aus unserem Paar beispiel..

public static <T> boolean linksGleichRechts(Paar<T> x) {
    return x.getLinks().equals(x.getRight());
}

public static void main(String[] args) {
    Hose hose = new Hose();
    Jeans jeans = new Jeans();

    Paar<Hose> paar1 = new Paar<Hose>(hose, jeans);
    System.out.println(linksGleichRechts(paar));
}

Wichtig

🚩 Was passiert, wenn man <T> durch eine Wildcard ersetzt <?>?

public static <T,S extends T> GenPaar<T> linksPaar(Paar<T> x, Paar<S> y) {
    return new GenPaar<T>(x.getL(),y.getL());
}

Wie kann diese Methode verwendet werden?

Übungen¶

Übung 1¶

Funktioniert das so?¶

Paar<?> p = new Paar<String>("a", "b");
String s = p.getLinks();

Übung 2¶

Funktioniert das?¶

List<String> temp = new ArrayList<>();
List<?> list = temp;

temp.add("Hallo");
list.add("Test");

Übung 3¶

Welches Problem könnte hierbei entstehen und welchen Vorteil hätte eine generische Klasse Box<T>?¶

class Box {
    private Object wert;

    public Box(Object wert) {
        this.wert = wert;
    }

    public Object getWert() {
        return wert;
    }
}

Box b = new Box("Hallo");
String s = (String) b.getWert();

Übung 4¶

In eigenen Worten - was bedeutet <T> und warum sind in Paar<Integer> nur Integer-Werte und in Paar<String> nur String-Werte erlaubt?

Was bedeutet <T> in einer Klasse?¶

public class Paar<T> {
    private T links;
    private T rechts;

    public Paar(T links, T rechts) {
        this.links = links;
        this.rechts = rechts;
    }

    public T getLinks() {
        return links;
    }
}

Paar<Integer> p1 = new Paar<>(1, 2);
Paar<String> p2 = new Paar<>("A", "B");

Übung 5¶

Warum braucht eine Methode manchmal ein eigenes <T>?¶

public static <T> T gibLinksZurueck(Paar<T> p) {
    return p.getLinks();
}

Was würde fehlen oder nicht mehr funktionieren, wenn man nur schreiben würde?¶

public static T gibLinksZurueck(Paar<T> p)

Übung 6¶

Was kompiliert, was nicht?¶

List<String> a = new ArrayList<String>();
List<String> b = new ArrayList<>();
List<Object> c = new ArrayList<String>();
List<?> d = new ArrayList<String>();
Object e = d.get(0);
String f = d.get(0);
String g = (String) d.get(0);

Übung 7¶

Wozu braucht man eingeschränkte Typenparameter?¶

public static <T extends Number> double doppelt(T wert) {
    return wert.doubleValue() * 2;
}

Was wäre das Problem, wenn die Methode nur so geschrieben würde?¶

public static <T> double doppelt(T wert)