Das Dokument beschreibt die Konzepte der objektorientierten Programmierung (OOP), deren Ziele, Techniken und Herausforderungen, wie z.B. die Verringerung von Softwarefehlern und die Verbesserung der Wiederverwendbarkeit und Wartbarkeit von Code. Es untersucht die Ursachen der Softwarekrise durch wachsende Komplexität, den Einfluss von technologischen Veränderungen und die Notwendigkeit, die Realität durch Objekte im Softwaredesign abzubilden. Außerdem werden fundamentale OOP-Prinzipien wie Datenkapselung, Methoden und die Bedeutung von Klassen und Objekten in der Softwareentwicklung behandelt.

1. 11.03.2012
1

2. 11.03.2012
2
Datenorientierte Sichtweise
 Gruppierung von Daten zu komplexen Typen
(Strukturierung)
 Definition von Operationen, die Daten verarbeiten
 Daten vor inkonsistenten Veränderungen schützen,
indem Zugriff beschränkt wird
 Daten und Funktionen bilden Einheit (Klasse bzw.
Objekt)
 1994: Eröffnung des Denver International
Airport um 9 Monate verzögert wegen
Softwareproblemen im Gepäcktransport‐
System
 1989‐1998: Entwicklung eines Systems zur
Unterstützung der Polizeiarbeit in Hamburg
abgebrochen (120 Mio. DM)
 1996: Verlust der Ariane 5 (>1,65 Mrd. DM)
 2003‐2006: Toll Collect (> 1 Mrd. EUR)
Studie der Standish Group International 1999:
 26 % aller Software‐Projekte werden erfolgreich
abgeschlossen
 46 % leiden unter erheblicher Kosten‐ und
Terminüberschreitung oder reduzierter
Funktionalität.
 28 % aller Software‐Projekte endet ohne
Auslieferung eines Produkts
Software ist fehlerhaft
 Laut INTEL: 80‐90 Bugs in Pentium
 Normale Software: 25 Fehler pro 1000 Programmzeilen.
 Gute Software: 2‐3 Fehler pro 1000 Zeilen.
 Space Shuttle Software: weniger als 0.1 Fehler pro 1000
Zeilen (laut NASA)
 Handy: 200 000 Zeilen Programm ca. 500 Fehler
 Windows 2000: 27 Mio. Zeilen ca. 50 000 Fehler

3. 11.03.2012
3
Ursachen der Softwarekrise
 Wachsende Komplexität
 technische Ressourcen und
Möglichkeiten wachsen sehr
schnell
 Mooresches Gesetz
 Das Mooresche Gesetz sagt
aus, dass sich die Komplexität
integrierter Schaltkreise etwa
alle zwei Jahre verdoppelt.
 (Software‐)Objekte besitzen einen internen Zustand und haben
ein festgelegtes Verhalten
 Ein Objekt:
 verwaltet seinen Zustand durch Variablen, Attribute genannt
 implementiert sein Verhalten durch Funktionen, Methoden genannt
 Qualität
 Fehlerfrei
 Entspricht den Anforderungen
 Einfach Bedienbar
 Preis
 Herstellungskosten
 Wartungskosten
 Geschwindigkeit (Ausführungsgeschwindigkeit)
 Antwortzeiten
 Rechenzeiten
 Echtzeit‐Anwendungen
 Qualität
 Komplexität
▪ größere Programme sind undurchschaubar
 Test
▪ 100%ige Test unmöglich
 Erweiterbarkeit
▪ Schwierig weil undurchschaubar, daher fehlerträchtig
 Preis
 Wiederverwendbarkeit
▪ Relativ schwierig, da keine konkreten Module vorhanden
▪ Oft nur auf Quellcode‐Ebene
 Erweiterbarkeit
▪ Schwierig, daher aufwendig

4. 11.03.2012
4
 Komplexität
 Programmier‐Modelle an unser Denken
anpassen
 Wiederverwendbarkeit
 Architekturen schaffen, die automatisch
Wiederverwendbar sind
 Lösung: Objekte
 Der Mensch denkt in Objekten
 > Objekt‐Orientierte Programmierung
 Wahrnehmung
 Die Wirklichkeit wird über Objekte
