3.4 Neue Objekte erzeugen

Eine Klasse beschreibt also, wie ein Objekt aussehen soll. In einer Mengen- beziehungsweise Element-Beziehung ausgedrückt, entsprechen Objekte den Elementen und Klassen den Mengen, in denen die Objekte als Elemente enthalten sind. Diese Objekte haben Eigenschaften, die sich nutzen lassen. Wenn ein Punkt Koordinaten repräsentiert, wird es Möglichkeiten geben, diese Zustände zu erfragen und zu ändern.

Im Folgenden wollen wir untersuchen, wie sich von der Klasse Point zur Laufzeit Exemplare erzeugen lassen und wie der Zugriff auf die Eigenschaften der Point-Objekte aussieht.

3.4.1 Anlegen eines Exemplars einer Klasse mit dem new-Operator

Objekte müssen in Java immer ausdrücklich erzeugt werden. Dazu definiert die Sprache den new-Operator.

new java.awt.Point();

Hinter dem new-Operator folgt der Name der Klasse, von der ein Exemplar erzeugt werden soll. Der Klassenname ist hier voll qualifiziert angegeben, da sich Point in einem Paket java.awt befindet. (Ein Paket ist eine Gruppe zusammengehöriger Klassen. Wir werden später mit den import-Deklarationen sehen, dass Entwickler diese Schreibweise auch abkürzen können.) Hinter dem Klassennamen folgt ein Paar runde Klammern für den Konstruktoraufruf. Dieser ist eine Art Methodenaufruf, über den sich Werte für die Initialisierung des frischen Objektes übergeben lassen.

Konnte die Speicherverwaltung von Java für das anzulegende Objekt freien Speicher reservieren und konnte der Konstruktor gültig durchlaufen werden, gibt der new-Ausdruck anschließend eine Referenz auf das frische Objekt an das Programm zurück.

Zusammenhang von new, Heap und Garbage-Collector

Bekommt das Laufzeitsystem die Anfrage, ein Objekt mit new zu erzeugen, so reserviert es so viel Speicher, dass alle Objekteigenschaften und Verwaltungsinformationen dort Platz haben. Ein Point-Objekt speichert die Koordinaten in zwei int-Werte, also sind mindestens 2 mal 4 Byte nötig. Den Speicherplatz nimmt die Laufzeitumgebung vom Heap. Der hat eine vordefinierte Maximalgröße (standardmäßig 64 MB), damit ein Java-Programm nicht beliebig viel Speicher vom Betriebssystem abgreifen kann, was die Maschine möglicherweise in den Ruin treibt.

Wird das Objekt nicht mehr vom Programm referenziert, so bemerkt dies der Garbage-Collector (GC) und gibt den reservierten Speichern wieder frei. [Mit dem gesetzten java-Schalter -verbose:gc für gibt es immer Konsolenausgaben, wenn der GC nicht mehr referenzierte Objekte erkennt und wegräumt.] Der GC testet dazu regelmäßig, ob die Objekte auf dem Heap noch benötigt werden, und wenn nicht, werden sie gelöscht. Es weht also immer ein Hauch von Friedhof über dem Heap, und blitzschnell nachdem die letzte Referenz vom Objekt genommen wird, ist es auch schon tot.

Ist das System nicht in der Lage, genügend Speicher für ein neues Objekt bereitzustellen, versucht der GC in einer letzten Rettungsaktion, alles wegzuräumen. Ist dann immer noch nicht ausreichend Speicher frei, generiert die Laufzeitumgebung einen OutOfMemoryError und bricht die Abarbeitung ab. [In diesem Fall ist aber ein new im Spiel, denn der Compiler generiert selbstständig zum Beispiel beim Ausdruck s + t einen Ausdruck wie new StringBuilder().append(s).append(t).toString().]

Heap und Stack

