Hoe werken klassen, objecten en constructoren?

Question

Accepted Answer

Een **class** is een blauwdruk; een **object** is een instantie die ervan is gemaakt. Een **constructor** is een speciale methode die een nieuw object initialiseert. Samen vormen zij de basis van Java's object-georiënteerde model.

## Waarom het belangrijk is

Klassen, objecten en constructoren zijn de absolute basis van Java-programmering — alles wat je bouwt bestaat uit objecten gemaakt van klassen.

Begrijpen hoe constructoren staat initialiseren (`this`, de rol van het `new` sleutelwoord, constructor overloading en chaining voor flexibele creatie, en de standaardconstructorregel) is essentieel voor het correct maken en initialiseren van objecten.

Deze concepten ondersteunen al het OOP-werk in Java, en constructor gedrag (vooral de verdwijnende standaard en chaining) is een veelvoorkomende bron van zowel interviewvragen als echte bugs.

## Een klasse met een constructor definiëren

```java
public class Person {
    private String name;        // fields (instance variables)
    private int age;

// CONSTRUCTOR — same name as the class, no return type
    public Person(String name, int age) {
        this.name = name;       // `this` distinguishes field from parameter
        this.age = age;
    }

public String greet() {     // method
        return "Hi, I'm " + name;
    }
}
```

De constructor wordt uitgevoerd wanneer u een object aanmaakt en stelt de initiële toestand in. `this` verwijst naar het huidige object en maakt onderscheid tussen velden en parameters met dezelfde naam.

## Objecten aanmaken

```java
Person p = new Person("Ann", 30);   // `new` allocates the object + calls the constructor
p.greet();                           // "Hi, I'm Ann"
```

Het `new` sleutelwoord reserveert geheugen op de heap en roept de constructor aan; `p` bevat een verwijzing naar het nieuwe object.

## Constructor overloading en chaining

```java
public class Person {
    private String name;
    private int age;

public Person(String name, int age) {   // primary constructor
        this.name = name;
        this.age = age;
    }
    public Person(String name) {             // overloaded — different parameters
        this(name, 0);                        // calls the other constructor (chaining)
    }
}
```

U kunt **meerdere constructoren** hebben met verschillende parameterlijsten (overloading), en de ene kan de ander aanroepen met `this(...)` om duplicering van initialisatie te voorkomen.

## De standaardconstructor

```java
public class Empty {
    // no constructor defined → Java provides an implicit no-arg constructor
}
Empty e = new Empty();   // works
// BUT: once you define ANY constructor, the implicit one is gone
```

Als u geen constructor schrijft, levert Java een argumentloze standaard. Zodra u een constructor definieert, verdwijnt die standaard (u moet deze expliciet toevoegen als nodig).