जावा में विधि ओवरराइडिंग

नमस्ते! आप पहले से ही जावा विधियों का उपयोग कर रहे हैं और उनके बारे में बहुत कुछ जानते हैं। आपने शायद उस स्थिति का सामना किया है जहाँ एक वर्ग में एक ही नाम के कई तरीके हैं लेकिन अलग-अलग पैरामीटर हैं। आपको याद होगा कि उन मामलों में हमने मेथड ओवरलोडिंग का इस्तेमाल किया था। आज हम एक और स्थिति पर विचार कर रहे हैं। कल्पना कीजिए कि हमारे पास एक ही साझा विधि है, लेकिन इसे अलग-अलग वर्गों में अलग-अलग काम करना चाहिए। हम इस व्यवहार को कैसे कार्यान्वित करते हैं? समझने के लिए, आइए एनिमल पैरेंट क्लास पर विचार करें, जो जानवरों का प्रतिनिधित्व करता है, और हम इसमें एक स्पीक मेथड बनाएंगे:

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

जावा में ओवरराइडिंग विधि बहुरूपता को लागू करने का एक तरीका है (ओओपी का सिद्धांत जिसे हमने पिछले पाठ में वर्णित किया है)। इसका मतलब है कि इसका मुख्य लाभ वही लचीलापन है जिसकी हमने पहले चर्चा की थी। हम कक्षाओं की एक सरल और तार्किक प्रणाली का निर्माण कर सकते हैं, प्रत्येक में एक विशिष्ट व्यवहार (कुत्ते भौंकते हैं, बिल्लियाँ म्याऊ करते हैं), एक सामान्य इंटरफ़ेस के साथ - उन सभी के लिए एक सिंगल स्पीक () विधि, बजाय कई तरीकों के, जैसे कि डॉगस्पीक ( ) , स्पीककैट () , आदि