this(x, y)

Polymorphie (Vielgestaltigkeit)
● = Methode oder Operation (gegeben durch Name) kann sich
an Kontext anpassen
● Unterscheiden:
statische Polymorphie:
- Überladen ⇒ Auswahl anhand der Parameter
- auch in nicht-objektorientierten Sprachen, z.B. '/' für int und
float
dynamische Polymorphie (Polymorphie im engeren Sinn)
- Überschreiben ⇒ Auswahl anhand des dynamischen Typs
● Verhalten der Methode sollte nur angepasst, aber nicht
grundsätzlich geändert werden (Gefahr von Programmierfehlern)
EinfProg ­ 86

Wiederverwendung und Erweiterbarkeit
● sind wichtige Vorteile der OO-Programmierung:
GeomFigur g;
switch (eingabe) {
}
case 'r': g = new Rechteck();
case 'k': g = new Kreis();
case 'd': g = new Dreieck();
// Programm enthält mehrere Zugriffe auf g:
... g.zeichne(); ...
... g.berechneFläche(); ...
⇒ gleiches Programm kann für alle Unterklassen genutzt
werden und muss bei Hinzufügen von Unterklassen nicht
angepasst werden
EinfProg ­ 87

Konstruktoren und Vererbung
Object
Oberklasse
Unterklasse
Initialisierungen 1.-4. für Object
Initialisierungen 1.-4. für Oberklasse
Initialisierungen 1.-4. für Unterklasse
Oberklassenkonstruktor wird rekursiv wie folgt ausgewählt:
a) falls der Unterklassenkonstruktor mit super(..) oder this(..)
beginnt, Aufruf des passenden Konstruktors
b) sonst Aufruf des parameterlosen bzw. default-Konstruktors
c) nicht vorhanden ⇒ Fehlermeldung des Compilers
EinfProg ­ 88

Das Schlüsselwort this
● this ist ein Verweis auf das aktuelle Objekt
● Verwendung:
Zugriff auf Attribute im Falle gleichnamiger lokaler
Variablen
void verschiebeNach(int x, int y) { this.x = x; this.y = y; }
Zugriff auf andere Konstruktoren einer Klasse
this(x, y);
Aufruf einer Methode mit dem aktuellen Objekt als
Parameter
anderesObjekt.dessenMethode(this);
EinfProg ­ 89

Das Schlüsselwort super
● super verweist auf das aktuelle Objekt, betrachtet als Objekt
der Oberklasse (entspricht Typkonvertierung)
● Verwendung:
Aufruf eines Konstruktors der Oberklasse
⇒ muss erste Anweisung im Unterklassen-Konstruktor sein
⇒ super(..) und this(..) können nicht gemeinsam
verwendet werden
super(farbe);
Zugriff auf überschriebene Methode der Oberklasse
void zeichne() { // in Unterklasse
}
super.zeichne(); ...
EinfProg ­ 90

Typkonvertierung für Objekte 1
● analog zu primitiven Typen, implizit in Richtung:
Unterklasse ⇒ Oberklasse ⇒ ... ⇒ Object (Up-Cast)
Rechteck r = new FarbigesRechteck();
● Gegenrichtung erfordert expliziten Typecast (Down-Cast)
Rechteck r = new FarbigesRechteck();
FarbigesRechteck f = (FarbigesRechteck) r;
● Typkonvertierung ist nur zwischen Vor- und Nachfahren
möglich, nicht zwischen Geschwistern
EinfProg ­ 91

Typkonvertierung für Objekte 2
● Typkonvertierung ändert die Sichtweise des Compilers (mehr
nicht)
● Compiler hat Sicht auf Objekte entsprechend des statischen
Typs und verbietet Zugriffe auf scheinbar nicht vorhandene
Attribute / Methoden
● Typkonvertierung ändert den statischen Typ:
Rechteck r = new FarbigesRechteck();
r.verschiebe(2,3);
// nicht zulässig: r.refill();
((FarbigesRechteck) r).refill(); // ist zulässig
EinfProg ­92

Typkonvertierung für Objekte 3
● Typkonvertierung hat keinen Einfluss auf den dynamischen
Typ:
FarbigesRechteck f = new FarbigesRechteck();
// Typkonvertierung bewirkt nichts:
((Rechteck) f).zeichne();
// malt farbig aus!!!
● Typkonvertierung passt den statischen an den dynamischen
Typ an: (NeuerTyp) obj ist nur zulässig falls:
- dynamischer Typ von obj = NeuerTyp oder
- dynamischer Typ von obj ist Unterklasse von NeuerTyp
EinfProg ­ 93

