Constructor Overloading in Java – Uitgelegd met Praktische Codevoorbeelden

Wat Is Een Constructor in Java?

Een constructor is een speciale methode die een nieuw aangemaakt object direct na geheugentoewijzing initialiseert. Het stelt de velden van het object in op gewenste waarden of, indien weggelaten, op hun standaardwaarden. Het definiëren van een constructor is optioneel; als er geen geleverd wordt, voorziet de compiler een standaard constructor die de standaardwaarden toekent:

• Numerieke primitieven (int, double, etc.) → 0
• char → '\0'
• Objectreferenties → null

Deze tutorial behandelt:

• Regels voor het maken van constructors
• Constructor overloading
• Constructor chaining

Regels Voor Het Maken Van Een Java Constructor

1. De naam van de constructor moet exact overeenkomen met de klassenaam.
2. Het mag geen return type hebben, niet eens void.

Voorbeeld 1 – Eerste Constructor

Stap 1: Voer de volgende code in je Java editor in.

class Demo {
    int waarde1;
    int waarde2;
    Demo() {
        waarde1 = 10;
        waarde2 = 20;
        System.out.println("Binnen Constructor");
    }
    public void display() {
        System.out.println("Waarde1 === " + waarde1);
        System.out.println("Waarde2 === " + waarde2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        d1.display();
    }
}

Stap 2: Compileer en voer het programma uit. Output:

Binnen Constructor
Waarde1 === 10
Waarde2 === 20

Constructor Overloading in Java

Java stelt een klasse in staat meerdere constructors te definiëren met verschillende parameterlijsten. De compiler onderscheidt ze op basis van het aantal en typen parameters.

Geldige constructors voor een klasse genaamd Rekening kunnen er als volgt uitzien:

Rekening(int a);
Rekening(int a, int b);
Rekening(String a, int b);

Voorbeeld 2 – Overloaded Constructors

Stap 1: Voeg de volgende code in.

class Demo {
    int waarde1;
    int waarde2;
    /* Demo() {
        waarde1 = 10;
        waarde2 = 20;
        System.out.println("Binnen 1e Constructor");
    } */
    Demo(int a) {
        waarde1 = a;
        System.out.println("Binnen 2e Constructor");
    }
    Demo(int a, int b) {
        waarde1 = a;
        waarde2 = b;
        System.out.println("Binnen 3e Constructor");
    }
    public void display() {
        System.out.println("Waarde1 === " + waarde1);
        System.out.println("Waarde2 === " + waarde2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo(30);
        Demo d3 = new Demo(30, 40);
        d1.display();
        d2.display();
        d3.display();
    }
}

Stap 2: Compileer en voer uit. Je zult een fout tegenkomen omdat de standaard constructor Demo() ontbreekt nadat je een parameterized constructor hebt toegevoegd. Om de standaard constructor te gebruiken, declarieer hem expliciet:

Demo() {
    // standaard initialisatie of custom logica
}

Na het uncommenten van het gecommentarieerde blok en hercompileren, draait het programma correct.

Constructor Chaining

Wanneer een subklasse geïnstantieerd wordt, voert de superklasse constructor eerst uit – dit heet constructor chaining.

Voorbeeld 3 – Chaining Tussen Parent en Child

Stap 1: Kopieer de onderstaande code.

class Demo {
    int waarde1;
    int waarde2;
    Demo() {
        waarde1 = 1;
        waarde2 = 2;
        System.out.println("Binnen 1e Parent Constructor");
    }
    Demo(int a) {
        waarde1 = a;
        System.out.println("Binnen 2e Parent Constructor");
    }
    public void display() {
        System.out.println("Waarde1 === " + waarde1);
        System.out.println("Waarde2 === " + waarde2);
    }
    public static void main(String[] args) {
        DemoChild d1 = new DemoChild();
        d1.display();
    }
}
class DemoChild extends Demo {
    int waarde3;
    int waarde4;
    DemoChild() {
        // super(5); // Uncomment om de overloaded parent constructor aan te roepen
        waarde3 = 3;
        waarde4 = 4;
        System.out.println("Binnen de Constructor van Child");
    }
    public void display() {
        System.out.println("Waarde1 === " + waarde1);
        System.out.println("Waarde2 === " + waarde2);
        System.out.println("Waarde3 === " + waarde3);
        System.out.println("Waarde4 === " + waarde4);
    }
}

Stap 2: Voer het programma uit. Omdat de child constructor niet expliciet super() aanroept, draait de standaard Demo() constructor eerst. Verwachte output:

Binnen 1e Parent Constructor
Binnen de Constructor van Child
Waarde1 === 1
Waarde2 === 2
Waarde3 === 3
Waarde4 === 4

Stap 3: Om de overloaded parent constructor Demo(int a) aan te roepen, plaats super(5); als eerste regel in de child constructor. Na uncommenten en opnieuw uitvoeren:

Binnen 2e Parent Constructor
Binnen de Constructor van Child
Waarde1 === 5
Waarde2 === 0
Waarde3 === 3
Waarde4 === 4

Het gebruik van super(...) is verplicht wanneer je een specifieke superklasse constructor nodig hebt voordat de subklasse logica draait.