Objektorientierte Programmierung OOP

class Rechnung {

   // Klassenattribute

   static final double

   STANDARD_MEHRWERTSTEUERSATZ = 0.19;

   static int naechsteRechnungsnummer = 10000;

   // Exemplarattribute

   double betrag;

   double mehrwertsteuer;

   double rabatt;

   Kunde rechnungsempfaenger;

   final int rechnungsnummer;

   // Konstruktoren

   Rechnung() {

      this(Rechnung.STANDARD_MEHRWERTSTEUER

      SATZ);

   }

   Rechnung(double mwst) {

      this.mehrwertsteuer = mwst;

      this.rechnungsnummer =

      Rechnung.naechsteRechnungsnummer;

      Rechnung.naechsteRechnungsnummer++;

    }

}

Für die Bezeichner von finalen Klassenattributen gelten die Konventionen finaler lokaler Variablen.

Klassenmethoden werden wie Methoden vereinbart, mit dem Unterschied, dass ihnen das Schlüsselwort static vorangestellt ist. [JLS: § 8.4.3.2]

Eine Variable für ein Feld wird wie folgt vereinbart:  

ElementTyp[] Feldname;  

Der Feldtyp ist durch den Datentyp der Elemente (ElementTyp), die in einem Feld enthalten sind, bestimmt.

Die Deklaration

int[] artikelnummern;

bezeichnet ein Feld mit Elementen vom Typ int, das artikelnummern genannt wird.

Bemerkung: Feldtypen sind Objekttypen. Jedes Feld ist somit auch ein Objekt. [JLS: § 4.3.1]

Einem Feldnamen wird ähnlich wie bei Objekten mittels Schlüsselworts new ein Feldobjekt fester Größe zugewiesen:

Feldname = new ElementTyp[IntAusdruck];

Mit dem Ausdruck auf der rechten Seite der Zuweisung wird ein konkretes Feld mit Elementen des Typs ElementTyp der Größe IntAusdruck angelegt. Die Feldgröße wird durch einen Ganzzahlausdruck bestimmt. Der Ausdruch muss zu einem nichtnegativen Wert evaluiert werden. Die Referenz auf das erzeugte Feld wird der Feldvariablen Feldname, die vom gleichen Typ sein muss, zugewiesen. Die Feldelemente sind von 0 bis IntAusdruck - 1 indiziert. [JLS: § 10.3, § 15.10]

Es ist auch möglich, die Variablenvereinbarung und Felderzeugung zu kombinieren [JLS: § 10.2]:

ElementTyp[] Feldname = new ElementTyp[IntAusdruck];

Statt das Schlüsselwort new zu verwenden, kann ein Feld auch durch eine Aufzählung gebildet und zugleich initialisiert werden [JLS: § 10.6]:  

ElementTyp[] Feldname = {v1, v2, ..., vn};

Die Ausdrücke v1, v2, ..., vN müssen Werte des Typs ElementTyp liefern.

Der Ausdruck:

int[] artikelnummern = new int[10];

erzeugt ein Feld mit 10 Elementen vom Typ int und weist es der Feldvariablen artikelnummern zu.

Das Feld deutscheVokale gibt ein Beispiel für die Aufzählungsdefinition eines Felds:

char[] deutscheVokale = {’a’, ’ä’, ’o’, ’ö’, ’u’, ’ü’, ’e’, ’i’};

Eine solche Aufzählung kann in dieser Form nur bei der Deklaration verwendet werden. Soll sie auch an anderer Stelle genutzt werden, so müssen der Aufzählung der Feldelemente, das Schlüsselwort new und der Feldtyp vorangestellt werden.

char[] deutscheVokale;

// ...

deutscheVokale = new char[]{’a’, ’ä’, ’o’, ’ö’, ’u’, ’ü’, ’e’, ’i’};

Jedes Feld besitzt eine finale Exemplarvariable length. Die Größe eines Felds Feldname kann somit im Programm durch den ganzzahligen Ausdruck:

Feldname.length

ermittelt werden. [JLS: § 10.7]

So liefert beispielsweise der Ausdruck deutscheVokale.length; den Wert 8, wenn die Variable deutscheVokalewie oben dargestellt initialisiert wurde.

Falls ein Feld aus Elementen primitiver Datentypen aufgebaut ist, wird jedes Feldelement mit dem Standardwert dieses Typs belegt. Für ein Ganzzahlfeld ist der Standardwert 0, für Gleitkommazahlen der Wert 0.0, für Zeichenelemente das Zeichen mit dem Ganzzahlcode 0, und für boolean ist es der Wert false. Handelt es sich bei dem Typ der Feldelemente um einen Objekttyp, so sind alle Elemente mit null initialisiert. [JLS: § 15.10.1, § 4,12.5]

