Konstruktoren, Dekonstruktoren, Rückgabewerte

[Nobody]

In jeder objektorientierten Programmiersprache lassen sich spezielle Methoden definieren, die bei der Initialisierung eines Objekts aufgerufen werden: die Konstruktoren. In Java werden Konstruktoren als Methoden ohne Rückgabewert definiert, die den Namen der Klasse erhalten, zu der sie gehören. Konstruktoren dürfen eine beliebige Anzahl an Parametern haben und können überladen werden.

Ein Codebeispiel dazu:

public class Auto{
  
  private String name;
  private int erstzulassung;
  private int kilometerstand;

  public Auto(){                      //Parameterloser Kontruktor
    name="nicht bekannt";
  }

  public Auto(String name){    //Der Name wird durch die ßbergabe vorbesetzt
    this.name=name;
  }
  
  public Auto(String name, int erstzulassung, int kilometerstand){
     this.name=name;
     this.erstzulassung=erstzulassung;
     this.kilometerstand=kilometerstand;
  }

Beim letzten Konstrukter werden alle Parameter die in der Klasse sind übergeben. Wenn weitere Werte benötigt sind um ein Paramter zu bestimmen, können dies auch übergeben werden. Je nachdem, was benötigt wird, kann dann der entsprechende Konstruktor übergeben werden.

Default-Konstruktoren
Falls eine Klasse überhaupt keinen expliziten Konstruktor besitzt, wird vom Compiler automatisch ein parameterloser default-Konstruktor generiert. Seine einzige Aufgabe besteht darin, den parameterlosen Konstruktor der Superklasse aufzurufen. Enthält eine Klassendeklaration dagegen nur parametrisierte Konstruktoren, wird kein default-Konstruktor erzeugt, und die Klassendatei besitzt überhaupt keinen parameterlosen Konstruktor.

Verkettung von Konstruktoren
Unterschiedliche Konstruktoren einer Klasse können in Java verkettet werden, d.h. sie können sich gegenseitig aufrufen. Der aufzurufende Konstruktor wird dabei als eine normale Methode angesehen, die über den Namen this aufgerufen werden kann. Die Unterscheidung zum bereits vorgestellten this-Pointer nimmt der Compiler anhand der runden Klammern vor, die dem Aufruf folgen. Der im vorigen Beispiel vorgestellte Konstruktor hätte damit auch so geschrieben werden können:

public Auto(String name,
            int    erstzulassung,
            int    leistung)
{
  this(name);
  this.erstzulassung = erstzulassung;
  this.leistung = leistung;
}

Der Vorteil der Konstruktorenverkettung besteht darin, daß vorhandener Code wiederverwendet wird. Führt ein parameterloser Konstruktor eine Reihe von nichttrivialen Aktionen durch, so ist es natürlich sinnvoller, diesen in einem spezialisierteren Konstruktor durch Aufruf wiederzuverwenden, als den Code zu duplizieren.
Wird ein Konstruktor in einem anderen Konstruktor derselben Klasse explizit aufgerufen, muß dies als erste Anweisung innerhalb der Methode geschehen. Steht der Aufruf nicht an erster Stelle, gibt es einen Compiler-Fehler.

Neben Konstruktoren, die während der Initialisierung eines Objekts aufgerufen werden, gibt es in Java auch Destruktoren. Sie werden unmittelbar vor dem Zerstören eines Objekts aufgerufen.

Ein Destruktor wird als geschützte (protected) parameterlose Methode mit dem Namen finalize definiert:

protected void finalize(){
  ......
}

Da Java über ein automatisches Speichermanagement verfügt, kommt den Destruktoren hier eine viel geringere Bedeutung zu als in anderen objektorientierten Sprachen. Anders als etwa in C++ muß sich der Entwickler ja nicht um die Rückgabe von belegtem Speicher kümmern; und das ist sicher eine der Hauptaufgaben von Destruktoren in C++.

Tatsächlich garantiert die Sprachspezifikation nicht, daß ein Destruktor überhaupt aufgerufen wird. Wenn er aber aufgerufen wird, so erfolgt dies nicht, wenn die Lebensdauer des Objektes endet, sondern dann, wenn der Garbage Collector den für das Objekt reservierten Speicherplatz zurückgibt. Dies kann unter Umständen nicht nur viel später der Fall sein (der Garbage Collector läuft ja als asynchroner Hintergrundprozeß), sondern auch gar nicht. Wird nämlich das Programm beendet, bevor der Garbage Collector das nächste Mal aufgerufen wird, werden auch keine Destruktoren aufgerufen. Selbst wenn Destruktoren aufgerufen werden, ist die Reihenfolge oder der Zeitpunkt ihres Aufrufs undefiniert. Der Einsatz von Destruktoren in Java sollte also mit der nötigen Vorsicht erfolgen.

Aus dem Javabuch


In der Objektorientierung ist es oft sinnvoll, Abläufe die von mehreren Methoden genutzt werden eigene Klassen zu schreiben. Da nach der bearbeitung in der Regel auch ein Rückgabe nötig ist, zb über den Erfolg des ganzen oder Werte die geändert wurden müssen wieder zurückgegeben werden. Das ganze funktioniert nicht nur innerhalb einer Klasse sonder lässt sich auch Klassenübergreifend durchführen.
Die Festlegung dieses Rückgabewerts erfolgt während der Formulierung der Methode:

public void Methode(){
  ...
}

In der Obrigen Methode erfolgt keine Rückgabe, was durch void festgelegt wird. Dies kann durch jeden Typ ersetzt werden der benötigt wird. Selbst durch den Programmierer festgelegt Typen lassen sich zurückgeben:

public EigenderDatentyp Methode(){
  EigenerDatentyp p = new EigenerDatentyp();   //Hier wird der Parameterlose Konstruktor aufgerufen
  ....
   return p;
}

Wenn ein Rückgabewert vorhanden ist muss dieser Immer zurückgegeben werden, was durch das return erfolgt.
Wichtig dabei ist, das stets nur ein Wert, Array... zurückgegeben werden. Auch kann diese Rückgabe bereits vor der letzen Zeile des Methodenblockes erfolgen, wenn er zb in Abhgängigkeit von anderen Werten zurückgegeben wird.