CodeGym /Corsi /Core Java /Creazione di un oggetto. Ordine di chiamata del costrutto...

Creazione di un oggetto. Ordine di chiamata del costruttore

Core Java

Livello 5, Lezione 5

Disponibile

"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:"

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."