SEW(3)-OOP-Vererbung

htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
Java Vererbung
Inhalt
1
Zielsetzung ........................................................................................................................... 2
1.1
2
Grundlagen der Vererbung................................................................................................... 2
2.1
3
Bewertung ..................................................................................................................... 2
Super und Subklassen ................................................................................................... 2
Überladen von Methoden .................................................................................................... 4
3.1
Unterschiedliche Parameter .......................................................................................... 4
3.2
Gleiche Parameter unterschiedlicher Rückgabewert .................................................... 4
4
Überschreiben von Methoden ............................................................................................. 5
5
Polymorphismus ................................................................................................................... 6
5.1
Grundlagen .................................................................................................................... 6
5.2
Zuordnung erst zur Laufzeit........................................................................................... 6
6
Beispielprojekt (Polymorphismus) ....................................................................................... 7
7
Abstrakte Klassen ................................................................................................................. 8
8
History .................................................................................................................................. 9
SEW(3)-OOP-Vererbung.doc
Seite 1
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
1 Zielsetzung
 Lerne die Grundlagen zur Vererbung kennen.
 Verstehe den Unterschied zwischen gleich lautenden Methoden aber
unterschiedlichen Parametern (=Überladen von Methoden) und gleich lautenden
Methoden mit gleichen Parametern aber in unterschiedlichen, abgeleiteten
(=Überschreiben von Methoden) Klassen.
 Lerne was Polymorphismus ist und wie erst zur Laufzeit entschieden wird, welche
