బేస్ క్లాస్ కన్స్ట్రక్టర్లు

హాయ్! చివరిసారి మేము కన్స్ట్రక్టర్ల గురించి మాట్లాడాము మరియు వారి గురించి చాలా నేర్చుకున్నాము. ఇప్పుడు మనం బేస్ క్లాస్ కన్స్ట్రక్టర్ల గురించి మాట్లాడబోతున్నాం . బేస్ క్లాస్ అంటే ఏమిటి ? జావాలో అనేక విభిన్న తరగతులు ఉమ్మడి మూలాన్ని కలిగి ఉండవచ్చనే వాస్తవంతో ఇది సంబంధం కలిగి ఉంటుంది. దీనినే వారసత్వం అంటారు . అనేక పిల్లల తరగతులకు ఒక సాధారణ పూర్వీకుడు ఉండవచ్చు. ఉదాహరణకు, మనకు ఒక Animalతరగతి ఉందని ఊహించుకోండి:

public class Animal {

   String name;
   int age;
}

మేము 2 పిల్లల తరగతులను ప్రకటించగలము: Catమరియు Dog. ఇది విస్తారిత కీవర్డ్ ఉపయోగించి చేయబడుతుంది .

public class Cat extends Animal {

}

public class Dog extends Animal {

}

భవిష్యత్తులో ఇది ఉపయోగకరంగా ఉండవచ్చు. ఉదాహరణకు, ఎలుకలను పట్టుకునే పని ఉంటే, మేము Cat మా ప్రోగ్రామ్‌లో ఒక వస్తువును సృష్టిస్తాము. కర్రను వెంబడించడమే పని అయితే, మేము ఒక Dog వస్తువును ఉపయోగిస్తాము. మరియు మేము వెటర్నరీ క్లినిక్‌ని అనుకరించే ప్రోగ్రామ్‌ను రూపొందించినట్లయితే, అది తరగతితో పని చేస్తుంది Animal (అందువలన పిల్లులు మరియు కుక్కలు రెండింటికీ చికిత్స చేయగలదు). ఒక వస్తువు సృష్టించబడినప్పుడు, దాని బేస్ క్లాస్ యొక్క కన్స్ట్రక్టర్ మొదటగా పిలువబడుతుందని గుర్తుంచుకోవడం చాలా ముఖ్యం . ఆ కన్స్ట్రక్టర్ పూర్తయిన తర్వాత మాత్రమే ప్రోగ్రామ్ మనం క్రియేట్ చేస్తున్న ఆబ్జెక్ట్‌కు సంబంధించిన క్లాస్ యొక్క కన్స్ట్రక్టర్‌ని ఎగ్జిక్యూట్ చేస్తుంది. మరో మాటలో చెప్పాలంటే, ఆబ్జెక్ట్‌ను సృష్టించేటప్పుడు Cat, కన్స్ట్రక్టర్ Animalమొదట అమలు చేయబడుతుంది మరియు తర్వాత మాత్రమేCatకన్స్ట్రక్టర్ అమలు చేయబడింది . దీన్ని చూడటానికి, Catమరియు Animalకన్‌స్ట్రక్టర్‌లకు కొంత కన్సోల్ అవుట్‌పుట్ జోడించండి.

public class Animal {

   public Animal() {
       System.out.println("Animal constructor executed");
   }
}


public class Cat extends Animal {

