≪ View Page

Differences

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

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
programmierung:klassen:constructor [2024/07/07 19:46] – sweprogrammierung: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. +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** 
-<WRAP group> +implementiert. Die Syntax ist die folgende: Der Klassen-Name (im 
-<WRAP half column> +Beispiel `Student`) wird nochmals aufgerufen. **Ohne Schlüsselwörter. 
-<code java [enable_line_numbers="true", highlight_lines_extra="5,6,7,8"]>+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 { class Student {
-   private String name;+   private final String name;
    private int age;    private int age;
  
-   Student(String name, int age){+   public Student(String name, int age){
       this.name = name;       this.name = name;
       this.age = age;       this.age = age;
Line 22: Line 35:
    }    }
 } }
-</code> +```
-</WRAP>+
  
-<WRAP half column> +\</WRAP\> 
-<code java [enable_line_numbers="true", highlight_lines_extra="4"]>+ 
 +\<WRAP half column\> 
 + 
 +``` java
 public class Main{ public class Main{
    public static void main(String args[]) {    public static void main(String args[]) {
Line 32: Line 47:
       Student obj1 = new Student("Maria", 32);       Student obj1 = new Student("Maria", 32);
              
-      obj1.display(); +      obj1.display(); 
-  +
    }    }
 } }
-</code> +``` 
-</WRAP> + 
-</WRAP>+\</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|