Methoden wirklich ausgeführt werden.
1.1 Bewertung
Abgabe des Beispielprojekts am Ende der Übungseinheit und die persönliche Mitarbeit
werden zur Beurteilung zu gleichen Teilen herangezogen.
2 Grundlagen der Vererbung
Vererbung basiert auf der Idee, dass Eltern ihren Kindern Eigenschaften mitgeben. Dabei
wird eine Kind-Klasse nicht komplett neu definiert, sondern von seiner Vater-Klasse
abgeleitet.
2.1 Super und Subklassen
Im Falle einer Vererbung, erbt die Kindklasse alle Eigenschaften der Vaterklasse und kann
nach Belieben eigene hinzufügen. In unserem Fall wäre also B von A abgeleitet. A wird als
Superklasse, B als Subklasse bezeichnet. Hier die wichtigsten Bezeichnungen:
Superklasse <-> Subklasse
Oberklasse <-> Unterklasse
Vater- oder Elternklasse
<-> Kindklasse
Basisklasse <-> Abgeleitete Klasse
2.1.1 Ableitung (extends)
Eine Klasse erweitert durch das Schlüsselwort extends eine andere Klasse. Sie wird dann zur
Unterklasse. Eine Oberklasse vererbt also Eigenschaften, und die Unterklasse erbt sie. Alle
Klassen haben direkt oder indirekt die Klasse java.lang.Object als Basisklasse.
public class Unerklasse extends Oberklasse {
}
SEW(3)-OOP-Vererbung.doc
Seite 2
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
Beispiel:
public class Article {
private int code;
private String label;
private double price;
...
}
public class CD extends Article {
private String artist;
private int songs;
...
}
public class Book extends Article {
private String author;
private int pages;
...
}
Damit ergibt sich das nachfolgende UML-Diagramm:
2.1.2 Super()
Konstruktoren werden im Gegensatz zu Methoden nicht vererbt. Das heißt, eine Unterklasse
muss ganz neue Konstruktoren angeben, denn mit den Konstruktoren der Oberklasse kann
ein Objekt der Unterklasse nicht erzeugt werden.
Java ruft im Konstruktor einer jeden Klasse (ausgenommen java.lang.Object) automatisch
den Default-Konstruktor der Oberklasse auf oder auch mit:
super(); // ruft den Default-Konstruktorauf
Will man nicht den Default-Konstruktor der Oberklasse, sondern einen anderen
(parametrisierten) Konstruktor der Oberklasse anzusprechen, muss man super(....) mit
Argumenten befüllen (angewendet auf das Beispiel Article siehe 2.1.1):
// ruft den Konstruktor der Vaterklasse (Article) auf
super(int code, String label, double price);
SEW(3)-OOP-Vererbung.doc
Seite 3
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
3 Überladen von Methoden
Überladen von Methoden hat nicht unbedingt etwas mit Vererbung zu tun, es kann in jeder
Klasse verwendet werden und ist etwas anderes als das Überschreiben von Methoden (siehe
Kapitel 4). Methoden haben bestimmte Merkmale an denen man sie erkennt:
a) einen Namen
b) die Anzahl, die Typen und die Reihenfolge der Parameter
c) einen Rückgabewert
Beispiel:
String text = new String(“Hallo“);
String neuerText = text.substring(1,4);
Wie lauten die Merkmale von der Methode substring?
Name = substring
Rückgabewert = String
Parameteranzahl = 2, Parametertypen = int und int, Parametrreihenfolge = zuerst
Start- dann End-Wert
3.1 Unterschiedliche Parameter
Java erlaubt es, den Namen der Funktion gleich zu lassen, aber andere Parameter
einzusetzen. Eine überladene Methode ist eine Funktion mit dem gleichen Namen wie eine
andere Funktion, aber einer unterschiedlichen Parameterliste.
text.substring(1,4);
text.substring(1);
3.2 Gleiche Parameter unterschiedlicher Rückgabewert
Liegt Unterscheid zweier Methoden innerhalb einer Klasse nur in ihrem Rückgabewert dann
werden sie als gleich angesehen, dies führt zu einem Fehler.
In der Klasse java.long.Math gibt es beispielsweise mehrere Methoden gleichen Namens mit
unterschiedlichen Rückgabewerten:
public int abs(int i) {...}
public double abs(double d) {...}
Hier ist aber wieder ein unterschiedlicher Parametertyp der Grund für keine Fehlermeldung.
Andere Beispiele wären die überladenen print-Methoden in System.out .
SEW(3)-OOP-Vererbung.doc
Seite 4
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
4 Überschreiben von Methoden
Beim Überschreiben (eng. Overriding) von Methoden besitzt eine Methode in einer
Kindklasse den Namen und die Parameterliste einer geerbten Methode der Vaterklasse.
Durch diese neue Methode wird innerhalb der Unterklasse die ursprüngliche Methode der
Oberklasse ersetzt.
Regeln beim Überschreiben:
 Der Methodenname muss übereinstimmen.
 Die Parameterliste und der Rückgabetyp müssen gleich sein.
 Eine überschreibende Methode darf im Zugriff nicht eingeschränkter sein als
