Klassen und Objekte

Objektorientierte Programmierung in Java:
Klassen, Objekte und Methoden
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Klassen, Objekte und Methoden
Vererbung
Modifikatoren
Klassenvariable und statische Methoden
Abstrakte Klassen
Schnittstellen
Zusammenfassung
4.1 Klassen, Objekte und Methoden
4-1
Objektorientierung
In diesem Kapitel lernen wir die nächsten Dinge der Objektorientierung kennen. Einige
Dinge kennen wir schon:
• Klasse, Objekt/Instanz
• Attribut, Methode, spezielle Methoden: Konstruktor, equals, . . .
• static, private, public
• Referenztyp vs. primitiver Datentyp, s. Zuweisung
• API, spezielle Typen: String, array, . . .
4.1 Klassen, Objekte und Methoden
4-2
Objektorientierung
Einige der Dinge, die jetzt kommen:
• Typischer Aufbau einer Klasse, Kapselung
• Beziehungen zwischen Klassen, Objekten/Instanzen
• Abstraktion und Modellierung
• abstrakte Klassen und Schnittstellen
• weitere Klassen und weitere Modifikatoren
• ...
4.1 Klassen, Objekte und Methoden
4-3
Grundlagen der Objektorientierung
Klassen
Begriffswelt des
Modellierenden
Person
Patient
Mitarbeiter
Arzt
Chefarzt
Krankenhaus
Mitarbeiter
Patienten
Schwestern Verwaltung
Ärzte
Prof. Dr. Sauerbruch
Dr. Quincy
Fr. Müller
Objekte/Instanzen
4.1 Klassen, Objekte und Methoden
Realität
4-4
Objekte
Ein Objekt ist die Repräsentation eines Gegenstands oder Sachverhalts der realen
Welt oder eines rein gedanklichen Konzepts.
Es ist gekennzeichnet durch
• eine eindeutige Identität, durch die es sich von anderen Objekten unterscheidet,
• Eigenschaften zur Darstellung des Zustands des Objekts in Form von Attributen,
• Eigenschaften in Form von Methoden, die das Verhalten des Objekts beschreiben.
4.1 Klassen, Objekte und Methoden
4-5
Beispiele für Objekte
• Eine Person mit Namen „Müller“ und Geburtsdatum „12.12.1953“ (Attribute mit
Belegungen) und Methode „int alter()“.
• Eine rationale Zahl mit Zähler und Nenner (Attribute) und Methoden
„normalisiere()“ und „addiere(r: RationaleZahl)“.
Es findet in der Regel eine Abstraktion statt. Gewisse Aspekte (zum Beispiel das
„Gewicht“ einer Person) werden nicht berücksichtigt.
Der Zustand eines Objekts zu einem Zeitpunkt entspricht der Belegung der Attribute
des Objekts zu diesem Zeitpunkt. Der Zustand eines Objekts kann mithilfe von
Methoden erfragt und geändert werden.
4.1 Klassen, Objekte und Methoden
4-6
Objektmodelle
• Wertbasierte Objektmodelle: In diesem Modell besitzen Objekte keine eigene
Identität im eigentlichen Sinn. Zwei Objekte werden schon als identisch angesehen,
wenn ihr Zustand gleich ist. Für zwei Objekte zur Datumsangabe
d1 = „6.12.1986“ und d2 = „6.12.1986“ gilt in diesem Modell d1 = d2.
• Identitätsbasierte Objektmodelle: Jedem Objekt innerhalb des Systems wird
eine vom Wert unabhängige Identität zugeordnet. Zwei Objekte für Personen
p1 = „Müller, 12.12.1953“ und p2 = „Müller, 12.12.1953“ sind in
diesem Modell nicht identisch: p1 6= p2.
4.1 Klassen, Objekte und Methoden
4-7
Kapselung und Geheimnisprinzip
Objekte verwenden das Geheimnisprinzip und das Prinzip der Kapselung. Sie
verbergen ihre Interna:
• Zustand (Belegung der Attribute),
• Implementierung ihres Zustands,
• Implementierung ihres Verhaltens.
Objekte sind nur über ihre Schnittstelle, also über die Menge der vom Objekt der
Außenwelt zur Verfügung gestellten Methoden, zugänglich. Man spricht von den
Diensten des Objekts.
4.1 Klassen, Objekte und Methoden
4-8
Nachrichten
Objekte interagieren über Nachrichten (evtl. auch über gemeinsame Daten):
• Ein Objekt x sendet eine Nachricht n an Objekt y . Das Objekt y empfängt die
Nachricht n von x .
• Innerhalb einer Programmiersprache wird dieser Vorgang meist durch einen
Methodenaufruf implementiert.
• Nachrichten (Methodenaufrufe) können den Zustand eines Objektes verändern.
• Ein Objekt kann sich selbst Nachrichten schicken.
4.1 Klassen, Objekte und Methoden
4-9
Beziehungen zwischen Objekten
Objekte können in Beziehungen zueinander stehen.
• Die Beteiligten an einer Beziehung nehmen Rollen ein.
Rolle des Arztes: „behandelnder Arzt“,
Rolle des Patienten: „Patient“.
• Ein Objekt kann mit mehreren Objekten in der gleichen Beziehung stehen.
Rolle von Arzt: „behandelnder Arzt“,
Rolle von Patient 1: „Patient“, Rolle von Patient 2: „Patient“.
• Nachrichten können nur ausgetauscht werden, wenn eine Beziehung besteht.
• Beziehungen können sich während der Lebenszeit eines Objekts verändern.
4.1 Klassen, Objekte und Methoden
4-10
Klassen
• Objekte besitzen eine Identität, verfügen über Attribute und Methoden, gehen
Beziehungen zu anderen Objekten ein und interagieren über Nachrichten.
• Es gibt in der Regel Objekte, die hinsichtlich ihrer Attribute, Methoden und
Beziehungen gleich sind. Daher bietet es sich an, diese Objekte zu einer Klasse
zusammenzufassen.
4.1 Klassen, Objekte und Methoden
4-11
Beziehungen
Beziehungen können bestehen (wie schon erwähnt) zwischen
• Objekten,
• Klassen (Beispiel: Vererbung),
• Objekten und Klassen (Beispiel: instance of).
Demnächst lernen wir Schnittstellen/interfaces und abstrakte Klassen kennen.
4.1 Klassen, Objekte und Methoden
4-12
Abstraktion und Modellierung
Jeffrey Kramer: Abstraction is
• the act of withdrawing or removing something,
• the act or process of leaving out of consideration one or more properties of a
complex object so as to attend others
→ remove detail (simplify) and focus (selection).
• a general concept formed by extracting common features from specific examples
• the process of formulating general concepts by abstracting common properties of
instances
→ generalisation.
4.1 Klassen, Objekte und Methoden
4-13
Abstraktion und Modellierung
Jeffrey Kramer:
• A model is a description from which detail has been removed in a systematic
manner and for a particular purpose. A simplification of reality intended to
promote understanding, reasoning and analysis.
• Models are the most important engineering tools; they allow us to understand and
analyse large and complex problems.
• A model should be as simple as possible, but no simpler – it should discard
elements of no interest.
4.1 Klassen, Objekte und Methoden
4-14
Abstraktion und Modellierung
Jeffrey Kramer:
How should we ensure that students can understand and make use of abstraction?
• Teach enough mathematics
• Teach formal modelling and analysis
4.1 Klassen, Objekte und Methoden
4-15
Modifikatoren
Die folgende Liste enthält Modifikatoren (modifier).
•
•
•
•
•
•
public, private, protected: Sichtbarkeit
static: Klassenvariable, Klassenmethode
final: nicht mehr veränderbar
abstract: noch nicht vollständig implementiert
synchronized, volatile: Parallelprogrammierung
transient: Serialisierung
Ihre genaue Bedeutung und Regeln zur Verwendung werden wir kennenlernen.
4.1 Klassen, Objekte und Methoden
4-16
Klassen
Unter einer Klasse versteht man die Zusammenfassung von Objekten gleicher Struktur
und gleichen Verhaltens. Eine Klasse kann als Schablone gesehen werden, die
beschreibt,
• wie Objekte aufgebaut sind (Attribute),
• wie man Objekte erzeugt, initialisiert, verändert, abfragt und zerstört,
• mit welchen Methoden Objekte bearbeitet werden können und
• welche Beziehungen zu anderen Klassen/Objekten existieren.
Ein konkret existierendes Objekt heißt auch Instanz der Klasse.
4.1 Klassen, Objekte und Methoden
4-17
Klassen
In Java wird eine Klassendefinition durch das Schlüsselwort class eingeleitet.
class Adresse {
String vorname;
String nachname;
String straße;
int nr;
int plz;
String ort = "Braunschweig";
... // ggf. weitere Attribute, Methoden
}
4.1 Klassen, Objekte und Methoden
4-18
Klassen
• Zusammen legen die Variablen die Struktur der Objekte fest. Sie werden auch
◦
◦
◦
◦
Membervariable,
Instanzvariable,
Instanzmerkmal oder
Attribut
genannt.
• Es ist guter Stil, wenn auch nicht zwingend erforderlich, jede Klassendefinition in
einer eigenen Datei zu speichern.
4.1 Klassen, Objekte und Methoden
4-19
Objekte
• Mithilfe des new-Operators wird ein neues Objekt einer Klasse erzeugt. Dies gilt
für alle Klassen. Ausnahmen sind lediglich Strings und Arrays, für die – wie bereits
gesehen – Objekte auch mit Literalen erzeugt werden können.
• Man kann eine Variable vom Typ der Klasse deklarieren und ihr mithilfe des
new-Operators ein neu erzeugtes Objekt zuweisen:
Adresse adr1;
adr1 = new Adresse();
• Die beiden Anweisungen lassen sich auch kombinieren:
Adresse adr1 = new Adresse();
4.1 Klassen, Objekte und Methoden
4-20
Objekte
• Alle Attribute eines Objekts besitzen Standardwerte. Der Standardwert einer
Referenz ist null, die Standardwerte der primitiven Datentypen haben wir bereits
kennengelernt. In unserem Beispiel wird Ort mit "Braunschweig" vorbesetzt, die
anderen Variablen sind mit den Standardwerten initialisiert.
• Den Variablen können entsprechend ihrem Typ Werte zugewiesen werden. Der
Zugriff erfolgt mit der Punktnotation:
adr1.vorname = "Hans";
adr1.nachname = "Müller";
adr1.straße = "Schillerstraße";
adr1.nr = 47;
adr1.plz = 38107;
4.1 Klassen, Objekte und Methoden
4-21
Objekte
• Es können – zumindest im Prinzip – beliebig viele Objekte (Instanzen) angelegt
werden:
Adresse adr2 = new Adresse();
adr2 = adr1;
adr2.vorname = "Eva";
Die Zuweisung kopiert nur die Referenz, nicht das Objekt.
4.1 Klassen, Objekte und Methoden
4-22
Methoden
• Methoden definieren das Verhalten der Objekte. Sie werden innerhalb einer
Klassendefinition angelegt und haben auf alle Variablen des Objekts Zugriff.
• Nach einer Reihe von Modifikatoren – auf sie kommen wir noch zu sprechen –
folgen der Typ des Rückgabewerts, der Name der Methode und eine optionale Liste
ihrer Parameter. Wenn eine Methode keinen Wert liefern, sondern nur
Seiteneffekte bewirken soll, ist void als Typ des Rückgabewerts zu deklarieren.
• Wir wollen eine Methode schreiben, die eine Adresse ausgibt:
void drucken() {
System.out.println(vorname + " " + nachname);
System.out.println(straße + " " + nr);
System.out.println(plz + " " + ort);
}
4.1 Klassen, Objekte und Methoden
4-23
Methoden
Der Aufruf einer Methode erfolgt ebenfalls unter Verwendung der Punktnotation. Die
Liste der Parameter wird in runden Klammern angefügt. Die Klammern müssen auch
dann stehen, wenn keine Parameter vorhanden sind.
adr1.drucken();
adr2.drucken();
4.1 Klassen, Objekte und Methoden
4-24
Beispiel: Adresskartei
class Adresse {
String vorname;
String nachname;
String straße;
int nr;
int plz;
String ort = "Braunschweig";
void drucken() {
System.out.println(vorname + " " + nachname);
System.out.println(straße + " " + nr);
System.out.println(plz + " " + ort);
System.out.println("");
}
}
4.1 Klassen, Objekte und Methoden
4-25
Beispiel: Adresskartei
public static void main(String[] args) {
Adresse adr1 = new Adresse();
adr1.vorname = "Hans";
adr1.nachname = "Müller";
adr1.straße = "Schillerstraße";
adr1.nr = 47;
adr1.plz = 38107;
adr1.drucken();
Adresse adr2 = new Adresse();
adr2 = adr1;
adr2.vorname = "Eva";
adr2.drucken();
adr1.drucken();
}
4.1 Klassen, Objekte und Methoden
4-26
Beispiel: Adresskartei
Hans Müller
Schillerstraße 47
38107 Braunschweig
Eva Müller
Schillerstraße 47
38107 Braunschweig
Eva Müller
Schillerstraße 47
38107 Braunschweig
4.1 Klassen, Objekte und Methoden
4-27
Der This-Zeiger
• Eine Methode darf auf alle Instanzvariablen ihrer Klasse ohne Punktnotation
zugreifen. Dies ist eine Kurzschreibweise für die this-Notation.
void drucken() {
System.out.println(this.vorname + " " + this.nachname);
System.out.println(this.straße + " " + this.nr);
System.out.println(this.plz + " " + this.ort);
System.out.println("");
}
• this ist eine Referenzvariable, die auf das aktuelle Objekt zeigt. Der this-Zeiger
kann wie eine ganz normale Objektvariable verwendet werden.
4.1 Klassen, Objekte und Methoden
4-28
Parameterübergabe
Alle Parameter einer Methode werden in Java per call-by-value übergeben. Das heißt:
• Beim Aufruf einer Methode wird der aktuelle Wert in die Parametervariable kopiert
und an die Methode übergeben. Veränderungen innerhalb der Methode bleiben
daher lokal und wirken sich nicht auf den Aufrufer aus.
• Objektvariable sind – wie gesehen – Referenzen. Auch sie werden per call-by-value
übergeben. Veränderungen wirken sich also direkt auf das Originalobjekt aus und
sind somit für den Aufrufer sichtbar.
4.1 Klassen, Objekte und Methoden
4-29
Parameterübergabe
Konsequenzen:
• Die Methode erhält keine Kopie, sondern arbeitet mit dem Originalobjekt.
• Die Übergabe von Objekten ist effizient, da nur eine Referenz und nicht das
Originalobjekt kopiert wird.
• Sollen Objekte kopiert werden, so muss dies explizit durch die Methode clone
erfolgen.
4.1 Klassen, Objekte und Methoden
4-30
Rückgabewert einer Methode
• Jede Methode in Java ist typisiert. Der Typ einer Methode wird zum Zeitpunkt der
Deklaration festgelegt und bestimmt den Typ des Rückgabewerts. Dieser kann von
einem primitiven Typ, einem Objekttyp (also einer Klasse) oder vom Typ void sein.
• Die Methoden vom Typ void haben keinen Rückgabewert und dürfen nicht in
Ausdrücken verwendet werden. Sie sind wegen der Seiteneffekte von Interesse und
dürfen daher nur als Ausdrucksanweisungen benutzt werden.
• Hat eine Methode einen Rückgabewert so wird dieser Wert mit der
return-Anweisung an den Aufrufer zurückgegeben.
return Ausdruck;
Der Ausdruck muss kompatibel zum Typ der Methode sein. Nach Ausführung einer
return-Anweisung wird die Methode beendet.
4.1 Klassen, Objekte und Methoden
4-31
Überladen von Methoden
• In Java ist es erlaubt, Methoden zu überladen: Innerhalb einer Klasse können
mehrere Methoden denselben Namen tragen.
• Der Compiler unterscheidet die Methoden anhand der Anzahl sowie der Typen und
der Reihenfolge der Parameter. Diese Information heißt Signatur der Methode.
• Der Rückgabetyp trägt (in Java) nicht zur Unterscheidung bei.
4.1 Klassen, Objekte und Methoden
4-32
Überladen von Methoden
Es ist z. B. erlaubt, die drei folgenden Methoden in einer Klasse zu definieren:
•
double f(int a, double b) { ... },
•
double f(double a, double b) { ... },
•
double f(double a, int b) { ... },
aber (in Java) nicht zusätzlich noch
•
int f(int a, double b) { ... }.
4.1 Klassen, Objekte und Methoden
4-33
Überladen von Methoden
public class Ueberladen {
static double f(int a,
double b) { return 1.0; }
static double f(double a, double b) { return 2.0; }
static double f(double a, int b)
{ return 3.0; }
public static void main(String[] args) {
System.out.println(f(1, 2.0)); // Ausgabe: 1.0
System.out.println(f(1.0,2.0)); // Ausgabe: 2.0
System.out.println(f(1.0,2 )); // Ausgabe: 3.0
// System.out.println(f(1 ,2 )); // reference to f is ambiguous
}
}
Typecasts sind evtl. trotzdem möglich.
4.1 Klassen, Objekte und Methoden
4-34
Konstruktoren
• Ein Konstruktor ist eine Methode zur Erzeugung von Objekten. In Java ist ein
Konstruktor eine Methode ohne Rückgabewert.
• Ein Konstruktor besitzt stets den Namen der Klasse.
• Konstruktoren können Parameter haben und überladen werden.
• Wird für eine Klasse vom Programmierer kein Konstruktor geschrieben, so wird
vom Compiler automatisch ein parameterloser Default-Konstruktor zur Verfügung
gestellt.
• Wird vom Programmierer explizit ein Konstruktor vorgesehen, so erzeugt der
Compiler keinen Default-Konstruktor.
4.1 Klassen, Objekte und Methoden
4-35
Verkettung von Konstruktoren
• Unterschiedliche Konstruktoren einer Klasse können verkettet werden.
• Der aufzurufende Konstruktor wird als normale Methode betrachtet, die über den
Namen this angesprochen wird.
• Als Methodenaufruf folgen auf this runde Klammern.
• Durch Verkettung von Konstruktoren lässt sich Duplizierung von Code vermeiden.
• Wird ein Konstruktor in einem anderen Konstruktor derselben Klasse explizit
aufgerufen, so muss dieser Aufruf an erster Stelle stehen.
4.1 Klassen, Objekte und Methoden
4-36
Konstruktoren
Adresse() {
}
Adresse(int plz) {
this.plz = plz;
}
Adresse(int plz, String ort) {
this(plz);
// Verkettung von Konstruktoren.
this.ort = ort;
}
4.1 Klassen, Objekte und Methoden
4-37
Konstruktoren
Adresse adr3 = new Adresse();
Adresse adr4 = new Adresse(38100);
Adresse adr5 = new Adresse(27356, "Rotenburg (Wümme)");
4.1 Klassen, Objekte und Methoden
4-38
Destruktoren
• Ein Destruktor ist eine Methode, die unmittelbar vor der Zerstörung eines Objekts
aufgerufen wird.
• Zur Verfügung gestellt wird ein Destruktor als parameterlose Methode
finalize().
• Ein Destruktor wird aufgerufen, wenn der Garbage Collector den für das Objekt
reservierten Speicherplatz zurückgibt. Dies kann viel später als der Aufruf des
Destruktors sein. Die Sprache garantiert nicht einmal, dass Destruktoren überhaupt
ausgeführt werden.
• Da ein Garbage Collector existiert, ist die Bedeutung der Destruktoren in Java
nicht sehr groß.
4.1 Klassen, Objekte und Methoden
4-39
Get- und Set-Methoden
public class Adresse {
private String vorname,
nachname;
...;
public String getVorname() {
return this.vorname;
}
public void setVorname(String vorname) {
this.vorname = vorname;
}
...;
}
4.1 Klassen, Objekte und Methoden
4-40
Typischer Aufbau einer Klasse
public class KlassenName
attribut1;
...
attributN;
Konstruktor1;
...
KonstruktorM;
get- und set-Methoden;
toString-Methode;
equals-Methode;
clone-Methode;
...;
main-Methode
}
4.1 Klassen, Objekte und Methoden
{
// private
// private
// public
//
//
//
//
//
//
//
public
public
Methode der Klasse Object, s. unten
Methode der Klasse Object, s. unten
Methode der Klasse Object, s. unten
weitere Instanz-/Klassenmethoden
optional
4-41
Typischer Aufbau einer Klasse (Beispiel)
public class Name {
private String vorname,
nachname;
public Name() {
}
public Name(String vorname, String nachname) {
this.vorname = vorname;
this.nachname = nachname;
}
4.1 Klassen, Objekte und Methoden
4-42
public void setVorname(String vorname) {
this.vorname = vorname;
}
public void setNachname(String nachname) {
this.nachname = nachname;
}
public String getVorname() {
return this.vorname;
}
public String getNachname() {
return this.nachname;
}
4.1 Klassen, Objekte und Methoden
4-43
public String toString() {
return vorname + " " + nachname;
}
public static void main(String[] args) {
Name n1 = new Name(),
n2 = new Name("Peter","Müller");
n1.setVorname("Monika");
n1.setNachname("Schäfer");
System.out.println(n1);
System.out.println(n2);
}
}
4.1 Klassen, Objekte und Methoden
4-44
Beispiele
Wir wollen die Konzepte, die wir soeben kennengelernt haben, an einigen – uns
teilweise bereits vertrauten – Beispielen vertiefen:
• Horner-Schema
• Aufruf von Methoden
• Bubblesort
• Newton-Verfahren
4.1 Klassen, Objekte und Methoden
4-45
Problemstellung
Was sind die Objekte?
Abstraktion und Modellierung: Diese Frage besitzt keine eindeutige Antwort!
4.1 Klassen, Objekte und Methoden
4-46
Beispiel: Horner-Schema
class Horner {
int[] b;
int n, y;
Horner(int[] a, int x) {
this.n = a.length - 1;
this.b = new int[n];
y = horner(a,x);
}
4.1 Klassen, Objekte und Methoden
4-47
Beispiel: Horner-Schema
int horner(int[] a, int x) {
b[n-1] = a[n];
for (int i = n - 2; i >= 0; i--) {
b[i] = x * b[i+1] + a[i+1];
}
return x * b[0] + a[0];
}
void ausgabe() {
System.out.println(y);
for (int i = n - 1; i >= 0; i--) {
System.out.print(b[i] + " ");
}
System.out.println();
}
4.1 Klassen, Objekte und Methoden
4-48
Beispiel: Horner-Schema
public static void main(String[] args) {
int[] feld = {-16, -20, -2, 2};
Horner auswertung = new Horner(feld, 5);
auswertung.ausgabe();
}
}
Ausgabe:
84
2 8 20
4.1 Klassen, Objekte und Methoden
4-49
Beispiel: Horner-Schema
Ist die Klasse Horner typisch aufgebaut?
Nein!
Was ist nicht erfüllt?
4.1 Klassen, Objekte und Methoden
4-50
Aufruf von Methoden
class AufrufTest {
void unterprogramm(int n) {
n = n * 5;
System.out.print(n);
}
AufrufTest t = new AufrufTest();
int n = 7;
System.out.print(n);
t.unterprogramm(n);
System.out.print(n);
Ausgabe:
7
35
4.1 Klassen, Objekte und Methoden
7
4-51
Aufruf von Methoden
void unterprogramm(int[] n) {
n[0] = n[0] * 5;
System.out.println(n[0]);
}
int m[] = {7};
System.out.println(m[0]);
t.unterprogramm(m);
System.out.println(m[0]);
Ausgabe:
7
35
4.1 Klassen, Objekte und Methoden
35
4-52
Aufruf von Methoden
int[] arraycopy(int[] n) {
int[] erg = new int[n.length];
for (int i = 0; i < n.length; i++)
erg[i] = n[i];
return erg;
}
int m[] = {7};
System.out.println(m[0]);
t.unterprogramm(t.arraycopy(m));
System.out.println(m[0]);
Ausgabe:
7
35
4.1 Klassen, Objekte und Methoden
7
4-53
Bubblesort
class BubbleSort {
int[] feld;
BubbleSort(int[] feld) {
this.feld = feld;
}
void print() {
for (int i = 0; i < feld.length; i++) {
System.out.print(feld[i] + " ");
}
System.out.println("");
}
4.1 Klassen, Objekte und Methoden
4-54
Bubblesort
void sort() {
boolean unsortiert = true;
while (unsortiert) {
int a = 0, x = 0, y = 1, z;
while (y <= feld.length - 1) {
if (feld[x] <= feld[y]) {
a++;
}
wie oben
}
}
}
4.1 Klassen, Objekte und Methoden
4-55
Bubblesort
public static void main(String[] args) {
int[] a = {12, -16, -20, -2, 2, 0};
BubbleSort bs = new BubbleSort(a);
bs.print();
bs.sort();
bs.print();
}
}
4.1 Klassen, Objekte und Methoden
4-56
Newton
Es soll die Nullstelle der Funktion
80
60
f (x ) = x 3 + 3x + 5
y
40
20
mithilfe des Newton-Verfahrens berechnet
werden:
f 0(x ) = 3x 2 + 3
xn+1
f (xn )
= xn − 0
f (xn )
4.1 Klassen, Objekte und Methoden
–4
–3
–2
–1
0
1
2
3
4
x
–20
–40
–60
–80
4-57
Newton
class Newton {
double x, eps;
static double f(double x) {
return x*x*x+3*x+5;
}
// statische Funktion
static double fs(double x) {
return 3*x*x+3;
}
// statische Funktion
4.1 Klassen, Objekte und Methoden
4-58
Newton
Newton(double x, double eps) {
this.x = x;
this.eps = eps;
}
void newton() {
do {
x = x - f(x) / fs(x);
System.out.println(x);
} while (Math.abs(f(x)) > eps);
}
4.1 Klassen, Objekte und Methoden
4-59
Newton
public static void main(String[] args) {
Newton n = new Newton(1.0, 0.000001);
n.newton();
System.out.println();
Newton m = new Newton(-1.0, 0.000001);
m.newton();
}
}
4.1 Klassen, Objekte und Methoden
4-60
Variable Parameterzahl
Es sollen n Zahlen, n ≥ 0, addiert werden:
static int summe(int v1, int v2) {
return v1+v2;
}
static int summe(int v1, int v2, int v3) {
return v1+v2+v3;
}
System.out.println(summe(1,2));
System.out.println(summe(1,2,3));
4.1 Klassen, Objekte und Methoden
4-61
Variable Parameterzahl
Die Zahlen können auch als Feld übergeben werden:
static int summe(int [] a) {
int sum = 0;
for (int v : a)
sum += v;
return sum;
}
System.out.println(summe(new int[] {1,2,3,4}));
4.1 Klassen, Objekte und Methoden
4-62
Variable Parameterzahl
Variable Parameterzahl (seit Java 5.0):
static int summe(int... a) {
int sum = 0;
for (int i=0; i<a.length; i++)
sum += a[i];
return sum;
}
System.out.println(summe());
System.out.println(summe(1));
System.out.println(summe(1,2));
System.out.println(summe(1,2,3));
System.out.println(summe(1,2,3,4));
4.1 Klassen, Objekte und Methoden
4-63
Variable Parameterzahl
Variable Parameterzahl und erweiterte For-Schleife (seit Java 5.0):
static int summe(int... a) {
int sum = 0;
for (int v : a)
sum += v;
return sum;
}
System.out.println(summe());
System.out.println(summe(1));
System.out.println(summe(1,2));
System.out.println(summe(1,2,3));
System.out.println(summe(1,2,3,4));
4.1 Klassen, Objekte und Methoden
4-64
Variable Parameterzahl
• Syntax: int summe(int... a)
• Ein Parameter der Form Typ... kann immer nur der letzte Parameter einer Liste
von formalen Parametern sein. Es ist daher auch nur ein einziger Vararg-Parameter
möglich.
• In einem Aufruf der Methode summe können beliebig viele (auch keine) Parameter
für a eingesetzt werden.
• Intern wird eine variable Parameterzahl durch ein Feld realisiert. Daher stehen zum
Beispiel Ausdrücke der Form a.length und a[i] zur Verfügung.
4.1 Klassen, Objekte und Methoden
4-65
Die Klasse Object
• Die Klasse Object definiert Methoden, die für viele Objekte nützlich sind:
protected Object clone()
boolean equals(Object obj)
protected void finalize()
Class<?> getClass()
int hashCode()
void notify()
void notifyAll()
String toString()
void wait()
void wait(long timeout)
void wait(long timeout, int nanos)
• Alle diese Methoden werden wir kennenlernen! Einige dieser Methoden sollten
selbst geschrieben, d. h. überlagert, werden.
4.1 Klassen, Objekte und Methoden
4-66
Fallstudie: Polynomarithmetik
import java.util.Arrays;
/**
* Definiert Polynome mit ganzzahligen Koeffizienten.
*
* @author Werner Struckmann, basierend auf Schiedermeier et al.
* @version 18.12.2008
*/
public class Polynomial {
public static final Polynomial ZERO = new Polynomial();
public static final Polynomial ONE = new Polynomial(1);
private final int[] a;
4.1 Klassen, Objekte und Methoden
4-67
/** Konstruktor erzeugt das Polynom c0+c1*x+c2*x^2+c3*x^3+...
* @param c Koeffizienten des Polynoms
*/
public Polynomial(final int... c) {
a = Arrays.copyOf(c, length(c));
}
4.1 Klassen, Objekte und Methoden
4-68
/**
* Bestimmt die reduzierte Länge eines Koeffizientenarrays a,
* d.h. den um 1 erhöhten größten Index d mit a[d]!=0.
* @param a Koeffizientenarray
* @return max. Index d mit a[d]!=0
*/
private static int length(final int[] a) {
int d = a.length - 1;
while(d >= 0 && a[d] == 0)
d--;
return d + 1;
}
4.1 Klassen, Objekte und Methoden
4-69
/**
* Bestimmt den Grad des Polynoms.
* @return Grad des Polynoms
*/
public int degree() {
return Math.max(0, a.length - 1);
}
4.1 Klassen, Objekte und Methoden
4-70
public boolean equals(final Object x) {
if(x == null)
return false;
if(getClass() != x.getClass())
return false;
final Polynomial p = (Polynomial) x;
return Arrays.equals(a, p.a);
}
4.1 Klassen, Objekte und Methoden
4-71
public boolean isZero() {
return equals(ZERO);
}
public boolean isOne() {
return equals(ONE);
}
4.1 Klassen, Objekte und Methoden
4-72
/**
* Multipliziert dieses Polynom mit einer Zahl r.
* @param r die Zahl
* @return das Produkt
*/
public Polynomial mult(final int r) {
if(isZero() || r == 0)
return ZERO;
final int[] b = new int[degree() + 1];
for(int i = 0; i <= degree(); i++)
b[i] = a[i]*r;
return new Polynomial(b);
}
4.1 Klassen, Objekte und Methoden
4-73
/** @param p das Polynom
* @return das Produkt
*/
public Polynomial mult(final Polynomial p) {
if(isZero() || p.isZero()) return ZERO;
if(isOne()) return p;
if(p.isOne()) return this;
final int[] c = new int[degree() + p.degree() + 1];
for(int i = 0; i <= degree(); i++)
for(int j = 0; j <= p.degree(); j++)
c[i + j] += a[i]*p.a[j];
return new Polynomial(c);
}
4.1 Klassen, Objekte und Methoden
4-74
/**
* Addiert dieses Polynom zu einem Polynom p.
* @param p das Polynom
* @return die Summe
*/
public Polynomial add(final Polynomial p) {
if(isZero()) return p;
if(p.isZero()) return this;
final int[] c = new int[Math.max(degree(),p.degree())+1];
for(int i = 0; i < c.length; i++)
c[i] = get(i) + p.get(i);
return new Polynomial(c);
}
4.1 Klassen, Objekte und Methoden
4-75
/**
* Subtrahiert von diesem Polynom ein anderes Polynom p.
* @param p das Polynom
* @return die Differenz
*/
public Polynomial sub(final Polynomial p) {
return add(p.mult(-1));
}
4.1 Klassen, Objekte und Methoden
4-76
/**
* Selektiert den i-ten Koeffizienten.
* @param i
* @return den i-ten Koeffizienten
*/
public int get(final int i) {
if(i < 0)
throw new IndexOutOfBoundsException();
return isZero() || i > degree() ? 0 : a[i];
}
4.1 Klassen, Objekte und Methoden
4-77
public String toString() {
if(isZero())
return "0";
String s = String.format("%+d", a[0]);
for(int i = 1; i < a.length; i++)
s = String.format("%+dx^%d", a[i], i) + s;
return s;
}
4.1 Klassen, Objekte und Methoden
4-78
/**
* Bestimmt den Wert dieses Polynoms an der Stelle x
* mithilfe des Horner-Schemas.
* @param x
* @return Wert dieses Polynoms an der Stelle x
*/
public int value(final int x) {
int y = 0;
for(int i = degree(); i >= 0; i--)
y = a[i] + x*y;
return y;
}
}
4.1 Klassen, Objekte und Methoden
4-79
Fallstudie: Polynomarithmetik
Polynomial p = new Polynomial(3, -1, 2);
Polynomial q = new Polynomial(0, 3, 0, -2, 0);
System.out.println("p = " + p);
System.out.println("Grad von p: "+p.degree());
System.out.println("p+q = "+p.add(q));
System.out.println("p-q = "+p.sub(q));
System.out.println("3*p = "+p.mult(3));
System.out.println("p*q = "+p.mult(q));
System.out.println("Koeffizient von x^2 von p: "+p.get(2));
System.out.println("Ist p-p=0? " + p.sub(p).isZero());
System.out.println("p(2) = " + p.value(2));
4.1 Klassen, Objekte und Methoden
4-80
Utility Klassen
• Falls alle Attribute und Methoden einer Klasse statisch sind, dann sollten von der
Klasse keine Instanzen erzeugt werden.
• Dies kann durch einen privaten Konstruktor erreicht werden.
• Außerdem sollte die Klasse final sein.
Eine solche Klasse bezeichnen manche Autoren als utility class.
4.1 Klassen, Objekte und Methoden
4-81
Objektorientierte Programmierung in Java:
Vererbung
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Klassen, Objekte und Methoden
Vererbung
Modifikatoren
Klassenvariable und statische Methoden
Abstrakte Klassen
Schnittstellen
Zusammenfassung
4.2 Vererbung
4-82
Einfache Vererbung
• B erbt alle Attribute und Methoden von
A und fügt in der Regel weitere hinzu.
• A ist die Basisklasse (Oberklasse,
Vaterklasse) und B die abgeleitete
Klasse (Unterklasse, Sohnklasse).
• B ist eine Spezialisierung von A und
A eine Generalisierung von B.
4.2 Vererbung
A
O
B
4-83
Einfache Vererbung
• „Jede Instanz b ∈ B ist auch ein
a ∈ A.“
A
O
• Einfache Vererbung: Jede abgeleitete
Klasse besitzt genau eine Vaterklasse.
• In Java:
class B extends A { ... }
4.2 Vererbung
B
4-84
Einfache Vererbung
Gegeben sei wiederum unsere Klasse Adresse.
class Adresse {
String vorname;
String nachname;
String straße;
int nr;
int plz;
String ort = "Braunschweig";
}
4.2 Vererbung
4-85
Einfache Vererbung
Wir erweitern diese Klasse durch Hinzufügen neuer Attribute zur Klasse Person, die
die Arbeitnehmer in einer Firma beschreibt.
class Person extends Adresse {
int persnr;
int steuerklasse;
double gehalt;
String gebdatum;
}
Die Klasse Person erbt die Attribute und Methoden von Adresse.
4.2 Vererbung
4-86
Einfache Vererbung
Die abgeleitete Klasse fügt auch neue Methoden hinzu, z. B. eine zur Gehaltserhöhung:
void erhöhe(double p) {
gehalt = gehalt * (1+p/100); // Gehaltserhöhung um p Prozent
}
Person pers = new Person();
...
pers.gehalt = 3456.78;
...
pers.erhöhe(2.3);
// Gehaltserhöhung um 2.3 Prozent
...
4.2 Vererbung
4-87
Zuweisungen
• Zuweisungen bei abgeleiteten Klassen:
Adresse adr = new Adresse();
...
// Initialisierung von adr
Person pers = new Person();
...
// Initialisierung von pers
• Jedes Objekt einer Unterklasse kann einer Variablen vom Typ seiner Oberklasse
zugewiesen werden:
adr = pers;
4.2 Vererbung
4-88
Zuweisungen
• Ein Objekt einer Unterklasse, auf das eine Variable der Oberklasse verweist, kann
nach einer geeigneten Typumwandlung einer Variablen vom Typ der Unterklasse
zugewiesen werden.
pers = (Person) adr;
// Cast, Typfehler zur Laufzeit möglich
Man sollte den instanceof-Operator verwenden:
if (adr instanceof Person)
pers = (Person) adr;
• Eine Variable vom Typ Adresse kann also während ihrer Lebensdauer auf Objekte
verschiedenen Typs (hier: Adresse und Person) verweisen. Dies wird als
Polymorphismus bezeichnet. Durch die Zuweisungen ändert sich das Objekt nicht.
4.2 Vererbung
4-89
Verdecken von Variablen
• Eine Unterklasse kann eine Variable deklarieren, die denselben Namen trägt wie
eine der Oberklasse.
• Hierdurch wird die weiter oben liegende Variable verdeckt.
• Dies wird häufig dazu benutzt, um den Typ einer Variablen der Oberklasse zu
überschreiben.
• Durch Verwendung des Präfixes super kann auf die verdeckte Variable zugegriffen
werden.
4.2 Vererbung
4-90
Verdecken von Variablen
class Person extends Adresse {
...
String nr;
// überdeckt die int-Variable nr
...
void nrsetzen(int nr) {
super.nr = nr;
}
...
}
4.2 Vererbung
4-91
Überlagern von Methoden
• Neben den Instanzvariablen erbt eine abgeleitete Klasse auch die Methoden der
Basisklasse (wenn dies nicht durch Modifikatoren verhindert wird).
• Methoden, die aus der Basisklasse geerbt werden, dürfen in der abgeleiteten Klasse
neu definiert, d. h. überlagert, werden.
• Da eine Variable einer Basisklasse Werte von verschiedenen Typen annehmen kann,
entscheidet sich bei überlagerten Methoden i. Allg. erst zur Laufzeit, welche
Methode zu verwenden ist: Dynamische Methodensuche.
• Wird eine Methode x in einer abgeleiteten Klasse überlagert, wird die ursprüngliche
Methode verdeckt. Aufrufe von x beziehen sich auf die überlagernde Variante.
Durch super.x( ... ) kann die Methode der Basisklasse aufgerufen werden.
4.2 Vererbung
4-92
Überlagern von Methoden
In der abgeleiteten Klasse Person wird die Methode drucken aus der Basisklasse
überlagert:
void drucken() {
System.out.println("Personalnummer: " + " " + persnr);
System.out.println("Steuerklasse:
" +" " + steuerklasse);
System.out.println(vorname + " " + nachname);
System.out.println(straße + " " + nr);
System.out.println(plz + " " + ort);
System.out.println("geb. " + gebdatum);
System.out.println("Gehalt: " + gehalt + " EUR");
}
4.2 Vererbung
4-93
Die Klasse Object
• Enthält eine Klasse keine extends-Klausel, so besitzt sie die implizite Vaterklasse
Object. Jede solche Klasse wird direkt aus Object abgeleitet.
• Jede explizit abgeleitete Klasse stammt am Ende ihrer Vererbungslinie von einer
Vaterklasse ohne extends-Klausel ab und ist damit aus Object abgeleitet.
• Object ist also (direkt oder indirekt) Vaterklasse aller anderen Klassen.
• Die Klasse Object definiert Methoden, die für viele Objekte nützlich sind:
String toString()
boolean equals(Object obj)
protected Object clone()
Class<?> getClass()
...
4.2 Vererbung
4-94
Die Methode toString
• Die Methode String toString() wird von allen Klassen geerbt.
• Häufig ist es zweckmäßig, diese Methode zu überlagern:
public String toString() {
return vorname+" "+nachname+" "+straße+" "+nr+" "+plz+" "+ort;
}
• Dadurch können Objekte z. B. mit System.out.println ausgegeben werden:
Person pers = new Person();
...
System.out.println(pers);
4.2 Vererbung
4-95
Die Methode toString
In der API steht:
public String toString()
Returns a string representation of the object. In general, the toString method returns
a string that “textually represents“ this object. The result should be a concise but
informative representation that is easy for a person to read. It is recommended that all
subclasses override this method.
4.2 Vererbung
4-96
Die Methode equals
• Die Methode boolean equals(Object obj) wird von allen Klassen geerbt.
• Häufig ist es zweckmäßig, diese Methode zu überlagern, z. B.
public boolean equals(Object x){
if (x == null) return false;
if (x.getClass() != getClass()) return false;
if (!super.equals(x)) return false; // nur ggf. sinnvoll
Classname other = (Classname) x; // Typcast von x auf aktuelle Klasse
...
// inhaltlicher Vergleich von other und this
return true;
}
• Mit dieser Methode können Objekte auf inhaltliche Gleichheit getestet werden. Der
Operator == vergleicht Referenzen und keine Inhalte.
4.2 Vererbung
4-97
Die Methode clone
• Die Methode Object clone() wird von allen Klassen geerbt.
• Aus der API:
Creates and returns a copy of this object.
The precise meaning of copy may depend on the class of the object.
• Häufig ist es zweckmäßig, diese Methode zu überlagern.
4.2 Vererbung
4-98
Konstruktoren
• Konstruktoren werden nicht vererbt. Alle Konstruktoren, die in einer abgeleiteten
Klasse benötigt werden, müssen selbst definiert werden.
• Das Anlegen von Konstruktoren in einer Klasse ist optional. Falls in einer Klasse
kein Konstruktor definiert wurde, erzeugt der Compiler einen parameterlosen
Default-Konstruktor. Dieser enthält nur einen Aufruf des parameterlosen
Konstruktors der Vaterklasse, des sogenannten Superklassenkonstruktors.
• Falls in einer abgeleiteten Klasse kein Konstruktor definiert wird und in der
Basisklasse kein Default-Konstruktor vorhanden ist, meldet der Compiler einen
Fehler.
4.2 Vererbung
4-99
Konstruktoren
• Falls als erste Anweisung in einem Konstruktor super steht, wird dies als ein
Aufruf des Superklassenkonstruktors interpretiert.
• Falls als erste Anweisung in einem Konstruktor kein Aufruf von super steht, setzt
der Compiler an dieser Stelle einen impliziten Aufruf super() ein.
• Durch diese Regel wird bei der Neuanlage eines Objekts eine ganze Kette von
Konstruktoren durchlaufen. Dabei wird zuerst der Konstruktor der Klasse Object
ausgeführt.
4.2 Vererbung
4-100
Konstruktoren
class Adresse {
String vorname;
...
String ort = "Braunschweig";
Adresse() {
}
Adresse(int plz, String ort) {
this(plz);
this.ort = ort;
}
...
}
4.2 Vererbung
4-101
Konstruktoren
class Person extends Adresse {
int persnr;
...
Person() {
}
Person(double gehalt) {
super(27344, "Brockel");
this.gehalt = gehalt;
}
...
... new Person(2288.97); ...
}
4.2 Vererbung
4-102
Einfache Vererbung
• Vererbungen können mehrstufig sein.
• Jede abgeleitete Klasse erbt die
Attribute und Methoden der jeweiligen
Vaterklasse.
• Es entstehen Vererbungshierarchien.
A
O
B
O
C
4.2 Vererbung
4-103
Einfache Vererbung
• Vererbungshierarchien können sehr
komplex sein.
F
A
O
Y
• Sie lassen sich durch gerichtete Bäume
darstellen.
B
C
E
4.2 Vererbung
E
D
O
F
Y
G
4-104
Finale Klassen
• Besitzt eine Klasse den Modifikator final, kann sie nicht abgeleitet werden.
• Die Klasse String ist final. Daher ist
class A extends String { ... }
nicht zulässig.
• Auf Modifikatoren kommen wir in Kürze zu sprechen.
4.2 Vererbung
4-105
Mehrfache Vererbung
A
X
F
C
B
• Man spricht von mehrfacher Vererbung, wenn eine abgeleitete Klasse mehr als eine
Vaterklasse haben kann.
• Mehrfache Vererbung ist in Java nicht erlaubt.
4.2 Vererbung
4-106
Beziehungen zwischen Klassen und Objekten
Mithilfe des instanceof-Operators kann festgestellt werden, ob ein Objekt obj
Instanz einer gegebenen Klasse cls ist.
Der Aufruf
obj instanceof cls
liefert das Ergebnis true, falls obj eine Instanz der Klasse cls ist.
Priorität: 5, Linksassoziativität.
4.2 Vererbung
4-107
Beziehungen zwischen Objekten
Zwischen Objekten können verschiedene Beziehungen bestehen:
• Assoziation, Kardinalität, Multiplizität
• Komposition / Aggregation
• ...
Die Sprache UML stellt Diagrammtypen bereit, mit denen Klassen, Objekte sowie
Beziehungen zwischen ihnen und viele weitere Dinge dargestellt werden können.
Klassen- und Objektdiagramme haben wir bereits kennengelernt.
4.2 Vererbung
4-108
Objektorientierte Programmierung in Java:
Modifikatoren
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Klassen, Objekte und Methoden
Vererbung
Modifikatoren
Klassenvariable und statische Methoden
Abstrakte Klassen
Schnittstellen
Zusammenfassung
4.3 Modifikatoren
4-109
Modifikatoren
Wir haben bereits – ohne jedoch alle Einzelheiten – einige Modifikatoren, z. B.
public oder static, kennengelernt. Mithilfe der Modifikatoren können Sichtbarkeit
und Eigenschaften von Klassen, Variablen und Methoden beeinflusst werden.
• Die Sichtbarkeit bestimmt, ob eine Klasse, Variable oder Methode in anderen
Klassen genutzt werden kann.
• Eigenschaften, die über Modifikatoren gesteuert werden können, sind z. B. die
Lebensdauer und die Veränderbarkeit.
Wir werden jetzt die wichtigsten Modifikatoren vorstellen – einige Details werden wir
erst später verstehen.
4.3 Modifikatoren
4-110
Modifikatoren für Klassen
• kein Modifikator
Jede Klasse gehört zu einem Paket. Wenn eine Klasse keinen Modifikator besitzt,
ist sie in ihrem eigenen Paket sichtbar. Wird eine Klasse keinem Paket zugeordnet,
ist sie im Default-Paket sichtbar.
• public
Die Klasse ist in allen Paketen sichtbar. In jeder Quelldatei darf höchstens eine
Klasse den Modifikator public besitzen.
4.3 Modifikatoren
4-111
Modifikatoren für Klassen
• final
Die Klasse kann nicht abgeleitet werden.
• abstract
Die Klasse wird als abstrakte Klasse deklariert. Auf abstrakte Klassen und
Methoden gehen wir noch ausführlich ein.
4.3 Modifikatoren
4-112
Modifikatoren für Variable und Methoden
• kein Modifikator
Variable und Methoden sind in der eigenen Klasse und in allen Klassen des eigenen
Pakets sichtbar.
• public
Variable und Methoden sind in allen Klassen sichtbar.
4.3 Modifikatoren
4-113
Modifikatoren für Variable und Methoden
• private
Variable und Methoden sind nur in der eigenen Klasse sichtbar.
• protected
Variable und Methoden sind nur in der eigenen Klasse und allen daraus
abgeleiteten Unterklassen sichtbar. Als protected deklarierte Variablen und
Methoden sind außerdem in allen Methoden des eigenen Pakets sichtbar.
4.3 Modifikatoren
4-114
Modifikatoren für Variable und Methoden
• static
Durch static deklarierte Variable und Methoden sind Klassenvariable und
-methoden. Sie existieren unabhängig von Instanzen genau einmal pro Klasse.
• final
Als final deklarierte Variable können nach der Initialisierung nicht mehr verändert
werden. Dies gilt auch für Parameter von Methoden. Für Methoden verhindert
final das Überlagern in abgeleiteten Klassen.
• abstract
Abstrakte Methoden werden durch den Modifikator abstract deklariert.
4.3 Modifikatoren
4-115
Modifikatoren
• Eine als final deklarierte Objektvariable wird zwar insgesamt vor Zuweisungen
geschützt, der Wert einzelner Instanzvariablen kann jedoch verändert werden. Dies
gilt z. B. auch für Arrays, die ja Objekte sind. Entsprechendes gilt für
final-Parameter von Methoden.
• Wenn eine Klasse oder Methode durch final deklariert wurde, kann auf die
dynamische Methodensuche verzichtet werden. Dies kann zu einer
Effizienzsteigerung führen.
• Die Zugriffsrechte von Klassen, Variablen und Methoden sollten nicht größer als
erforderlich vergeben werden. Ebenso sollten Variable als Konstante deklariert
werden, wenn dies möglich ist. Diese Maßnahmen erhöhen die Sicherheit.
4.3 Modifikatoren
4-116
Modifikatoren
final int[] a = {1,2};
int[] b = {3,4};
// a = b;
// verboten
a[0] = b[0];
a[1] = b[1];
// erlaubt
// erlaubt
// Entsprechendes gilt für alle Referenztypen
// und für final-Parameter von Methoden.
4.3 Modifikatoren
4-117
Modifikatoren
Beispiel:
final int[] a = {1,2,3,4};
for (int i : a)
System.out.print(i+"
"); // Ausgabe: 1 2 3 4
a[3] = 5;
for (int i : a)
System.out.print(i+"
4.3 Modifikatoren
"); // Ausgabe: 1 2 3 5
4-118
Weitere Modifikatoren
Es gibt außerdem die Modifikatoren
• transient (keine Serialisierung),
• native (Bezug zu anderen Sprachen: multilingual),
• volatile (Parallelprogrammierung) und
• synchronized (Parallelprogrammierung).
Wir gehen hierauf an dieser Stelle noch nicht ein.
4.3 Modifikatoren
4-119
Objektorientierte Programmierung in Java:
Klassenvariable und statische Methoden
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Klassen, Objekte und Methoden
Vererbung
Modifikatoren
Klassenvariable und statische Methoden
Abstrakte Klassen
Schnittstellen
Zusammenfassung
4.4 Klassenvariable und statische Methoden
4-120
Klassenvariable
• Es gibt Attribute von Klassen, die nicht an konkrete Instanzen gebunden sind.
Diese heißen Klassenvariable oder auch statische Variable.
• Klassenvariable existieren für die gesamte Lebensdauer einer Klasse genau einmal –
unabhängig davon, wie viele Objekte erzeugt wurden.
• Jede Klassenvariable kann von allen Methoden der Klasse benutzt werden. Daher
sind Zuweisungen an eine Klassenvariable von allen Instanzen der Klasse
beobachtbar.
• In Java werden Klassenvariable durch den Modifikator static definiert.
• Von außen erfolgt der Zugriff auf eine Klassenvariable durch
Klassenname.Variablenname.
4.4 Klassenvariable und statische Methoden
4-121
Beispiel: Objektzähler
class Objektzaehler {
static int objcnt = 0;
Objektzaehler() {
++objcnt;
System.out.println(objcnt);
}
public static void main(String[]
new Objektzaehler();
// gibt
new Objektzaehler();
// gibt
new Objektzaehler();
// gibt
new Objektzaehler();
// gibt
}
}
4.4 Klassenvariable und statische Methoden
args) {
1 aus
2 aus
3 aus
4 aus
4-122
Konstante
• Durch Kombination des static- und des final-Modifikators entsteht eine
Konstante mit der Lebensdauer der Klasse. Die Konstante ist somit von allen
Instanzen der Klasse nutzbar.
• Eine Konstante zur Umrechung zwischen DM- und Euro-Beträgen lässt sich z. B.
durch
static final double FACTOR = 1.95583;
definieren.
• Es hat sich die Konvention gebildet, Konstantennamen in Großbuchstaben zu
schreiben.
4.4 Klassenvariable und statische Methoden
4-123
Klassenmethoden
• Neben Klassenvariablen gibt es in Java auch Klassenmethoden, d. h. Methoden,
deren Existenz nicht an konkrete Objekte gebunden ist.
• Klassenmethoden werden ebenfalls durch den Modifikator static definiert. Der
Aufruf erfolgt analog zur Benutzung der Klassenvariable durch Voranstellen des
Klassennamens.
• Klassenmethoden werden auch als statische Methoden bezeichnet.
• Klassenmethoden können natürlich nicht auf Instanzvariable zugreifen. Demzufolge
existiert auch der this-Zeiger nicht.
• Beispiel: Die Methoden der Klasse Math sind statisch, z. B. die Methode sqrt.
4.4 Klassenvariable und statische Methoden
4-124
Beispiel: Währungsumrechnung
public class Euro {
static final double FACTOR = 1.95583;
static double dm(double euro) {
return euro * FACTOR;
}
public static void main(String[] args) {
for (double i = 1.0; i <= 10.0; i++) {
System.out.println("" + i + " EUR = " + dm(i) + " DM");
}
}
}
4.4 Klassenvariable und statische Methoden
4-125
Beispiel: Tabelle der Quadratwurzeln
public class Quadratwurzel {
public static void main(String[] args) {
double x, y;
for (x = 0.0; x <= 10.0; x = x + 1.0) {
y = Math.sqrt(x);
// Aufruf der statischen Methode sqrt der Klasse Math
System.out.println("sqrt(" + x + ") = " + y);
}
}
}
4.4 Klassenvariable und statische Methoden
4-126
Die Klassenmethode main
• Ein weiteres Beispiel ist die bereits bekannte Klassenmethode main.
public static void main(String[] args)
• Beim Start einer Applikation wird die zugehörige Klasse geladen und dann nach
der Klassenmethode main gesucht. Anschließend wird ein Array mit den
Kommandozeilenparametern gebildet und an main übergeben. Dann wird main
gestartet.
• Da beim Start des Programms noch kein Objekt vorhanden ist, muss main eine
Klassenmethode sein.
• Da das Laufzeitsystem die Methode main aufruft, muss sie mit dem Modifikator
public versehen sein.
4.4 Klassenvariable und statische Methoden
4-127
Die Klassenmethode main
class MainTest {
public static void main(String[] args) {
System.out.println(args[0]+" + "+args[0]+" = "+args[1]);
}
}
Der Aufruf
java MainTest "Eins" "Zwei"
liefert die Ausgabe
Eins + Eins = Zwei.
4.4 Klassenvariable und statische Methoden
4-128
Statische Konstruktoren
• Neben den bisher behandelten Konstruktoren gibt es noch statische Konstruktoren.
Sie werden nicht jedes Mal aufgerufen, wenn ein neues Objekt angelegt wird,
sondern nur einmal beim Laden der Klasse.
• Ein statischer Konstruktor ist eine parameterlose Methode mit dem Namen
static.
• Wenn eine Klasse mehrere statische Konstruktoren enthält, werden diese in der
textuellen Reihenfolge ausgeführt.
• Mit statischen Konstruktoren können Initialisierungen vorgenommen werden.
4.4 Klassenvariable und statische Methoden
4-129
Statische Konstruktoren
class Statisch {
static int i;
static int j;
static {
i = 5;
j = 3 * i;
}
static {
i = 6;
}
...
}
Beim Laden der Klasse werden i auf 6 und j auf 15 gesetzt.
4.4 Klassenvariable und statische Methoden
4-130
Utility Klassen
• Falls alle Attribute und Methoden einer Klasse statisch sind, dann sollten von der
Klasse keine Instanzen erzeugt werden.
• Dies kann durch einen privaten Konstruktor erreicht werden.
• Außerdem sollte die Klasse final sein.
Eine solche Klasse bezeichnen manche Autoren als utility class.
4.4 Klassenvariable und statische Methoden
4-131
Objektorientierte Programmierung in Java:
Abstrakte Klassen
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Klassen, Objekte und Methoden
Vererbung
Modifikatoren
Klassenvariable und statische Methoden
Abstrakte Klassen
Schnittstellen
Zusammenfassung
4.5 Abstrakte Klassen
4-132
Abstrakte Methoden
• Eine Methode heißt abstrakt, wenn ihre Deklaration nur den Kopf, nicht aber die
Implementierung, d. h. den Rumpf, enthält. Im Gegensatz dazu stehen konkrete
Methoden, deren Deklaration vollständig ist.
• Die Deklaration einer abstrakten Methode enthält den Modifikator abstract.
Anstelle des Rumpfes steht lediglich ein Semikolon.
• Abstrakte Methoden können nicht aufgerufen werden, sie definieren nur eine
Schnittstelle. Erst durch Überlagerung in einer abgeleiteten Klasse und durch
Implementierung des fehlenden Rumpfes wird eine abstrakte Methode konkret.
4.5 Abstrakte Klassen
4-133
Abstrakte Klassen
• Eine Klasse, die mindestens eine abstrakte Methode besitzt, heißt abstrakte Klasse.
Sie muss ebenfalls mithilfe des Modifikators abstract deklariert werden.
• Abstrakte Klassen können nicht instanziiert werden.
• Auch Klassen, die nur konkrete Methoden enthalten, dürfen den Modifikator
abstract bekommen.
• Es ist ggf. erforderlich, abstrakte Klassen abzuleiten und in der abgeleiteten Klasse
eine oder mehrere abstrakte Methoden zu implementieren.
• Eine abstrakte Klasse wird eine konkrete Klasse, wenn alle ihren Methoden konkret
sind. Die Konkretisierung kann über mehrere Stufen erfolgen.
4.5 Abstrakte Klassen
4-134
Fallstudie: Abstrakte Klassen und Polymorphismus
• Wir wollen an einem Beispiel den Gebrauch von abstrakten Klassen und
polymorphen Variablen demonstrieren. Es soll die Gehaltsberechnung in einer
Firma mit unterschiedlichen Typen von Mitarbeitern – Managern, Angestellten und
Arbeitern – durchgeführt werden.
• Abstrakte Klassen und Methoden:
Es wird eine abstrakte Klasse Mitarbeiter definiert, die die abstrakte Methode
monatsBrutto enthält. Für jeden Typ der Mitarbeiter wird diese Methode
unterschiedlich konkretisiert.
• Polymorphismus:
Es wird ein Feld für Mitarbeiter angelegt. Als Feldelemente können Objekte der
Klassen Manager, Angestellter oder Arbeiter gespeichert werden.
4.5 Abstrakte Klassen
4-135
Fallstudie: Abstrakte Klassen und Polymorphismus
abstract class Mitarbeiter {
int persnr;
String name;
static int anzahl = 0;
public String toString() {
return persnr + " " + name + " " + monatsBrutto();
}
abstract double monatsBrutto();
}
4.5 Abstrakte Klassen
4-136
Fallstudie: Abstrakte Klassen und Polymorphismus
class Manager extends Mitarbeiter {
double fixgehalt;
double provision;
double umsatz;
Manager(double fixgehalt,
double provision,
double umsatz) {
this.fixgehalt = fixgehalt;
this.provision = provision;
this.umsatz = umsatz;
Mitarbeiter.anzahl++;
}
4.5 Abstrakte Klassen
4-137
Fallstudie: Abstrakte Klassen und Polymorphismus
public double monatsBrutto() {
return fixgehalt + umsatz * provision / 100;
}
}
4.5 Abstrakte Klassen
4-138
Fallstudie: Abstrakte Klassen und Polymorphismus
class Angestellter extends Mitarbeiter {
double grundgehalt;
double ortszuschlag;
double zulage;
Angestellter(double grundgehalt,
double ortszuschlag,
double zulage) {
this.grundgehalt = grundgehalt;
this.ortszuschlag = ortszuschlag;
this.zulage = zulage;
Mitarbeiter.anzahl++;
}
4.5 Abstrakte Klassen
4-139
Fallstudie: Abstrakte Klassen und Polymorphismus
public double monatsBrutto() {
return grundgehalt + ortszuschlag + zulage;
}
}
4.5 Abstrakte Klassen
4-140
Fallstudie: Abstrakte Klassen und Polymorphismus
class Arbeiter extends Mitarbeiter {
double
double
double
double
stundenlohn;
anzahlstunden;
überstundenzuschlag;
anzahlüberstunden;
Arbeiter(double
double
double
double
4.5 Abstrakte Klassen
stundenlohn,
anzahlstunden,
überstundenzuschlag,
anzahlüberstunden) {
4-141
Fallstudie: Abstrakte Klassen und Polymorphismus
this.stundenlohn = stundenlohn;
this.anzahlstunden = anzahlstunden;
this.überstundenzuschlag = überstundenzuschlag;
this.anzahlüberstunden = anzahlüberstunden;
Mitarbeiter.anzahl++;
}
public double monatsBrutto() {
return stundenlohn * anzahlstunden +
überstundenzuschlag * anzahlüberstunden;
}
}
4.5 Abstrakte Klassen
4-142
Fallstudie: Abstrakte Klassen und Polymorphismus
public class Gehaltsberechnung {
static final int MAX_MA = 100;
static Mitarbeiter[] ma = new Mitarbeiter[MAX_MA];
static double bruttosumme = 0.0;
public static void main(String[] args) {
ma[0] = new Manager(4000.00, 5.00, 30000.00);
ma[0].persnr = 15;
ma[0].name = "Hans Müller";
4.5 Abstrakte Klassen
4-143
Fallstudie: Abstrakte Klassen und Polymorphismus
ma[1] = new Angestellter(2500.00, 1000.00, 500.00);
ma[1].persnr = 20;
ma[1].name = "Fritz Meier";
ma[2] = new Arbeiter(15.00, 200.0, 1.50, 40.00);
ma[2].persnr = 77;
ma[2].name = "Gerd Schulze";
ma[3] = new Arbeiter(15.00, 160.0, 1.50, 0.00);
ma[3].persnr = 27;
ma[3].name = "Hans Lange";
4.5 Abstrakte Klassen
4-144
Fallstudie: Abstrakte Klassen und Polymorphismus
for (int i = 0; i < Mitarbeiter.anzahl; ++i) {
System.out.println(ma[i]);
bruttosumme += ma[i].monatsBrutto();
}
System.out.println(Mitarbeiter.anzahl + " Mitarbeiter ");
System.out.println("Bruttolohnsumme: " + bruttosumme);
System.out.println("Mittel: "+bruttosumme/Mitarbeiter.anzahl);
}
}
4.5 Abstrakte Klassen
4-145
Fallstudie: Abstrakte Klassen und Polymorphismus
15 Hans Müller 5500.0
20 Fritz Meier 4000.0
77 Gerd Schulze 3060.0
27 Hans Lange 2400.0
4 Mitarbeiter
Bruttolohnsumme: 14960.0
Mittel: 3740.0
4.5 Abstrakte Klassen
4-146
Polymorphe Methoden in Konstruktoren
• Im folgenden Beispiel wird zunächst der Konstruktor der Basisklasse SingleValue
aufgerufen. Der erste Aufruf von print wird polymorph ausgeführt. Da ein Paar
instanziiert werden soll, wird die Methode print der Klasse ValuePair
verwendet und 1 0 ausgegeben. Dann wird value1 auf 3 gesetzt und
anschließend 3 0 ausgedruckt.
• value2 wird erst nach Ende des Aufrufs des Konstruktors der Basisklasse – und
damit nach Ausführung der print-Anweisung – auf 2 initialisiert. Damit werden
3 2 und 3 4 ausgedruckt.
• Polymorphe Methoden sollten in Konstruktoren vorsichtig angewendet werden.
4.5 Abstrakte Klassen
4-147
Polymorphe Methoden in Konstruktoren
class SingleValue {
int value1 = 1;
SingleValue(int value1) {
print();
this.value1 = value1;
print();
}
void print() {
System.out.println(value1);
}
}
4.5 Abstrakte Klassen
4-148
Polymorphe Methoden in Konstruktoren
class ValuePair extends SingleValue {
int value2 = 2;
ValuePair(int value1, int value2) {
super(value1);
print();
this.value2 = value2;
print();
}
void print() {
System.out.println(value1 + " " + value2);
}
}
4.5 Abstrakte Klassen
4-149
Polymorphe Methoden in Konstruktoren
public class Polymorph {
public static void main(String[] args) {
new ValuePair(3,4);
}
}
4.5 Abstrakte Klassen
4-150
Objektorientierte Programmierung in Java:
Schnittstellen
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Klassen, Objekte und Methoden
Vererbung
Modifikatoren
Klassenvariable und statische Methoden
Abstrakte Klassen
Schnittstellen
Zusammenfassung
4.6 Schnittstellen
4-151
Definition einer Schnittstelle
• Ein Interface ist eine Klasse, die ausschließlich abstrakte Methoden und
Konstanten enthält.
• Zur Definition einer Schnittstelle wird das Schlüsselwort class durch das
Schlüsselwort interface ersetzt.
• Alle Methoden eines Interfaces sind implizit abstrakt und öffentlich, alle Konstanten
final, statisch und öffentlich. Redundante Modifikatoren dürfen angegeben werden.
• Ein Interface darf keine Konstruktoren enthalten.
4.6 Schnittstellen
4-152
Beispiel
interface Groesse {
int laenge();
int breite();
int hoehe();
int inhalt();
}
interface Groesse {
public int laenge();
public int breite();
public int hoehe();
public int inhalt();
}
4.6 Schnittstellen
4-153
Implementierung einer Schnittstelle
• Um ein Interface zu implementieren, muss die class-Anweisung um eine
implements-Anweisung erweitert werden.
• Ein Interface kann von mehreren Klassen implementiert werden.
• Eine Interface-Variable ist zu allen Objekten kompatibel, deren Klassen dieses
Interface implementieren (Erinnerung: Polymorphismus).
• Eine Klasse kann mehrere Interfaces implementieren.
4.6 Schnittstellen
4-154
Beispiel
class Quader implements Groesse {
public int laenge() {
return 5;
}
public int breite() {
return 6;
}
public int hoehe() {
return 7;
}
4.6 Schnittstellen
4-155
Beispiel
public int inhalt() {
return laenge() * breite() * hoehe();
}
public static void main(String[] args) {
Quader q = new Quader();
System.out.println(q.inhalt());
}
}
4.6 Schnittstellen
4-156
Beispiel
class Rechteck implements Groesse {
public int laenge() {
return 5;
}
public int breite() {
return 6;
}
public int hoehe() {
return 0;
}
4.6 Schnittstellen
4-157
Beispiel
public int inhalt() {
return laenge() * breite();
}
public static void main(String[] args) {
Rechteck r = new Rechteck();
System.out.println(r.inhalt());
}
}
4.6 Schnittstellen
4-158
Das Interface Comparable
interface Comparable<T> {
int compareTo(T o);
}
Die Methode compareTo liefert
• einen negativen Wert, wenn das aktuelle Objekt „kleiner“ als o ist,
• 0, wenn es „gleich“ o ist und
• einen positiven Wert, wenn es „größer“ als o ist.
Das Interface erzwingt eine totale Relation auf der sie implementierenden Klasse.
4.6 Schnittstellen
4-159
Das Interface Comparable
In der Api steht über die Methode compareTo:
The natural ordering for a class C is said to be consistent with equals if und
only if e1.compareTo(e2) == 0 has the same boolean value as
e1.equals(e2) for every e1 and e2 of class C.
It is strongly recommended (though not required) that natural orderings be
consistent with equals.
Beispiel: Wie folgt könnte es sein, muss aber nicht.
Zwei Dreiecke x und y sind gleich (d.h. x.equals(y) == true), falls sie aus den
drei selben Punkten bestehen. x und y sind gleichgroß
(d.h. x.compareTo(y) == 0), falls sie den gleichen Flächeninhalt besitzen.
4.6 Schnittstellen
4-160
Die Klasse String
Beispielsweise implementiert String das Interface Comparable, die entstehende
Relation ist die lexikografische Ordnung.
class String implements Comparable<String>, ... {
...
}
String a = "abcdee";
String b = "abcdef";
System.out.println(a.compareTo(b)); // liefert einen negativen Wert
System.out.println(a.compareTo(a)); // liefert 0
System.out.println(b.compareTo(a)); // liefert einen positiven Wert
Die genauen Werte interessieren nicht, nur das Vorzeichen ist garantiert.
4.6 Schnittstellen
4-161
Beispiel: kleinstes Element
public static Object getSmallest(Comparable[] objects) {
Object smallest = objects[0];
for (int i = 1; i < objects.length; ++i) {
if (objects[i].compareTo(smallest) < 0) {
smallest = objects[i];
}
}
return smallest;
}
Note: xxxx.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint: unchecked for details.
4.6 Schnittstellen
4-162
Beispiel: Bubblesort
public static void bubbleSort(Comparable[] objects) {
boolean sorted;
do {
sorted = true;
for (int i = 0; i < objects.length - 1; ++i) {
if (objects[i].compareTo(objects[i + 1]) > 0) {
Comparable tmp = objects[i];
objects[i] = objects[i + 1];
objects[i + 1] = tmp;
sorted = false;
}
}
} while (!sorted);
}
4.6 Schnittstellen
4-163
Beispiel: Bubblesort
// Erzeugen und Ausgeben eines String-Arrays
Comparable[] objects = new Comparable[4];
objects[0] = "STRINGS";
objects[1] = "SIND";
objects[2] = "PAARWEISE"; objects[3] = "VERGLEICHBAR";
for (int i = 0; i < objects.length; i++) {
System.out.println((String) objects[i]);
}
// Ausgeben des kleinsten Elements
System.out.println((String) getSmallest(objects));
// Sortieren und Ausgeben
bubbleSort(objects);
for (int i = 0; i < objects.length; ++i) {
System.out.println((String) objects[i]);
}
4.6 Schnittstellen
4-164
Beispiel: Bubblesort
STRINGS
SIND
PAARWEISE
VERGLEICHBAR
PAARWEISE
PAARWEISE
SIND
STRINGS
VERGLEICHBAR
4.6 Schnittstellen
4-165
Generizität
• Die Implementierung von getSmallest und bubbleSort ist typunabhängig.
• Es wird nur vorausgesetzt, dass die jeweilige Klasse das Interface Comparable
implementiert.
• Man spricht von Generizität.
• Seit der Version 5.0 gibt es in Java so genannte Generics. Auf sie kommen wir in
späteren Kapiteln ausführlich zu sprechen.
4.6 Schnittstellen
4-166
Implementierung einer Schnittstelle
• Eine Klasse kann ein Interface auch dann implementieren, wenn sie nicht alle seine
Methoden implementiert.
• Die Klasse ist dann als abstrakte Klasse zu deklarieren. Objekte können in diesem
Fall nicht erzeugt werden.
4.6 Schnittstellen
4-167
Mehrfache Implementierung
I1
X
F
I2
K
• Mehrfache Vererbung ist in Java nicht erlaubt.
• Mehrfache Implementierung ist hingegen möglich.
Beispiel: Die Klasse String implementiert außer Comparable<String> auch die
Interfaces Serializable und CharSequence.
4.6 Schnittstellen
4-168
Beispiel
interface Groesse {
int laenge();
int breite();
int hoehe();
int inhalt();
}
class Quader implements Groesse, Comparable {
// Implementierung von Größe wie oben
// Implementierung von Comparable, zum Beispiel durch Vergleich
// der Länge oder der Grundfläche
}
4.6 Schnittstellen
4-169
Schnittstellen und Vererbung
• Eine Klasse erbt die Interfaces und Implementierungen ihrer Basisklasse.
class A
extends B
implements C
...
}
{
• Interfaces können abgeleitet und so „in verschiedenen Richtungen verfeinert“
werden.
• Beispiele hierfür werden wir im Laufe der Vorlesung kennenlernen.
4.6 Schnittstellen
4-170
Schnittstellen und Vererbung: Beispiel für Fehler
interface A {
int X = 1;
}
class B implements A {
final static int X = 2;
public static void main(String[] args) {
System.out.println(X);
}
}
class C extends B implements A {
public static void main(String[] args) {
System.out.println(X);
}
}
Dies führt zu einem Fehler.
4.6 Schnittstellen
4-171
Verwendung von Schnittstellen
Interfaces werden benutzt, wenn Eigenschaften beschrieben werden sollen, die
entweder
• nicht in der normalen Vererbungshierachie der jeweiligen Klasse abgebildet werden
können/sollen,
oder
• auch auf andere Klassen zutreffen.
Wir werden im Folgenden viele Beispiele für Schnittstellen behandeln.
4.6 Schnittstellen
4-172
Konstanten
Wie bereits erläutert wurde, dürfen Interfaces auch Konstanten enthalten:
interface Constants {
public static final
public static final
public static final
public static final
...
int CONST1 = ...;
int CONST2 = ...;
float CONST3 = ...;
boolean CONST4 = ...;
Die Konstanten stehen dann in jeder Klasse, die das Interface implementiert, zur
Verfügung und können direkt, d. h. ohne Klassennamen, angesprochen werden. Auf
diese Weise können alle Konstanten an einer gemeinsamen Stelle definiert werden.
4.6 Schnittstellen
4-173
Objektorientierte Programmierung in Java:
Zusammenfassung
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Klassen, Objekte und Methoden
Vererbung
Modifikatoren
Klassenvariable und statische Methoden
Abstrakte Klassen
Schnittstellen
Zusammenfassung
4.7 Zusammenfassung
4-174
Klassen und Objekte
Unter einer Klasse versteht man die Beschreibung von Objekten gleicher Struktur und
gleichen Verhaltens. Eine Klasse kann als Schablone gesehen werden, die beschreibt,
• wie Objekte aufgebaut sind,
• wie man Objekte erzeugt, initialisiert und zerstört,
• mit welchen Methoden Objekte bearbeitet werden können und
• welche Beziehungen zu anderen Klassen/Objekten existieren.
Ein konkret existierendes Objekt heißt auch Instanz der Klasse.
Erinnerung: Abstraktion und Modellierung.
4.7 Zusammenfassung
4-175
Attribute und Methoden
• Die Werte der Attribute beschreiben den Zustand eines Objekts.
• Objekte interagieren über Nachrichten. Innerhalb einer Programmiersprache wird
dieser Vorgang meist durch einen Methodenaufruf implementiert
• Methoden definieren das Verhalten der Objekte. Sie werden innerhalb einer
Klassendefinition angelegt und haben auf alle Variablen des Objekts Zugriff.
• Ein Konstruktor ist eine Methode zur Erzeugung von Objekten.
• In Java ist ein Konstruktor eine Methode ohne Rückgabewert. Ein Konstruktor
besitzt stets den Namen der Klasse. Konstruktoren können Parameter haben und
überladen werden.
4.7 Zusammenfassung
4-176
Beziehungen
• Beziehung zwischen Klassen und Objekten:
instanceof-Operator
• Beziehungen zwischen Klassen bzw. Objekten:
Einfach-/Mehrfachvererbung
Assoziation, Aggregation, Komposition
Multiplizität, Kardinalität
4.7 Zusammenfassung
4-177
Vererbung
A
O
B
• B erbt alle Attribute und Methoden von A und fügt in der Regel weitere hinzu.
• A ist die Basisklasse und B die abgeleitete Klasse.
• Einfachvererbung: Jede abgeleitete Klasse besitzt genau eine Vaterklasse.
• Java: Keine Mehrfachvererbung.
4.7 Zusammenfassung
4-178
Vorteile der Vererbung
• Mehrfache Verwendung eines Quelltexts
• Vermeidung von Code-Verdopplung, -Verdreifachung, ....
• Leichtere Wartbarkeit
• Leichtere Erweiterbarkeit
4.7 Zusammenfassung
4-179
Überlagerung und Polymorphismus
• Variable können in abgeleiteten Klassen überdeckt werden.
• Methoden können in abgeleiteten Klassen überlagert werden. Zur Identifizierung
wird die Signatur einer Methode herangezogen.
• Eine Variable vom Typ einer Basisklasse kann während ihrer Lebensdauer sowohl
Objekte ihres eigenen Typs als auch solche von abgeleiteten Klassen aufnehmen.
Dies wird als Polymorphismus bezeichnet.
• In der Genetik wird das Auftreten mehrerer Genvarianten innerhalb einer Population
als Polymorphismus bezeichnet. In diesem Sinne benutzen wir diesen Begriff nicht.
4.7 Zusammenfassung
4-180
Modifikatoren
Mithilfe der Modifikatoren können Sichtbarkeit und Eigenschaften von Klassen,
Variablen und Methoden beeinflusst werden.
• Die Sichtbarkeit bestimmt, ob eine Klasse, Variable oder Methode in anderen
Klassen genutzt werden kann.
• Eigenschaften, die über Modifikatoren gesteuert werden können, sind z. B. die
Lebensdauer und die Veränderbarkeit.
• Modifikatoren sind z. B. public, static und final.
4.7 Zusammenfassung
4-181
Klassenvariable und -methoden
• Es gibt Attribute von Klassen, die nicht an konkrete Instanzen gebunden sind.
Diese heißen Klassenvariable.
• Klassenvariable existieren für die gesamte Lebensdauer einer Klasse genau einmal –
unabhängig davon, wie viele Objekte erzeugt wurden.
• Neben Klassenvariablen gibt es in Java auch Klassenmethoden, d. h. Methoden,
deren Existenz nicht an konkrete Objekte gebunden ist.
• Sogenannte Utility Klassen lernten wir kennen.
4.7 Zusammenfassung
4-182
Abstrakte Methoden und Klassen
• Eine Methode heißt abstrakt, wenn ihre Deklaration nur den Kopf, nicht aber die
Implementierung, d. h. den Rumpf, enthält.
• Abstrakte Methoden können nicht aufgerufen werden, sie definieren nur eine
Schnittstelle. Erst durch Überlagerung in einer abgeleiteten Klasse und durch
Implementierung des fehlenden Rumpfes wird eine abstrakte Methode konkret.
• Eine Klasse, die mindestens eine abstrakte Methode besitzt, heißt abstrakte Klasse.
• Abstrakte Klassen können nicht instanziiert werden.
• Es ist erforderlich, abstrakte Klassen abzuleiten und in der abgeleiteten Klasse eine
oder mehrere abstrakte Methoden zu implementieren. Die Konkretisierung kann
über mehrere Stufen erfolgen.
4.7 Zusammenfassung
4-183
Schnittstellen
• Ein Interface ist eine Klasse, die ausschließlich Konstante und abstrakte Methoden
enthält.
• Ein Interface kann von einer oder mehreren Klassen implementiert werden.
• Eine Interface-Variable ist zu allen Objekten kompatibel, deren Klassen dieses
Interface implementieren.
• Eine Klasse kann mehrere Interfaces implementieren.
4.7 Zusammenfassung
4-184
Objektorientiertes Programmieren
• Identifizieren Sie die Beziehungen zwischen Klassen, zwischen Objekten sowie
zwischen Klassen und Objekten. Achten Sie auf Datenkapselung und
Wiederverwendbarkeit.
• Definieren Sie die Attribute und Methoden. Denken Sie an die Möglichkeit von
abstrakten Methoden und Klassen.
• Attribute und Methoden, die unabhängig von Instanzen existieren, sind als
Klassenvariable bzw. -methoden zu vereinbaren. In der Regel sollten Sie sich auf
wenige Klassenvariable und -methoden beschränken.
4.7 Zusammenfassung
4-185
Objektorientiertes Programmieren
• Achten Sie auf Programmiersicherheit. Vergeben Sie nicht mehr Zugriffsrechte als
erforderlich (Geheimnisprinzip).
• Variable, die nicht verändert werden, sollten auch als Konstante im Programm
deklariert werden.
• Orientieren Sie sich am typischen Aufbau einer Klasse, s. nächste Folie
(Wiederholung).
4.7 Zusammenfassung
4-186
Typischer Aufbau einer konkreten Klasse
public class KlassenName
attribut1;
...
attributN;
Konstruktor1;
...
KonstruktorM;
get- und set-Methoden;
toString-Methode;
equals-Methode;
clone-Methode;
...
...
...
main-Methode
}
4.7 Zusammenfassung
{
// private
// private
// public
//
//
//
//
//
//
//
//
//
public
public
Methode der Klasse Object
Methode der Klasse Object
Methode der Klasse Object
evtl. weitere Methoden der Klasse Object
private, Hilfsmethoden
public, Instanz-, Klassenmethoden
optional
4-187
Anmerkungen 1
Das objektorientierte Paradigma kann anders (und/oder erweitert) als in Java
angeboten werden:
• keine primitiven Datentypen
• keine statischen Attribute, keine statischen Methoden
• singleton object, standalone object, case class
• companion object, companion class
• Mehrfachvererbung
• mixin, trait
• ...
4.7 Zusammenfassung
4-188
Anmerkungen 2
Die Mehrfachvererbung führt (wie schon beschrieben) zum sog. Diamond-Problem.
Mixins und Traits ermöglichen eine wiederverwendbare Menge von Attributen und
Methoden (ähnlich wie Klassen). Traits sind eine Variante der Mixins. Traits gibt es
inzwischen in vielen Programmiersprachen, zum Beispiel Scala.
Lothar Piepmeyer: Anders als in Java ist in Scala alles ein Objekt. Die Teilung in
primitive Typen und den Rest der Welt kennt Scala nicht. Unter der Haube bildet der
Compiler den Scala-Typen Int auf die Java-Typen int und Integer ab.
4.7 Zusammenfassung
4-189