జావాలో ఓవర్‌రైడింగ్ పద్ధతి

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

public class Animal {

   public void speak() {

       System.out.println("Hello!");
   }
}

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

public class Bear extends Animal {
   @Override
   public void speak() {
       System.out.println("Growl!");
   }
}
public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void speak() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void speak() {
       System.out.println("Hiss!");
   }
}

"భవిష్యత్తు కోసం ఇక్కడ ఒక చిన్న లైఫ్‌హాక్ ఉంది: పేరెంట్ క్లాస్ పద్ధతులను ఓవర్‌రైడ్ చేయడానికి, IntelliJ IDEలోని చైల్డ్ క్లాస్ కోడ్‌కి వెళ్లి, Ctrl+O క్లిక్ చేసి, మెనులో "ఓవర్‌రైడ్ మెథడ్స్..." ఎంచుకోండి. హాట్ కీలను ఉపయోగించడం అలవాటు చేసుకోండి. ప్రారంభం నుండి — ఇది ప్రోగ్రామ్‌లను వేగంగా వ్రాయడంలో మీకు సహాయం చేస్తుంది!మాకు అవసరమైన ప్రవర్తనను పేర్కొనడానికి, మేము కొన్ని పనులు చేసాము:

1. ప్రతి పిల్లల తరగతిలో, మేము పేరెంట్ క్లాస్ పద్ధతి వలె అదే పేరుతో ఒక పద్ధతిని సృష్టించాము.


2. పేరెంట్ క్లాస్‌లో ఉన్న పద్ధతికి పేరు పెట్టడం యాదృచ్ఛికం కాదని మేము కంపైలర్‌కి చెప్పాము: మేము దాని ప్రవర్తనను భర్తీ చేయాలనుకుంటున్నాము. కంపైలర్‌కు దీన్ని కమ్యూనికేట్ చేయడానికి, మేము పద్ధతి పైన @Override ఉల్లేఖనాన్ని సెట్ చేసాము.
   ఒక పద్ధతి పైన ఉంచినప్పుడు, @Override ఉల్లేఖన కంపైలర్‌కు తెలియజేస్తుంది (అలాగే మీ కోడ్‌ని చదివే ప్రోగ్రామర్లు): 'అంతా ఓకే. ఇది పొరపాటు కాదు. నేను మతిమరుపు కాదు. అటువంటి పద్ధతి ఇప్పటికే ఉందని నాకు తెలుసు మరియు నేను దానిని భర్తీ చేయాలనుకుంటున్నాను'.


3. మేము ప్రతి పిల్లల తరగతికి అవసరమైన అమలును వ్రాసాము. స్పీక్() పద్ధతిని పిలిచినప్పుడు , పాము బుసలు కొట్టాలి, ఎలుగుబంటి కేకలు వేయాలి, మొదలైనవి.

ప్రోగ్రామ్‌లో ఇది ఎలా పనిచేస్తుందో చూద్దాం:

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();

       animal1.speak();
       animal2.speak();
       animal3.speak();
       animal4.speak();
   }
}

కన్సోల్ అవుట్‌పుట్:

Woof!
Meow!
Growl!
Hiss!

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

1. ఓవర్‌రైడ్ పద్ధతి తప్పనిసరిగా పేరెంట్ పద్ధతి వలె అదే పారామితులను కలిగి ఉండాలి.

   పేరెంట్ క్లాస్ స్పీచ్ మెథడ్‌లో స్ట్రింగ్ పారామీటర్ ఉంటే, చైల్డ్ క్లాస్‌లోని ఓవర్‌రైడ్ మెథడ్ తప్పనిసరిగా స్ట్రింగ్ పారామీటర్‌ను కలిగి ఉండాలి. లేకపోతే, కంపైలర్ లోపాన్ని సృష్టిస్తుంది:

   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Hello! " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override // Error!
      public void speak() {
          System.out.println("Meow!");
      }
   }




2. ఓవర్‌రైడ్ పద్ధతి తప్పనిసరిగా పేరెంట్ పద్ధతి వలె తిరిగి వచ్చే రకాన్ని కలిగి ఉండాలి.

   లేకపోతే, మేము కంపైలర్ ఎర్రర్‌ను పొందుతాము:

   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String speak() {         // Error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }




3. ఓవర్‌రైడ్ పద్ధతిలో యాక్సెస్ మాడిఫైయర్ తప్పనిసరిగా 'ఒరిజినల్' పద్ధతి వలె ఉండాలి:

   public class Animal {
   
         public void speak() {
   
               System.out.println("Hello!");
         }
   }
   
   public class Cat extends Animal {
   
          @Override
          private void speak() {      // Error!
              System.out.println("Meow!");
          }
   }

పాలీమార్ఫిజమ్‌ని అమలు చేయడానికి జావాలో ఓవర్‌రైడింగ్ పద్ధతి ఒక మార్గం (మనం చివరి పాఠంలో వివరించిన OOP సూత్రం). దీని అర్థం మనం ఇంతకుముందు చర్చించిన అదే వశ్యత దాని ప్రధాన ప్రయోజనం. మేము ఒక సాధారణ ఇంటర్‌ఫేస్‌తో ఒక నిర్దిష్ట ప్రవర్తన (కుక్కలు మొరగడం, పిల్లులు మియావ్) కలిగి ఉండే ఒక సాధారణ మరియు తార్కిక తరగతుల వ్యవస్థను రూపొందించవచ్చు — అనేక పద్ధతుల కంటే వాటి కోసం ఒకే స్పీక్() పద్ధతి , ఉదా. డాగ్‌స్పీక్() , స్పీక్ క్యాట్ () , మొదలైనవి