"नमस्कार, अमीगो! अब मैं आपको यह बताने जा रहा हूँ कि वस्तुएँ कैसे बनाई जाती हैं।"

"इसमें इतना जटिल क्या है, अंकल ऋषि? आप नया और क्लास का नाम लिखें, सही कंस्ट्रक्टर का संकेत दें, और आपका काम हो गया!"

"यह सच है। लेकिन जब आप ऐसा करते हैं तो वस्तु के अंदर क्या होता है?"

"क्या होता है?"

"ऐसा होता है: वस्तु कई चरणों में बनाई जाती है।"

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;
 }
}

"अब यह बहुत अधिक स्पष्ट है: पहले बेस क्लास, फिर कंस्ट्रक्टर के बाहर वेरिएबल्स, फिर कंस्ट्रक्टर कोड।"

"शाबाश, अमीगो! बस!"