Auswahl der Methode beim Überladen
● erfolgt zur Übersetzungszeit anhand des statischen Typs
● falls eindeutig bestimmt, wird die Methode mit den passenden
Parametern (Anzahl, Typ) ausgewählt, gegebenenfalls mit
impliziter Typkonvertierung
Son son = new Son();
public void test(Father father) { ... }
test(son); // bewirkt Aufruf test(Father)
● falls mehrere Methoden passen, wird diejenige mit den
speziellsten Parametern ausgewählt (nicht eindeutig ⇒
Fehlermeldung des Compilers)
Son son = new Son(); Father wer = new Son();
public void test(Father father) { ... }
public void test(Son son) { ... }
test(son); // bewirkt Aufruf test(Son)
test(wer); // bewirkt Aufruf test(Father)
EinfProg ­ 94

Überdecken von Variablen
● = Redefinition eines Attributs in der Unterklasse:
public class Punkt {
int x, y;
...
}
public class FeinPunkt extends Punkt {
double x, y;
...
}
● überdeckte Variablen sind gültig, aber nicht sichtbar
● Auswahl erfolgt zur Übersetzungszeit, laut statischem Typ
● Zugriff möglich: super.x bzw. ((Punkt) fp).x
●
Überdecken von Variablen vermeiden!
EinfProg ­ 95

Überdecken von Klassenmethoden
Klassenmethoden werden nicht überschrieben, sondern überdeckt:
class Oben {
static String greeting() { return "Guten Tag"; }
String name() { return "Fritz"; }
}
class Unten {
static String greeting() { return "Hallo"; }
String name() { return "Susi"; }
}
class Test {
public static void main(String[] args) {
Oben obj = new Unten();
Out.println( obj.greeting() + obj.name() );
}
}
⇒ Guten Tag Susi
vermeiden!
EinfProg ­ 96

Programmierparadigmen und -sprachen
imperativ
● prozedural
● objektorientiert
Fortran, Ada
Smalltalk, C#
deklarativ
● funktional
● logisch
Haskell, ML, Lisp
Prolog, Oz
● Skriptsprachen
Perl, PHP, Python
EinfProg ­ 97

Funktionale Programmierung
● Programm = Abbildung Eingaben → Ausgaben
● Programm = mathematische Funktion, durch Ausdruck
beschrieben
● Ausführung Programm = Berechnung Ausdruck
● funktionales Programm umfasst:
- Funktionsdefinitionen
- Ausdruck: enthält Funktionsaufrufe, liefert Ergebnis
● nicht vorhanden: Anweisungen, Variablen, Seiteneffekte
EinfProg ­ 98

Funktionen
● Abbildungen Eingabe → Ausgabe
● Funktionsdefinition:
square :: Int -> Int pechzahl :: Int
square n = n * n pechzahl = 13
● Funktion mit mehreren Parametern:
max:: Int -> Int -> Int
max x y
| x >= y = x
| otherwise = y
● Funktionsanwendung:
square 5 = 5 * 5
square (2+4) = (2+4) * (2+4)
EinfProg ­ 99

Kombination von Funktionen
● Kombination bei Funktionsanwendung:
square pechzahl
max (square 3, max(square pechzahl, 7))
● oder auch in Funktionsdefinition:
maxSquare :: Int -> Int -> Int
maxSquare x y = max ( square x, square y)
● oder mit Verkettungsoperator:
power4 :: Int -> Int
power4 = square . square
● x, y, max, power4 etc. sind Bezeichner (keine Variablen!)
- nur einmalige Wertzuweisung
EinfProg ­ 100

Listen - Beispiel
Liste = vordefinierte Datenstruktur (vergleichbar Arrays in Java)
mit veränderlicher Anzahl von Einträgen
● vordefinierte Funktionen: reverse, map etc.
Bild: X 0 0
X 0 0
X 0 0
X X X
[ [X, 0, 0],
[X, 0, 0],
[X, 0, 0],
[X, X, X] ]
flipH Bild:
X X X
X 0 0
X 0 0
X 0 0
[ [X, X, X],
[X, 0, 0],
[X, 0, 0],
[X, 0, 0] ]
flipH = reverse
EinfProg ­ 101

Listen – Beispiel (Forts.)
Bild: X 0 0
X 0 0
X 0 0
X X X
[ [X, 0, 0],
[X, 0, 0],
[X, 0, 0],
[X, X, X] ]
flipH Bild:
0 0 X
0 0 X
0 0 X
X X X
[ [0, 0, X],
[0, 0, X],
[0, 0, X],
[X, X, X] ]
flipH = map reverse
Funktionen sind 'first-class citizens' ⇒ Verwendung entspricht
Datentypen wie int, Bild
EinfProg ­ 102

Ausblick
Rekursion ist von zentraler Bedeutung:
fac :: Int -> Int
fac n
| n == 0 = 1
| n > 0 = fac (n-1) * n
Problem funktionaler Sprachen: Ein-/Ausgabe (sind zeitlos)
Literatur: Simon Thompson. Haskell: The Craft of Functional
Programming
EinfProg ­ 103