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: Der Name der Klasse, in der dieser Konstruktor erstellt wird;
ParameterType: Der Typ des Parameters, 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 den Klassenfeldern mithilfe der übergebenen Parameter 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. Dadurch wird explizit auf das Klassenfeld und nicht auf die lokale Variable verwiesen, die als Parameter an den Konstruktor oder die Methode übergeben wurde. Auf diese Weise können Klassenfelder durch den Konstruktor mit folgender Syntax initialisiert werden: this.name = name;.

Beispiel

Im Folgenden betrachten wir ein Beispiel für einen Konstruktor in einer Klasse, der uns hilft, alle Felder zu initialisieren, 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;
    }
}

Wir haben eine Klasse namens Person mit drei Feldern. Jedes dieser Felder wurde mithilfe des Schlüsselworts this dem Konstruktor hinzugefügt. Daher initialisiert der Konstruktor die Felder mit den Werten aus den Parametern. Nutzen wir diesen Konstruktor in der main-Methode, um zu sehen, 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);
    }
}

Wir initialisierten das Person-Objekt bob mithilfe des Konstruktors, indem wir name, age und gender als Parameter übergeben haben. Anschließend wurden die Parameter auf dem Bildschirm ausgegeben, sodass 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 wir das Geschlecht von Alice nicht angeben möchten, können wir den Konstruktor überladen, 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);
    }
}

Es werden drei verschiedene Konstruktoren verwendet, um jeweils ein Person-Objekt 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 erstellen.

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 4. Kapitel 6

Fragen Sie AI

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

Suggested prompts:

Can you explain more about how constructor overloading works?

What happens if I don't define any constructor in my class?

Can you give more examples of using the "this" keyword in constructors?

Awesome!

Completion rate improved to 2.63

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: Der Name der Klasse, in der dieser Konstruktor erstellt wird;
ParameterType: Der Typ des Parameters, 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 den Klassenfeldern mithilfe der übergebenen Parameter zugewiesen.

Schlüsselwort "this"

Beispiel

Im Folgenden betrachten wir ein Beispiel für einen Konstruktor in einer Klasse, der uns hilft, alle Felder zu initialisieren, 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;
    }
}

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);
    }
}

Konstruktorüberladung

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

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);
    }
}

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 4. Kapitel 6