Java-constructors

In deze tutorial leren we over Java-constructors, hun typen en hoe je ze gebruikt met behulp van voorbeelden.

Wat is een Constructor?

Een constructor in Java lijkt op een methode die aangeroepen wordt wanneer een object van de klasse wordt aangemaakt.

In tegenstelling tot Java-methodes heeft een constructor dezelfde naam als de klasse en heeft geen return-type. Bijvoorbeeld,

class Test {
    Test() {
        // constructor body
    }
}

Hier is Test() een constructor. Het heeft dezelfde naam als de klasse en heeft geen return-type.

Aanbevolen lezing: Waarom constructors geen waarden retourneren

---

Voorbeeld 1: Java-constructor

class Main {
    private String name;
    // constructor
    Main() {
        System.out.println("Constructor aangeroepen:");
        name = "Programiz";
    }
    public static void main(String[] args) {
        // constructor wordt aangeroepen tijdens
        // het aanmaken van een object van de Main-klasse
        Main obj = new Main();
        System.out.println("De naam is " + obj.name);
    }
}

Output:

Constructor aangeroepen:
De naam is Programiz

In het bovenstaande voorbeeld hebben we een constructor genaamd Main() aangemaakt. Binnen de constructor initialiseren we de waarde van de name-variabele.

Let op de statement voor het aanmaken van een object van de Main-klasse.

Main obj = new Main();

Hier wordt de Main()-constructor aangeroepen wanneer het object wordt aangemaakt. En de waarde van de name-variabele wordt geïnitialiseerd.

Daarom print het programma de waarde van de name-variabele als Programiz.

---

Typen Constructors

In Java kunnen constructors in 3 typen verdeeld worden:

1. No-Arg Constructor
2. Parameterized Constructor
3. Default Constructor

---

1. Java No-Arg Constructors

Vergelijkbaar met methodes kan een Java-constructor wel of geen parameters (argumenten) hebben.

Als een constructor geen parameters accepteert, heet het een no-argument constructor. Bijvoorbeeld,

private Constructor() {
    // body of the constructor
}

---

Voorbeeld 2: Java private no-arg constructor

class Main {
    int i;
    // constructor zonder parameter
    private Main() {
        i = 5;
        System.out.println("Constructor wordt aangeroepen");
    }
    public static void main(String[] args) {
        // constructor aanroepen zonder parameter
        Main obj = new Main();
        System.out.println("Waarde van i: " + obj.i);
    }
}

Output:

Constructor wordt aangeroepen
Waarde van i: 5

In het bovenstaande voorbeeld hebben we een constructor Main() aangemaakt. Hier accepteert de constructor geen parameters. Daarom heet het een no-arg constructor.

Let op dat we de constructor als private gedeclareerd hebben.

Eenmaal een constructor gedeclareerd als private, kan deze niet vanaf buiten de klasse benaderd worden. Dus het aanmaken van objecten vanaf buiten de klasse is verboden met de private constructor.

Hier creëren we het object binnen dezelfde klasse. Daarom kan het programma de constructor benaderen. Lees meer: Java Implement Private Constructor.

Als we echter objecten buiten de klasse willen aanmaken, moeten we de constructor als public declareren.

Voorbeeld 3: Java public no-arg constructors

class Company {
    String name;
    // public constructor
    public Company() {
        name = "Programiz";
    }
}
class Main {
    public static void main(String[] args) {
        // object wordt aangemaakt in een andere klasse
        Company obj = new Company();
        System.out.println("Bedrijfsnaam = " + obj.name);
    }
}

Output:

Bedrijfsnaam = Programiz

Aanbevolen lezing: Java Access Modifier

---

2. Java Parameterized Constructor

Een Java-constructor kan ook een of meer parameters accepteren. Zulke constructors heten parameterized constructors (constructor met parameters).

Voorbeeld 4: Parameterized constructor

class Main {
    String languages;
    // constructor die enkele waarde accepteert
    Main(String lang) {
        languages = lang;
        System.out.println(languages + " Programmeertaal");
    }
    public static void main(String[] args) {
        // constructor aanroepen door een enkele waarde door te geven
        Main obj1 = new Main("Java");
        Main obj2 = new Main("Python");
        Main obj3 = new Main("C");
    }
}

