Vorlesung Programmieren - KIT · 2016-12-21 · Abstrakte Klassen vs. Interfaces Abstrakte Klassen:...

KIT – Universität des Landes Baden-Württemberg und

nationales Forschungszentrum in der Helmholtz-Gemeinschaft

ARBEITSGRUPPE ARCHITECTURE-DRIVEN REQUIREMENTS ENGINEERING (ARE)

INSTITUT FÜR PROGRAMMSTRUKTUREN UND DATENORGANISATION (IPD), KIT-FAKULTÄT FÜR INFORMATIK

www.kit.edu

are.ipd.kit.edu

Vorlesung Programmieren

9. Interfaces, Generics

14.12.2016 | Jun.-Prof. Dr.-Ing. Anne Koziolek Version 1.1

Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements

Engineering, Institut für Programmstrukturen und Datenorganisation

2

Literaturhinweis - Weiterlesen

Dietmar Ratz, Jens Scheffler, Detlef Seese und Jan Wiesenberger

"Grundkurs Programmieren in Java", 7. Auflage, 2014 (mit Java 8),

Hansa-Verlag

Kapitel 7 "Die objektorientierte Philosophie"

Abschnitt 7.3 "Die vier Grundpfeiler objektorientierter Programmierung"

Kapitel 9 "Vererbung und Polymorphismus"

Abschnitt 9.6 "Abstrakte Klassen und Interfaces"

Kapitel 11 "Fortgeschrittene objektorientierte Programmierung"

Abschnitt 11.2 "Generische Datentypen"

Abschnitte 11.2.1, 11.2.2, 11.2.3., 11.2.6.

Abschnitt 11.3 "Sortieren von Feldern und das Interface Comparable"

Kapitel 21 "Neuerung in Java 7"

Abschnitt 21.1.2 Verkürzte Notation bei generischen Datentypen

Vorlesung Programmieren: Interfaces und Generics14.12.2016



3

Debugging

Der systematische Prozess der Fehlersuche und -behebung im

Programm wird Debugging genannt.

Hierzu finden Sie den Wiki-Artikel "Debugging" unter:

https://ilias.studium.kit.edu/goto.php?target=wiki_583570_Debugging

Eine praktische Einführung in Debugging-Methoden erhalten Sie in

Ihrem jeweiligen Tutorium




4

Motivation - Interfaces

Wir können Punkte auch mit Polarkoordinaten implementieren:

class PolarPoint {

private double phi;

private double r;

public PolarPoint(double phi, double r) { ... }

public void shift(double x, double y) { ... }

public void rotate(double phi) { ... }

public void rotate(PolarPoint Center, double phi) { ... }

public double distanceTo(PolarPoint p) { ... }

public boolean equals(PolarPoint p) { ... }

...

}

Um für Klarheit bei der Verwendung der unterschiedlichen Implementierungen zu sorgen, benennen wir die Klasse Vector2D in CartesianPoint um.


rφ



5

Interfaces als Schnittstellenbeschreibung (I)

Was ist nun zu tun, um eine Liste von Punkten zu implementieren?

Definiere ein Interface Point. Ein Interface definiert alle nötigen

public-Methoden, ohne eine Implementierung vorzugeben.

interface Point {

void shift(double x, double y);

void rotate(double phi); // rotate around origin

void rotate(Point Center, double phi);

double distanceTo(Point p);

boolean equals(Point p);

double getX();

double getY();

double distance();

double angle();

}

Dieses Interface kann dann in einer Listen-Implementierung (z.B. PointList)

anstelle von CartesianPoint verwendet werden.




6

Interfaces als Schnittstellenbeschreibung (II)

Die Klassen CartesianPoint und PolarPoint müssen nun das Interface

Point implementieren:

class CartesianPoint implements Point {

private double x;

private double y;

...

}

class PolarPoint implements Point {

private double phi;

private double r;

...

}

Dabei müssen alle im Interface Point vorgegebenen Methoden implementiert

werden und public verfügbar sein!

CartesianPoint und PolarPoint sind Subtypen von Point




7

Interfaces als Schnittstellenbeschreibung (III)

Ein Interface

ist eine Sammlung von Methodensignaturen ohne Implementierung

legt die Methoden-Namen und Parameter-Typen fest

macht aber keine Annahme über die Implementierung der Methoden

kann selbst zur Typisierung verwendet werden

➜ Eine Klasse C, die ein Interface I implementiert, bildet einen Subtyp

von I.

wird von einer Klasse implementiert, indem für jede Methode aus dem

