Constructeur

Comment simplifier l'initialisation des classes ?

Initialiser chaque champ à chaque fois peut être fastidieux. Pour de tels cas, les classes ont des constructeurs. La syntaxe d'un constructeur est la suivante :

Main


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

Passons en revue chaque mot écrit ici :

modifier : Cela fait référence au modificateur d'accès, qui est souvent public pour les constructeurs. Les cas où un constructeur peut avoir un modificateur d'accès différent seront abordés dans un cours séparé;
ClassName : C'est simplement le nom de la classe dans laquelle vous créez ce constructeur;
ParameterType : C'est le type de paramètre qui sera utilisé dans le constructeur. Il est important de faire attention ici car ce paramètre doit être du même type que le champ dans la classe; Par exemple : Si la classe a deux paramètres, String name et int age, alors le constructeur doit avoir les mêmes paramètres (si nous voulons initialiser tous les champs via le constructeur). Si nous voulons initialiser uniquement un champ spécifique de la classe via le constructeur, par exemple, name, alors nous devrions utiliser un seul paramètre avec le même type et nom que le champ dans la classe;
Ensuite, à l'intérieur du corps du constructeur, nous assignons des valeurs aux champs de la classe en utilisant les valeurs passées dans le paramètre.

Mot-clé "this"

Avec l'aide du mot-clé this, nous pouvons faire référence au champ de la classe dans lequel nous écrivons la valeur de ce mot-clé. Par exemple, lorsque nous avons une classe avec deux champs : name et age, nous pouvons écrire this.name à l'intérieur du constructeur ou de la méthode, et cela fera spécifiquement référence au champ de la classe, pas à la variable locale qui est passée en tant que paramètre à ce constructeur ou méthode. De cette façon, nous pouvons initialiser les champs de la classe via le constructeur en utilisant la syntaxe : this.name = name;.

Exemple

Regardons un exemple de constructeur dans une classe qui nous aidera à initialiser tous les champs pour rendre cela plus clair :

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

Nous avons une classe appelée Person avec trois champs. Chacun de ces champs a été ajouté au constructeur en utilisant le mot-clé this. Par conséquent, le constructeur initialise les champs avec les valeurs des paramètres. Utilisons ce constructeur dans la méthode main afin que vous puissiez voir que les champs sont initialisés avec ce que nous passons en tant que paramètres :

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

Nous avons initialisé l'objet Person bob en utilisant le constructeur en passant le name, l'age et le gender comme paramètres. Ensuite, nous avons imprimé ses paramètres à l'écran et constaté que l'objet a des valeurs de champ comme spécifié dans les paramètres du constructeur.

Surcharge du constructeur

Le constructeur peut également être surchargé et ne pas couvrir l'initialisation de tous les champs de la classe. Par exemple, si nous ne voulons pas spécifier le genre d'Alice, nous pouvons surcharger le constructeur pour n'accepter que 2 paramètres et initialiser les champs avec eux :

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

On peut conclure qu'un constructeur, comme une méthode, peut être surchargé et accepter différents nombres et types de paramètres.

Constructeur par défaut

Un constructeur par défaut est un constructeur qui ne prend aucun paramètre et n'initialise aucun champ. Il existe dans toutes les classes par défaut si elles n'ont pas d'autre type de constructeur, c'est pourquoi on l'appelle le constructeur par défaut. Chaque fois que nous créons un objet de n'importe quelle classe, nous utilisons un constructeur. Afin d'utiliser le constructeur par défaut lorsque nous avons déjà un constructeur qui accepte des paramètres, nous devons également écrire un constructeur vide :

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

Nous utilisons 3 constructeurs différents pour initialiser chacun des objets Person. Comme nous pouvons le voir dans le dernier exemple, John n'a pas de nom ni d'âge car ces champs ne sont pas initialisés pour l'objet. Ainsi, nous pouvons surcharger le constructeur autant de fois que nécessaire et créer des objets à travers lui.

1. Laquelle des affirmations suivantes concernant les constructeurs est vraie ?

2. Quel est le but d'un constructeur en Java ?

3. Lequel des extraits de code suivants démontre la manière correcte de créer un constructeur paramétré ?

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 6