Die JVM-Spezifikation sieht für Daten fünf verschiedene Speicherbereiche (engl. runtime data area) vor. Neben dem Heap-Speicher wollen wir uns den Stack-Speicher (Stapelspeicher) kurz anschauen. Den nutzt die Java Laufzeitumgebung zum Beispiel für lokale Variablen. Auch verwendet Java den Stack beim Methodenaufruf mit Parametern. Die Argumente kommen vor dem Methodenaufruf auf den Stapel, und die aufgerufene Methode kann über den Stack auf die Werte lesend oder schreibend zugreifen. Bei endlosen rekursiven Methodenaufrufen ist irgendwann die maximale Stackgröße erreicht, und es kommt zu einer Exception vom Typ java.lang.StackOverflowError. Da mit jedem Thread ein JVM-Stack assoziiert ist, bedeutet das das Ende des Threads.

3.4.2 Deklarieren von Referenzvariablen

Das Ergebnis des new-Operators ist eine Referenz auf das neue Objekt. Die Referenz wird in der Regel in einer Referenzvariablen zwischengespeichert, um fortlaufende Eigenschaften vom Objekt nutzen zu können.

java.awt.Point p; 
p = new java.awt.Point();

Die Deklaration und Initialisierung einer Referenzvariablen lassen sich kombinieren (auch eine lokale Referenzvariable ist zu Beginn uninitialisiert):

java.awt.Point p = new java.awt.Point();

Die Typen müssen natürlich kompatibel sein, und ein Haus-Objekt geht nicht vom Typ einer Socke durch. Der Versuch einer Zuweisung eines Punktobjekts an eine int- oder String-Variable ergibt einen Compilerfehler.

int    p = new java.awt.Point(); // Type mismatch: cannot convert from Point to int 
String s = new java.awt.Point(); // Type mismatch: cannot convert from Point to int

Damit speichert eine Variable entweder einen einfachen Wert (Variable vom Typ int, boolean, double …) oder einen Verweis auf ein Objekt. Referenztypen gibt es in drei Ausführungen: Klassentypen, Schnittstellentypen (auch Interface-Typen genannt) und Feldtypen (auch Array-Typen genannt). In unserem Beispiel haben wir ein Beispiel für einen Klassentyp.

+ ermöglicht es, entweder eine neue lokale Variable oder eine Objektvariable für den Ausdruck anzulegen.

3.4.3 Zugriff auf Variablen und Methoden mit dem ».«

Die in einer Klasse deklarierten Variablen heißen Objektvariablen beziehungsweise Exemplar-, Instanz- oder Ausprägungsvariablen. Wird ein Objekt geschaffen, dann erhält es seinen eigenen Satz von Objektvariablen. [Es gibt auch den Fall, dass sich mehrere Objekte eine Variable teilen, sogenannte statische Variablen. Diesen Fall werden wir später betrachten.] Sie bilden den Zustand des Objekts.

Der Punktoperator ».« erlaubt auf Objekten den Zugriff auf die Methoden oder Variablen. Er steht zwischen einem Ausdruck, der eine Referenz zurückgibt, [Sprachlich wird diese Formulierung gerne mit »Rechts steht eine Referenz« abgekürzt.] und der Objekteigenschaft. Welche Möglichkeiten eine Klasse genau bietet, erfährt der Entwickler in der API-Dokumentation.

java.awt.Point p = new java.awt.Point(); 
p.x = 1; 
p.y = 2 + p.x;

+ zeigt an, welche Eigenschaften eine Referenz ermöglicht. Eine Auswahl mit wählt die Eigenschaft aus und setzt insbesondere bei Methoden den Cursor zwischen das Klammerpaar.

Ein Methodenaufruf gestaltet sich genauso einfach wie ein Variablenzugriff. Hinter dem Ausdruck mit der Referenz folgt nach dem Punkt der Methodenname.

Das nachfolgende Beispiel erzeugt einen Punkt, belegt ihn mit Werten und gibt eine String-Repräsentation des Objektes aus.

Listing 3.1 MyPoint.java

