"హలో, అమిగో! ఇప్పుడు నేను మీకు వస్తువులు ఎలా సృష్టించబడతాయో చెప్పబోతున్నాను."

"ఇందులో చాలా సంక్లిష్టత ఏమిటి, రిషీ, మీరు కొత్త మరియు తరగతి పేరు వ్రాసి, సరైన కన్స్ట్రక్టర్‌ను సూచించండి మరియు మీరు పూర్తి చేసారు!"

"అది నిజమే. కానీ మీరు అలా చేసినప్పుడు వస్తువు లోపల ఏమి జరుగుతుంది?"

"ఏం జరుగుతుంది?"

"ఇది జరుగుతుంది: వస్తువు అనేక దశల్లో సృష్టించబడుతుంది."

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

"ఇప్పుడు ఇది చాలా స్పష్టంగా ఉంది: మొదట బేస్ క్లాస్, ఆపై కన్స్ట్రక్టర్ వెలుపల వేరియబుల్స్, ఆపై కన్స్ట్రక్టర్ కోడ్."

"బాగా చేసారు, అమిగో! అంతే!"