Programmierkurs Java

Programmierkurs Java
Teil
Objektorientierte Programmierung
Unterrichtseinheit 31
Polymorphie
Dr. Dietrich Boles
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 1
Gliederung
 Definition
 Beispiel
 Protokolleinschränkung
 Typumwandlung
 Klasse Object
 Beispiel Stack
 Zusammenfassung
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 2
Definition
Polymorphie:
 Fähigkeit einer Objektvariablen vom Typ T1, auf Objekte von
Klassen eines anderen Typs T2 verweisen zu können
 in Java: T2 muss Unterklasse von T1 sein
 Protokoll ist auf das Protokoll von T1 eingeschränkt
 Hintergrund: Protokoll von T1 ist echte Teilmenge von Protokoll von
T2
 Relevanz: Compilierzeit
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 3
Beispiel
 Sei B eine direkte oder indirekte Unterklasse von A .
A
C
A object1 = new B(); // Polymorphie
B
static void f(A object) { ... }
B b = new B();
f(b); // Polymorphie
B object2 = new A();
// Fehler
A object3 = new C();
// Fehler
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 4
Protokolleinschränkung
class Person {
String name;
Person(String name) { this.name = name; }
void print() { IO.println(name); }
}
class Mitarbeiter extends Person {
String buero;
Mitarbeiter(String name, String buero) {
super(name); this.buero = buero;
}
void changeBuero(String neuB) { buero = neuB; }
}
class PersonenTest {
public static void main(String[] args) {
Mitarbeiter kai = new Mitarbeiter("Kai Meyer", "E 67");
Person karl = new Mitarbeiter("Karl Schmidt", "E 50");
kai.changeBuero("E 69"); // ok!
karl.changeBuero("E 68"); // Fehler (Protokolleinschr.)
} }
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 5
Typumwandlung
 Typumwandlung (Typ-Cast) von Oberklasse auf Unterklasse
explizit möglich (allerdings u.U. unsicher!)
class
class
class
class
A
B
B
C
a
b1
b2
c
D d
A
B
C
D
=
=
=
=
{ ... }
extends A { ... }
extends A { ... }
{ ... }
new B();
a;
//
(B)a;
(C)a;
//
//
= (D)a;
//
A
B
D
C
Syntaxfehler!
ok, allerdings beim Zugriff
Laufzeitfehler
Syntaxfehler
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 6
Klasse Object (1)
 Jede Klasse in Java ist von der Klasse Object abgeleitet:
public class Object {
public Object clone(); // Werte-Kopie
public boolean equals(Object obj); // Wertgleichheit?
public String toString(); // konvertiert in String
...
}
 Fehlt bei der Klassendefinition das extends, ist automatisch die Klasse
Object direkte Oberklasse
 die angeführten Methoden sollten von jeder neu definierten
(ADT-)Klasse reimplementiert (überschrieben) werden!
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 7
Klasse Object (2)
// ADT-Klasse:
public class Int extends Object {
private int value;
public Int(int v) { this.value = v; }
public Int(Int obj) { this.value = obj.value; }
public Object clone() {
return new Int(this); // auch hier Polymorphie
}
public boolean equals(Object obj) {
return this.value == ((Int)obj).value;
}
public String toString() {
return String.valueOf(this.value);
} ...
}...
Int intObject = new Int(4711);
IO.println("Wert = " + intObject);
// automatischer Aufruf von toString!!!
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 8
Beispiel Stack (1)
 Vorteil der Polymorphie: Wiederverwendbarkeit
class Stack {
Object[] store;
int current;
// zum Speichern von Daten
// aktueller Index
Stack(int size) {
store = new Object[size]; current = -1;
}
boolean isFull() { return current == (store.length-1); }
boolean isEmpty() { return this.current == -1; }
void push(Object value) {
this.store[++this.current] = value;
}
Object pop() { return this.store[this.current--]; }
}
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 9
Beispiel Stack (2)
class Rueckwaerts {
public static void main(String[] args) {
Stack haufen = new Stack(10);
while (!haufen.isFull()) {
String eingabe = IO.readString("Eingabe:");
haufen.push(eingabe);
}
while (!haufen.isEmpty()) {
Object obj = haufen.pop();
String str = (String)obj;
System.out.println(str);
}
} }
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 10
Beispiel Stack (3)
class RueckwaertsInt {
public static void main(String[] args) {
Stack haufen = new Stack(10);
while (!haufen.isFull()) {
int zahl = IO.readInt("Eingabe:");
haufen.push(zahl);
}
while (!haufen.isEmpty()) {
int zahl = (Integer)haufen.pop();
System.out.println(zahl);
}
}
}
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 11
Beispiel Stack (4)
class Akte {
int nummer;
Akte(int n) { this.nummer = n; }
void print() { IO.println(this.nummer); }
}
class Verwaltung {
public static void main(String[] args) {
Stack haufen = new Stack(8);
while (!haufen.isFull()){
haufen.push(new Akte(IO.readInt("Zahl: ")));
}
while (!haufen.isEmpty()) {
Akte akte = (Akte)haufen.pop();
akte.print();
}
}
}
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 12
Zusammenfassung
 Polymorphie: Fähigkeit einer Objektvariablen vom Typ T1, auf Objekte
von Klassen eines anderen Typs T2 verweisen zu können, wobei in
Java T2 Unterklasse von T1 sein muss
 Vorteil der Polymorphie: flexible Wiederverwendbarkeit von Klassen
Programmierkurs Java
UE 31
Polymorphie
Dietrich Boles
Seite 13