"हॅलो, अमिगो! आता मी तुम्हाला वस्तू कशा तयार केल्या जातात याबद्दल सांगणार आहे."

"काका ऋषी, यात इतके क्लिष्ट काय आहे? तुम्ही नवीन आणि वर्गाचे नाव लिहा, योग्य रचनाकार दर्शवा आणि तुमचे काम पूर्ण झाले!"

"ते खरे आहे. पण जेव्हा तुम्ही असे करता तेव्हा वस्तूच्या आत काय होते?"

"काय होतं?"

"हे असे होते: ऑब्जेक्ट अनेक टप्प्यात तयार केला जातो."

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  - पेट मध्ये व्हेरिएबल्स इनिशियल करा.
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;
 }
}

"आता ते अधिक स्पष्ट झाले आहे: प्रथम बेस क्लास, नंतर कन्स्ट्रक्टरच्या बाहेरील व्हेरिएबल्स, नंतर कन्स्ट्रक्टर कोड."

"शाबास, अमिगो! बस्स!"