Literatur

Objekte in Java

Nun haben wir gelernt, was Klassen sind.  Die Klassen geben sozusagen den Rahmen für unsere Objekte vor.  Ein Objekt erzeugen wir mit Hilfe des new-Operators. Ein Beispiel dafür haben Sie bereits im Kapitel "Zeichenketten" kennengelernt:

String zeichenkette = new String ("Ich bin eine Zeichenkette");  /* ein neues String-Objekt wird erzeugt */

 

Durch die Verwendung des new-Operators wird der sogenannte Konstruktor einer Klasse aufgerufen. Der Konstruktor ist eine spezielle Methode einer Klasse und dient zur Initialisierung von Attributen eines Objektes dieser Klasse.  Der Konstruktor ist wie eine Methode aufgebaut, die den Namen der Klasse hat. Eine Klasse kann mehrere Konstruktoren haben. Diese müssen sich jedoch in ihren Übergabeparametern unterschieden.

Welcher der Konstrukturen aufgerufen wird, ist abhängig davon, welche Parameter bei der Erzeugung des Objektes übergeben werden. Datentyp und Anzahl der Parameter müssen übereinstimmen.

Um auf die Attribute und Methoden eines Objektes zuzugreifen, bedient man sich der Punktnotation. Auch diese haben wir bereits im Kapitel "Zeichenketten" kennengelernt.

int laenge = zeichenkette.length();  /* Über Punktnotation wird auf die Methode length zugegriffen */

Nehmen wir jetzt unsere Beispiel-Klasse Punkt wieder zur Hilfe. Wir erweitern die Klasse Punkt um mehrere Konstruktoren.

class Punkt  /* Deklaration der Klasse Punkt */
{                
    int x_koordinate;    /* Gibt die x-Position unseres Punktes als 32 Bit Ganzzahl an */
    int y_koordinate;    /* Gibt die y-Position unseres Punktes als 32 Bit Ganzzahl an */
 
    /* Standardkonstruktor setzt die Variablen x_koordinate und y_koordinate auf 10 */
    Punkt()
    {
        this.x_koordinate = 10;
        this.y_koordinate = 10;
    }
 
    /* Konstruktor setzt die Variable x_koordinate auf den Wert von x_koord
       und die Variable y_koordinate auf 10 */
    Punkt(int x_koord)
    {
        this.x_koordinate = x_koord;
        this.y_koordinate = 10;
    }
 
    /* Konstruktor setzt die Variable x_koordinate auf den Wert von x_koord
       und die Variable y_koordinate auf den Wert von y_koord */
    Punkt(int x_koord, int y_koord)
    {
        this.x_koordinate = x_koord;
        this.y_koordinate = y_koord;
    }
 
    // Anfang der Methode methode
    public void methode()
    {
        int lokale_variable;  
    }
   // Ende der Methode methode
}

Wir haben jetzt unsere Klasse Punkt um drei Konstruktoren erweitert.

Der erste Konstruktor ist der Standardkonstruktor ohne Übergabeparameter, hier werden die Variablen x_koordinate und y_koordinate mit einem Standardwert initialisiert.

Der zweite Konstruktor besitzt einen Übergabeparameter mit dem Datentyp int. In diesem Konstruktor wird die x_koordinate mit dem übergebenen Wert von x_koord initialisiert und die Variable y_koordinate wird diesmal mit einem anderen Standardwert initialisiert. Man könnte hier auch anstelle der x_koordinate und x_koord die y_koordinate und y_koord verwenden. Ein zweiter Konstruktor mit dem Datentyp int und einem Übergabeparameter ist nicht möglich. Warum das so ist, wird in dem Kapitel Methoden näher erklärt.

Der dritte Konstruktor besitzt zwei Übergabeparameter, mit denen unsere Variablen x_koordinate und y_koordinate initialisiert werden sollen. Wie Ihnen vielleicht aufgefallen ist, besitzen die Konstruktoren denselben Namen wie unsere Klasse. Dies ist bei einem Konstruktor auch zwingend erforderlich, denn ansonsten wäre es eine normale Methode. Die Implementiertung eines oder mehrer er Konstruktoren ist in Java jedoch nicht zwingend erforderlich, da die Klasse, wenn keine Konstruktoren definiert wurden, einen Standardkonstruktor verwendet, der im Prinzip nicht anders funktioniert als ein leerer Konstruktor ohne Parameter.

