"Bună, Amigo! Acum am să-ți spun despre cum sunt create obiectele."

"Ce este atât de complicat, unchiule Rishi? Scrieți nou și numele clasei, indicați constructorul corect și ați terminat!"

"Asta este adevărat. Dar ce se întâmplă în interiorul obiectului când faci asta?"

"Ce se întâmplă?"

„Iată ce se întâmplă: obiectul este creat în mai multe etape”.

1)  În primul rând, memoria este alocată pentru toate variabilele membre ale clasei.

2)  Apoi clasa de bază este inițializată.

3)  Apoi tuturor variabilelor li se atribuie valori, dacă sunt specificate.

4)  În cele din urmă, constructorul este numit.

„Nu pare foarte dificil: mai întâi variabilele, apoi constructorul”.

„Să vedem cum funcționează acest lucru într-un exemplu cu două clase:”

Java webinar
Cod Descriere 
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; ←-
 }
}
 Declarați două clase: Pet(animal de companie) și Cat(cat).

În clasa Cat, vedem un apel explicit la constructorul clasei de bază .
Ar trebui să fie întotdeauna pe prima linie din constructor.

Iată ce se întâmplă după ce memoria este alocată:
18  – apelați constructorul clasei de bază.
3, 4  – inițializați variabilele în Pet.
8, 9  – executați codul în constructorul Pet.

Apoi clasa Cat începe să fie inițializată.
14  – inițializați variabile în Cat
19  – executați codul în constructorul Cat

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

"Este un pic confuz. De ce este atât de complicat?"

„De fapt, nu este dificil dacă știi ce se întâmplă cu adevărat:”

Dacă o clasă nu are niciun constructor, unul va fi creat automat.

Constructor implicit 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x = 5;
 int y = 5;
 public Cat() 
 {
 }
}

Dacă nu apelați constructorul clasei de bază, acesta va fi apelat automat.

Apelul constructorului clasei de bază 
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();
 }
}

Variabilele membre sunt inițializate în constructor.

Inițializarea variabilelor membre 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x;
 int y;
 public Cat()
 {
  super();
  this.x = 5;
  this.y = 5;
  }
}
Ce se întâmplă cu adevărat 
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;
 }
}

„Acum este mult mai clar: mai întâi clasa de bază, apoi variabilele din afara constructorului, apoi codul constructorului.”

"Bravo, Amigo! Asta e!"