Constructeurs en Java : initialiser des objets avec new

Pourquoi les constructeurs existent

Sur la page précédente, vous avez créé des classes et des objets avec new. Un constructeur est le code qui s'exécute réellement pendant cet appel à new. Son unique but est de vous rendre un objet prêt à l'emploi : tous ses champs obligatoires renseignés, aucun état à moitié initialisé.

Un constructeur ressemble à une méthode, avec deux différences : il porte le même nom que la classe et il n'a aucun type de retour, pas même void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // constructeur : même nom que la classe, pas de type de retour
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // le constructeur s'exécute ici
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) alloue l'objet puis exécute le corps du constructeur avec x = 3 et y = 4. Au moment où new se termine, p est entièrement initialisé.

Le mot-clé this

Dans le constructeur ci-dessus, les paramètres s'appellent x et y, comme les champs. this.x désigne « le champ x appartenant à cet objet », tandis que x seul fait référence au paramètre. Sans this, x = x affecterait simplement le paramètre à lui-même et laisserait le champ inchangé.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // champ = paramètre
        this.balance = balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Sam", 100.0);
        System.out.println(a.owner + " has " + a.balance);
    }
}

Vous n'avez besoin de this que lorsqu'un paramètre masque un champ, mais beaucoup l'utilisent partout par souci de clarté. L'erreur courante est de l'oublier quand les noms entrent en collision : le code compile, s'exécute et laisse silencieusement vos champs à leurs valeurs par défaut (null, 0, false).

Le constructeur par défaut

Si vous n'écrivez jamais de constructeur, Java fournit discrètement un constructeur par défaut : un constructeur public, sans argument, qui ne fait rien de plus. C'est pourquoi new fonctionnait sur des classes qui n'avaient aucun constructeur.

Le piège : dès que vous écrivez un constructeur, le gratuit disparaît.

class Box {
    int size;

    Box(int size) {       // il n'y a plus de constructeur sans argument
        this.size = size;
    }
}

new Box();   // erreur de compilation : aucun constructeur Box() n'existe

Si vous voulez quand même que new Box() fonctionne, déclarez vous-même le constructeur sans argument :

class Box {
    int size;

    Box() {               // constructeur sans argument explicite
        this.size = 1;
    }

    Box(int size) {
        this.size = size;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Box().size);     // 1
        System.out.println(new Box(10).size);   // 10
    }
}

La surcharge de constructeurs

Une classe peut avoir plusieurs constructeurs tant que leurs listes de paramètres diffèrent : ce n'est que la surcharge de méthodes appliquée aux constructeurs. Chacun propose une façon différente de construire l'objet.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // un carré 1x1 par défaut
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // un carré
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // un rectangle complet
        this.width = width;
        this.height = height;
    }

    int area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Rectangle().area());        // 1
        System.out.println(new Rectangle(5).area());       // 25
        System.out.println(new Rectangle(2, 3).area());    // 6
    }
}

Java choisit le constructeur correspondant en fonction du nombre et des types d'arguments que vous passez à new.

Le chaînage avec this()

Remarquez la duplication ci-dessus : chaque constructeur affecte lui-même les champs. Vous pouvez l'éviter en faisant qu'un constructeur en appelle un autre avec this(...). L'appel doit être la première instruction du constructeur.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // délègue au constructeur à deux arguments
    }

    Rectangle(int side) {
        this(side, side);    // délègue aussi
    }

    Rectangle(int width, int height) {   // l'unique « vrai » constructeur
        this.width = width;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4);
        System.out.println(r.width + "x" + r.height);   // 4x4
    }
}

Maintenant, l'initialisation réelle tient en un seul endroit. Les constructeurs plus petits se contentent de renseigner les valeurs par défaut et de transmettre le travail. Si vous essayez un jour de placer une instruction avant this(...), le compilateur la rejette.

Les constructeurs et super()

Chaque constructeur appelle implicitement d'abord le constructeur de sa superclasse. Si vous n'écrivez rien, Java insère un super() caché (le constructeur sans argument de la superclasse) en haut du corps. Vous travaillerez directement avec cela dès que vous commencerez à créer des sous-classes, ce qui est le prochain sujet.

class Animal {
    String name;
    Animal(String name) { this.name = name; }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // il faut ici appeler explicitement le constructeur du parent
    }
}

Comme Animal n'a pas de constructeur sans argument, Dog doit appeler super(name) explicitement : il n'y a aucun super() gratuit sur lequel se rabattre. Comme this(), un appel à super(...) doit être la première instruction du constructeur.

Suite : L'héritage

Les constructeurs initialisent un seul objet, mais super() laissait déjà entrevoir quelque chose de plus grand : les classes peuvent s'appuyer sur d'autres classes, en réutilisant leurs champs, leurs méthodes et leurs constructeurs. Cette relation, une classe qui en étend une autre, c'est l'héritage, et c'est la prochaine page.