   public Cat() {
       System.out.println("Cat constructor executed!");
   }

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

కన్సోల్ అవుట్‌పుట్: యానిమల్ కన్‌స్ట్రక్టర్ ఎగ్జిక్యూట్ చేయబడింది క్యాట్ కన్‌స్ట్రక్టర్ ఎగ్జిక్యూట్ చేయబడింది! నిజానికి, ఇది ఆ విధంగా పని చేస్తుంది! ఎందుకు? రెండు తరగతుల మధ్య భాగస్వామ్యం చేయబడిన ఫీల్డ్‌లను నకిలీ చేయడాన్ని నివారించడం ఒక కారణం. ఉదాహరణకు, ప్రతి జంతువుకు గుండె మరియు మెదడు ఉంటుంది, కానీ ప్రతి జంతువుకు తోక ఉండదు. మేము మాతృ తరగతిలో అన్ని జంతువులకు సాధారణమైన మెదడు మరియు గుండెAnimal క్షేత్రాలను మరియు సబ్‌క్లాస్‌లో టెయిల్ ఫీల్డ్‌ను ప్రకటించవచ్చు Cat. . Catఇప్పుడు మేము మొత్తం 3 ఫీల్డ్‌లకు ఆర్గ్యుమెంట్‌లను తీసుకునే క్లాస్ కన్‌స్ట్రక్టర్‌ని ప్రకటిస్తాము .

public class Cat extends Animal {

   String tail;