wahrgenommen
▪ Diese Fähigkeit zur erlangen ist ein großer Teil unseres
Lernens in den ersten Jahren unseres Lebens
▪ Z.B. Wald – Baum (Nadelbaum, Laubbaum, Tanne, Eiche,
...) – Ast – Blatt ‐Wurzel ‐ ... – Chlorophyll
 Denken
 Generalisieren, klassifizieren u. abstrahieren
 Folgerung
 Software soll die Wirklichkeit im Programm
abbilden ‐> auch Software in Objekte einteilen
Menschen sehen ihre Umwelt im wesentlichen in Form einer
Ansammlung von Gegenständen, weniger als Folge von
Zustandsänderung, die durch Algorithmen beschrieben werden.
Bei der Lösung von Problemen mit Hilfe des Computers ist es
deshalb sinnvoll, die Gegenstände im Rechner abzubilden und dazu
alles, was über den Gegenstand bekannt ist, also Attribute,
Strukturen, Funktionen, Verhaltensweisen und
Gebrauchsmöglichkeiten.
Dies ist die Idee der objektorientierten Programmierung.
Objektorientierte Programmierung geht der Frage nach, wie man
Objekte (konkrete Gegenstände und abstrakte Begriffe) der Welt im
Rechner abbilden kann.
 Qualität
+ höher durch durchschaubare Architektur
+ höher durch Wiederverwendbarkeit
 Preis (=Entwicklungs‐Geschwindigkeit)
+ geringer durch Wiederverwendbarkeit
 (Ausführungs‐)Geschwindigkeit
‐ evtl. langsamer, durch nicht an Maschine
angepasste Architektur

5. 11.03.2012
5
 objektorientierte Softwareentwicklung
Hier werden die Konzepte der Analyse, des Systementwurfs und der OOP in
einen Zusammenhang gebracht.
 objektorientierte Vorgehensweise
Der Prozeß der in einem Entwicklungsprojekt zu einem Ergebnis führt,
nämlich dem Produkt.
M
M
M
M
M
M
M M M
M
M
M
M
M
M
Daten
Methoden
Kapselung
 Besteht aus Daten und Funktionalität
 Es bietet Dienste/Funktionalität an
 Es erhält Nachrichten/ Messages, die es
Auffordern einen Dienst zu erbringen
 Es verbirgt die Art und Weise wie es diesen
Dienst erbringt vor dem Aufrufenden
 Gegenstände eines Büroarbeitsplatzes

6. 11.03.2012
6
 Ordner
Ordner
•entnehmen
•einfügen
•beschriften
•...
Der Gegenstand
(was ist das?)
Die Methoden
(was kann ich damit tun?)
 Glühlampe
LightBulb
•on
•off
•brighten
•dim
•...
Der Gegenstand
(was ist das?)
Die Methoden
(Was kann ich damit tun?
Wie verhält es sich? )
 Baum
Tree
•Size
•grow
•...
Der Gegenstand
(was ist das?)
Die Methoden
(Was kann ich damit tun?
Wie verhält es sich? )
Die Daten (Attribute)
(Wie ist es intern
definiert? )
 Schüler
• Lehrer
Schüler
•Name
•Vorname
•Geburtsdatum

Zuhören

FrageStellen

FrageBeantworten

Mitschreiben

...
Der Gegenstand
(was ist das?)
Die Methoden
(Was kann ich damit tun?
Wie verhält es sich? )
Lehrer
•Name
•Vorname
•Geburtsdatum

Reden

FrageStellen

FrageBeantworten

...
Die Daten (Attribute)
(Wie ist es intern
definiert? )

7. 11.03.2012
7
M
M
M
M
M
M
MMM
M
M
M
M
M
M
M
M
M
M
M
M
MMM
M
M
M
M
M
M
M
M
M
M
M
M
MMM
M
M
M
M
M
M
M
M
M
M
M
M
MMM
M
M
M
M
M
M
M
M
M
M
M
M
MMM
M
M
M
M
M
M
M
M
M
M
M
M
MMM
M
M
M
M
M
M
Maschinenorientierte
Programmierung
Prozedurale
Programmierung
Modulare
Programmierung
Objektorientierte
Programmierung
public class Girokonto {
private int kontostand=0; // in Cent gerechnet
/* Einzahlen und Abheben */
public void zahle (int cent){
kontostand = kontostand + cent;
}
public int holeKontostand() {
return (kontostand);
}
}
Modifier class Klassenname
{
Attribut-Deklarationen
Methoden
}
Modifier class Klassenname
{
Attribut-Deklarationen
Methoden
}
 Exemplare aus einer Klassen‐Schablone:

 Erzeugen
