Java Konstruktoren meistern: Typen, Verwendung und praktische Beispiele

Java Konstruktoren

In diesem Tutorial lernen wir Java-Konstruktoren, ihre Typen und wie man sie anhand von Beispielen verwendet.

Was ist ein Konstruktor?

Ein Konstruktor in Java ähnelt einer Methode, die aufgerufen wird, wenn ein Objekt der Klasse erstellt wird.

Im Gegensatz zu Java-Methoden hat ein Konstruktor denselben Namen wie die Klasse und hat keinen Rückgabetyp. Zum Beispiel:

class Test {
    Test() {
        // Konstruktor-Rumpf
    }
}

Hier ist Test() ein Konstruktor. Er hat denselben Namen wie die Klasse und keinen Rückgabetyp.

Empfohlene Lektüre: Warum Konstruktoren keine Werte zurückgeben

---

Beispiel 1: Java Konstruktor

class Main {
    private String name;
    // Konstruktor
    Main() {
        System.out.println("Konstruktor aufgerufen:");
        name = "Programiz";
    }
    public static void main(String[] args) {
        // Konstruktor wird aufgerufen beim
        // Erstellen eines Objekts der Main-Klasse
        Main obj = new Main();
        System.out.println("Der Name ist " + obj.name);
    }
}

Ausgabe:

Konstruktor aufgerufen:
Der Name ist Programiz

Im obigen Beispiel haben wir einen Konstruktor namens Main() erstellt. Innerhalb des Konstruktors initialisieren wir den Wert der name-Variable.

Beachten Sie die Anweisung zum Erstellen eines Objekts der Main-Klasse.

Main obj = new Main();

Hier wird beim Erstellen des Objekts der Main()-Konstruktor aufgerufen. Und der Wert der name-Variable wird initialisiert.

Daher gibt das Programm den Wert der name-Variable als Programiz aus.

---

Konstruktortypen

In Java können Konstruktoren in 3 Typen unterteilt werden:

1. No-Arg Konstruktor
2. Parameterisierter Konstruktor
3. Standardkonstruktor

---

1. Java No-Arg Konstruktoren

Ähnlich wie Methoden kann ein Java-Konstruktor Parameter (Argumente) haben oder nicht.

Wenn ein Konstruktor keine Parameter akzeptiert, wird er als no-argument Konstruktor bezeichnet. Zum Beispiel:

private Constructor() {
    // Körper des Konstruktors
}

---

Beispiel 2: Java private no-arg Konstruktor

class Main {
    int i;
    // Konstruktor ohne Parameter
    private Main() {
        i = 5;
        System.out.println("Konstruktor wird aufgerufen");
    }
    public static void main(String[] args) {
        // Konstruktor ohne Parameter aufrufen
        Main obj = new Main();
        System.out.println("Wert von i: " + obj.i);
    }
}

Ausgabe:

Konstruktor wird aufgerufen
Wert von i: 5

Im obigen Beispiel haben wir einen Konstruktor Main() erstellt. Hier akzeptiert der Konstruktor keine Parameter. Daher ist er als no-arg Konstruktor bekannt.

Beachten Sie, dass wir den Konstruktor als private deklariert haben.

Sobald ein Konstruktor als private deklariert ist, kann er von außerhalb der Klasse nicht zugegriffen werden. Daher ist das Erstellen von Objekten von außerhalb der Klasse mit dem privaten Konstruktor verboten.

Hier erstellen wir das Objekt innerhalb derselben Klasse. Daher kann das Programm auf den Konstruktor zugreifen. Mehr erfahren unter Java Private Konstruktor implementieren.

Wenn wir jedoch Objekte außerhalb der Klasse erstellen wollen, müssen wir den Konstruktor als public deklarieren.

Beispiel 3: Java public no-arg Konstruktoren

class Company {
    String name;
    // public Konstruktor
    public Company() {
        name = "Programiz";
    }
}
class Main {
    public static void main(String[] args) {
        // Objekt wird in einer anderen Klasse erstellt
        Company obj = new Company();
        System.out.println("Firmenname = " + obj.name);
    }
}

Ausgabe:

Firmenname = Programiz

Empfohlene Lektüre: Java Zugriffsmodifizierer

---

2. Java Parameterisierter Konstruktor

Ein Java-Konstruktor kann auch einen oder mehrere Parameter akzeptieren. Solche Konstruktoren werden als parameterisierte Konstruktoren (Konstruktor mit Parametern) bezeichnet.

Beispiel 4: Parameterisierter Konstruktor

class Main {
    String languages;
    // Konstruktor akzeptiert einzelnen Wert
    Main(String lang) {
        languages = lang;
        System.out.println(languages + " Programmiersprache");
    }
    public static void main(String[] args) {
        // Konstruktor durch Übergeben eines einzelnen Werts aufrufen
        Main obj1 = new Main("Java");
        Main obj2 = new Main("Python");
        Main obj3 = new Main("C");
    }
}

