Hoe het initialiseren van klassen te vereenvoudigen

Het telkens opnieuw initialiseren van elk veld kan omslachtig zijn. Voor dergelijke doeleinden beschikken klassen over constructors. De syntaxis voor een constructor is als volgt:

Main.java


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

Laten we elk woord hier doornemen:

modifier: Dit verwijst naar de access modifier, die vaak public is voor constructors. Gevallen waarin een constructor een andere access modifier kan hebben, worden behandeld in een aparte cursus;
ClassName: Dit is eenvoudigweg de naam van de klasse waarin deze constructor wordt aangemaakt;
ParameterType: Dit is het type parameter dat in de constructor wordt gebruikt. Het is belangrijk hier goed op te letten, omdat deze parameter hetzelfde type moet hebben als het veld in de klasse; Bijvoorbeeld: Als de klasse twee parameters heeft, String name en int age, dan moet de constructor dezelfde parameters hebben (als we alle velden via de constructor willen initialiseren). Als we slechts één specifiek klasseveld via de constructor willen initialiseren, bijvoorbeeld name, dan gebruiken we slechts één parameter met hetzelfde type en dezelfde naam als het veld in de klasse;
Vervolgens wijzen we binnen het constructorlichaam waarden toe aan de klassevelden met behulp van de waarden die in de parameter zijn doorgegeven.

"this" Trefwoord

Met behulp van het trefwoord this kunnen we verwijzen naar het klasseveld waarin we de waarde van dit trefwoord schrijven. Bijvoorbeeld, wanneer we een klasse hebben met twee velden: name en age, kunnen we this.name schrijven binnen de constructor of methode, en het zal specifiek verwijzen naar het klasseveld, niet naar de lokale variabele die als parameter aan die constructor of methode wordt doorgegeven. Op deze manier kunnen we klassevelden initialiseren via de constructor met de syntaxis: this.name = name;.

Voorbeeld

Bekijk een voorbeeld van een constructor in een klasse die ons helpt alle velden te initialiseren om het duidelijker te maken:

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

We hebben een klasse genaamd Person met drie velden. Elk van deze velden is toegevoegd aan de constructor met behulp van het trefwoord this. Daarom initialiseert de constructor de velden met de waarden van de parameters. Laten we deze constructor gebruiken in de main-methode zodat je kunt zien dat de velden worden geïnitialiseerd met wat we als parameters doorgeven:

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

We hebben het Person-object bob geïnitialiseerd met behulp van de constructor door de name, age en gender als parameters door te geven. Vervolgens hebben we de parameters op het scherm afgedrukt en zien we dat het object veldwaarden heeft zoals gespecificeerd in de constructorparameters.

Constructor Overload

De constructor kan ook overladen worden en hoeft niet alle klassevelden te initialiseren. Bijvoorbeeld, als we het geslacht van Alice niet willen specificeren, kunnen we de constructor overladen zodat deze slechts 2 parameters accepteert en de velden daarmee initialiseert:

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

Hieruit kan worden geconcludeerd dat een constructor, net als een methode, overbelast kan worden en verschillende aantallen en typen parameters kan accepteren.

Standaardconstructor

Een standaardconstructor is een constructor die geen parameters accepteert en geen velden initialiseert. Deze bestaat standaard in alle klassen als er geen andere constructor aanwezig is, vandaar de naam standaardconstructor. Elke keer dat we een object van een klasse aanmaken, gebruiken we een constructor. Om de standaardconstructor te kunnen gebruiken wanneer er al een constructor met parameters aanwezig is, moeten we ook een lege constructor schrijven:

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

We gebruiken drie verschillende constructors om elk van de Person-objecten te initialiseren. Zoals te zien is in het laatste voorbeeld, heeft John geen naam of leeftijd omdat deze velden niet voor het object zijn geïnitialiseerd. Op deze manier kunnen we de constructor zo vaak als nodig overbelasten en objecten ermee aanmaken.

1. Welke van de volgende uitspraken over constructors is waar?

2. Wat is het doel van een constructor in Java?

3. Welke van de volgende codevoorbeelden toont de correcte manier om een constructor met parameters te maken?

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 4. Hoofdstuk 6

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

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

Veeg om het menu te tonen

Hoe het initialiseren van klassen te vereenvoudigen

Het telkens opnieuw initialiseren van elk veld kan omslachtig zijn. Voor dergelijke doeleinden beschikken klassen over constructors. De syntaxis voor een constructor is als volgt:

Main.java


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

Laten we elk woord hier doornemen:

modifier: Dit verwijst naar de access modifier, die vaak public is voor constructors. Gevallen waarin een constructor een andere access modifier kan hebben, worden behandeld in een aparte cursus;
ClassName: Dit is eenvoudigweg de naam van de klasse waarin deze constructor wordt aangemaakt;
ParameterType: Dit is het type parameter dat in de constructor wordt gebruikt. Het is belangrijk hier goed op te letten, omdat deze parameter hetzelfde type moet hebben als het veld in de klasse; Bijvoorbeeld: Als de klasse twee parameters heeft, String name en int age, dan moet de constructor dezelfde parameters hebben (als we alle velden via de constructor willen initialiseren). Als we slechts één specifiek klasseveld via de constructor willen initialiseren, bijvoorbeeld name, dan gebruiken we slechts één parameter met hetzelfde type en dezelfde naam als het veld in de klasse;
Vervolgens wijzen we binnen het constructorlichaam waarden toe aan de klassevelden met behulp van de waarden die in de parameter zijn doorgegeven.

"this" Trefwoord

Voorbeeld

Bekijk een voorbeeld van een constructor in een klasse die ons helpt alle velden te initialiseren om het duidelijker te maken:

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

Constructor Overload

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

Hieruit kan worden geconcludeerd dat een constructor, net als een methode, overbelast kan worden en verschillende aantallen en typen parameters kan accepteren.

Standaardconstructor

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. Welke van de volgende uitspraken over constructors is waar?

2. Wat is het doel van een constructor in Java?

3. Welke van de volgende codevoorbeelden toont de correcte manier om een constructor met parameters te maken?

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 4. Hoofdstuk 6