Constructeur Java

En Java, les constructeurs sont des méthodes spéciales utilisées pour créer des objets d'une classe.

Lorsqu'un objet est créé à l'aide du mot-clé `new`, le constructeur est automatiquement appelé pour initialiser les attributs de l'objet.

Les constructeurs présentent les caractéristiques suivantes :

  • Même nom que la classe: Le nom du constructeur doit correspondre exactement au nom de la classe, y compris la casse. Il s'agit d'une exigence de base pour les constructeurs.

  • Aucun type de retour: Les constructeurs n'ont pas de déclaration de type de retour, mêmevoid`void` n'est pas écrit. Cela les distingue des méthodes ordinaires.

  • Invocation automatique: Chaque foisnew`new` est utilisé pour créer un objet, le constructeur est automatiquement invoqué pour initialiser les attributs et l'état de l'objet.

  • Ne peuvent pas être appelés directement: Les constructeurs ne peuvent être appelés que via lenewmot-clé `new` lors de la création d'un objet ; ils ne peuvent pas être appelés directement comme des méthodes ordinaires.

  • Prend en charge la surcharge: Vous pouvez définir plusieurs constructeurs pour une classe tant que leurs listes de paramètres sont différentes. Grâce à la surcharge, différents constructeurs peuvent être créés pour répondre à différents besoins d'initialisation.

  • Constructeur par défaut: Si aucun constructeur n'est défini, Java fournit un constructeur par défaut sans argument. Mais dès qu'un autre constructeur est défini, Java ne fournit plus le constructeur par défaut.

  • thisUtilisation du mot-clé `this`: Dans les constructeurs, vous pouvez utiliser `this`thispour faire référence aux attributs et méthodes de l'objet courant, ou pour appeler un autre constructeur (doit être la première ligne du constructeur), afin d'éviter la duplication de code.

  • Ne peut pas être hérité, mais peut être appelé: Les constructeurs ne peuvent pas être hérités par les sous-classes, mais les sous-classes peuvent utiliser `super`super()pour appeler le constructeur de la classe parente, afin d'initialiser les attributs hérités.

  • Garantie d'initialisation de l'objet: La fonction principale d'un constructeur est d'initialiser les attributs et l'état de l'objet, en veillant à ce que l'objet soit dans un état initial valide lors de sa création.

Le rôle des constructeurs :

  • Initialiser les attributs de l'objet: Le rôle principal d'un constructeur est d'attribuer des valeurs initiales aux attributs de l'objet.
  • Garantir la complétude de l'initialisation de l'objet: Dans les constructeurs, vous pouvez définir des valeurs par défaut ou des paramètres obligatoires pour éviter le problème d'une initialisation incomplète de l'objet.

Types de constructeurs

Les constructeurs en Java sont divisés en deux types :Constructeur sans argumentetConstructeur paramétré。

1. Constructeur sans argument (constructeur par défaut)

Si une classe n'a pas de constructeur défini, Java fournit par défaut un constructeur sans argument. Par exemple :

Exemple

public class Person {
    public Person() {
        System.out.println("Person object created");
    }
}
  • Lorsqu'aucun constructeur n'est explicitement défini, Java fournit automatiquement un constructeur par défaut sans argument.
  • Dès qu'un autre constructeur est défini, Java ne fournira plus le constructeur par défaut.

2. Constructeur paramétré

Vous pouvez définir des constructeurs avec des paramètres pour attribuer des valeurs aux attributs lors de la création d'objets :

Exemple

public class Person {
    String name;
    int age;

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

Lors de l'appel d'un constructeur paramétré, vous pouvez initialiser les attributs de l'objet :

Person p = new Person("Alice", 25);

Surcharge des constructeurs

Java prend en charge la surcharge des constructeurs, ce qui signifie que vous pouvez définir plusieurs constructeurs dans la même classe tant que les listes de paramètres sont différentes. Par exemple :

Exemple

public class Person {
    String name;
    int age;

    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

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

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

Lors de la création d'un objet, Java choisit automatiquement le constructeur correspondant en fonction du nombre et du type des arguments passés :

Person p1 = new Person(); // 调用无参构造方法
Person p2 = new Person("Alice"); // 调用单参数构造方法
Person p3 = new Person("Bob", 30); // 调用双参数构造方法

Le mot-clé this dans les constructeurs

Dans les constructeurs, le mot-clé `this` est généralement utilisé dans deux cas :

1. Faire référence aux attributs ou méthodes de l'objet courant :Lorsque les noms des paramètres d'un constructeur sont identiques aux noms des attributs de la classe, utilisez `this` pour distinguer les attributs de la classe des paramètres. Par exemple :

Exemple

public Person(String name, int age) {
    this.name = name; // this.name fait référence à l'attribut de classe
    this.age = age;
}

2. Appeler un autre constructeur :Vous pouvez utiliser `this()` pour appeler un autre constructeur de la classe courante. Il est souvent utilisé pour éviter la duplication de code, mais il doit être placé à la première ligne du constructeur.

Exemple

public Person(String name) {
    this(name, 0); // Appeler un autre constructeur à deux paramètres
}

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

Les constructeurs sont une partie très importante de la programmation orientée objet en Java. Grâce aux constructeurs, vous pouvez contrôler efficacement le processus d'initialisation des objets et garantir l'intégrité et la cohérence de l'état de l'objet créé.

Autres extensions