Differences

This shows you the differences between two versions of the page.

--- programmierung:klassen:constructor [2024/08/30 14:48] – swe
+++ programmierung:klassen:constructor [2025/12/20 14:53] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
-====== Konstruktor ======
+# Konstruktor
-Ein Konstruktor wird benötigt, um einem Objekt einer Klasse unmittelbar bei seiner Erzeugung initiale Werte zuzuweisen. Diese Werte müssen bei der Erzeugung des Objekts natürlich irgendwie mitgegeben werden.
+Ein Konstruktor wird benötigt, um einem Objekt einer Klasse unmittelbar
+bei seiner Erzeugung initiale Werte zuzuweisen. Diese Werte müssen bei
+der Erzeugung des Objekts natürlich irgendwie mitgegeben werden.
 Schau dir folgendes Beispiel an.
-Ab Zeile 5 wird in der Klasse ''Student'' der **Konstruktor** implementiert. Die Syntax ist die folgende: Der Klassen-Name (im Beispiel ''Student'') wird nochmals aufgerufen. **Ohne Schlüsselwörter. Einfach nur der Klassen-Name**. Diesem Aufruf werden **Argumente** übergeben. Mit diesen Argument werden in den Zeilen 6 und 7 jeweils **Klassen-Atrribute** initialisiert. Entsprechend müssen natürlich auch die Datentypen bei der Übergabe an den Konstruktor mit den Datentypen der Attribute übereinstimmen. Klar.
+Ab Zeile 5 wird in der Klasse `Student` der **Konstruktor**
+implementiert. Die Syntax ist die folgende: Der Klassen-Name (im
+Beispiel `Student`) wird nochmals aufgerufen. **Ohne Schlüsselwörter.
+Einfach nur der Klassen-Name**. Diesem Aufruf werden **Argumente**
+übergeben. Mit diesen Argument werden in den Zeilen 6 und 7 jeweils
+**Klassen-Atrribute** initialisiert. Entsprechend müssen natürlich auch
+die Datentypen bei der Übergabe an den Konstruktor mit den Datentypen
+der Attribute übereinstimmen. Klar.
-In der ''Main'' wird nun in Zeile 5 ein Objekt der Klasse ''Student'' erzeugt. Diesmal werden aber beim Aufruf gleich die Initialwert mit übergeben. Ein späteres Setzen dieser Werte ist nicht notwendig.
+In der `Main` wird nun in Zeile 5 ein Objekt der Klasse `Student`
-<WRAP group>
+erzeugt. Diesmal werden aber beim Aufruf gleich die Initialwert mit
-<WRAP half column>
+übergeben. Ein späteres Setzen dieser Werte ist nicht notwendig. \<WRAP
-<code java [enable_line_numbers="true", highlight_lines_extra="5,6,7,8",enable_keyword_links="false"]>
+group\> \<WRAP half column\>
+``` java
 class Student {
    private final String name;
@@ Line 24: / Line 35: @@
    }
 }
-</code>
+```
-</WRAP>
+\</WRAP\>
+\<WRAP half column\>
-<WRAP half column>
+``` java
-<code java [enable_line_numbers="true", highlight_lines_extra="4",enable_keyword_links="false"]>
 public class Main{
    public static void main(String args[]) {
@@ Line 37: / Line 50: @@
    }
 }
-</code>
+```
-</WRAP>
-</WRAP>
-===== Konstruktor oder setter-Methode =====
+\</WRAP\> \</WRAP\>
-Natürlich fragst du dich jetzt, ob wir nicht im Abschnitt über getter- und setter-Methoden gelernt haben, dass wir ''private''-Attribute von außen abkapseln. Wie passt das jetzt mit dem **Konstruktor** zusammen, der ja doch wieder die Attribute einfach setzt?
+## Konstruktor oder setter-Methode
-Zunächst wird der Code im Zweifel nicht so einfach wie im Beispiel sein. Checks können natürlich auch den Konstruktor mit eingebaut werden.
+Natürlich fragst du dich jetzt, ob wir nicht im Abschnitt über getter-
+und setter-Methoden gelernt haben, dass wir `private`-Attribute von
+außen abkapseln. Wie passt das jetzt mit dem **Konstruktor** zusammen,
+der ja doch wieder die Attribute einfach setzt?
-Vielleicht ist dir ja in der Klasse ''Student'' das Schlüsselwort ''final'' aufgefallen. Es besagt, dass ein Attribut zur Lebenszeit eines Objekt unter keinen Umständen mehr geändert werden darf. Gleichzeitig wollen wir sicherstellen, dass für ein Attribut auf jeden Fall ein konkreter Wert eingetragen wird.
+Zunächst wird der Code im Zweifel nicht so einfach wie im Beispiel sein.
+Checks können natürlich auch den Konstruktor mit eingebaut werden.
-Kurz gesagt: Mit einem Konstruktor können wir Attribute, an die wir auch mit einer **setter-Methode** nicht herankämen **einmalig** setzen - nämlich während der **Instanzierung**. Gleichzeitig kann diese Erzeugung nicht passieren, ohne dass bestimmte Werte übergeben werden.
+Vielleicht ist dir ja in der Klasse `Student` das Schlüsselwort `final`
+aufgefallen. Es besagt, dass ein Attribut zur Lebenszeit eines Objekt
+unter keinen Umständen mehr geändert werden darf. Gleichzeitig wollen
+wir sicherstellen, dass für ein Attribut auf jeden Fall ein konkreter
+Wert eingetragen wird.
+Kurz gesagt: Mit einem Konstruktor können wir Attribute, an die wir auch
+mit einer **setter-Methode** nicht herankämen **einmalig** setzen -
+nämlich während der **Instanzierung**. Gleichzeitig kann diese Erzeugung
+nicht passieren, ohne dass bestimmte Werte übergeben werden.
-^ Setter Methoden^  Konstruktor^
+  |Setter Methoden         |                                                                                                                   Konstruktor|
-| Der Wert einer Variable kann sich zur Laufzeit ändern  | Der Wert ändert sich nicht. Er ist **immutable**|
+  |---------------------------------------------------------------|--------------------------------------------------------------------------------------|
-| Validierungs-Logik wird benötigt, bevor ein Wert gesetzt wird |  Sicherstellen, dass bestimmte Attribute ganz sicher zur creation time gesetzt werden|
+  |Der Wert einer Variable kann sich zur Laufzeit ändern     |                                           Der Wert ändert sich nicht. Er ist **immutable**|
-| Werte werden nach der Initialisierung gesetzt  | Wert der Variablen soll sich nach der Initialisierung nicht mehr ändern  |
+  |Validierungs-Logik wird benötigt, bevor ein Wert gesetzt wird |    Sicherstellen, dass bestimmte Attribute ganz sicher zur creation time gesetzt werden|
+  |Werte werden nach der Initialisierung gesetzt     |                             Wert der Variablen soll sich nach der Initialisierung nicht mehr ändern|