Girokonto einKonto= new Girokonto();
 Löschen: wenn nirgendwo mehr benutzt (automatische Garbage‐
Collection)
 Zustand eines Objekts verändern ( Attribute)
Nachrichten an ein Objekt senden ( Methoden)
Klasse ObjName =
new Klasse(Typ1 name1, ...)
Klasse ObjName =
new Klasse(Typ1 name1, ...)
Girokonto
Kontostand
Ein-/Auszahlen
Kontostand abfragen
Objekt
Objekt
Objekt
Objekt

8. 11.03.2012
8
 Teile des Gesamtzustands eines Objekts
private int kontostand;
private Girokonto meinKonto;
 Verändern von Attributen
kontostand = kontostand + cent;
 Einkapseln von Attributen ( Ziel: möglichst alle Attribute einkapseln)
 privat d.h. nur innerhalb des Objekts sichtbar (private)
 öffentlich d.h. auch außerhalb des Objekts sichtbar (public)
Modifier Datentyp attributname
Modifier Datentyp attributname
 Teile des möglichen Verhaltens eines Objekts
(d.h. Nachrichten, die vom Objekt verarbeitet
werden können)
public void zahle (int cent){
kontostand = kontostand + cent;
}
 public int holeKontostand() {
 return (kontostand);
 }
Modifier Rückgabetyp Methodenname (Typ1 ParamName1,Typ2 Param...){
Liste von Anweisungen;
[ return (Rückgabewert) ]
}
Modifier Rückgabetyp Methodenname (Typ1 ParamName1,Typ2 Param...){
Liste von Anweisungen;
[ return (Rückgabewert) ]
}
Spezieller Rückgabewert: void
Spezieller Rückgabewert: void
 Aufruf von Methoden eines Objektes (Punkt‐Notation,
qualifizierter Zugriff)
konto.holeKontostand();
konto.zahle(+100);
 Übergeben von Parametern
 statt komplette Objekte zu übergeben, nur Zeiger darauf („by reference“)
 bei einfachen Datentypen als Wert kopiert („by value“)
 Einkapseln von Methoden
 privat, d.h. nur als interne Hilfs‐Methode zugreifbar (private)
 öffentlich, d.h. extern sichtbar (public)
 Einsprungpunkt bei "Ausführen" einer
Applikation
 Übergeben von Argumenten aus der Kommandozeile
möglich
 für Testen von Klassen‐Implementierungen geeignet
public class TestGirokonto {
...
public static void main(String[] args) {
... // Hier Code zum Testen einfügen
}
...
}

9. 11.03.2012
9
 Klasse erweitern um Attribute, Methoden
 Erzeugen von Objekten und Nachrichtenaustausch (Methoden)
zwischen Objekten
 Ergänzen Sie die Klasse "Girokonto":
 zum Sperren eines Kontos: boolesches Attribut istGesperrt mit den
Methoden void sperre(), void entsperre() und boolean istGesperrt()
 zum Überschreiben des aktuellen Kontostandes mit einem übergebenen Betrag die
Methode setzeKontostand()
 Testen der Klasse "Girokonto"
 Erzeugen eines Girokonto‐Objekts
 Nacheinander Einzahlen von 100 Pfennigen, Abheben von 20 Pfennigen und Einzahlen
von 30 Pfennigen
 Anschließend Kontostand ausgeben
 Lösung 1:
public class Girokonto {
...
private boolean istGesperrt;
...
public void sperre() {
istGesperrt=true;
}
public void entsperre(){
istGesperrt=false;
}
public boolean istGesperrt (){
return (istGesperrt);
}
...
}
 Lösung 2:
public class TestGirokonto {
public static void main(String[] args) {
// erzeuge neues Konto
Girokonto konto = new Girokonto();
// führe Transaktionen durch
konto.zahle(+100);
konto.zahle(+30);
konto.zahle(-20);
// gib Kontostand aus
int aktuellerStand = konto.holeKontostand();
System.out.println(aktuellerStand);
}
}
 Methode, die automatisch bei Erzeugung eines Objektes
aufgerufen wird
 Wird in der Regel benutzt, um Attribute zu initialisieren
 Dadurch charakterisiert, daß der Methodenname mit dem