Interface eine Implementierung angegeben wird

kann von einem anderen Interface erben:


interface I {

public void foo();

}

interface J extends I {

public void bar();

}



8

Interfaces – Syntax

Syntax:

Interface-Deklaration: interface Name { Konstanten, Methodenköpfe }

Implementierung: class KlassenName implements InterfaceNamen { ... }

Eine Klasse kann mehrere Interfaces gleichzeitig implementieren

(Namen werden mit Kommas getrennt)

Werden mehrere Interfaces implementiert und enthalten diese dieselbe

Methodensignatur, so wird die entsprechende Methode in der Klasse nur

einmal implementiert

In der implementierenden Klasse muss jede Methode aus den Interfaces

implementiert sein




9

Interfaces – Verwendung

Gegebene Methode (in einer weiteren Klasse):

public static void foo(Point p) {

p.shift(3.0, 5.0);

}

Was passiert bei ... ?

PolarPoint q = new PolarPoint(90.0, 1.0);

foo(q);

CartesianPoint r = new CartesianPoint(0.0, 1.0);

foo(r);

p hat den (statischen) Typ Point. Beim Aufruf von p.shift(...) wird von

Java ermittelt, welches Objekt momentan in der Variable steckt und dann die

entsprechende Methode dieses Objekts aufgerufen.

➜ Bei foo(q) wird shift() aus PolarPoint aufgerufen

➜ Bei foo(r) wird shift() aus CartesianPoint aufgerufen




10

Beispiel – Liste

Nächster Abstraktions-Schritt:

Ein Algorithmus, der auf einer Liste von Punkten arbeitet, sollte

unabhängig von der Implementierung der Liste funktionieren

➜ Erstelle ein Interface PointList, das von der Implementierung

abstrahiert

interface PointList {

void addFirst(Point p);

void addLast(Point p);

Point getFirst();

Point getLast();

...

}

class DoublyLinkedPointList implements PointList {

private ListCell first;

private ListCell last;

...

}




11

Interfaces – Übersicht

Reine Definition eines Typen (Menge von Methoden-Signaturen)

➜ Definition einer Schnittstelle

Methoden-Implementierung erst in den Klassen

Objekte können mehrere Typen haben

(Typ einer Klasse und mehrere Interfaces)

Interfaces können nicht instanziiert werden➜ Keine Erzeugung mit new




12

Abstrakte Klassen vs. Interfaces

Abstrakte Klassen:

Nicht instanziierbare Oberklassen

Können Attribute und Methoden-Implementierungen enthalten

Verwendung: partielle Implementierung für gemeinsame Funktionalität

zur Verfügung stellen

Interfaces:

Definieren Schnittstelle (Menge von Methoden, die eine Klasse zwingend

zur Verfügung stellen muss)

Verwendung: Abstraktion von konkreter Implementierung




13 Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements


Quiz

1. Welche Aussage zu Interfaces und abstrakten Klassen ist nicht richtig?

(A) Man kann eine abstrakte Klasse von einer anderen abstrakten Klasse

ableiten

(B) Eine von einer abstrakten Klasse abgeleitete Klasse muss alle abstrakten

Methoden implementieren

(C) Eine Klasse kann mehrere Interfaces implementieren

(D) Man kann ein Interface von einem anderen mittels extends ableiten

(E) In einer abstrakten Klasse können sämtliche Methoden nicht-abstrakt sein


http://inta.fzi.de/inta

Umfrage-ID: 116



14

Motivation - Generische Klassen

Aufgabe 1: Erstelle eine Liste für Point-Objekte

Haben wir bereits gemacht (Interface PointList, Implementierung

DoublyLinkedPointList)

Aufgabe 2: Erstelle eine Liste für Line-Objekte

Entwerfe Interface LineList und Klasse DoublyLinkedLineList

analog zu Punkt-Listen

Aufgabe 3: Erstelle eine Liste für ???-Objekte

???

Beim Entwurf der Liste sollte es egal sein, welchen Typ die enthaltenen

Objekte haben!

➜ Mache den Typ des Listeninhalts generisch!




15

Generics – Konzept

Beobachtung:

Code von Container-Datentypen (und anderen Datenstrukturen) ist

unabhängig vom Typ der Basisdaten

Beispiel:

Code zum Einfügen in eine Liste ist unabhängig vom Elementtyp

Idee: Typ der Basisdaten ist Parameter der Datenstruktur

Also: Auch Typen können Parameter sein, nicht nur Werte!

Vorteile:

