Konstruktor

Allgemeines

Ein Konstruktor ist ein besonderes Sprachelement einer Java-Klasse. Er wird automatisch ausgeführt, sobald mit dem Operator new ein neues Objekt erzeugt wird.

Die wichtigste Aufgabe eines Konstruktors besteht darin

• ein neues Objekt zu initialisieren
• den Instanzvariablen sinnvolle Anfangswerte zuzuweisen und
• das Objekt in einen konsistenten Anfangszustand zu versetzen

Ein Konstruktor besitzt keinen Rückgabetyp – auch nicht void. Außerdem trägt er immer denselben Namen wie die Klasse.

Beispiel:

public class Circle
{
    public Circle()
    {
        diameter = 30;
        xPosition = 20;
        yPosition = 60;
        color = "blue";
        isVisible = false;
    }
}

Beim Aufruf

Circle kreis = new Circle();

erzeugt Java ein neues Objekt der Klasse Circle mit dem Namen kreis, und anschließend wird der Konstruktor aufgerufen.

Konstruktoren sind keine Methoden

In vielen Schulbüchern und auch in der Fachliteratur werden Konstruktoren als spezielle Methoden bezeichnet. Diese Formulierung ist didaktisch hilfreich, fachlich jedoch nicht ganz korrekt. Zwischen Methoden und Konstruktoren bestehen nämlich ein paar kleine aber wichtige Unterschiede:

Gute Konstruktoren

Ein Konstruktor sollte dafür sorgen, dass ein Objekt sofort benutzbar ist.

Ein schlechter Konstruktor der Klasse Circle würde beispielsweise einen Kreis erzeugen, dessen Durchmesser negativ ist oder der keine Farbe hat (color = null) oder dessen Position außerhalb des Zeichenfensters liegt.

Ein gut geschriebener Konstruktor verhindert solche ungültigen Zustände bereits beim Erzeugen des Objekts.

Konstruktor oder Setter?

Oft stellt sich die Frage, ob Attribute bereits im Konstruktor gesetzt oder später mit Setter-Methoden verändert werden sollen. Beide Vorgehensweisen sind möglich. In vielen Klassen werden sogar beide Verfahren miteinander kombiniert.

public class Kreis // Alternative 1
{
   int xPos, yPos;
	
   public Kreis(int xPos, int yPos)
	{
	   this.xPos = xPos;
		this.yPos = yPos;
	}
}

public class Kreis // Alternative 2
{
   int xPos, yPos;
	
   public Kreis(int xPos, int yPos)
	{
	   setXPos(xPos);
		setYPos(yPos);
	}
}

Alternative 1

In dieser einfachen Variante werden die Parameter den Instanzvariablen unmittelbar zugewiesen. Eine Validierung findet hier nicht statt, wäre aber durchaus möglich.

Alternative 2

Bei der Alternative 2 werden die übergebenen Werte an zwei Setter-Methoden weitergereicht. Die Setter-Methoden können die übergebenen Werte zunächst überprüfen. Sind die Werte ungültig, können sie diese korrigieren oder eine Exception auslösen. Erst anschließend werden die Werte den Instanzvariablen zugewiesen.

Alternative 3

In der Praxis wird häufig eine dritte Alternative bevorzugt:

public class Kreis // Alternative 3
{
   private int xPos, yPos;

   public Kreis(int xPos, int yPos)
   {
      checkXPos(xPos); 
      this.xPos = xPos;
      checkYPos(yPos);
      this.yPos = yPos;
   }
   
   private void checkXPos(int x)
   {
      if ((x < 0) || (x > 1920))
         throw new IllegalArgumentException
            ("x-Wert außerhalb des gültigen Bereichs")
      // weitere Validierungen ...
   }

   // weitere private check-Methoden ...
   
   public void setXPos(int xNeu)
   {
      checkXPos(xNeu);
      this.xPos = xNeu;
   }
	
   // weitere Setter ...	
}

Die Überprüfung der Werte erfolgt in eigenen check...()-Methoden, die sowohl vom Konstruktor als auch von den Setter-Methoden aufgerufen werden. Dadurch muss die Validierungslogik nur einmal geschrieben werden. Änderungen oder Erweiterungen der Prüfungen müssen daher ebenfalls nur an einer einzigen Stelle vorgenommen werden.

Eine Klasse kann mehrere Konstruktoren besitzen

Überladen von Konstruktoren

Eine Klasse kann durchaus zwei, drei oder noch mehr Konstruktoren besitzen, allerdings müssen sich die Signaturen dieser Konstruktoren (also die "Köpfe") unterscheiden.

Beispiel:

public class Circle
{
    public Circle()
    {
        diameter = 30;
        color = "blue";
    }

    public Circle(int d)
    {
        diameter = d;
        color = "blue";
    }
}

Der erste Konstruktor erzeugt einen Kreis mit dem Standarddurchmesser 30 Pixel:

Circle c1 = new Circle();

Der zweite Konstruktor erwartet einen Parameter:

Circle c2 = new Circle(100);

Der neu erzeugte Kreis besitzt dann gleich einen Durchmesser von 100 Pixeln.

Dieses Verfahren nennt man übrigens Überladen von Konstruktoren.

Zugriffsmodifikatoren eines Konstruktors

Wie Methoden können auch Konstruktoren mit einem Zugriffsmodifikator versehen werden. Dieser legt fest, von wo aus ein Konstruktor aufgerufen und damit ein neues Objekt erzeugt werden darf.

• public: Der Konstruktor kann von jeder anderen Klasse aufgerufen werden. Das ist der Normalfall und immer dann erforderlich, wenn Objekte dieser Klasse auch außerhalb der Klasse erzeugt und verwendet werden sollen.

• private: Der Konstruktor kann nur innerhalb derselben Klasse aufgerufen werden. Private Konstruktoren werden häufig zusammen mit öffentlichen Konstruktoren verwendet, um die Objekterzeugung innerhalb der Klasse zu steuern.

• protected: Der Konstruktor kann nur von Methoden der selben Klasse und von Methoden ihrer Unterklassen aufgerufen werden. Dieser Zugriffsmodifikator spielt vor allem bei der Vererbung eine Rolle.