Output:

Java Programmeertaal
Python Programmeertaal
C Programmeertaal

In het bovenstaande voorbeeld hebben we een constructor genaamd Main() aangemaakt. Hier neemt de constructor een enkele parameter. Let op de expressie,

Main obj1 = new Main("Java");

Hier geven we een enkele waarde door aan de constructor. Op basis van het doorgegeven argument wordt de language-variabele binnen de constructor geïnitialiseerd.

---

3. Java Default Constructor

Als we geen constructor aanmaken, creëert de Java-compiler automatisch een no-arg constructor tijdens de uitvoering van het programma. Deze constructor heet default constructor.

Voorbeeld 5: Default Constructor

class Main {
    int a;
    boolean b;
    public static void main(String[] args) {
        // Een default constructor wordt aangeroepen
        Main obj = new Main();
        System.out.println("Standaardwaarde:");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

Output:

a = 0
b = false

Hier hebben we geen constructors aangemaakt. Daarom creëert de Java-compiler automatisch de default constructor.

De default constructor initialiseert niet-geïnitialiseerde instance-variabelen met standaardwaarden.

Type	Standaardwaarde
boolean	false
byte	0
short	0
int	0
long	0L
char	\u0000
float	0.0f
double	0.0d
object	Referentie null

In het bovenstaande programma worden de variabelen a en b geïnitialiseerd met standaardwaarde 0 en false respectievelijk.

Het bovenstaande programma is equivalent aan:

class Main {
    int a;
    boolean b;
    // een private constructor
    private Main() {
        a = 0;
        b = false;
    }
    public static void main(String[] args) {
        // constructor aanroepen
        Main obj = new Main();
        System.out.println("Standaardwaarde:");
        System.out.println("a = " + obj.a);
        System.out.println("b = " + obj.b);
    }
}

De output van het programma is hetzelfde als Voorbeeld 5.

---

Belangrijke opmerkingen over Java-constructors

• Constructors worden impliciet aangeroepen wanneer je objecten instantieert.
• Twee regels voor het aanmaken van een constructor:
  De naam van de constructor moet hetzelfde zijn als de klasse.
  Een Java-constructor mag geen return-type hebben.
• Als een klasse geen constructor heeft, creëert de Java-compiler automatisch een default constructor tijdens runtime. De default constructor initialiseert instance-variabelen met standaardwaarden. Bijv. de int-variabele wordt geïnitialiseerd op 0.
• Constructor-typen:
  No-Arg Constructor - een constructor die geen argumenten accepteert
  Parameterized constructor - een constructor die argumenten accepteert
  Default Constructor - een constructor die automatisch door de Java-compiler wordt aangemaakt als deze niet expliciet gedefinieerd is.
• Een constructor kan niet abstract, static of final zijn.
• Een constructor kan overloaded worden maar niet overridden.

---

Constructor-overloading in Java

Vergelijkbaar met Java-method-overloading kunnen we ook twee of meer constructors met verschillende parameters aanmaken. Dit heet constructor-overloading.

Voorbeeld 6: Java Constructor Overloading

class Main {
    String language;
    // constructor zonder parameter
    Main() {
        this.language = "Java";
    }
    // constructor met een enkele parameter
    Main(String language) {
        this.language = language;
    }
    public void getName() {
        System.out.println("Programmeertaal: " + this.language);
    }
    public static void main(String[] args) {
        // constructor zonder parameter aanroepen
        Main obj1 = new Main();
        // constructor met een enkele parameter aanroepen
        Main obj2 = new Main("Python");
        obj1.getName();
        obj2.getName();
    }
}

Output:

Programmeertaal: Java
Programmeertaal: Python

In het bovenstaande voorbeeld hebben we twee constructors: Main() en Main(String language). Hier initialiseren beide constructors de waarde van de variabele language met verschillende waarden.

Op basis van de parameter die tijdens objectcreatie wordt doorgegeven, worden verschillende constructors aangeroepen en verschillende waarden toegewezen.

Het is ook mogelijk om één constructor vanuit een andere constructor aan te roepen. Lees meer: Java Call One Constructor from Another.

Let op: We hebben het this-keyword gebruikt om de variabele van de klasse aan te duiden. Meer over this keyword: Java this keyword.