Konstruktor

Wie kann man die Initialisierung von Klassen vereinfachen?

Jedes Feld jedes Mal zu initialisieren, kann umständlich sein. Für solche Zwecke haben Klassen Konstruktoren. Die Syntax für einen Konstruktor ist wie folgt:

Main


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

Gehen wir jedes hier geschriebene Wort durch:

modifier: Dies bezieht sich auf den Zugriffsmodifikator, der oft public für Konstruktoren ist. Fälle, in denen ein Konstruktor einen anderen Zugriffsmodifikator haben kann, werden in einem separaten Kurs behandelt;
ClassName: Dies ist einfach der Name der Klasse, in der Sie diesen Konstruktor erstellen;
ParameterType: Dies ist der Typ des Parameters, der im Konstruktor verwendet wird. Es ist wichtig, hier darauf zu achten, da dieser Parameter den gleichen Typ wie das Feld in der Klasse haben sollte; Zum Beispiel: Wenn die Klasse zwei Parameter hat, String name und int age, dann sollte der Konstruktor die gleichen Parameter haben (wenn wir alle Felder über den Konstruktor initialisieren wollen). Wenn wir nur ein bestimmtes Klassenfeld über den Konstruktor initialisieren wollen, zum Beispiel name, dann sollten wir nur einen Parameter mit dem gleichen Typ und Namen wie das Feld in der Klasse verwenden;
Als nächstes weisen wir innerhalb des Konstruktorkörpers den Klassenfeldern die Werte zu, die im Parameter übergeben wurden.

"this" Schlüsselwort

Mit Hilfe des this Schlüsselworts können wir auf das Klassenfeld verweisen, in dem wir den Wert dieses Schlüsselworts schreiben. Zum Beispiel, wenn wir eine Klasse mit zwei Feldern haben: name und age, können wir this.name innerhalb des Konstruktors oder Methode schreiben, und es wird sich speziell auf das Klassenfeld beziehen, nicht auf die lokale Variable, die als Parameter an diesen Konstruktor oder diese Methode übergeben wird. Auf diese Weise können wir Klassenfelder durch den Konstruktor mit der Syntax initialisieren: this.name = name;.

Beispiel

Schauen wir uns ein Beispiel eines Konstruktors in einer Klasse an, das uns hilft, alle Felder zu initialisieren, um es klarer zu machen:

Person


              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 dem Konstruktor mit dem Schlüsselwort this hinzugefügt. Daher initialisiert der Konstruktor die Felder mit den Werten aus den Parametern. Lassen Sie uns diesen Konstruktor in der main Methode verwenden, damit Sie sehen können, dass die Felder mit dem, was wir als Parameter übergeben, initialisiert werden:

Main


              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 haben das Person-Objekt bob mit dem Konstruktor initialisiert, indem wir den name, das age und das gender als Parameter übergeben haben. Dann haben wir seine Parameter auf dem Bildschirm ausgegeben und sehen, dass das Objekt Feldwerte hat, wie sie in den Konstruktorparametern angegeben sind.

Konstruktorüberladung

Der Konstruktor kann auch überladen werden und muss nicht die Initialisierung aller Klassenfelder abdecken. Zum Beispiel, wenn wir Alice's Geschlecht nicht angeben möchten, können wir den Konstruktor überladen, um nur 2 Parameter zu akzeptieren und die Felder mit ihnen zu initialisieren:

Main


              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 kann geschlossen werden, dass ein Konstruktor, ähnlich wie eine Methode, überladen werden kann und unterschiedliche Anzahlen und Typen von Parametern akzeptieren kann.

Standardkonstruktor

Ein Standardkonstruktor ist ein Konstruktor, der keine Parameter annimmt und keine Felder initialisiert. Er existiert in allen Klassen standardmäßig, wenn sie keinen anderen Konstruktor haben, weshalb er als Standardkonstruktor bezeichnet wird. Jedes Mal, wenn wir ein Objekt einer Klasse erstellen, verwenden wir einen Konstruktor. Um den Standardkonstruktor zu verwenden, wenn wir bereits einen Konstruktor haben, der Parameter akzeptiert, müssen wir auch einen leeren Konstruktor schreiben:

Main


              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 3 verschiedene Konstruktoren, um jedes der Person-Objekte zu initialisieren. Wie wir im letzten Beispiel sehen können, hat John weder einen Namen noch ein Alter, da diese Felder für das Objekt nicht initialisiert sind. Daher können wir den Konstruktor so oft überladen, wie wir es benötigen, und Objekte darüber erstellen.

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

2. Was ist der Zweck eines Konstruktors in Java?

3. Welcher der folgenden Code-Snippets zeigt die korrekte Art, einen parametrisierten Konstruktor zu erstellen?

War alles klar?

Danke für Ihr Feedback!

Abschnitt 4. Kapitel 6