Differences

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

--- programmierung:klassen:constructor [2024/07/07 19:28] – created 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.
-<code java>
+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. \<WRAP
+group\> \<WRAP half column\>
+``` java
 class Student {
-   private String name;
+   private final String name;
    private int age;
-   Student(String name, int age){
+   public Student(String name, int age){
       this.name = name;
       this.age = age;
@@ Line 19: / Line 35: @@
    }
 }
-</code>
+```
+\</WRAP\>
+\<WRAP half column\>
+``` java
+public class Main{
+   public static void main(String args[]) {
+      Student obj1 = new Student("Maria", 32);
+      obj1.display();
+   }
+}
+```
+\</WRAP\> \</WRAP\>
+## Konstruktor oder setter-Methode
+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?
+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.
+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|
+  |---------------------------------------------------------------|--------------------------------------------------------------------------------------|
+  |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|
+  |Werte werden nach der Initialisierung gesetzt     |                             Wert der Variablen soll sich nach der Initialisierung nicht mehr ändern|