Der Compiler kann eine Typprüfung durchführen

➜ Programmierfehler werden frühzeitig erkannt

Keine redundanten Implementierungen

Programm-Code wird lesbarer




16

Syntax – Polymorphie in Java

Generische / polymorphe Typen in Java

Syntax:

class Name<Typ-Parameter> { ... }

interface Name<Typ-Parameter> { ... }

Verwendung:

TypName<BasisTyp>

Beispiel:

Klassendeklaration:

class DoublyLinkedList<Data> { ... }

Verwendung:

DoublyLinkedList<Point> ps = new DoublyLinkedList<Point>();




17

Generische Listen (I)

class Vector2DDoublyLinkedList {

private class ListCell {

Vector2D content;

ListCell prev; // Vorgänger

ListCell next; // Nachfolger

ListCell(Vector2D v, ListCell p, ListCell n) {

this.content = v;

this.prev = p;

this.next = n;

}

}

private ListCell first, last;

public Vector2DDoublyLinkedList() {

first = last = null; // leere Liste

}

public void addFirst(Vector2D p) { ... }

public void addLast(Vector2D p) { ... }

public void remove(Vector2D p) { ... }

public boolean contains(Vector2D p) { ... }

}




18


class Vector2DDoublyLinkedList {

private class ListCell {

Vector2D content;

ListCell prev; // Vorgänger

ListCell next; // Nachfolger

ListCell(Vector2D v, ListCell p, ListCell n) {

this.content = v;

this.prev = p;

this.next = n;

}

}

private ListCell first, last;

public Vector2DDoublyLinkedList() {


}

public void addFirst(Vector2D p) { ... }

public void addLast(Vector2D p) { ... }

public void remove(Vector2D p) { ... }

public boolean contains(Vector2D p) { ... }

}




19


class DoublyLinkedList<T> {

private class ListCell<T> {

T content;

ListCell<T> prev; // Vorgänger

ListCell<T> next; // Nachfolger

ListCell(T v, ListCell<T> p, ListCell<T> n) {

this.content = v;

this.prev = p;

this.next = n;

}

}

private ListCell<T> first, last;

public DoublyLinkedList<T>() {


}

public void addFirst(T p) { ... }

public void addLast(T p) { ... }

public void remove(T p) { ... }

public boolean contains(T p) { ... }

}




20

Generische Listen (II)



T content;



ListCell(T c, ListCell<T> p, ListCell<T> n) {

this.content = c;

this.prev = p;

this.next = n;

}

}




}

public void addFirst(T elmt) { ... }

public void addLast(T elmt) { ... }

public void remove(T elmt) { ... }

public boolean contains(T elmt) { ... }

}




21




T content;




this.content = c;

this.prev = p;

this.next = n;

}

}




}





}


Weitere Abstraktion:

interface List<T> {

void addFirst(T elmt);

void addLast(T elmt);

void remove(T elmt);

boolean contains(T elmt);

}



22


class DoublyLinkedList<T> implements List<T> {


T content;




this.content = c;

this.prev = p;

this.next = n;

}

}




}





}



interface List<T> {





}



23


class DoublyLinkedList<T> implements List<T> {


T content;




this.content = c;

this.prev = p;

this.next = n;

}

}




}





}



interface List<T> {





}

Verwendung:

public void foo() {

List<Vector2D> l = new

DoublyLinkedList<Vector2D>;

Vector2D p = new

Vector2D(2.0, 4.0);

l.addFirst(p);

...

}



24

Generische Listen (III)

Aufgabe 1: Erstelle eine Liste für Point-Objekte

Lösung:List<Point> pList = new DoublyLinkedList<Point>();

Aufgabe 2: Erstelle eine Liste für Line-Objekte

Lösung:List<Line> lList = new DoublyLinkedList<Line>();

➜ Man kann jetzt Listen mit beliebigen Typen einfach erstellen!




25

Mehrere Typ-Parameter

Es dürfen auch mehrere Typ-Parameter verwendet werden:

class Pair<A, B> {

private A first;

private B second;

Pair(A a, B b) {

first = a;

second = b;

}

A getFirst() { return first; }

B getSecond() { return second; }

}




26

Vergleichen von Objekten

Sollen Objekte z.B. sortiert werden, muss man sie vergleichen können.

