Java Language
Constructeurs

Introduction

Remarques

Constructeur par défaut

La "valeur par défaut" pour les constructeurs est qu'ils n'ont aucun argument. Si vous ne spécifiez aucun constructeur, le compilateur générera un constructeur par défaut pour vous.
Cela signifie que les deux extraits suivants sont sémantiquement équivalents:

public class TestClass {
    private String test;
}

public class TestClass {
    private String test;
    public TestClass() {

    }
}

La visibilité du constructeur par défaut est la même que celle de la classe. Ainsi, une classe définie package-private a un constructeur par défaut package-private

Cependant, si vous avez un constructeur autre que celui par défaut, le compilateur ne générera pas de constructeur par défaut pour vous. Donc, ils ne sont pas équivalents:

public class TestClass {
    private String test;
    public TestClass(String arg) {
    }
}

public class TestClass {
    private String test;
    public TestClass() {
    }
    public TestClass(String arg) {
    }
}

Attention, le constructeur généré n'effectue aucune initialisation non standard. Cela signifie que tous les champs de votre classe auront leur valeur par défaut, à moins qu'ils n'aient un initialiseur.

public class TestClass {

    private String testData;

    public TestClass() {
        testData = "Test"
    }
}

Les constructeurs sont appelés comme ceci:

TestClass testClass = new TestClass();

Constructeur avec arguments

Les constructeurs peuvent être créés avec n'importe quel type d'arguments.

public class TestClass {

    private String testData;

    public TestClass(String testData) {
        this.testData = testData;
    }
}

Appelé comme ceci:

TestClass testClass = new TestClass("Test Data");

Une classe peut avoir plusieurs constructeurs avec des signatures différentes. Pour enchaîner les appels de constructeur (appeler un constructeur différent de la même classe lors de l'instanciation), utilisez this() .

public class TestClass {

    private String testData;

    public TestClass(String testData) {
        this.testData = testData;
    }

    public TestClass() {
        this("Test"); // testData defaults to "Test"
    }
}

Appelé comme ceci:

TestClass testClass1 = new TestClass("Test Data");
TestClass testClass2 = new TestClass();

Appeler le constructeur parent

Disons que vous avez une classe Parent et une classe Enfant. Pour construire une instance Child, vous devez toujours exécuter un constructeur Parent au sein même du constructeur Child. Nous pouvons sélectionner le constructeur Parent que nous voulons en appelant explicitement super(...) avec les arguments appropriés dans notre première déclaration de constructeur Child. Cela vous fait gagner du temps en réutilisant le constructeur de la classe Parent au lieu de réécrire le même code dans le constructeur de la classe Child.

Sans super(...) méthode:

(implicitement, la version no-args super() est appelée de manière invisible)

class Parent {
    private String name;
    private int age;
    
    public Parent() {} // necessary because we call super() without arguments
    
    public Parent(String tName, int tAge) {
        name = tName;
        age = tAge;
    }
}

// This does not even compile, because name and age are private,
// making them invisible even to the child class.
class Child extends Parent {
    public Child() {
        // compiler implicitly calls super() here
        name = "John";
        age = 42;
    }
}

Avec la méthode super() :

class Parent {
    private String name;
    private int age;
    public Parent(String tName, int tAge) {
        name = tName;
        age = tAge;
    }
}

class Child extends Parent {
    public Child() {
        super("John", 42);   // explicit super-call
    }
}

Remarque: Les appels à un autre constructeur (chaînage) ou au super constructeur DOIVENT être la première instruction à l'intérieur du constructeur.

Si vous appelez explicitement le constructeur super(...) , un constructeur parent correspondant doit exister (c'est simple, n'est-ce pas?).

Si vous n'appelez aucun constructeur super(...) explicitement, votre classe parent doit avoir un constructeur no-args - et ceci peut être écrit explicitement ou créé par défaut par le compilateur si la classe parente ne fournit pas n'importe quel constructeur.

class Parent{
    public Parent(String tName, int tAge) {}
}

class Child extends Parent{
    public Child(){}
}

La classe Parent n'a pas de constructeur par défaut, le compilateur ne peut donc pas ajouter de super dans le constructeur Child. Ce code ne sera pas compilé. Vous devez changer les constructeurs pour les adapter des deux côtés, ou écrire votre propre super appel, comme ça:

class Child extends Parent{
    public Child(){
          super("",0);
    }
}