Swipe um das Menü anzuzeigen

Vereinfachung der Klasseninitialisierung

Das manuelle Initialisieren jedes Feldes kann umständlich sein. Für solche Zwecke verfügen Klassen über Konstruktoren. Die Syntax für einen Konstruktor ist wie folgt:

Main.java


              1234
            
modifier ClassName(ParameterType parameter1, ParameterType parameter2) {
    this.parameter1 = parameter1;
    this.parameter2 = parameter2;
}

Im Folgenden werden die einzelnen Begriffe erläutert:

modifier: Bezieht sich auf den Zugriffsmodifizierer, der bei Konstruktoren häufig public ist. Fälle, in denen ein Konstruktor einen anderen Zugriffsmodifizierer haben kann, werden in einem separaten Kurs behandelt;
ClassName: Bezeichnet den Namen der Klasse, in der dieser Konstruktor erstellt wird;
ParameterType: Gibt den Typ des Parameters an, der im Konstruktor verwendet wird. Hier ist besondere Aufmerksamkeit erforderlich, da dieser Parameter denselben Typ wie das Feld in der Klasse haben sollte; Beispiel: Wenn die Klasse zwei Parameter hat, String name und int age, sollte der Konstruktor dieselben Parameter enthalten (wenn alle Felder über den Konstruktor initialisiert werden sollen). Wenn nur ein bestimmtes Klassenfeld über den Konstruktor initialisiert werden soll, zum Beispiel name, sollte nur ein Parameter mit demselben Typ und Namen wie das Feld in der Klasse verwendet werden;
Anschließend werden im Rumpf des Konstruktors die Werte der Klassenfelder mit den übergebenen Parametern zugewiesen.

Schlüsselwort "this"

Mit dem Schlüsselwort this kann auf das Klassenfeld verwiesen werden, in dessen Kontext dieses Schlüsselwort verwendet wird. Wenn beispielsweise eine Klasse zwei Felder name und age besitzt, kann innerhalb des Konstruktors oder einer Methode this.name geschrieben werden. Dies bezieht sich explizit auf das Klassenfeld und nicht auf die lokale Variable, die als Parameter an den Konstruktor oder die Methode übergeben wird. Auf diese Weise können Klassenfelder im Konstruktor mit der Syntax this.name = name; initialisiert werden.

Beispiel

Im Folgenden wird ein Beispiel für einen Konstruktor in einer Klasse gezeigt, der alle Felder initialisiert, um das Konzept zu verdeutlichen:

Person.java


              1234567891011
            
class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

Es gibt eine Klasse mit dem Namen Person und drei Feldern. Jedes dieser Felder wird im Konstruktor mithilfe des Schlüsselworts this hinzugefügt. Der Konstruktor initialisiert somit die Felder mit den Werten der Parameter. Im Folgenden wird dieser Konstruktor in der main-Methode verwendet, um zu zeigen, dass die Felder mit den übergebenen Parametern initialisiert werden:

Main.java


              123456789101112131415161718192021
            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
    }
}

Das Person-Objekt bob wurde mithilfe des Konstruktors initialisiert, indem name, age und gender als Parameter übergeben wurden. Anschließend wurden die Parameter auf dem Bildschirm ausgegeben, wodurch ersichtlich ist, dass das Objekt die Feldwerte entsprechend den im Konstruktor angegebenen Parametern besitzt.

Konstruktorüberladung

Der Konstruktor kann ebenfalls überladen werden und muss nicht alle Felder der Klasse initialisieren. Zum Beispiel, wenn das Geschlecht von Alice nicht angegeben werden soll, kann der Konstruktor überladen werden, sodass er nur 2 Parameter akzeptiert und die Felder mit diesen initialisiert:

Main.java


              12345678910111213141516171819202122232425262728
            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
    }
}

Es lässt sich feststellen, dass ein Konstruktor, ähnlich wie eine Methode, überladen werden kann und unterschiedliche Anzahlen sowie Typen von Parametern akzeptieren kann.

Standardkonstruktor

Ein Standardkonstruktor ist ein Konstruktor, der keine Parameter entgegennimmt und keine Felder initialisiert. Er ist in allen Klassen standardmäßig vorhanden, sofern keine andere Art von Konstruktor definiert ist, weshalb er als Standardkonstruktor bezeichnet wird. Jedes Mal, wenn ein Objekt einer Klasse erstellt wird, wird ein Konstruktor verwendet. Um den Standardkonstruktor zu nutzen, wenn bereits ein Konstruktor mit Parametern existiert, muss zusätzlich ein leerer Konstruktor geschrieben werden:

Main.java


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

class Person {
    String name;
    int age;
    String gender;

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

public class Main {
    public static void main(String[] args) {
        Person bob = new Person("Bob", 20, "Male");
        System.out.println("Bob's name: " + bob.name + ", Bob's age: "
                + bob.age + ", Bob's gender: " + bob.gender);
        Person alice = new Person("Alice", 17);
        System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age);
        Person john = new Person();
        System.out.println("John's name: " + john.name + ", John's age: " + john.age);
    }
}

Wir verwenden drei verschiedene Konstruktoren, um jedes der Person-Objekte zu initialisieren. Wie im letzten Beispiel zu sehen ist, hat John weder einen Namen noch ein Alter, da diese Felder für das Objekt nicht initialisiert wurden. Somit kann der Konstruktor beliebig oft überladen werden, um Objekte darüber zu erzeugen.

1. Welche der folgenden Aussagen über Konstruktoren ist richtig?

2. Was ist der Zweck eines Konstruktors in Java?

3. Welcher der folgenden Codeausschnitte zeigt die korrekte Erstellung eines parametrisierten Konstruktors?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 6

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Abschnitt 1. Kapitel 6