   public Cat(String brain, String heart, String tail) {
       this.brain = brain;
       this.heart = heart;
       this.tail = tail;
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

గమనిక: తరగతికి Catమెదడు మరియు హృదయ క్షేత్రాలు లేనప్పటికీ కన్స్ట్రక్టర్ సరిగ్గా పని చేస్తుంది . Animalఈ ఫీల్డ్‌లు బేస్ క్లాస్ నుండి "అనువంశికంగా" పొందబడ్డాయి . ఇన్‌హెరిటింగ్ క్లాస్‌కి బేస్ క్లాస్ ఫీల్డ్‌లకు యాక్సెస్ ఉందిCat , కాబట్టి అవి మా క్లాస్‌లో కనిపిస్తాయి . ఫలితంగా, మేము ఈ ఫీల్డ్‌లను తరగతిలో నకిలీ చేయాల్సిన అవసరం లేదు Cat. మేము వాటిని తరగతి నుండి తీసుకోవచ్చు Animal. ఇంకా ఏమిటంటే, మేము చైల్డ్ క్లాస్ కన్‌స్ట్రక్టర్‌లో బేస్ క్లాస్ కన్‌స్ట్రక్టర్‌ని స్పష్టంగా పిలుస్తాము. బేస్ క్లాస్‌ని " సూపర్ క్లాస్ " అని కూడా అంటారు. అందుకే జావా బేస్ క్లాస్‌ని సూచించడానికి సూపర్ అనే కీవర్డ్‌ని ఉపయోగిస్తుంది. మునుపటి ఉదాహరణలో

public Cat(String brain, String heart, String tail) {
       this.brain = brain;
       this.heart = heart;
       this.tail = tail;
   }

మేము మా పేరెంట్ క్లాస్‌లోని ప్రతి ఫీల్డ్‌ను విడిగా కేటాయించాము. వాస్తవానికి మనం దీన్ని చేయవలసిన అవసరం లేదు. పేరెంట్ క్లాస్ కన్‌స్ట్రక్టర్‌కి కాల్ చేసి, అవసరమైన ఆర్గ్యుమెంట్‌లను పాస్ చేస్తే సరిపోతుంది:

public class Animal {

   String brain;
   String heart;

   public Animal(String brain, String heart) {
       this.brain = brain;
       this.heart = heart;
   }

public class Cat extends Animal {

   String tail;

   public Cat(String brain, String heart, String tail) {
       super(brain, heart);
       this.tail = tail;
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

కన్స్ట్రక్టర్‌లో Cat, మేము Animalకన్స్ట్రక్టర్‌ని పిలిచి, రెండు ఫీల్డ్‌లను పాస్ చేసాము. స్పష్టంగా ప్రారంభించడానికి మాకు ఒకే ఒక ఫీల్డ్ ఉంది: తోక , ఇది లో లేదు Animal. ఆబ్జెక్ట్‌ని సృష్టించినప్పుడు పేరెంట్ క్లాస్ కన్‌స్ట్రక్టర్‌ని మొదట పిలుస్తారని మేము పేర్కొన్నట్లు గుర్తుందా? అందుకే కన్స్ట్రక్టర్‌లో సూపర్() ఎల్లప్పుడూ మొదటి స్థానంలో ఉండాలి! లేకపోతే, కన్స్ట్రక్టర్ లాజిక్ ఉల్లంఘించబడుతుంది మరియు ప్రోగ్రామ్ లోపాన్ని సృష్టిస్తుంది.

public class Cat extends Animal {

   String tail;

   public Cat(String brain, String heart, String tail) {
       this.tail = tail;
       super(brain, heart);// Error!
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

చైల్డ్ క్లాస్ యొక్క ఆబ్జెక్ట్ సృష్టించబడినప్పుడు, బేస్ క్లాస్ కన్స్ట్రక్టర్‌ని మొదట పిలుస్తారని కంపైలర్‌కు తెలుసు. మరియు మీరు ఈ ప్రవర్తనను మాన్యువల్‌గా మార్చడానికి ప్రయత్నిస్తే, కంపైలర్ దానిని అనుమతించదు.

ఒక వస్తువు ఎలా సృష్టించబడుతుంది

మేము మునుపు బేస్ మరియు పేరెంట్ క్లాస్‌తో ఒక ఉదాహరణను చూసాము: Animalమరియు Cat. ఈ రెండు తరగతులను ఉదాహరణలుగా ఉపయోగించి, ఇప్పుడు మనం ఆబ్జెక్ట్‌ని సృష్టించడం మరియు వేరియబుల్‌లను ప్రారంభించే ప్రక్రియను పరిశీలిస్తాము. స్టాటిక్ మరియు ఇన్‌స్టాన్స్ (నాన్-స్టాటిక్) వేరియబుల్స్ ఉన్నాయని మాకు తెలుసు . Animalబేస్ క్లాస్‌కు వేరియబుల్స్ ఉన్నాయని మరియు Catచైల్డ్ క్లాస్‌కు దాని స్వంతం ఉందని కూడా మాకు తెలుసు . Animalస్పష్టత కోసం, మేము మరియు తరగతులకు ఒక్కో స్టాటిక్ వేరియబుల్‌ని జోడిస్తాము Cat. తరగతిలోని జంతువుల గణన వేరియబుల్ భూమిపై ఉన్న మొత్తం జంతు జాతుల సంఖ్య మరియు క్యాట్‌కౌంట్‌నిAnimal సూచిస్తుందివేరియబుల్ పిల్లి జాతుల సంఖ్యను సూచిస్తుంది. అదనంగా, మేము రెండు తరగతులలోని అన్ని నాన్-స్టాటిక్ వేరియబుల్స్‌కు ప్రారంభ విలువలను కేటాయిస్తాము (అది కన్స్ట్రక్టర్‌లో మార్చబడుతుంది).

public class Animal {

   String brain = "Initial value of brain in the Animal class";
   String heart = "Initial value of heart in the Animal class";

   public static int animalCount = 7700000;

   public Animal(String brain, String heart) {
       System.out.println("Animal base class constructor is running");
       System.out.println("Have the variables of the Animal class already been initialized?");
       System.out.println("Current value of static variable animalCount = " + animalCount);
       System.out.println("Current value of brain in the Animal class = " + this.brain);
       System.out.println("Current value of heart in the Animal class = " + this.heart);
       System.out.println("Have the variables of the Cat class already been initialized?");
       System.out.println("Current value of static variable catCount = " + Cat.catCount);

       this.brain = brain;
       this.heart = heart;
       System.out.println("Animal base class constructor is done!");
       System.out.println("Current value of brain = " + this.brain);
       System.out.println("Current value of heart = " + this.heart);
   }
}

public class Cat extends Animal {

   String tail = "Initial value of tail in the Cat class";

   static int catCount = 37;

   public Cat(String brain, String heart, String tail) {
       super(brain, heart);
       System.out.println("The cat class constructor has started (The Animal constructor already finished)");
       System.out.println("Current value of static variable catCount = " + catCount);
       System.out.println("Current value of tail = " + this.tail);
       this.tail = tail;
       System.out.println("Current value of tail = " + this.tail);
   }

   public static void main(String[] args) {
       Cat cat = new Cat("Brain", "Heart", "Tail");
   }
}

కాబట్టి మేము క్లాస్ యొక్క కొత్త ఉదాహరణను సృష్టిస్తున్నాము Cat, ఇది వారసత్వంగా వస్తుంది Animal. ఏమి జరుగుతుందో మరియు ఏ క్రమంలో జరుగుతుందో చూడటానికి మేము కొన్ని వివరణాత్మక కన్సోల్ అవుట్‌పుట్‌ని జోడించాము. Catవస్తువు సృష్టించబడినప్పుడు ఇది ప్రదర్శించబడుతుంది :యానిమల్ బేస్ క్లాస్ కన్స్ట్రక్టర్ రన్ అవుతోంది యానిమల్ క్లాస్ యొక్క వేరియబుల్స్ ఇప్పటికే ప్రారంభించబడిందా? స్టాటిక్ వేరియబుల్ జంతువు యొక్క ప్రస్తుత విలువ గణన = 7700000 జంతు తరగతిలో మెదడు యొక్క ప్రస్తుత విలువ = జంతు తరగతిలో మెదడు యొక్క ప్రారంభ విలువ జంతు తరగతిలో గుండె యొక్క ప్రస్తుత విలువ = జంతు తరగతిలో గుండె యొక్క ప్రారంభ విలువ ఇప్పటికే క్యాట్ క్లాస్ యొక్క వేరియబుల్స్ కలిగి ఉంది ప్రారంభించబడిందా? స్టాటిక్ వేరియబుల్ catCount = 37 యానిమల్ బేస్ క్లాస్ కన్స్ట్రక్టర్ యొక్క ప్రస్తుత విలువ పూర్తయింది! మెదడు యొక్క ప్రస్తుత విలువ = మెదడు ప్రస్తుత విలువ గుండె = గుండె పిల్లి తరగతి కన్స్ట్రక్టర్ ప్రారంభమైంది (జంతు కన్స్ట్రక్టర్ ఇప్పటికే పూర్తయింది) స్టాటిక్ వేరియబుల్ ప్రస్తుత విలువ catCount = 37 తోక యొక్క ప్రస్తుత విలువ = పిల్లి తరగతిలో తోక యొక్క ప్రారంభ విలువ తోక ప్రస్తుత విలువ = తోక కాబట్టి, ఇప్పుడు మనం కొత్త వస్తువు సృష్టించబడినప్పుడు వేరియబుల్ ఇనిషియలైజేషన్ మరియు కన్స్ట్రక్టర్ కాల్‌ల క్రమాన్ని స్పష్టంగా చూడవచ్చు:

1. బేస్ క్లాస్ ( ) యొక్క స్టాటిక్ వేరియబుల్స్ Animalప్రారంభించబడ్డాయి. మా విషయంలో, Animalక్లాస్ యొక్క వేరియబుల్ యానిమల్‌కౌంట్ 7700000కి సెట్ చేయబడింది.



2. చైల్డ్ క్లాస్ ( ) యొక్క స్టాటిక్ వేరియబుల్స్ Catప్రారంభించబడ్డాయి.

   గమనిక: మేము ఇంకా కన్స్ట్రక్టర్‌లోనే ఉన్నాము Animalమరియు మేము ఇప్పటికే ప్రదర్శించాము:

   యానిమల్ బేస్ క్లాస్ కన్స్ట్రక్టర్ రన్ అవుతోంది
   యానిమల్ క్లాస్ యొక్క వేరియబుల్స్ ఇప్పటికే ప్రారంభించబడిందా?
   స్టాటిక్ వేరియబుల్ జంతువు యొక్క ప్రస్తుత విలువ గణన = 7700000
   జంతు తరగతిలో మెదడు యొక్క ప్రస్తుత విలువ = జంతు తరగతిలో మెదడు యొక్క ప్రారంభ విలువ
   జంతు తరగతిలో గుండె యొక్క ప్రస్తుత విలువ = జంతు తరగతిలో గుండె యొక్క ప్రారంభ విలువ
   ఇప్పటికే క్యాట్ క్లాస్ యొక్క వేరియబుల్స్ కలిగి ఉంది ప్రారంభించబడిందా?
   స్టాటిక్ వేరియబుల్ catCount యొక్క ప్రస్తుత విలువ = 37




3. అప్పుడు బేస్ క్లాస్ యొక్క నాన్-స్టాటిక్ వేరియబుల్స్ ప్రారంభించబడతాయి. మేము ప్రత్యేకంగా వారికి ప్రారంభ విలువలను కేటాయించాము, అవి కన్స్ట్రక్టర్‌లో భర్తీ చేయబడతాయి. యానిమల్ కన్స్ట్రక్టర్ ఇంకా పూర్తి కాలేదు, కానీ మెదడు మరియు గుండె యొక్క ప్రారంభ విలువలు ఇప్పటికే కేటాయించబడ్డాయి:

   యానిమల్ బేస్ క్లాస్ కన్స్ట్రక్టర్ రన్ అవుతోంది
   యానిమల్ క్లాస్ యొక్క వేరియబుల్స్ ఇప్పటికే ప్రారంభించబడిందా?
   స్టాటిక్ వేరియబుల్ యానిమల్ కౌంట్ = 7700000
   జంతు తరగతిలో మెదడు యొక్క ప్రస్తుత విలువ = జంతు తరగతిలో మెదడు యొక్క ప్రారంభ విలువ
   జంతు తరగతిలో గుండె యొక్క ప్రస్తుత విలువ = జంతు తరగతిలో గుండె యొక్క ప్రారంభ విలువ




4. బేస్ క్లాస్ కన్స్ట్రక్టర్ ప్రారంభమవుతుంది.
   ఈ దశ నాల్గవది అని మేము ఇప్పటికే ఒప్పించుకున్నాము: కన్స్ట్రక్టర్ ప్రారంభంలో మొదటి మూడు దశల్లో Animal, అనేక వేరియబుల్స్ ఇప్పటికే విలువలు కేటాయించబడ్డాయి.




5. పిల్లల తరగతి ( ) యొక్క నాన్-స్టాటిక్ ఫీల్డ్‌లు Catప్రారంభించబడ్డాయి.
   కన్స్ట్రక్టర్ రన్ చేయడం ప్రారంభించే ముందు ఇది జరుగుతుంది Cat.
   ఇది అమలు చేయడం ప్రారంభించినప్పుడు, టెయిల్ వేరియబుల్ ఇప్పటికే విలువను కలిగి ఉంది:

   క్యాట్ క్లాస్ కన్స్ట్రక్టర్ ప్రారంభించబడింది (యానిమల్ కన్స్ట్రక్టర్ ఇప్పటికే పూర్తయింది) స్టాటిక్ వేరియబుల్ క్యాట్‌కౌంట్ = 37 ప్రస్తుత విలువ తోక = పిల్లి తరగతిలో తోక యొక్క ప్రారంభ విలువ




6. చైల్డ్ క్లాస్ యొక్క కన్స్ట్రక్టర్ Catఅంటారు

   మరియు జావాలో వస్తువును సృష్టించడం ఎలా ఉంటుందో!

   మేము రోట్-లెర్నింగ్‌కి పెద్దగా అభిమానులు కాదని నేను చెప్పాలి, అయితే వేరియబుల్ ఇనిషియలైజేషన్ మరియు కన్స్ట్రక్టర్ కాల్‌ల క్రమాన్ని గుర్తుంచుకోవడం ఉత్తమం .

   ఇది ప్రోగ్రామ్ యొక్క ప్రవాహం మరియు ఏదైనా నిర్దిష్ట క్షణంలో మీ వస్తువుల స్థితిపై మీ అవగాహనను బాగా పెంచుతుంది.

   అంతేకాకుండా, అనేక తరగతులు వారసత్వాన్ని ఉపయోగించవు. ఈ సందర్భంలో, బేస్ క్లాస్‌కు సంబంధించిన దశలు వర్తించవు.