Klassennamen übereinstimmt
 Konstruktoren besitzen keinen Rückgabewert (auch nicht
void)
 Überladen von Konstruktoren ist möglich

10. 11.03.2012
10
 Methoden für das Durchführen von Arbeiten direkt bei
der Objekt‐Erzeugung:
 Methodenname = Klassenname
 Folge von Anweisungen, die abzuarbeiten sind
 kein Rückgabewert
class Girokonto {
...
public Girokonto() {
kontostand = 0;
...
}
}
 Argumente der Konstruktormethode werden bei
Objekterzeugung durch…
new Klassenname(Argument1, Argument2, ...);
…an den Konstruktor übergeben
 Ohne Angabe eines Konstruktors ist nur der leere
Konstruktor ohneArgumente definiert
 Ist ein (nicht leerer) Konstruktor definiert, muß der
leere Konstruktor explizit definiert werden, um noch
benutzt werden zu dürfen
 Bei primitiven Datentypen enthält eineVariable direkt den
Inhalt (z. B. einen Int‐Zahlenwert)
 Bei Objekten von Klassen symbolisiert die Variable nur
eine Referenz (einenVerweis) auf das Objekt
 Es können auch mehrere Referenzen auf ein Objekt zeigen
 Ein Referenz kann auch leer sein, null ist das Schlüsselwort
für die leere Referenz
 Beispiel:
 Girokonto k = null;
 Mit dem ==‐Operator kann man zwei
Referenzen auf Gleichheit testen:
 Beispiel:
