"Helló, Amigo! Most arról fogok mesélni, hogyan jönnek létre a tárgyak."

"Mi ebben olyan bonyolult, Rishi bácsi? Írsz újat és az osztálynevet, megjelölöd a megfelelő konstruktort, és kész!"

– Ez igaz. De mi történik a tárgy belsejében, amikor ezt megteszed?

"Mi történik?"

"Ez történik: az objektum több szakaszban jön létre."

1)  Először is, a memória le van foglalva az osztály összes tagváltozójához.

2)  Ezután az alaposztály inicializálódik.

3)  Ezután minden változóhoz értéket rendelünk, ha vannak megadva.

4)  Végül a konstruktort meghívjuk.

"Nem tűnik túl nehéznek: először a változók, aztán a konstruktor."

"Nézzük meg, hogyan működik ez egy példán két osztályból:"

Java university
Kód Leírás 
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; ←-
 }
}
 Jelöljön ki két osztályt: kisállat (kisállat) és macska (macska).

A Cat osztályban explicit hívást látunk az alaposztály konstruktorához .
Mindig az első sorban kell lennie a konstruktorban.

Íme, mi történik a memória lefoglalása után:
18  – hívja meg az alaposztály konstruktorát.
3, 4  – változók inicializálása a Pet.
8, 9  – a kód végrehajtása a Pet konstruktorban.

Ezután megkezdődik a Cat osztály inicializálása.
14  – változók inicializálása a Cat
19- ben  – a kód végrehajtása a Cat konstruktorban

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

"Ez egy kicsit zavaró. Miért olyan bonyolult?"

"Tulajdonképpen nem nehéz, ha tudod, mi történik valójában:"

Ha egy osztálynak nincs konstruktora, akkor automatikusan létrejön egy.

Alapértelmezett konstruktor 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x = 5;
 int y = 5;
 public Cat() 
 {
 }
}

Ha nem hívja meg az alaposztály konstruktorát, akkor az automatikusan meghívódik.

Az alaposztály konstruktorának hívása 
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();
 }
}

A tagváltozók inicializálása a konstruktorban történik.

Tagváltozók inicializálása 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x;
 int y;
 public Cat()
 {
  super();
  this.x = 5;
  this.y = 5;
  }
}
Mi történik valójában 
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;
 }
}

"Most már sokkal egyértelműbb: először az alaposztály, majd a konstruktoron kívüli változók, majd a konstruktor kód."

"Jól van, Amigo! Ez az!"