Java Language
constructors

Invoering

Opmerkingen

Standaard Constructor

De "standaard" voor constructeurs is dat ze geen argumenten hebben. Als u geen constructor opgeeft, genereert de compiler een standaardconstructor voor u.
Dit betekent dat de volgende twee fragmenten semantisch equivalent zijn:

public class TestClass {
    private String test;
}

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

    }
}

De zichtbaarheid van de standaardconstructor is hetzelfde als de zichtbaarheid van de klasse. Zo heeft een door de klasse gedefinieerde pakket-privé een pakket-privé-standaardconstructor

Als u echter een niet-standaard constructor hebt, genereert de compiler geen standaardconstructor voor u. Dus deze zijn niet equivalent:

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

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

Let op dat de gegenereerde constructor geen niet-standaard initialisatie uitvoert. Dit betekent dat alle velden van uw klas hun standaardwaarde hebben, tenzij ze een initialisatie hebben.

public class TestClass {

    private String testData;

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

Constructors worden zo genoemd:

TestClass testClass = new TestClass();

Aannemer met argumenten

Constructors kunnen worden gemaakt met allerlei soorten argumenten.

public class TestClass {

    private String testData;

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

Zo genoemd:

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

Een klasse kan meerdere constructors met verschillende handtekeningen hebben. Gebruik this() om constructeuroproepen aan elkaar te koppelen (een andere constructor van dezelfde klasse aanroepen bij het instantiëren this() .

public class TestClass {

    private String testData;

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

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

Zo genoemd:

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

Bovenliggende constructor bellen

Stel dat u een ouderklasse en een kindklasse heeft. Om een Child-instantie te construeren, moet altijd een ouderconstructor worden uitgevoerd bij het begin van de Child-constructor. We kunnen de bovenliggende constructor selecteren door expliciet super(...) aan te roepen met de juiste argumenten als onze eerste instructie voor de constructor van het kind. Door dit te doen, besparen we tijd door de constructor van de bovenliggende klassen opnieuw te gebruiken in plaats van dezelfde code in de constructor van de onderliggende klassen te herschrijven.

Zonder super(...) methode:

(impliciet wordt de no-args-versie super() onzichtbaar genoemd)

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

Met de methode 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
    }
}

Opmerking: aanroepen naar een andere constructor (chaining) of de superconstructor MOET de eerste instructie in de constructor zijn.

Als u de constructor super(...) expliciet aanroept, moet er een overeenkomende constructor van de ouder bestaan (dat is eenvoudig, nietwaar?).

Als u geen super(...) -constructor expliciet aanroept, moet uw bovenliggende klasse een no-args-constructor hebben - en deze kan ofwel expliciet worden geschreven of door de compiler als standaard worden gemaakt als de bovenliggende klasse niet voorziet elke constructeur.

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

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

De klasse Parent heeft geen standaardconstructor, dus de compiler kan geen super toevoegen in de constructor Child. Deze code wordt niet gecompileerd. Je moet de constructors veranderen om aan beide kanten te passen, of je eigen super call schrijven, zoals dat:

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