Girokonto k1 = new Girokonto();
...
Girokonto k2 = k1;
...
if (k1 == k2)
System.out.println(”k1 und k2 verweisen auf
dasselbe Objekt");

11. 11.03.2012
11
 Mit dem ==‐Operator kann man ebenso
abfragen, ob eine Referenz leer ist:
 Beispiel:
Girokonto k = null;
...
if (k == null)
System.out.println(”k ist leere Referenz");
 Ist die letzte Referenz auf ein Objekt verschwunden , weil
 die Referenzen den Gültigkeitsbereich verlassen haben, oder weil
 null‐Referenzen zugewiesen wurden,
 wird das Objekt der Garbage Collection zugeführt.
 => es sind keine free‐ oder delete‐Methoden nötig!
 Dies funktioniert auch, falls sich Objekte gegenseitig noch zyklisch
referenzieren
 Mit
System.gc();
 wird eine Empfehlung an die Garbage Collection ausgegeben,
aktiv zu werden, in der Regel ist dies aber nicht nötig
 Attribute und Methoden gehören zu
Objekten (also Instanzen) einer Klasse
Aber: es gibt Klassenattribute und ‐
methoden, die nicht zu Instanzen (also
Objekten) gehören, sondern zu den
Klassen selbst
 Attribute, die für jedes Objekt neue Instanzen
bilden, heißen Instanzvariablen (Standardfall)
 Werden Attribute mit static gekennzeichnet,
handelt es sich um Klassenvariablen, die für die
gesamte Klasse nur eine Instanz besitzen
 Klassenvariablen existieren auch ohne die
Existenz eines Objektes. Auf sie kann durch
Klassenname.Attributname zugegriffen werden.

12. 11.03.2012
12
 Methoden, die ausschließlich auf Klassenvariablen
zurückgreifen, dürfen mit static gekennzeichnet
werden, sie heißen Klassenmethoden.
Klassenmethoden dürfen auch nur
Klassenmethoden benutzen
 Klassenmethoden können auch ohne Existenz eines
Objektes mit Klassenname.Methodenname(...)
aufgerufen werden.
 Die main()‐Methode ist eine Klassenmethode, da zu
Beginn noch keineObjekte erzeugt wurden
class Demo {
int a;
static int b;
public static void main (String[] args) {
a = 1; // nicht erlaubt
b = 1; // erlaubt
test(); // nicht erlaubt
new Demo().test(); // erlaubt
test2(); // erlaubt
new Demo().test2();// erlaubt
}
void test() {
a = 2; // erlaubt
b = 2; // erlaubt
}
static void test2() {
b = 3;
}
}
...
Demo d = new Demo();
d.a = 1; // erlaubt
d.b = 1; // erlaubt
Demo.a = 1; // nicht erlaubt
Demo.b = 1; // erlaubt
Demo.test(); // nicht erlaubt
Demo.test2(); // erlaubt
...
 Wunsch für Methoden/Attribute: Gleiche Namen für gleiche
Zwecke
 z.B. Girokonto erzeugen ohne/mit einem initialen Kontostand
 Benutzt werden sollen Methoden mit gleichen Namen
 Problem: Wie diese Methoden auseinanderhalten?
 Idee: unterscheide anhand Parameter‐Typen:
Methoden gleichen Namens müssen sich also im Typ von
mindestens einem Parameter oder in der Anzahl der Parameter
unterscheiden (=Signatur)
zahle (int betrag)
zahle (int betrag, String verwendungszweck)
 Unterschiedliche Methoden müssen sich im
Methodennamen oder in der
Übergabeparameterliste (oder in beidem)
unterscheiden
 Hat eine Klasse mehrere Methoden mit
identischem Namen, nennt man diese Methode
überladen
 In unterschiedlichen Klassen dürfen auch Methoden
mit identischem Namen und identischen
Übergabeparameterlisten deklariert werden

13. 11.03.2012
13
 Verwenden von Variablen mit bereits benutzten
Namen
 Zugreifen auf überdeckte Attribute über this
public class Girokonto {
private int kontostand; // in Cent gerechnet
...
public void setzeKontostand(int kontostand) {
this.kontostand = kontostand;
}
...
}
 Variablendeklarationen in Klassenmethoden
überdecken die Attribute der Klasse
 Die Attribute sind nur überdeckt, nicht
überschrieben
 Auf Attribute der Klasse kann dann über das
Schlüsselwort this zugegriffen werden
 this ist eine Referenz auf das zur Methode
zugehörendeObjekt
 In einem OO‐System kooperieren Objekte, um
gemeinsam eine Aufgabe zu lösen
 Jede Klasse kann etwas besonders gut
(Spezialist)
 z.B. Klasse "Girokonto" für Umgang mit Girokonten
 Beim Erstellen eines OO‐Systems müssen
Spezialisten ausgemacht werden
 z.B. Erweiterung um Währungsrechnen
 Zusammenspiel mehrerer Objekte, Überladen von Namen
 Ändern einer bestehenden Klasse
 Aufgabe:
 Entwerfen und implementieren Sie eine neue Klasse „Waehrungsrechner“ für das Umrechnen
von Euro in US‐Dollar (1 US‐Dollar ~ 0.77 EUR)
 Überlegen Sie, ob diese Klasse Attribute besitzen muss? Welche könnte sie besitzen?
 Ergänzen Sie die Methoden toDollar und toEuro
 Die Klasse "Girokonto" soll angepasst werden:
 Einem Girokonto‐Objekt soll beim Erzeugen stets ein "individueller" Währungsrechner
übergeben werden können, der für Konvertierungen benutzt wird.
 Verstecken Sie nach außen, dass der Kontostand intern stets in EuroCent gespeichert wird
und jede andere Währung konvertiert wird („Information‐Hiding“).

14. 11.03.2012
14
public class WaehrungsRechnerDollar {
private float faktor = 0.77292f;
float toDollar (float euroCent) {
float dollarCent = (euroCent/(faktor/100));
return(dollarCent);
}
float toEuro (float dollarCent) {
float euroCent = (dollarCent * (faktor/100));
return(euroCent);
}
String getWaehrung()
{
return("US-Dollar");
}
}
public class Konto {
private float kontoStand;
private float ueberziehungsRahmen;
private WaehrungsRechnerDollar wr = null;
private boolean valid;
…
public Konto(int kontoStand, WaehrungsRechnerDollar wr)
{
this.wr = wr;
this.kontoStand = wr.toEuro(kontoStand);
}
…
public void einzahlen(int betrag)
{
if (wr != null)
kontoStand += wr.toEuro(betrag);
else
kontoStand += betrag;
}
• Klassen können zueinander in einer "ist ein"‐Beziehung stehen
• Beispiel: Jeder PKW ist ein Kraftfahrzeug,
jedes Kraftfahrzeug ist einTransportmittel
aber: auch jeder LKW ist ein Kraftfahrzeug und jeder Zug,
jedes Schiff und jedes Flugzeug ist einTransport‐
mittel
Transportmittel
Kraftfahrzeug Zug Boot Flugzeug
PKW LKW Segelbooot Motorboot
• VW Golf Opel Astra
• Sowohl PKWs, als auch LKWs besitzen Fahrersitze und Fahrertüren,
es handelt sich also um Attribute der Oberklasse Kraftfahrzeug
• Sowohl PKWs als auch LKWs haben die Methoden Sitz verstellen,
Tür schließen und fahren, es sind Methoden der Oberklasse
Kraftfahrzeug
• PKWs haben jedoch mit der Rückbank und dem Kofferraum eigene
Attribute und mit "hinten einsteigen" eigene Methoden
• LKWs haben mit der Ladefläche und dem Anhänger auch eigene
Attribute und "beladen" ist eine eigene Methode
=> Unterklassen PKWs und LKWs besitzen alle Attribute und
Methoden der Oberklasse, haben jedoch noch zusätzliche

15. 11.03.2012
15
 Und bei Konten tritt so was ähnliches natürlich auch
auf
• Zusammenfassen von gleichen Attributen und
Methoden
Girokonto
kontostand : int
inhaber : Person
habenzinsen : int
sollzinsen : int
dispo : int
holeKontostand()
zahle()
Sparkonto
kontostand : int
inhaber : Person
habenzinsen : int
holeKontostand()
zahle()
kuendigen()
Festgeld
kontostand : int
inhaber : Person
habenzinsen : int
mindBetrag : int
laufzeit : int
holeKontostand()
zahle()
kuendigen()
Konto
kontostand : int
inhaber : Person
habenzinsen : int
holeKontostand()
zahle()
Girokonto
sollzinsen : int
dispo : int
Festgeldkonto
mindBetrag : int
laufzeit : int
kuendigen()
Sparkonto
kuendigen()
• Die vererbende Klasse heißt Superklasse.
• Die erbenden Klassen sind Unter‐ oder
Subklassen.
• Konto ist also die Superklasse der Klassen
Girokonto, Festgeldkonto, Sparkonto. Diese
sind die Subklassen der Klasse Konto.
• Alle Objekte sind Konten!
• Einige sind besondere Arten von Konten.
• Die Menge der Sparkonten, Girokonen,
Festgeldkonten ist jeweils eineTeilmenge der
Menge der Konten
• Die Teilmengen sind disjunkt.

16. 11.03.2012
16
• Wir nehmen folgende Deklarationen an:
Girokonto einGirokonto;
Sparkonto einSparkonto;
Konto einKonto, einAnderesKonto;
• Legale Zuweisungen:
einGirokonto = new Girokonto();
einSparkonto = new Sparkonto();
einGirokonto.sollzinsen = 12;
einKonto = einGirokonto;
einAnderesKonto = new Sparkonto();
• Wir nehmen folgende Deklarationen an:
Girokonto einGirokonto;
Sparkonto einSparkonto;
Konto einKonto, einAnderesKonto;
• Nicht legale Zuweisungen:
einSparkonto = einGirokonto;
einGirokonto = new Sparkonto();
 Erläuterungen:
 Jedes Sparkonto / Girokonto ist auch ein Konto,
deshalb ist einKonto = einSparkonto
legal.
 Ein Objekt der einen Klasse kann also mehrere
Erscheinungsformen haben, es kann ein Objekt
der Klasse selbst sein, oder es kann ein Objekt
einer der Unterklassen dieser Klasse sein. Es ist
also polymorph.
 Erläuterungen:
 Nicht jedes Konto ist ein Sparkonto.
 Ist dann einSparkonto = einKonto legal?
 Ja, denn Objekte der Klasse Sparkonto sind
wandelbar zu Objekten der Klasse Konto.
Allerdings ist der Zugriff auf alle Attribute nicht
möglich, denn einKonto hat ja nicht die
Sparkonto‐Attribute.

17. 11.03.2012
17
 Erläuterungen:
Was passiert bei folgenderAnweisung?
if (x%2 == 0)
einKonto = einSparkonto;
else
einKonto = einGirokonto;
 Der Compiler ist nicht in der Lage, die Klasse von
einKonto zu ermitteln. Die Klasse von einKonto nach
dieser Zuweisung ist nicht vorhersehbar. einKonto
kann also nach der Anweisung eine von mehreren
Klassen haben, es ist halt polymorph.
 Vererbung wird über Schüsselwort extends
realisiert:
class Unterklasse extends Oberklasse {
... // Hier zusätzliche Attribute und Methoden
}
 Die neu definierte Unterklasse erweitert also die
anderswo definierteOberklasse um neue
Attribute und Methoden.
 Alle Methoden und Attribute der Oberklasse
werden übernommen.
• Jede Klasse hat genau eine Oberklasse (Java kennt keine
Mehrfachvererbung)
• Ist keine Oberklasse definiert (kein extends), so ist die
Systemklasse Object die Oberklasse
=> Object ist eine Oberklasse für alle Klassen
(bis auf Object selbst)
• Konstruktoren werden nicht vererbt,
Konstruktoren der abgeleiteten Klasse
müssen neu definiert werden!
• Über Schlüsselwort super kann am Anfang
eines Konstruktors der abgeleiteten Klasse
ein Konstruktor der Oberklasse aufgerufen
werden.

18. 11.03.2012
18
• Wenn in der ersten Anweisung des
Subklassen‐Konstruktors nicht einer der
Konstruktoren der Superklasse aufgerufen
wird, dann wird der parameterlose
Superklassen‐Konstruktor (Standard‐
Konstruktor) automatisch aufgerufen, bevor
irgendeine andere Anweisung des
Subklassen‐Konstruktors aufgerufen wird.
• private Methoden und Attribute sind nur in
der Klasse zugreifbar, in der sie definiert sind.
Sie sind nicht in den erbenden Klassen
zugreifbar.
• Oft ist es so, dass Methoden und Attribute
nicht von außen zugreifbar sein sollen, dass
sie aber schon vererbt werden sollen. Genau
dies wird durch das Schlüsselwort
protected vereinbart.
• protected Methoden und Attribute sind in der
Klasse selbst und in allen Subklassen sichtbar.
Konto
private kontostand
protected habenzinsen
Girokonto
Bankautomat
„habenzinsen“ ist hier unbekannt
„habenzinsen“ ist hier bekannt
erweitert
benutzt
• protected Methoden und Attribute einer
Oberklasse A können auch in einer Unterklasse
B zur Oberklasse A zugreifbar sein, d.h. genau:
– sie können benutzt werden über eine Referenz auf
ein Objekt der Klasse A oder auf ein Objekt einer
Unterklasse der Klasse A.

19. 11.03.2012
19
• Methode: berechneZinsen(int tage)
• gleiche Implementierung in Sparkonto und
Festgeld
• aber: in Girokonto Berechnung aus Sollzinsen
und Habenzinsen
• Lösung: Standard‐Implementierung in Konto
und Überschreiben in Girokonto
public class Konto {
...
/**
berechnet für die Anzahl Tage die angefallenen
Zinsen
*/
protected int berechneZinsen(int tage) {
Float zinsen =
new Float(kontostand*(habenzinsen/100)*(tage/360));
return (zinsen.intValue());
}
...
}
Wrapper-Klasse: Float
Wrapper-Klasse: Float
public class Girokonto extends Konto {
...
protected int berechneZinsen(int tage) {
int guthaben = holeKontostand();
if (guthaben > 0) {
Float zinsen = new Float(guthaben*(habenzinsen/100)*(tage/360));
return (zinsen.intValue());
} else {
Float zinsen = new Float(guthaben*(sollzinsen/100)*(tage/360));
return (zinsen.intValue());
}
}
}
 In einemObjekt einer abgeleiteten Klasse ist super
eine Referenz auf das Teilobjekt der Oberklasse
 Attribute und Methoden der Oberklasse lassen sich so
ansprechen (auch überschriebeneAttribute und
Methoden)
 Beispiel:
class A { class B extends A {
int variable; int variable; // Überschreibendes Attr.
void methode() { void methode() { // Überschreibende Meth.
... ...
} }
} void methode2() { // Zugriff auf
super.variable = 3; // überschriebene
super.methode(); // Attribute und
} // Methoden der
} // Oberklasse

20. 11.03.2012
20
 Verhindert, daß eine Methode überschrieben
wird
public final int holeKontostand() {
...
}
 Erben von einer Klasse verbieten
public final class Girokonto extends Konto {
...
}
 Alle Methoden und Attribute einer finalen Klasse
sind implizit auch final.
 Finale Klassen und Methoden sind aus Sicherheitsgründen
zuweilen erforderlich. Sie tun das, was sie tun sollen und
können nicht manipuliert werden. Typische Anweisung: eine
Methode zur Passwort‐Prüfung.
 final ‐ Attribute sind Konstanten, sie dürfen nicht verändert
werden
 public final int mwst;
• Situation: Jede Subklasse hat die gleiche Methode aber
unterschiedliche Implementierung
• Beispiel: auszahlen(int betrag)
– Girokonto: beliebige Auszahlung bis Limit
– Sparkonto: Restguthaben nötig (außer nach Kündigung)
– Festgeld: Auszahlung erst nach Ende der Laufzeit
• Lösung: abstrakte Methode in der Superklasse. Eine
abstrakte Methode ist eine Methode, die nicht realisiert ist.
• Die abstrakte Methode der Superklasse gibt dann nur die
Signatur der Methode an, nicht aber ihre Realisierung.
public abstract class Konto {
protected Datum letzteTransaktion;
...
public void einzahlen(int betrag) {
Datum heute = Datum.aktuellesDatum();
int zinstage = heute.gibDifferenz(letzteTransaktion);
int zinsen = berechneZinsen(zinstage);
zahle(betrag+zinsen);
}
public abstract int auszahlen(int betrag);
}
Schlüsselwort: abstract
vor Methode und Klasse
Schlüsselwort: abstract
vor Methode und Klasse

21. 11.03.2012
21
class Girokonto extends Konto {
...
public int auszahlen(int betrag) {
Datum heute = Datum.aktuellesDatum();
int zinstage = heute.gibDifferenz(letzteTransaktion);
int zinsen = berechneZinsen(zinstage);
zahle(zinsen);
if (kontostand-betrag > dispo) {
zahle(-betrag);
return (betrag);
} else Bildschirm.gibAus(“Kein Auszahlen möglich“);
return (0);
}
}
• Enthält eine Klasse eine abstrakte Methode, so ist die ganze
Klasse abstract
• Eine abstrakte Klasse kann nicht instanziiert werden. D.h., es
können keine Objekte zu dieser Klasse erzeugt werden. Es
kann nur Objekte zu den nicht abstrakten Unterklassen
geben.
• Abstrakte Methoden müssen in den Subklassen
implementiert werden (oder die Subklassen sind wieder
abstract)
• Wunsch:
Alle Objekte aus der Oberklasse “Konto” sollen in der
gleichen Weise behandelt werden können.
• Lösung: Polymorphie
Eine Oberklassen‐Referenz kann auch auf Objekte der
Subklassen verweisen.
• Methoden der Oberklasse können so aufgerufen werden.
Wurde eine Methode von einer Subklasse überschrieben, so
wird nicht die Methodenimplementierung der Oberklasse
aufgerufen, sondern die Implementierung der Subklasse.
 Methoden können so mit allen möglichen Konten
arbeiten
public int berechneVermoegen(Konto[] konten) {
int vermoegen = 0;
for (int i=0; i<konten.length; i++) {
Konto k = konten[i];
vermoegen += k.holeKontostand();
}
return (vermoegen);
}
 Methodenaufruf wird an die entsprechende
Subklasse weitergeleitet

22. 11.03.2012
22
• Polymorphie wird beiVererbung durch
Überschreiben der Methoden der Oberklasse
erreicht, dabei muß die Signatur (also
Parameterliste und Rückgabetyp) mit der Methode
der Oberklasse übereinstimmen.
• Beim Überschreiben werden die allgemeineren
Methoden (der Oberklasse) durch die konkreteren
der Unterklasse überschrieben.
134
• Auch wenn ein Objekt durch eineVariable eines
allgemeinerenTyps referenziert wird, so werden
immer die zum Objekt gehörenden Methoden
aufgerufen.
• Überschreiben darf nicht mit Überladen
verwechselt werden, bei überladenen Methoden
hat man unterschiedliche Signaturen und nur der
Methodenname ist der gleiche.
• Da jedes Objekt auch über Referenzen der Oberklasse
angesprochen werden kann, ist nicht immer klar, zu welcher
Klasse ein Objekt gehört. Daher gibt es das Schlüsselwort
instanceof, um die Klassenzugehörigkeit zu bestimmen:
if(Objektname instanceof Klassenname)
Anweisung
• Die Abfrage liefert auch dann true, wenn durch
Klassenname eine Oberklasse für das zu Objektname
zugehörige Objekt angegeben wird