Aller au contenu principal

Les constructeurs

Notions théoriques​

Qu'est-ce qu'un constructeur ?​

Un constructeur est une méthode spéciale appelée automatiquement lors de la création d'un objet avec new. Il permet d'initialiser les attributs dès la création de l'objet.

Le constructeur se reconnaît à deux caractéristiques :

  • Il porte le même nom que la classe
  • Il n'a pas de type de retour (pas même void)
public class Personnage {
    String nom;
    int force;
    int pointsDeVie;

    // Constructeur
    public Personnage(String nom, int force, int pointsDeVie) {
        this.nom = nom;
        this.force = force;
        this.pointsDeVie = pointsDeVie;
    }
}

Constructeur par défaut (implicite)​

Si vous ne déclarez aucun constructeur, Java en fournit un automatiquement : le constructeur par défaut (sans paramètres). C'est ce qui permettait d'écrire new Personnage() dans les séances précédentes.

attention

Dès que vous déclarez un constructeur avec des paramètres, le constructeur par défaut disparaît. Si vous voulez encore pouvoir écrire new Personnage(), vous devez déclarer explicitement un constructeur sans paramètres.

Surcharge de constructeurs​

Java permet de définir plusieurs constructeurs dans une même classe, tant qu'ils ont des signatures différentes (types ou nombre de paramètres différents). C'est la surcharge (ou overloading).

public class Personnage {
    String nom;
    int force;
    int pointsDeVie;

    // Constructeur sans paramètres
    public Personnage() {
        this.nom = "Inconnu";
        this.force = 10;
        this.pointsDeVie = 50;
    }

    // Constructeur avec nom seulement
    public Personnage(String nom) {
        this.nom = nom;
        this.force = 10;
        this.pointsDeVie = 50;
    }

    // Constructeur complet
    public Personnage(String nom, int force, int pointsDeVie) {
        this.nom = nom;
        this.force = force;
        this.pointsDeVie = pointsDeVie;
    }
}

Chaîner les constructeurs avec this(...)​

Pour éviter de répéter du code entre constructeurs, on peut appeler un constructeur depuis un autre avec this(...) :

public Personnage() {
    this("Inconnu", 10, 50);   // appelle le constructeur complet
}

public Personnage(String nom) {
    this(nom, 10, 50);          // appelle le constructeur complet
}

public Personnage(String nom, int force, int pointsDeVie) {
    this.nom = nom;
    this.force = force;
    this.pointsDeVie = pointsDeVie;
}
info

this(...) doit toujours être la première instruction du constructeur.

Exemple pratique​

// Fichier : Personnage.java
public class Personnage {
    String nom;
    int force;
    int defense;
    int pointsDeVie;

    // Constructeur complet (le constructeur principal)
    public Personnage(String nom, int force, int defense, int pointsDeVie) {
        this.nom = nom;
        this.force = force;
        this.defense = defense;
        this.pointsDeVie = pointsDeVie;
    }

    // Constructeur simplifié : utilise des valeurs par défaut
    public Personnage(String nom) {
        this(nom, 10, 5, 100);  // force=10, defense=5, pv=100 par défaut
    }

    // Constructeur par défaut explicite
    public Personnage() {
        this("Inconnu");
    }

    void afficher() {
        System.out.println("=== " + nom + " ===");
        System.out.println("Force   : " + force);
        System.out.println("Défense : " + defense);
        System.out.println("PV      : " + pointsDeVie);
    }
}

// Fichier : Main.java
public class Main {
    public static void main(String[] args) {
        // Utilisation du constructeur complet
        Personnage guerrier = new Personnage("Aria", 18, 10, 120);

        // Utilisation du constructeur simplifié
        Personnage apprenti = new Personnage("Tom");

        // Utilisation du constructeur sans paramètres
        Personnage anonyme = new Personnage();

        guerrier.afficher();
        apprenti.afficher();
        anonyme.afficher();
    }
}

Test de mémorisation/compréhension​


Qu'est-ce qui distingue un constructeur des autres méthodes ?


Que se passe-t-il si on déclare un constructeur avec paramètres sans déclarer de constructeur sans paramètres ?


Que fait `this(nom, 10, 5, 100)` dans un constructeur ?


Peut-on avoir deux constructeurs avec exactement les mêmes types de paramètres dans la même classe ?


Quelle est la bonne pratique concernant l'initialisation des attributs ?


TP pour réfléchir et résoudre des problèmes​

Vous allez transformer la classe Personnage pour utiliser des constructeurs qui garantissent une initialisation correcte dès la création.

Étape 1 — Ajouter le constructeur complet​

Ajoutez un constructeur qui prend les quatre attributs en paramètres (nom, force, defense, pointsDeVie).


Bonne pratique - Toujours utiliser this.attribut dans les constructeurs

Quand un paramètre du constructeur a le même nom qu'un attribut, utilisez this.nom = nom pour lever l'ambiguïté. this.nom désigne l'attribut de l'objet, nom seul désigne le paramètre. Sans this, les deux feraient référence au paramètre et l'attribut ne serait pas initialisé.

Étape 2 — Ajouter un constructeur simplifié avec this(...)​

Ajoutez un constructeur qui ne prend que le nom, et qui appelle le constructeur complet avec des valeurs par défaut (force=10, defense=5, pointsDeVie=100).


Bonne pratique - Centraliser l'initialisation dans un seul constructeur

En chaînant les constructeurs avec this(...), toute la logique d'initialisation est centralisée dans un seul constructeur (le plus complet). Si vous devez changer les valeurs par défaut, vous n'avez à modifier qu'un seul endroit.

Étape 3 — Utiliser les constructeurs dans Main​

Utilisez les différents constructeurs pour créer trois personnages de façon concise.


Bonne pratique - Initialiser dans le constructeur, pas après

Préférez toujours initialiser les attributs dans le constructeur plutôt qu'après la création. Cela garantit qu'un objet est dans un état valide dès sa création : new Personnage("Aria", 18, 10, 120) est plus sûr et plus lisible que créer d'abord l'objet puis assigner chaque attribut séparément.

📌 Une solution