Ausgabe:

Java Programmiersprache
Python Programmiersprache
C Programmiersprache

Im obigen Beispiel haben wir einen Konstruktor namens Main() erstellt. Hier nimmt der Konstruktor einen einzelnen Parameter entgegen. Beachten Sie den Ausdruck:

Main obj1 = new Main("Java");

Hier übergeben wir einen einzelnen Wert an den Konstruktor. Basierend auf dem übergebenen Argument wird die Sprachvariable im Konstruktor initialisiert.

---

3. Java Standardkonstruktor

Wenn wir keinen Konstruktor erstellen, erstellt der Java-Compiler automatisch einen no-arg Konstruktor während der Programmausführung. Dieser Konstruktor wird Standardkonstruktor genannt.

Beispiel 5: Standardkonstruktor

class Main {
    int a;
    boolean b;
    public static void main(String[] args) {
        // Ein Standardkonstruktor wird aufgerufen
        Main obj = new Main();
        System.out.println("Standardwerte:");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

Ausgabe:

a = 0
b = false

Hier haben wir keine Konstruktoren erstellt. Daher erstellt der Java-Compiler automatisch den Standardkonstruktor.

Der Standardkonstruktor initialisiert alle nicht initialisierten Instanzvariablen mit Standardwerten.

Typ	Standardwert
boolean	false
byte	0
short	0
int	0
long	0L
char	\u0000
float	0.0f
double	0.0d
object	Referenz null

Im obigen Programm werden die Variablen a und b mit den Standardwerten 0 und false initialisiert.

Das obige Programm ist äquivalent zu:

class Main {
    int a;
    boolean b;
    // ein privater Konstruktor
    private Main() {
        a = 0;
        b = false;
    }
    public static void main(String[] args) {
        // Konstruktor aufrufen
        Main obj = new Main();
        System.out.println("Standardwerte:");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

Die Ausgabe des Programms ist dieselbe wie in Beispiel 5.

---

Wichtige Hinweise zu Java Konstruktoren

• Konstruktoren werden implizit aufgerufen, wenn Sie Objekte instanziieren.
• Die zwei Regeln für die Erstellung eines Konstruktors sind:
  Der Name des Konstruktors sollte derselbe wie die Klasse sein.
  Ein Java-Konstruktor darf keinen Rückgabetyp haben.
• Wenn eine Klasse keinen Konstruktor hat, erstellt der Java-Compiler automatisch einen Standardkonstruktor zur Laufzeit. Der Standardkonstruktor initialisiert Instanzvariablen mit Standardwerten. Zum Beispiel wird die int-Variable mit 0 initialisiert.
• Konstruktortypen:
  No-Arg Konstruktor – ein Konstruktor, der keine Argumente akzeptiert
  Parameterisierter Konstruktor – ein Konstruktor, der Argumente akzeptiert
  Standardkonstruktor – ein Konstruktor, der automatisch vom Java-Compiler erstellt wird, wenn er nicht explizit definiert ist.
• Ein Konstruktor kann nicht abstract, static oder final sein.
• Ein Konstruktor kann überladen, aber nicht überschrieben werden.

---

Konstruktor-Überladung in Java

Ähnlich wie bei Java-Methodenüberladung können wir auch zwei oder mehr Konstruktoren mit unterschiedlichen Parametern erstellen. Dies wird Konstruktor-Überladung genannt.

Beispiel 6: Java Konstruktor-Überladung

class Main {
    String language;
    // Konstruktor ohne Parameter
    Main() {
        this.language = "Java";
    }
    // Konstruktor mit einem Parameter
    Main(String language) {
        this.language = language;
    }
    public void getName() {
        System.out.println("Programmiersprache: " + this.language);
    }
    public static void main(String[] args) {
        // Konstruktor ohne Parameter aufrufen
        Main obj1 = new Main();
        // Konstruktor mit einem Parameter aufrufen
        Main obj2 = new Main("Python");
        obj1.getName();
        obj2.getName();
    }
}

Ausgabe:

Programmiersprache: Java
Programmiersprache: Python

Im obigen Beispiel haben wir zwei Konstruktoren: Main() und Main(String language). Hier initialisieren beide Konstruktoren den Wert der Variablen language mit unterschiedlichen Werten.

Basierend auf dem bei der Objekterstellung übergebenen Parameter werden verschiedene Konstruktoren aufgerufen und unterschiedliche Werte zugewiesen.

Es ist auch möglich, einen Konstruktor aus einem anderen Konstruktor aufzurufen. Mehr erfahren unter Java Einen Konstruktor aus einem anderen aufrufen.

Hinweis: Wir haben das this-Schlüsselwort verwendet, um die Variable der Klasse zu spezifizieren. Mehr über this unter Java this-Schlüsselwort.