"Hallo, Amigo! Nu ga ik je vertellen hoe objecten worden gemaakt."

"Wat is er zo ingewikkeld aan, oom Rishi? Je schrijft new en de klassenaam, geeft de juiste constructor aan en je bent klaar!"

"Dat is waar. Maar wat gebeurt er in het object als je dat doet?"

"Wat gebeurt er?"

"Dit is wat er gebeurt: het object wordt in verschillende fasen gemaakt."

1)  Eerst wordt er geheugen toegewezen voor alle lidvariabelen van de klasse.

2)  Vervolgens wordt de basisklasse geïnitialiseerd.

3)  Vervolgens krijgen alle variabelen waarden toegewezen, als die zijn opgegeven.

4)  Ten slotte wordt de constructor aangeroepen.

"Het ziet er niet heel moeilijk uit: eerst de variabelen, dan de constructor."

Java webinar

"Laten we eens kijken hoe dit werkt in een voorbeeld met twee klassen:"

Code Beschrijving 
class Pet
{
 int x = 5, y = 5; ←-
 int weight = 10; ←-

 Pet(int x, int y)
 {
  this.x = x; ←-
  this.y = y; ←-
 }
}
class Cat extends Pet
{
 int tailLength = 8; ←-
 int age;
 Cat(int x, int y, int age)
 {
  super(x, y); ←-
  this.age = age; ←-
 }
}
 Declareer twee klassen: Pet(pet) en Cat(cat).

In de klasse Cat zien we een expliciete aanroep naar de constructor van de basisklasse .
Het moet altijd op de eerste regel in de constructor staan.

Dit is wat er gebeurt nadat het geheugen is toegewezen:
18  – bel de constructor van de basisklasse.
3, 4  – initialiseer variabelen in Pet.
8, 9  – voer de code uit in de Pet-constructor.

Vervolgens wordt de Cat-klasse geïnitialiseerd.
14  – initialiseer variabelen in Cat
19  – voer de code uit in de Cat-constructor

 
public static void main(String[] args)
{
 Cat cat = new Cat (50, 50, 5);
}

"Dat is een beetje verwarrend. Waarom is het zo ingewikkeld?"

"Het is eigenlijk niet moeilijk als je weet wat er echt aan de hand is:"

Als een klasse geen constructors heeft, wordt er automatisch een gemaakt.

Standaard constructeur 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x = 5;
 int y = 5;
 public Cat() 
 {
 }
}

Als u de constructor van de basisklasse niet aanroept, wordt deze automatisch aangeroepen.

Aanroep van de constructor van de basisklasse 
class Pet
{
 public String name;
}
 
class Pet extends Object
{
 public String name;
 public Pet()
 {
  super();
 }
}
 
class Cat extends Pet
{
 int x = 5;
 int y = 5;
}
 
class Cat extends Pet
{
 int x = 5;
 int y = 5;
 public Cat()
 {
  super();
 }
}

Lidvariabelen worden geïnitialiseerd in de constructor.

Initialisatie van lidvariabelen 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x;
 int y;
 public Cat()
 {
  super();
  this.x = 5;
  this.y = 5;
  }
}
Wat gebeurt er echt 
class Pet
{
 int x = 5, y = 5;
 int weight = 10;
 Pet(int x, int y)
 {
  this.x = x;
  this.y = y;
 }
}

class Cat extends Pet
{
 int tailLength = 8;
 int age;
 Cat(int x, int y, int age)
 {
  super(x, y);
  this.age = age;
 }
}
 
class Pet extends Object
{
 int x;
 int y;
 int weight;

 Pet(int x, int y)
 {
  //call of the base class's constructor
  super();
  //initialize variables
  this.x = 5;
  this.y = 5;
  this.weight = 10;
  //execute the constructor code
  this.x = x;
  this.y = y;
 }
}
class Cat extends Pet
{
 int tailLength;
 int age;
 Cat(int x, int y, int age)
 {
  //call of the base class's constructor
   super(x, y);
  //initialize variables
  this.tailLength = 8;
  //execute the constructor code
  this.age = age;
 }
}

"Nu is het veel duidelijker: eerst de basisklasse, dan variabelen buiten de constructor, dan de constructorcode."

"Goed gedaan, Amigo! Dat is het!"