class MyPoint 
{ 
  public static void main( String[] args ) 
  { 
    java.awt.Point p = new java.awt.Point(); 
    p.x = p.y = 12; 
    p.translate( –3, 2 ); 
 
    java.awt.Point q = new java.awt.Point(); 
    q.setLocation( 10, 100 ); 
 
    System.out.println( p.toString() );   // java.awt.Point[x=9,y=14] 
    System.out.println( q.toString() );   // java.awt.Point[x=10,y=100] 
  } 
}

Im ersten Fall belegen wir die Variablen x, y explizit und verschieben dann mit translate() die Koordinaten um –3, 2. Die Methode verändert die Zustände, was das spätere toString() anschaulich zeigt. Im zweiten Fall setzen wir nicht direkt die Objektzustände über die Variablen, sondern verändern die Zustände über die Methode setLocation(). Die beiden Objekte besitzen eigene Koordinaten und kommen sich nicht in die Quere.

Abbildung 3.2 Die Abhängigkeit, dass MyPoint einen java.awt.Point nutzt, zeigt das UML-Diagramm mit einer gestrichelten Linie an. Die Parameterliste und Rückgabe sind in UML optional und hier nicht dargestellt.

+ auf einem Eigenschaftennamen (oder bei einer Methoden im Klammerpaar) zeigt die API-Dokumentation in einem kleinen Fenster an.

Nach dem Punkt geht’s weiter

Die Methode toString() liefert als Ergebnis ein String-Objekt, das den Zustand des Punkts preisgibt.

java.awt.Point  p = new java.awt.Point(); 
String          s = p.toString(); 
System.out.println( s );                     // java.awt.Point[x=0,y=0]

Das String-Objekt besitzt selbst wieder Methoden. Eine davon ist length(), die die Länge der Zeichenkette liefert.

System.out.println( s.length() );            // 23

Das Erfragen des String-Objekts und dessen Länge können wir zu einer Anweisung verbinden – p sei wieder unser Point-Objekt:

System.out.println( p.toString().length() );  // 23

Objekterzeugung ohne Variablenzuweisung

Bei der Nutzung von Objekteigenschaften muss der Typ links vom Punkt immer eine Referenz sein.

System.out.println( new Point().toString().length() ); // 23

Im Prinzip funktioniert auch Folgendes:

new java.awt.Point().x = 1;

Dies ist hier allerdings unsinnig, da zwar das Objekt erzeugt und ein Attribut gesetzt wird, anschließend das Objekt aber für den Garbage-Collector wieder Freiwild ist. Interessant ist die Anwendung zum Beispiel bei einem File-Objekt, um etwa herauszufinden, wie groß eine Datei ist:

long size = new java.io.File( "file.txt" ).length();

3.4.4 Konstruktoren nutzen

Werden Objekte mit dem new-Operator angelegt, so wird ein Konstruktor aufgerufen, eine Art Methode mit besonderer Signatur. [Ein Konstruktor hat keinen Rückgabetyp und trägt auch denselben Namen wie die Klasse.] Bei der Schaffung eines Objekts sollen in der Regel die Objektvariablen initialisiert werden. Diese Initialisierung wird dazu in den Konstruktor gesetzt, um sicherzustellen, dass das neue Objekt einen sinnvollen Anfangszustand aufweist.

Ein Konstruktor ohne Argumente ist der Standard-Konstruktor (auch »Default-Konstruktor«, selten auch »No-Arg-Konstruktor« genannt).

java.awt.Point p1 = new java.awt.Point(); 
p1.setLocation( 10, 10 ); 
System.out.println( p1 );  // java.awt.Point[x=10,y=10] 
java.awt.Point p2 = new java.awt.Point( 10, 10 ); 
System.out.println( p2 );  // java.awt.Point[x=10,y=10] 
java.awt.Point p3 = new java.awt.Point( p2 ); 
System.out.println( p3 );  // java.awt.Point[x=10,y=10]

Ihr Kommentar