Die Werte der Elemente eines Feldes können durch den vordefinierten Indexausdruck: Feldname[IntAusdruck] abgefragt oder verändert werden. Der Indexausdruck muss ein ganzzahliger Wert sein. [JLS: § 10.4]

Feldindizes beginnen immer mit 0. Daher dürfen Indexausdrücke in Feldzugriffen weder negative ganze Zahlen sein, noch dürfen sie den größten Indexwert Feldname.length - 1 überschreiten. Falls der int-Ausdruck, der den Index bestimmt, außerhalb der Feldgrenzen 0 bis Feldname.length - 1 liegt, wird dieser Zugriff einen Laufzeitfehler erzeugen. [JLS: § 10.4]

Die obige Vereinbarung der Feldvariable deutscheVokale vorausgesetzt, ist der Ausdruck

deutscheVokale[3]

ein gültiger Zugriff und liefert das Ergebnis ö.

Die Elemente eines Felds können durch eine for-Schleife einheitlich mit Anfangswerten belegt werden:

for (int i = 0; i < Feldname.length; i++) {

    Feldname[i] = Wert;

}

wobei Wert verträglich mit dem den Typ der Feldelemente sein muss.

Beachten Sie, dass eine als final deklarierte Feldvariable lediglich keine neue Zuweisung an diese Variable zulässt. Eine Veränderung der Feldinhalte ist jedoch trotzdem möglich.

Die erweiterte for-Schleife besitzt die folgende Syntax:

for (ElementTyp VarName : Feldname) {

// ...

}

wobei der Typ ElementTyp mit dem Typ der Elemente des Feldes Feldname verträglich sein muss. [JLS: § 14.14.2]

int[][] meinFeld = new int[4][3];

for (int[] x : meinFeld) {

    for (int y : x) {

        // y ist das aktuelle Feldelement

    }

}

Im Gegensatz zu der einfachen for-Schleife gibt es bei dieser Form jedoch keine Variable, die den aktuellen Index im Feld repräsentiert. Somit ist es ohne weitere Hilfsvariable auch nicht möglich zwei Felder parallel zu durchlaufen. Zudem ermöglicht die erweiterte for-Schleife nur einen lesenden Zugriff auf die Feldelemente und somit keine Veränderung der Feldinhalte.

Damit eine Klasse verwendet werden kann, muss sie am Ort der Verwendung sichtbar sein. Solange keine ausdrücklichen Vorkehrungen zur Sichtbarkeit getroffen werden, umfasste der Kontext gewisse Klassen der Java-Laufzeitbibliothek (API) sowie diejenigen eigenen Klassen, die sich in demselben Verzeichnis wie die aufrufende Klasse befinden.

• Objekte sind Exemplare1 einer Klasse.

• Objekte haben Attribute, auch Exemplarvariablen genannt.

• Attribute haben einen Typ und einen Attributwert.

• Der Zustand eines Objekts ist durch die Werte seiner Attribute festgelegt.

• Objekte haben Methoden, deren Ausführung durch das Senden einer Nachricht an das Objekt ausgelöst wird.

• Klassen beschreiben die Eigenschaften und das Verhalten aller ihrer Exemplare, denn durch die Klassenbeschreibung ist festgelegt, welche Attribute und Methoden Objekte dieser Klasse besitzen.

In Java lassen sich die Attribute des Objekts rechnung1 wie folgt ansprechen [JLS: § 6.2, § 15.11]:

rechnung1.betrag

rechnung1.rabatt

Attributwerte lassen sich als Ausdrücke in Anweisungen auswerten:

System.out.println(rechnung1.betrag);

double nettopreis = rechnung1.betrag * (1 - rechnung1.rabatt);

Weiterhin können Attributen neue Werte zugewiesen werden:

rechnung1.betrag = 78.70;

rechnung1.rabatt = 0.0;

Bei der Auswertung wie bei der Zuweisung von Attributwerten gelten die Regeln der Typverträglichkeit.

Wir erkennen, dass jede Methode einen Namen hat, der mit einem Klammerpaar endet. Über den Namen kann die Methode aufgerufen werden. Falls im Inneren des Klammerpaars ein oder mehrere Parameter angegeben sind, so bedeutet dies, dass die Methode bei ihrem Aufruf entsprechende Argumente benötigt. So muss beim Aufruf der Methode legeRabattFest() ein double-Wert an das Objekt übergeben werden. Die Anweisung  