Nun wollen wir Objekte unserer Klasse Punkt erzeugen. Dazu erstellen wir uns wieder eine Java-Startklasse, die wie folgt aussieht:

public class Beispiel
{
    public static void main(String[] args)
    {
        // Aufruf des Standardkonstruktors
        Punkt p = new Punkt();
        // Ausgabe des Objektes p und seiner Variablen
        System.out.println("Objekt p: "+p);
        System.out.println("Standardkonstruktor x_koordinate: "+p.x_koordinate);
        System.out.println("Standardkonstruktor y_koordinate: "+p.y_koordinate);
 
        // Aufruf des Konstruktors mit einem Parameter
        p = new Punkt(25);
        // Ausgabe des Objektes p und seiner Variablen
        System.out.println("Objekt p nach dem zweiten Aufruf eines Konstruktors: "+p);
        System.out.println("Konstruktor mit einem Übergabeparameter x_koordinate: "+p.x_koordinate);
        System.out.println("Konstruktor mit einem Übergabeparameter y_koordinate: "+p.y_koordinate);
 
        // Aufruf des Konstruktors mit zwei Parametern
        p = new Punkt(33,45);
        // Ausgabe des Objektes p und seiner Variablen
        System.out.println("Objekt p nach dem dritten Aufruf eines Konstruktors: "+p);
        System.out.println("Konstruktor mit zwei Übergabeparametern  x_koordinate: "+p.x_koordinate);
        System.out.println("Konstruktor mit zwei Übergabeparametern  y_koordinate: "+p.y_koordinate);
 
    }
}

Als erstes erstellen wir uns eine lokale Variable p. Diese besitzt den Datentyp Punkt unserer Beispielklasse. Wir  weisen der Variablen ein neues Punkt-Objekt zu, in dem wir den Konstruktor der Klasse Punkt mit dem new-Operator aufrufen. Da die runden Klammern hinter Punkt leer sind, rufen wir den Standardkonstruktor unserer Punkt-Klasse auf, der keine Parameter hat. Dadurch werden die Variablen von p, nämlich x_koordinate und y_koordinate, mit dem Wert 10 initialisiert.

Anschließend erfolgt die Ausgabe des Objektes p und dessen Variablen, indem wir auf diese über die Punktnotation zugreifen und mit System.out.println ausgeben.

Wenn Sie die beiden obengenannten Klassen erstellt und ausgeführt haben, sehen Sie schon sämtliche Ausgaben. Für p wird etwas ausgegeben, was so ähnlich aussieht wie Punkt@45a877. Punkt vor dem @ gibt an, dass das ausgegebene Objekt vom Datentyp Punkt ist. Die Zahl wird bei Ihnen mit Sicherheit abweichen, da sie eine Speicheradresse im Arbeitsspeicher (RAM) darstellt. Ausgaben von komplexen Objekten sehen in der Regel immer so aus und machen in der Praxis kaum Sinn. Hier dient diese Ausgabe nur der Beweisführung, dass ein Objekt der Klasse Punkt erzeugt worden ist. Die Variablen von unserem Objekt p werden nun mit jeweils 10 ausgegeben.

Nun folgt erneut ein Konstruktoraufruf allerdings nur mit einem Parameter, nämlich der 25. Anschließend erfolgen wieder die Ausgaben. Da wir durch den erneuten Aufruf des new-Operators ein neues Objekt erzeugt haben, ergibt sich für die Ausgabe unseres Objektes natürlich auch eine neue Speicheradresse (z.B. Punkt@1372a1a). Die Ausgabe für die x_koordinate ergibt nun 25 und für die y_koordinate 10. Anschließend erzeugen wir wieder ein neues Objekt mit dem Operator new, allerdings übergeben wir diesmal dem Konstruktor zwei Parameter nämlich 33 und 45. Nun erfolgt erneut die Ausgabe für unser Objekt p und wir erhalten wieder eine neue Adresse. Für die Variablen x_koordinate erhalten wir nun 33 und für die y_koordinate 45.


Wie Sie sehen, wird durch den new-Operator immer ein neues Objekt erzeugt. Die Initialisierung wird aber vom Konstruktor bestimmt, sofern man welche, mit Ausnahme des Standardkonstruktors, verwendet.