View
1
Download
0
Category
Preview:
Citation preview
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
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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.
Vorlesung Programmieren: Interfaces und Generics14.12.2016
rφ
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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.
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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:
Vorlesung Programmieren: Interfaces und Generics14.12.2016
interface I {
public void foo();
}
interface J extends I {
public void bar();
}
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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;
...
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
13 Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
http://inta.fzi.de/inta
Umfrage-ID: 116
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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!
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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>();
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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) { ... }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
18
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) { ... }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
19
Generische Listen (I)
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>() {
first = last = null; // leere Liste
}
public void addFirst(T p) { ... }
public void addLast(T p) { ... }
public void remove(T p) { ... }
public boolean contains(T p) { ... }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
20
Generische Listen (II)
class DoublyLinkedList<T> {
private class ListCell<T> {
T content;
ListCell<T> prev; // Vorgänger
ListCell<T> next; // Nachfolger
ListCell(T c, ListCell<T> p, ListCell<T> n) {
this.content = c;
this.prev = p;
this.next = n;
}
}
private ListCell<T> first, last;
public DoublyLinkedList<T>() {
first = last = null; // leere Liste
}
public void addFirst(T elmt) { ... }
public void addLast(T elmt) { ... }
public void remove(T elmt) { ... }
public boolean contains(T elmt) { ... }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
21
Generische Listen (II)
class DoublyLinkedList<T> {
private class ListCell<T> {
T content;
ListCell<T> prev; // Vorgänger
ListCell<T> next; // Nachfolger
ListCell(T c, ListCell<T> p, ListCell<T> n) {
this.content = c;
this.prev = p;
this.next = n;
}
}
private ListCell<T> first, last;
public DoublyLinkedList<T>() {
first = last = null; // leere Liste
}
public void addFirst(T elmt) { ... }
public void addLast(T elmt) { ... }
public void remove(T elmt) { ... }
public boolean contains(T elmt) { ... }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Weitere Abstraktion:
interface List<T> {
void addFirst(T elmt);
void addLast(T elmt);
void remove(T elmt);
boolean contains(T elmt);
}
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
22
Generische Listen (II)
class DoublyLinkedList<T> implements List<T> {
private class ListCell<T> {
T content;
ListCell<T> prev; // Vorgänger
ListCell<T> next; // Nachfolger
ListCell(T c, ListCell<T> p, ListCell<T> n) {
this.content = c;
this.prev = p;
this.next = n;
}
}
private ListCell<T> first, last;
public DoublyLinkedList<T>() {
first = last = null; // leere Liste
}
public void addFirst(T elmt) { ... }
public void addLast(T elmt) { ... }
public void remove(T elmt) { ... }
public boolean contains(T elmt) { ... }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Weitere Abstraktion:
interface List<T> {
void addFirst(T elmt);
void addLast(T elmt);
void remove(T elmt);
boolean contains(T elmt);
}
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
23
Generische Listen (II)
class DoublyLinkedList<T> implements List<T> {
private class ListCell<T> {
T content;
ListCell<T> prev; // Vorgänger
ListCell<T> next; // Nachfolger
ListCell(T c, ListCell<T> p, ListCell<T> n) {
this.content = c;
this.prev = p;
this.next = n;
}
}
private ListCell<T> first, last;
public DoublyLinkedList<T>() {
first = last = null; // leere Liste
}
public void addFirst(T elmt) { ... }
public void addLast(T elmt) { ... }
public void remove(T elmt) { ... }
public boolean contains(T elmt) { ... }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Weitere Abstraktion:
interface List<T> {
void addFirst(T elmt);
void addLast(T elmt);
void remove(T elmt);
boolean contains(T elmt);
}
Verwendung:
public void foo() {
List<Vector2D> l = new
DoublyLinkedList<Vector2D>;
Vector2D p = new
Vector2D(2.0, 4.0);
l.addFirst(p);
...
}
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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!
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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; }
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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> {
...
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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"
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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;
}
}
Vorlesung Programmieren: Interfaces und Generics14.12.2016
Jun.-Prof. Dr.-Ing. Anne Koziolek, Arbeitsgruppe Architecture-Driven Requirements
Engineering, Institut für Programmstrukturen und Datenorganisation
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: Interfaces und Generics14.12.2016
Recommended