die Ursprungsmethode.
Beispiel:
Public class Zweirad {
public void fahren() {
System.out.println("Zweirad: Vaterklasse");
}
}
public class Fahrrad extends Zweirad {
public void fahren() {
System.out.println("Fahrrad: Pedale betätigen");
}
}
public class Motorrad extends Zweirad {
// public void fahren() {
// System.out.println("Motorrad: Gashebel betätigen");
// }
}
SEW(3)-OOP-Vererbung.doc
Seite 5
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
public class Main {
public static void main(String[] args) {
Fahrrad z1 = new Fahrrad();
Motorrad z2 = new Motorrad();
z1.fahren();
z2.fahren();
}
}
Existiert in der Kindklasse ’Motorrad’ keine passende Methode fahren() so wird einfach die
der Vaterklasse verwendet. Sobald aber die Kindklasse eine passende Methode besitzt wird
diese auch verwendet.
5 Polymorphismus
5.1 Grundlagen
Polymorphismus bedeutet soviel wie Vielgestaltigkeit, und deutet auf die Fähigkeit von
Objektvariablen, Objekte unterschiedlicher Klassen aufzunehmen.
5.2 Zuordnung erst zur Laufzeit
Schauen wir auf folgendes Beispiel:
public class Main {
public static void main(String[] args) {
Zweirad z1 = new Fahrrad();
// Der zugewiesene Wert passt zum Typ, wenn er
// vom gleichen Typ oder von einem Subtyp ist.
Zweirad z2 = new Motorrad(); // Instanzen können Objekte auch von beliebigen
Subtypen halten.
z1.fahren();
// Zuordnung erst zur Laufzeit
z2.fahren();
}
}
Ein Fahrrad ist nun mal ein Zweirad, hat alle Eigenschaften eines Zweirads. Dass es
möglicherweise ein paar zusätzliche Eigenschaften besitzt, stört den Compiler nicht. Er hat
nur sicherzustellen, dass die Eigenschaften eines Zweirads vollständig vorhanden sind. Die
Zuordnung dieser Funktion zum Methodennamen erfolgt erst zur Laufzeit (dynamisches
Binden). Anders herum funktioniert Polymorphismus nicht.
SEW(3)-OOP-Vererbung.doc
Seite 6
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
6 Beispielprojekt (Polymorphismus)
Eine allgemeine Superklasse (Vaterklasse) Fahrzeug soll durch 2 weitere Subklassen
(Kindklassen) Kraftfahrzeug und Fahrrad erweitert werden (siehe unten). Ergänzt wird das
ganze durch die Aufrufe im Hauptprogramm.
Aufgabe: Folgender Code im Hauptprogramm soll zum laufen gebracht werden:
Arralist liste = new ArrayList();
Fahrzeug f1 = new Kraftfahrzeug(35508, “rot“, 2500, 5.7);
f1.fahren(255);
liste.add(f1);
Fahrzeug f2 = new Fahrrad(870, “silber“, 21);
f2.fahren(28);
liste.add(f2);
...
for(int i=0; i<liste.size(); i++) {
Fahrzeug x =(Fahrzeug) liste.get(i);
x. ausgabeDaten();
}
Weiters:
a) beim “fahren“ sollen die “gefahreneKm“ entsprechend erhöht werden
b) beim “fahren“ wird entsprechend dem Verbrauch der “verbrauchteTreibstoff“ erhöht
SEW(3)-OOP-Vererbung.doc
Seite 7
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
7 Abstrakte Klassen
In Java ist es möglich, abstrakte Methoden zu definieren. Im Gegensatz zu den konkreten
Methoden enthalten sie nur die Deklaration der Methode, nicht aber ihre Implementierung.
Syntaktisch unterscheiden sich abstrakte Methoden dadurch, dass anstelle der geschweiften
Klammern lediglich ein Semikolon steht. Zusätzlich wird die Methode mit dem Attribut
abstract versehen.
Abstrakte Methoden können nicht aufgerufen werden, sie definieren nur eine Schnittstelle.
Erst durch Überlagerung in einer abgeleiteten Klasse und Implementierung des fehlenden
Methodenrumpfes wird eine abstrakte Klasse konkret und kann aufgerufen werden.
Eine Klasse, die mindestens eine abstrakte Methode enthält, wird selbst als abstrakt
angesehen und muss ebenfalls mit dem Schlüsselwort abstract versehen werden.
SEW(3)-OOP-Vererbung.doc
Seite 8
25.05.2016
htl donaustadt
Donaustadtstraße 45
1220 Wien
www.htl-donaustadt.at
8 History
Version
1.00
1.01
1.02
1.03
Datum
24.02.2013
2.3.2013
3.3.2013
10.3.2013
SEW(3)-OOP-Vererbung.doc
Name
SACH
SACH
SACH
SACH
Bemerkung
Erstfassung
Kapitel 2.1.1 & 2.1.2
Kapitel 3 bis 5
Kapitel 7
Seite 9
25.05.2016