Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- modul:archiv:m320:learningunits:lu02:theorie:lu2-kapitel_3 [2026/08/30 14:06] – gelöscht - Externe Bearbeitung (Unbekanntes Datum) 127.0.0.1
+++ modul:archiv:m320:learningunits:lu02:theorie:lu2-kapitel_3 [2026/08/30 14:09] (aktuell) – ↷ Links angepasst, weil Seiten im Wiki verschoben wurden 74.7.243.195
@@ Zeile 1: / Zeile 1: @@
+==== 3. Konstruktor ====
+Konstruktoren dienen der Initialisierung von Objekten bei deren Erzeugung. Der Code des Konstruktors wird genau einmal ausgeführt. \\
+=== Merkmale ===
+  * 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.
+=== Default Konstruktor ===
+Er wird OHNE Parameter aufgerufen und initialisiert alle Attribute mit einem vorgegebenen Wert (Default-Wert).\\
+----
+//Beispiel 2.3: Default Konstruktor// \\
+<code python>
+class Shoe:
+  def __init__(self):
+    self._shoe_size = 40
+    self._color     = 'green'
+    self._shoe_type = 'sneaker'
+</code>
+----
+=== Parametrierter Konstruktor ===
+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.
+----
+//Beispiel 2.4: Parametrierter Konstruktor//\\
+<code python>
+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
+</code>
+----
+Wird im Code nach Beispiel 2.4 ein Objekt erzeugt, dem keine Werte mitgeliefert werden (Default-Konstruktor), übernimmt Python die Initialwerte. Der entsprechende Aufruf sieht dann wie folgt aus:
+<code python>
+  shoe = Shoe()
+</code>
+Werden alle Werte übergeben, empfiehlt es sich, die Reihenfolge der Parameter einzuhalten. Im gezeigten Beispiel 2.4 also den Code wie folgt zu realisieren:
+<code python>
+  shoe = Shoe(44, 'black', 'boots')
+</code>
+Es ist aber auch möglich, nur einzelne der definierten Parameter anzugeben!
+Dazu muss beim Aufruf dann aber das Attribut genannt werden. Wird im Beispiel nur für das Attribut''color'' ein Wert geliefert, ist der Code wie folgt zu realisieren:
+<code python>
+ shoe = Shoe(color='blue')
+</code>
+=== Darstellung in UML ===
+Viele Programmiersprachen kennen die Möglichkeit der Benennung von Parametern - wie oben gezeigt - 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.
+----
+//Beispiel 2.5: Parametrierte Konstruktoren//\\
+Java-Code zu Beispiel 2.4
+<code java>
+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;
+  }
+  :
+  :
+ }
+</code>
+----
+Bei der Objekterzeugung wird je nach Parameterliste dann auf den entsprechende Konstruktor zugegriffen.
+<code java>
+  ....
+  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
+</code>
+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.
+{{modul:archiv:m320:learningunits:lu02:theorie:lu02_-_uml-klassendiagramm.png?700|}}\\
+//Abb 2.3:// UML-Klassendiagramm mit überladenen Konstruktoren
+----
+[[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] (c) René Probst