Iedere klasse heeft een constructor. Een constructor is de code die wordt uitgevoerd als het object gecreëerd of geconstrueerd wordt met de new-operator. Deze code wordt gebruik om het object te initialiseren. Een constructor lijkt op een gewone methode maar heeft geen return-type en de naam komt overeen met de klasse-naam. Bovendien kan deze code maar eenmaal opgeroepen worden, namelijk tijdens de constructie van het object.
De definitie van de constructor ziet er als volgt uit:
[public | private | protected] ClassName(parameters) {
// Initialisatie van het object
}
Een klasse kan meerdere constructors hebben die verschillen in het aantal en/of het type van de parameters. Men noemt dit constructor overloading. Afhankelijk van de parameters zal de compiler de juiste constructor gebruiken.
Indien een constructor niet expliciet gedefinieerd wordt, krijgt de klasse een standaard-constructor zonder parameters. Zodra een constructor gespecificeerd wordt, vervalt deze standaard-constructor en moet die dan eventueel explicit gedeclareerd worden.
Het toegangsniveau van de constructor wordt bepaald door de componenten public
, private
of protected
. Indien geen expliciet toegangsniveau wordt gespecifieerd, geld het niveau package.
Component | Beschrijving |
public | Iedere andere klasse kan een object maken van deze klasse door middel van deze constructor. |
private | Geen enkele andere klasse kan een object maken van deze klasse door middel van deze constructor. De klasse zelf kan deze constructor wel gebruiken. |
protected | Enkel subklassen en pakketklassen kunnen deze constructor gebruiken. |
- (package) | Enkel klassen binnen hetzelfde pakket kunnen deze constructor gebruiken |
Deze constructor wordt opgeroepen als we een nieuw object maken van deze klasse
ClassName newObject = new ClassName(parameters)
We gaan ons voorbeeld van de rechthoek twee constructors toevoegen. Eentje zonder parameters en eentje die de hoogte en breedte als parameter neemt.
public class Rectangle {
private int x;
private int y;
private int height;
private int width;
public Rectangle() {
}
public Rectangle(int width, int height) {
setWidth(width);
setHeight(height);
}
...
}
De eerste constructor heeft geen parameters. De tweede constructor heeft als parameter de hoogte en breedte van de rechthoek.
Merk op dat we voor het instellen van de breedte en hoogte de methoden setWidth()
en setHeight()
oproepen. Dit zorgt ervoor dat ook hier de controle op negatieve waarden gebeurt. Eventueel kunnen we ook heir de this
-referentie gebruiken:
public Rectangle(int width, int height) {
this.setWidth(width);
this.setHeight(height);
}
We roepen hier namelijk een methode op van het huidige object.
We kunnen dus een nieuwe rechthoek op twee manieren creëren:
public class RectangleApp {
public static void main(String[] args){
Rectangle rect1 = new Rectangle();
Rectangle rect2 = new Rectangle(4,12);
}
}
Naargelang het aantal en type van de parameters wordt de juiste constructor gebruikt.
In ons voorbeeld hebben we inmiddels vier constructors.
Het is mogelijk om een constructor een andere constructer te laten aanroepen met de nodige (standaard) parameters. Hiervoor gebruikt men de referentievariabele this
.
De constructor zonder parameters kunnen we dus als volgt schrijven:
public class Rectangle {
...
public Rectangle() {
this(0,0)
}
public Rectangle(int width, int height) {
setWidth(width);
setHeight(height);
setPosition(0, 0);
}
...
}
Door het statement this(0, 0);
wordt dus eerst de constructor met de hoogte en de breedte aangeroepen. Nadien zou de constructer zelf nog een aantal dingen kunnen doen.
Het voordeel hiervan is dat de eigenlijke code voor het initialiseren van het object maar op één plaats geschreven hoeft te worden. Dit maakt de code compacter en overzichtelijker en vermindert ook het risico op fouten als de code later aangepast moet worden. Aanpassingen moeten namelijk gebeuren in één constructor in plaats van in elke constructor. We gaan hier later nog een voorbeeld van zien.
Opmerking: Indien een constructor een andere constructor aanroept, moet dit steeds op de eerste regel van het codeblok gebeuren.