ఆపరేటర్ యొక్క జావా ఉదాహరణ

హాయ్! ఈ రోజు మనం ఆపరేటర్ యొక్క ఉదాహరణ గురించి మాట్లాడుతాము , అది ఎలా ఉపయోగించబడుతుందో ఉదాహరణలను పరిశీలిస్తాము మరియు ఇది ఎలా పని చేస్తుందో కొన్ని అంశాలను తాకండి:) మీరు ఇప్పటికే ఈ ఆపరేటర్‌ని CodeGym యొక్క ప్రారంభ స్థాయిలలో ఎదుర్కొన్నారు. మాకు ఇది ఎందుకు అవసరమో మీకు గుర్తుందా? కాకపోతే చింతించకండి. కలిసి గుర్తుచేసుకుందాం. X వేరియబుల్ ద్వారా సూచించబడిన వస్తువు కొంత Y తరగతి ఆధారంగా సృష్టించబడిందో లేదో తనిఖీ చేయడానికి ఆపరేటర్ యొక్క ఉదాహరణ అవసరం . సింపుల్ గా అనిపిస్తుంది. మేము ఈ అంశానికి ఎందుకు తిరిగి వచ్చాము? అన్నింటిలో మొదటిది, ఎందుకంటే ఇప్పుడు మీరు జావా యొక్క ఇన్హెరిటెన్స్ మెకానిజం మరియు OOP యొక్క ఇతర సూత్రాల గురించి బాగా తెలుసుకున్నారు. ఆపరేటర్ యొక్క ఉదాహరణ ఇప్పుడు చాలా స్పష్టంగా ఉంటుంది మరియు అది ఎలా ఉపయోగించబడుతుందో మేము మరింత అధునాతన ఉదాహరణలను పరిశీలిస్తాము. వెళ్దాం!చెక్ మూల్యాంకనం చేసినట్లయితే నిజమైన ఆపరేటర్ యొక్క ఉదాహరణ నిజమని లేదా వ్యక్తీకరణ తప్పు అయితే తప్పు అని మీరు బహుశా గుర్తుంచుకోవాలి . తదనుగుణంగా, ఇది సాధారణంగా అన్ని రకాల షరతులతో కూడిన వ్యక్తీకరణలలో సంభవిస్తుంది ( అయితే... లేకపోతే ). కొన్ని సరళమైన ఉదాహరణలతో ప్రారంభిద్దాం:

public class Main {

   public static void main(String[] args) {

       Integer x = new Integer(22);

       System.out.println(x instanceof Integer);
   }
}

కన్సోల్‌లో ఏమి ప్రదర్శించబడుతుందని మీరు అనుకుంటున్నారు? సరే, ఇది ఇక్కడ స్పష్టంగా ఉంది.:) x ఆబ్జెక్ట్ ఒక పూర్ణాంకం, కాబట్టి ఫలితం నిజం అవుతుంది . కన్సోల్ అవుట్‌పుట్: నిజం ఇది స్ట్రింగ్ కాదా అని తనిఖీ చేద్దాం :

public class Main {

   public static void main(String[] args) {

       Integer x = new Integer(22);

       System.out.println(x instanceof String); // Error!
   }
}

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

public class Animal {

}

public class Cat extends Animal {

}

public class MaineCoon extends Cat {

}

ఆబ్జెక్ట్ ఒక తరగతికి సంబంధించిన ఉదంతమా కాదా అని తనిఖీ చేసినప్పుడు ఉదాహరణ ఎలా ప్రవర్తిస్తుందో మాకు ఇప్పటికే తెలుసు , కానీ మనం తల్లిదండ్రుల-పిల్లల సంబంధాన్ని పరిగణనలోకి తీసుకుంటే ఏమి జరుగుతుంది? ఉదాహరణకు, ఈ వ్యక్తీకరణలు ఏమి ఇస్తాయని మీరు అనుకుంటున్నారు:

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();

       System.out.println(cat instanceof Animal);

       System.out.println(cat instanceof MaineCoon);

   }
}

