"Hello, Amigo! Ngayon sasabihin ko sa iyo kung paano nilikha ang mga bagay."

"Ano ang kumplikado tungkol dito, Tiyo Rishi? Sumulat ka ng bago at ang pangalan ng klase, ipahiwatig ang tamang constructor, at tapos ka na!"

"Totoo yan. Pero ano ang nangyayari sa loob ng bagay kapag ginawa mo iyon?"

"Anong nangyayari?"

"Ito ang nangyayari: Ang bagay ay nilikha sa maraming yugto."

1)  Una, ang memorya ay inilalaan para sa lahat ng mga variable ng miyembro ng klase.

2)  Pagkatapos ay ang batayang klase ay pinasimulan.

3)  Pagkatapos ang lahat ng mga variable ay nakatalaga ng mga halaga, kung mayroon man ay tinukoy.

4)  Sa wakas, tinawag ang tagabuo.

"Hindi ito mukhang napakahirap: una ang mga variable, pagkatapos ay ang tagabuo."

Java webinar

"Tingnan natin kung paano ito gumagana sa isang halimbawa na may dalawang klase:"

Code Paglalarawan 
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; ←-
 }
}
 Ideklara ang dalawang klase: Pet(pet) at Cat(cat).

Sa klase ng Cat, nakikita natin ang isang tahasang tawag sa constructor ng base class .
Dapat palaging nasa unang linya sa constructor.

Narito kung ano ang mangyayari pagkatapos ilaan ang memorya:
18  – tawagan ang tagabuo ng batayang klase.
3, 4  – simulan ang mga variable sa Pet.
8, 9  – i-execute ang code sa Pet constructor.

Pagkatapos ay magsisimulang masimulan ang klase ng Cat.
14  – simulan ang mga variable sa Cat
19  – isagawa ang code sa Cat constructor

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

"Medyo nakakalito. Bakit ba napakakomplikado?"

"Hindi talaga mahirap kung alam mo kung ano talaga ang nangyayari:"

Kung ang isang klase ay walang anumang mga konstruktor, ang isa ay awtomatikong malilikha.

Default na tagabuo 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x = 5;
 int y = 5;
 public Cat() 
 {
 }
}

Kung hindi mo tatawagan ang base class constructor, awtomatiko itong tatawagin.

Tawag ng constructor ng base class 
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();
 }
}

Ang mga variable ng miyembro ay sinisimulan sa constructor.

Pagsisimula ng mga variable ng miyembro 
class Cat
{
 int x = 5;
 int y = 5;
}
 
class Cat
{
 int x;
 int y;
 public Cat()
 {
  super();
  this.x = 5;
  this.y = 5;
  }
}
Kung ano talaga ang nangyayari 
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;
 }
}

"Ngayon ito ay mas malinaw: una ang base class, pagkatapos ay mga variable sa labas ng constructor, pagkatapos ay ang constructor code."

"Magaling, Amigo! Ayan na!"