"Ciao, Amigo! Ora ti parlerò di come si creano gli oggetti."

"Cosa c'è di così complicato, zio Rishi? Scrivi nuovo e il nome della classe, indica il costruttore corretto e il gioco è fatto!"

"È vero. Ma cosa succede all'interno dell'oggetto quando lo fai?"

"Che succede?"

"Questo è ciò che accade: l'oggetto viene creato in più fasi."

1)  Innanzitutto, la memoria viene allocata per tutte le variabili membro della classe.

2)  Quindi la classe base viene inizializzata.

3)  Quindi a tutte le variabili vengono assegnati valori, se ne sono specificati.

4)  Infine, viene chiamato il costruttore.

"Non sembra molto difficile: prima le variabili, poi il costruttore."

"Vediamo come funziona in un esempio con due classi:"

Java webinar
Codice Descrizione 
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; ←-
 }
}
 Dichiara due classi: Pet(pet) e Cat(cat).

Nella classe Cat, vediamo una chiamata esplicita al costruttore della classe base .
Dovrebbe essere sempre sulla prima riga del costruttore.

Ecco cosa succede dopo che la memoria è stata allocata:
18  – chiama il costruttore della classe base.
3, 4  – inizializza le variabili in Pet.
8, 9  – esegue il codice nel costruttore Pet.

Quindi la classe Cat inizia ad essere inizializzata.
14  – inizializza le variabili in Cat
19  – esegue il codice nel costruttore Cat

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

"Questo crea un po' di confusione. Perché è così complicato?"

"In realtà non è difficile se sai cosa sta realmente accadendo:"

Se una classe non ha costruttori, ne verrà creato uno automaticamente.

Costruttore predefinito 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x = 5;
 int y = 5;
 public Cat() 
 {
 }
}

Se non chiami il costruttore della classe base, verrà chiamato automaticamente.

Chiamata del costruttore della classe base 
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();
 }
}

Le variabili membro vengono inizializzate nel costruttore.

Inizializzazione delle variabili membro 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x;
 int y;
 public Cat()
 {
  super();
  this.x = 5;
  this.y = 5;
  }
}
Cosa succede davvero 
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;
 }
}

"Ora è molto più chiaro: prima la classe base, poi le variabili al di fuori del costruttore, poi il codice del costruttore."

"Ben fatto, Amigo! Ecco fatto!"