LU04a - Konstruktor

• Ein Konstruktor liefert KEINEN Rückgabewert.
• Ein Konstruktor kann die Attribute mit einem Defaultwert setzen oder mittels Parameter konkrete Werte zuweisen.
• Ein Konstruktor führt i.d.R. keine Programmlogik aus.

Er wird OHNE Parameter aufgerufen und initialisiert alle Attribute mit einem vorgegebenen Wert (Default-Wert).

class Shoe:
  def __init__(self):
    self._shoe_size = 40
    self._color     = 'green'
    self._shoe_type = 'sneaker'

Ein Konstruktor kann Initialwerte entgegennehmen und ein Objekt so in einem definierten Zustand erzeugen. Es empfiehlt sich, die Attribute mit einem Initalwert zu versehen, damit keine undefinierten Werte resultieren können. Dies ist vor allem bei Wertzusicherungen wichtig.

class Shoe:
  def __init__(self, shoe_size = 40, color = 'green', shoe_type = 'sneaker'):
    self._shoe_size = shoe_size
    self._color     = color
    self._shoe_type = shoe_type

Wird ein Objekt erzeugt, ohne Werte anzugeben (Default-Konstruktor), übernimmt Python die Initialwerte. Der entsprechende Aufruf sieht dann wie folgt aus:

  shoe = Shoe()

Werden beim Erzeugen eines Objekts Initialwerte mitgegeben, müssen Sie Sie die Reihenfolge der Parameter einhalten. Im Beispiel sieht dies so aus:

  shoe = Shoe(44, 'black', 'boots')

Eine andere (bessere?) Möglichkeit ist es, die Namen der Attribute beim Aufruf mitzugeben:

 shoe = Shoe(color='blue', shoe_size=45)

Diese Variante ist vor allem sinnvoll, wenn nur ein Teil der definierten Parameter mitgegeben wird.

Viele Programmiersprachen kennen die oben gezeigte Möglichkeit der Benennung von Parametern nicht. Daher wird bei der Nutzung unterschiedlicher Konstruktoren das Konzept des Überladens (overloading) angewendet. Dabei darf ein Methodenname mehrfach deklariert werden, solange die Paramterliste eine klare Unterscheidung (bezüglich der Datentypen) zulässt. Als Beispiel wird hier der Code der Klasse Shoe in Java wiedergegeben.

public class Shoe{
  // Deklaration der Attribute und Zuweisung der Initialwerte
  private int shoe_size    = 40;
  private String color     = "green";
  private String shoe_type = "sneaker";
 
  public Shoe(){
    // do nothing --> Default Konstruktor
    // die Attribute sind hier mit den oben zugewiesenen Werten initialisert.
  }
 
  public Shoe(int size){
    // überladener Konstruktor mit einem Parameter
    this();  // Aufruf des eigenen Default-Konstruktors
    shoe_size = size;
  }
 
  public Shoe(int size, String color){
    // überladener Konstruktor mit zwei Parametern
    this(size); // Aufruf des Konstruktors mit dem Parameter size
    this.color = color; // um das Attribut vom Parameter zu unterscheiden, wird das Schlüsselwort this benötigt.
  }
 
  public Shoe(int size, String color, String type){
    // überladener Konstruktor mit drei Parametern
    this(size, color); // Aufruf des Konstruktors mit den Parametern size und color
    shoe_type = type;
  }
  :
  :
 }

Bei der Objekterzeugung wird je nach Parameterliste dann auf den entsprechende Konstruktor zugegriffen.

  ....
  Shoe shoe_1 = new Shoe();                        // Aufruf des Default-Konstuktors
  Shoe shoe_2 = new Shoe(45);                      // Aufruf des Konstruktors mit dem Parameter für size
  Shoe shoe_3 = new Shoe(39, 'yellow');            // Aufruf des Konstruktors mit den Parametern für size und color
  Shoe shoe_4 = new Shoe(41, 'grey', 'slipper');   // Aufruf des Konstruktors mit den Parametern für size, color und style

Diese Technik hat sich auch in die Darstellung der UML übertragen. So wird im Klassendiagramm für jede mögliche Parameterliste der Konstruktor vollständig angeschrieben.

Abb: UML-Klassendiagramm mit überladenen Konstruktoren

René Probst, bearbeitet durch Marcel Suter