"வணக்கம், அமிகோ! இப்போது பொருள்கள் எவ்வாறு உருவாக்கப்படுகின்றன என்பதைப் பற்றி நான் உங்களுக்குச் சொல்லப் போகிறேன்."

"அதில் என்ன சிக்கலானது, ரிஷி மாமா? நீங்கள் புதிதாகவும் வகுப்பின் பெயரையும் எழுதுகிறீர்கள், சரியான கன்ஸ்ட்ரக்டரைக் குறிப்பிடுகிறீர்கள், நீங்கள் முடித்துவிட்டீர்கள்!"

"அது உண்மை. ஆனால் அதைச் செய்யும்போது பொருளுக்குள் என்ன நடக்கும்?"

"என்ன நடக்கும்?"

"இதுதான் நடக்கும்: பொருள் பல நிலைகளில் உருவாக்கப்படுகிறது."

1)  முதலில், அனைத்து வகுப்பின் உறுப்பினர் மாறிகளுக்கும் நினைவகம் ஒதுக்கப்படுகிறது.

2)  பின்னர் அடிப்படை வகுப்பு துவக்கப்படுகிறது.

3)  பின்னர் அனைத்து மாறிகளுக்கும் மதிப்புகள் ஒதுக்கப்படும், ஏதேனும் குறிப்பிடப்பட்டிருந்தால்.

4)  இறுதியாக, கட்டமைப்பாளர் அழைக்கப்படுகிறார்.

"இது மிகவும் கடினமாகத் தெரியவில்லை: முதலில் மாறிகள், பின்னர் கட்டமைப்பாளர்."

"இரண்டு வகுப்புகளுடன் ஒரு எடுத்துக்காட்டில் இது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்:"

குறியீடு விளக்கம்
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; -
 }
}
இரண்டு வகுப்புகளை அறிவிக்கவும்: செல்லப்பிராணி (செல்லப்பிராணி) மற்றும் பூனை (பூனை).

கேட் வகுப்பில், அடிப்படை வகுப்பின் கட்டமைப்பாளருக்கான வெளிப்படையான அழைப்பைக் காண்கிறோம் .
இது எப்போதும் கன்ஸ்ட்ரக்டரில் முதல் வரியில் இருக்க வேண்டும்.

நினைவகம் ஒதுக்கப்பட்ட பிறகு என்ன நடக்கிறது என்பது இங்கே:
18  - அடிப்படை வகுப்பின் கட்டமைப்பாளரை அழைக்கவும்.
3, 4  - Pet இல் மாறிகளை துவக்கவும்.
8, 9  - பெட் கட்டமைப்பாளரில் குறியீட்டை இயக்கவும்.

பின்னர் பூனை வகுப்பு தொடங்கத் தொடங்குகிறது.
14  - கேட்
19 இல் மாறிகளை துவக்கவும்  - கேட் கட்டமைப்பாளரில் குறியீட்டை இயக்கவும்

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

"அது கொஞ்சம் குழப்பமாக இருக்கிறது. ஏன் இவ்வளவு சிக்கலானது?"

"உண்மையில் என்ன நடக்கிறது என்று உங்களுக்குத் தெரிந்தால் அது கடினம் அல்ல:"

ஒரு வகுப்பில் கன்ஸ்ட்ரக்டர்கள் இல்லை என்றால், ஒன்று தானாகவே உருவாக்கப்படும்.

இயல்புநிலை கட்டமைப்பாளர்
class Cat
{
 int x = 5;
 int y = 5;
}
class Cat
{
 int x = 5;
 int y = 5;
 public Cat() 
 {
 }
}

பேஸ் கிளாஸ் கன்ஸ்ட்ரக்டரை நீங்கள் அழைக்கவில்லை என்றால், அது தானாகவே அழைக்கப்படும்.

அடிப்படை வகுப்பின் கட்டமைப்பாளரின் அழைப்பு
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();
 }
}

கன்ஸ்ட்ரக்டரில் உறுப்பினர் மாறிகள் துவக்கப்படும்.

உறுப்பினர் மாறிகளின் துவக்கம்
class Cat
{
 int x = 5;
 int y = 5;
}
class Cat
{
 int x;
 int y;
 public Cat()
 {
  super();
  this.x = 5;
  this.y = 5;
  }
}
உண்மையில் என்ன நடக்கிறது
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;
 }
}

"இப்போது இது மிகவும் தெளிவாக உள்ளது: முதலில் அடிப்படை வகுப்பு, பின்னர் கட்டமைப்பாளருக்கு வெளியே மாறிகள், பின்னர் கட்டமைப்பாளர் குறியீடு."

"நல்லது, அமிகோ! அவ்வளவுதான்!"