అవుట్‌పుట్: ట్రూ ఫాల్స్‌కి సమాధానం ఇవ్వాల్సిన ప్రధాన ప్రశ్న ఏమిటంటే, 'తరగతి ఆధారంగా సృష్టించబడిన వస్తువు'ని ఎలా అర్థం చేసుకుంటుంది ? ' క్యాట్ ఇన్‌స్టాన్స్ ఆఫ్ యానిమల్ ' అనేది నిజమని అంచనా వేస్తుంది , అయితే ఖచ్చితంగా మనం ఆ పదాలలో తప్పును కనుగొనవచ్చు. జంతు తరగతి ఆధారంగా పిల్లి వస్తువు ఎందుకు సృష్టించబడుతుంది ? ఇది కేవలం దాని స్వంత తరగతి ఆధారంగా సృష్టించబడినది కాదా? సమాధానం చాలా సులభం, మరియు మీరు ఇప్పటికే దాని గురించి ఆలోచించి ఉండవచ్చు. ఆబ్జెక్ట్‌ను సృష్టించేటప్పుడు కన్స్ట్రక్టర్‌లను పిలిచే మరియు వేరియబుల్స్ ప్రారంభించబడే క్రమాన్ని గుర్తుంచుకోండి. మేము ఇప్పటికే ఈ అంశాన్ని క్లాస్ కన్స్ట్రక్టర్‌ల గురించిన కథనంలో కవర్ చేసాము . ఆ పాఠం నుండి ఇక్కడ ఒక ఉదాహరణ:

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

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

System.out.println(cat instanceof MaineCoon);

క్యాట్ వస్తువు సృష్టించబడినప్పుడు MaineCoon కన్స్ట్రక్టర్‌ని పిలవలేదు , ఇది అర్ధమే. అన్నింటికంటే, మైనేకూన్ పిల్లి యొక్క వారసుడు , పూర్వీకుడు కాదు. మరియు ఇది పిల్లి కోసం ఒక టెంప్లేట్ కాదు . సరే, మేము దానిపై స్పష్టంగా ఉన్నామని నేను భావిస్తున్నాను. కానీ మనం ఇలా చేస్తే ఏమవుతుంది?:

public class Main {

   public static void main(String[] args) {

       Cat cat = new MaineCoon();

       System.out.println(cat instanceof Cat);
       System.out.println(cat instanceof MaineCoon);


   }
}

అయ్యో... ఇప్పుడు అది కష్టం. దాని గురించి మాట్లాడుకుందాం. మేము MaineCoon ఆబ్జెక్ట్‌ని కేటాయించిన క్యాట్ వేరియబుల్‌ని కలిగి ఉన్నాము . మార్గం ద్వారా, అది కూడా ఎందుకు పని చేస్తుంది? మనం అలా చేయగలం, సరియైనదా? అవును మనం చేయగలం. అన్ని తరువాత, ప్రతి MaineCoon ఒక పిల్లి. అది పూర్తిగా స్పష్టంగా తెలియకపోతే, ఆదిమ రకాలను విస్తరించే ఉదాహరణను గుర్తుంచుకోండి:

public class Main {

   public static void main(String[] args) {

       long x = 1024;

   }
}

1024 సంఖ్య చిన్నది : ఇది సులభంగా పొడవాటి వేరియబుల్‌కి సరిపోతుంది , ఎందుకంటే దానికి సరిపోయేంత బైట్‌లు ఉన్నాయి (బొమ్మలతో ఉదాహరణను గుర్తుంచుకోవాలా?). ఒక అవరోహణ వస్తువు ఎల్లప్పుడూ పూర్వీకుల వేరియబుల్‌కు కేటాయించబడుతుంది. ప్రస్తుతానికి, దీన్ని గుర్తుంచుకోండి మరియు తదుపరి పాఠాలలో ఇది ఎలా పనిచేస్తుందో విశ్లేషిస్తాము. కాబట్టి మా ఉదాహరణ ఏమి అవుట్‌పుట్ చేస్తుంది?

Cat cat = new MaineCoon();
System.out.println(cat instanceof Cat);
System.out.println(cat instanceof MaineCoon);

తనిఖీ యొక్క ఉదాహరణ ఏమిటి ? మా క్యాట్ వేరియబుల్ లేదా మా మైన్‌కూన్ ఆబ్జెక్ట్? సమాధానం ఈ ప్రశ్న నిజానికి చాలా సులభం. మీరు ఆపరేటర్ యొక్క నిర్వచనాన్ని మళ్లీ చదవాలి: X వేరియబుల్ ద్వారా సూచించబడిన వస్తువు కొంత Y తరగతి ఆధారంగా సృష్టించబడిందో లేదో తనిఖీ చేయడానికి ఆపరేటర్ యొక్క ఉదాహరణ అవసరం . ఆపరేటర్ యొక్క ఉదాహరణ ఒక వస్తువు యొక్క మూలాన్ని పరీక్షిస్తుంది, వేరియబుల్ రకం కాదు. కాబట్టి, ఈ ఉదాహరణలో, మా ప్రోగ్రామ్ రెండు సందర్భాల్లోనూ నిజాన్ని ప్రదర్శిస్తుంది : మాకు MaineCoon ఆబ్జెక్ట్ ఉంది. సహజంగానే, ఇది MaineCoon తరగతి ఆధారంగా సృష్టించబడింది , కానీ ఇది పిల్లి ఆధారంగా సృష్టించబడిందిపేరెంట్ క్లాస్ కూడా!