Dies wird am Besten über eine einheitliche Schnittstelle gemacht:interface Comparable<T> {

/** Compares this object with the specified object for order.

* Returns a negative integer, zero, or a positive integer as this

* object is less than, equal to, or greater than the specified

* object.

int compareTo(T obj);

}

Diese Methode vergleicht zwei Objekte A und B des gleich Typs

A.compareTo(B) liefert:

einen positiven Wert (z.B. +1), wenn A größer als B ist

einen negativen Wert (z.B. -1), wenn A kleiner als B ist

die Zahl 0, wenn die beiden Objekte gleich sind

Viele Java-Datenklassen implementieren das Interface Comparable, z.B.:

java.util.Date

java.lang.String




27

Vergleichen von Objekten

Beispiel-Implementierung des Interfaces bei gleichzeitiger Instanziierung:

class Student implements Comparable<Student> {

private final int matrNr;

public Student(int matrNr) { ... }

public int compareTo(Student s) {

return this.matrNr - s.matrNr;

}

...

}

Ziel: Beliebige Felder von selbst definierten Objekten mit der sort-Methode

sortieren.

Ein Feld numbers von int-Werten kann durch den Befehl sortiert werden:

java.util.Arrays.sort(numbers)

Andere einfache Datentypen können analog sortiert werden.

Nach dem Implementieren des Interface Comparable können students analog

mit der Methode java.util.Arrays.sort(students) sortiert werden.

Nach welchem Kriterium vergleicht die sort-Methode die Studenten?

Matrikelnummer




28

Einschränkungen

Die Typ-Parameter dürfen nur mit Referenz-Typen instanziiert werden

(also keine primitiven Typen)

Man kann auch die zulässigen Typen einschränken

class PointList<T extends Point> {

...

}

PointList darf nur mit Typen instanziiert werden, die das Interface Point

implementieren:

PointList<PolarPoint> pps = new PointList<PolarPoint>();

ist ok

PointList<String>

erzeugt einen Fehler

Es sind auch mehrere einschränkende (Interface-)Typen erlaubt

interface I<T extends C & I1 & I2> {

...

}




29

Wrapper-Objekte, Autoboxing

Problem: Typ-Parameter können nicht mit primitiven Typen instanziiert werden

Lösung: Wrapper-Klassen (definiert in java.lang)

Wrapper-Klassen nehmen einen primitiven Datentyp in einem Objekt auf

Byte, Short, Integer, Long, Double, Float, Boolean, Character (und Void)

Anwendungsbeispiele:Erzeugen von Wrapper-Objekten:

Integer intObj = new Integer(5);

intObj = Integer.valueOf(17);

Double doubleObj = new Double(4.5);

"Rechnen" mit Wrapper-Objekten vor Java 5 nicht direkt möglich:

intObj = new Integer(intObj.intValue() + 1);

Seit Java 5: Autoboxing (automatisches Konvertieren zwischen primitiven Typen und Wrapper-

Objekten)

int i = 42;

Integer j = i; // expandiert zu j = Integer.valueOf(i); "Boxing"

int k = j; // expandiert zu k = j.intValue(); "Unboxing"




30

Generische Methoden

Man kann auch generische Methoden definieren

Syntax:<Typ-Parameter> Typ Name(Parameter-Liste) { ... }

Beispiele:

Zufällige Auswahl zweier Werte:public static <T> T randomSelect(T e1, T e2) {

return (Math.random() > 0.5 ? e1 : e2);

}

Eine generische Methode, die das Minimum zweier mit sich selbst

vergleichbaren Objekte liefert:<T extends Comparable<T>> T min(T e1, T e2) {

if (e1.compareTo(e2) <= 0) {

return e1;

} else {

return e2;

}

}




31

Zusammenfassung

Abstrakte Klassen:

Nicht instanziierbare Oberklassen

Können Attribute und Methoden-Implementierungen enthalten

Verwendung: partielle Implementierung für gemeinsame Funktionalität

zur Verfügung stellen

Interfaces:

Definieren Schnittstelle (Menge von Methoden, die eine Klasse zwingend

zur Verfügung stellen muss)

Verwendung: Abstraktion von konkreter Implementierung

Generics:

Ersetzen eines konkreten Typs durch eine "Typ-Variable" (Parameter)

Typ-Parameter erlaubt Wiederverwendung bzw. Generalisierung von

Programmcode

Verwendung: Container-Klassen, Abstraktion von Typen


Vorlesung Programmieren - KIT · 2016-12-21 · Abstrakte Klassen vs. Interfaces Abstrakte Klassen:...

Documents

Transcript of Vorlesung Programmieren - KIT · 2016-12-21 · Abstrakte Klassen vs. Interfaces Abstrakte Klassen:...