rechnung1.legeRabattFest(0.05);  

bewirkt, dass die Methode legeRabattFest() des Rechnung-Objekts rechnung1 mit dem Parameter 0.05 ausgeführt wird. [JLS: § 6.2, § 15.12]

Parameternamen, wie sie in der UML und auch in anderen Dokumentationsarten für Methoden oft angegeben werden, dienen dem Verständnis der Methode. Für den Methodenaufruf sind sie bedeutungslos.

Parameterreihenfolge Die Parameter müssen bei einem Methodenaufruf stets in der dokumentierten Reihenfolge übergeben werden.

Methoden können weiterhin ein Ergebnis zurückliefern, das außerhalb des Objekts weiter verwendet werden kann. Falls eine Methode ein Ergebnis zurückliefert, ist dies in einem UML-Klassendiagramm am Rückgabetyp zu erkennen, der hinter dem Klammerpaar und einem Doppelpunkt angegeben ist. Die Methode berechneNettopreis() liefert einen double-Wert an die aufrufende Stelle zurück, der beispielsweise in einer Zuweisung weiter verwendet werden kann:  

double nettopreis = rechnung1.berechneNettopreis();

  Für die Übergabe von Argumenten wie für die Auswertung von Rückgabewerten gelten die Regeln der Typverträglichkeit.

Im Unterschied zu Werten primitiver Datentypen haben Objekte eine Lebensdauer. Ein Objekt muss explizit erzeugt werden, bevor es einer Variablen zugewiesen werden kann. Nach seiner Erzeugung existiert ein Objekt solange, wie ein Verweis auf das Objekt existiert. Ein solcher Verweis ist beispielsweise eine andere Variable, der dasselbe Objekt zugewiesen ist. Ein Objekt, auf das kein Verweis mehr existiert, wird von Javas automatischer Speicherverwaltung (engl. garbage collection) aus dem Programmsystem entfernt.

Zur Erzeugung eines Objekts wird dem Konstruktor das Schlüsselwort new vorangestellt [JLS: § 15.9]. Ein Objekt vom Typ Rechnung können wir mit dem Ausdruck new Rechnung() erzeugen. Die Erzeugung wird in der Regel mit einer Zuweisung verbunden. Durch die Anweisung

Rechnung rechnung2 = new Rechnung();

wird eine Variable vom Typ Rechnung deklariert und dieser ein neu erzeugtes Rechnung-Objekt zugewiesen. Die Zuweisung kann auch an eine bereits zuvor deklarierte Variable erfolgen:

Rechnung rechnung3;

...

rechnung3 = new Rechnung();

Zunächst kann eine Variable eines Objekttyps nur dann deklariert werden, wenn dieser Objekttyp im Kontext der Deklaration definiert ist. (Diese Einschränkung gilt verständlicherweise auch für die Erzeugung von Objekten.) Demgegenüber sind primitive Datentypen in Java global verfügbar, so dass Variablen - wie auch Literale - primitiver Datentypen an jeder Stelle eines Java-Programms auftreten können.

Eine Variable ist eine benannte Speicherstelle im Arbeitsspeicher eines Rechners. Im Falle von primitiven Datentypen befindet sich an dieser Speicherstelle jeweils der Wert, der einer Variablen zugewiesen ist [JLS: § 4.12.1]. Abbildung zeigt schematisch die int-Variable laenge1 mit dem Wert 100.

Im Falle von Objekttypen befindet sich an der zugehörigen Speicherstelle nun aber nicht, wie man vielleicht vermuten könnte, das Objekt, das einer Variablen zugeReferenz wiesen ist, sondern lediglich eine Referenz auf einen anderen Speicherbereich, der das eigentliche Objekt beherbergt [JLS: § 4.12.2]. Die Abbildung zeigt schematisch die Variable rechnung1 vom Typ Rechnung. Das ihr zugewiesene RechnungObjekt befindet sich in einem anderen, von der virtuellen Maschine verwalteten Speicherbereich, auf dessen Adresse die Speicherstelle von rechnung1 verweist.

Nehmen wir zwei Wertvariablen:

var1 = var2;

Eine solche Zuweisung bewirkt, dass der Inhalt der Speicherstelle von var2 in die Speicherstelle von var1 kopiert wird. Handelt es sich bei var1 und var2 um Variablen eines primitiven Datentyps (und somit um Wertvariablen), so wird der Wert von var2 in die Speicherstelle von var1 kopiert (Abbildung). 

