పద్ధతి ఓవర్‌రైడింగ్

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

public class Animal {

   public void speak() {

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

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

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 ఉల్లేఖనం ద్వారా తెలియజేయబడుతుంది.
   ఒక పద్ధతి పైన ఉన్న @ఓవర్‌రైడ్ ఉల్లేఖనం కంపైలర్‌కి (అలాగే మీ కోడ్‌ని చదివే ఇతర ప్రోగ్రామర్లు) చెబుతుంది, "చింతించకండి. ఇది పొరపాటు లేదా పర్యవేక్షణ కాదు. ఈ పద్ధతి ఇప్పటికే ఉందని నాకు తెలుసు మరియు నేను దానిని భర్తీ చేయాలనుకుంటున్నాను .

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

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

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

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

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

   speakపేరెంట్ క్లాస్ యొక్క పద్ధతిని ఇన్‌పుట్‌గా తీసుకుంటే , Stringడిసెండెంట్ క్లాస్‌లోని ఓవర్‌రైడ్ పద్ధతి కూడా తప్పనిసరిగా Stringఇన్‌పుట్‌గా తీసుకోవాలి. లేకపోతే, కంపైలర్ లోపాన్ని సృష్టిస్తుంది:

   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Speaking: " + 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!");
      }
   }

జావాలో, మెథడ్ ఓవర్‌రైడింగ్ అనేది పాలిమార్ఫిజమ్‌ని అమలు చేయడానికి ఒక మార్గం. అంటే దాని ప్రధాన ప్రయోజనం ఏమిటంటే మనం ఇంతకు ముందు మాట్లాడిన వశ్యత. మేము తరగతుల యొక్క సరళమైన మరియు తార్కిక సోపానక్రమాన్ని నిర్మించగలము, ఒక్కొక్కటి నిర్దిష్ట ప్రవర్తనతో (మొరిగే కుక్కలు, పిల్లులు మొరిగేవి) కానీ ఒకే ఇంటర్‌ఫేస్ — speak()విభిన్న పద్ధతుల సమూహం కాకుండా అందరికీ ఒకే పద్ధతి, ఉదా bark(), meow()మొదలైనవి.