Nach Ausführung der Anweisungsfolge

int laenge1 = 100;

int laenge2 = laenge1;

sind sowohl laenge1 als auch laenge2 mit dem Wert 100 belegt. (Die Zuweisung in der zweiten Zeile entspricht dem in Abb. 17.3-3 gezeigte Kopiervorgang.) Wie wir wissen, sind diese Werte zwar gleich, aber voneinander vollkommen unabhängig. So bewirkt die nachfolgende Anweisung

laenge2 += 300;

dass laenge2 den Wert 400 erhält, während laenge1 weiterhin mit dem Wert 100 belegt ist

Handelt es sich bei var1 und var2 jedoch um Variablen eines Objekttyps (und somit um Verweisvariablen), so wird die Referenz auf ein Objekt in die Speicherstelle von var1 kopiert (Abbildung). Das Resultat des Kopiervorgangs sind somit zwei identische Referenzen, so dass rechnung1 und rechnung2 auf ein und dasselbe Rechnung-Objekt verweisen. Während die Wertvariablen laenge1 und laenge2 nach dem Kopiervorgang voneinander unabhängig geblieben sind, sind die Verweisvariablen durch den Kopiervorgang miteinander gekoppelt worden. Nach Ausführung der Anweisungsfolge

Rechnung rechnung1 = new Rechnung();

rechnung1.betrag = 100.0;

Rechnung rechnung2 = rechnung1;

rechnung2.betrag += 300.0;

ist sowohl rechnung1.betrag als auch rechnung2.betrag mit dem Wert 400.0 belegt, denn es handelt sich bei rechnung1.betrag und rechnung2.betrag um ein und dasselbe Attribut eines einzigen Objekts.

• new Rechnung() veranlasst die Erzeugung eines Rechnung-Objekts in einem von der virtuellen Maschine verwalteten Speicherbereich und liefert eine Referenz auf das Objekt. Eine Rechnung-Variable rechnung1 wird deklariert und erhält durch Zuweisung diese Referenz.

• Dem betrag-Attribut des von rechnung1 referenzierten Rechnung Objekts wird der Wert 100.0 zugewiesen.

• Eine weitere Rechnung-Variable rechnung2 wird deklariert und erhält durch Zuweisung eine Kopie der in rechnung1 gespeicherten Referenz. Die Zuweisung entspricht dem in der Abbildung gezeigte Kopiervorgang. Sie hat zur Folge, dass beide Variablen rechnung1 und rechnung2 auf dasselbe Rechnung-Objekt verweisen

rechnung2 = new Rechnung();

rechnung1 == rechnung2    -> TRUE wenn sie die gleiche referenz haben.

rechnung1 != rechnung2   -> TRUE wenn die beiden Variablen eine unterschiedliche Referenzen besitzen.

Die Abbildung zeigt die Variable rechnung5 vom Typ Rechnung, die auf kein Objekt verweist. Das Schlüsselwort null können wir in Verbindung mit einem Gleichheits- oder Ungleichheitsoperator sowie in Zuweisungen verwenden. Der Ausdruck

rechnung5 == null

liefert true, falls rechnung5 auf kein Objekt verweist. Der Ausdruck

rechnung5 != null

liefert in demselben Fall entsprechend false. Wird ein referenziertes Objekt nicht mehr benötigt, so kann es durch

rechnung5 = null

von der referenzierenden Variablen gelöst werden. Falls es keine anderen Verweise auf dasselbe Objekt gibt, wird es in der Folge durch die automatische Speicherverwaltung entfernt.

Wie Variablen für primitive Datentypen können auch Variablen für Objekttypen mit dem Schlüsselwort final versehen werden:

final Rechnung RECHNUNG;

Nachdem der finalen Variablen RECHNUNG zum ersten Mal ein Rechnung-Objekt zugewiesen worden ist, kann keine erneute Zuweisung an diese Variable erfolgen. Beachten Sie jedoch, dass der Zustand des zugewiesenen Rechnung-Objekts weiterhin veränderlich ist.

Attribute primitiver Datentypen werden in der Attributliste einer Klasse aufgeführt. Ein Attribut eines Objekttyps kann entweder in der Attributliste aufgeführt oder durch eine Assoziation kenntlich gemacht werden. Die Darstellung durch eine Assoziation empfiehlt sich insbesondere bei der gleichzeitigen Darstellung des zugehörigen Objekttyps.