Java मध्ये ओव्हरराइडिंग पद्धत

हाय! तुम्ही आधीपासून Java पद्धती वापरत आहात आणि त्यांच्याबद्दल बरेच काही माहित आहे. तुम्ही कदाचित अशा परिस्थितीचा सामना केला असेल जिथे एका वर्गात एकाच नावाच्या परंतु भिन्न पॅरामीटर्सच्या अनेक पद्धती आहेत. तुम्हाला आठवत असेल की त्या प्रकरणांमध्ये आम्ही पद्धत ओव्हरलोडिंग वापरली. आज आम्ही आणखी एका परिस्थितीचा विचार करत आहोत. अशी कल्पना करा की आमच्याकडे एकच सामायिक पद्धत आहे, परंतु ती वेगवेगळ्या वर्गांमध्ये भिन्न गोष्टी करणे आवश्यक आहे. आपण हे वर्तन कसे अंमलात आणू? समजून घेण्यासाठी, प्राणी पालक वर्गाचा विचार करूया , जो प्राण्यांचे प्रतिनिधित्व करतो आणि आम्ही त्यात बोलण्याची पद्धत तयार करू:

public class Animal {

   public void speak() {

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

जरी आम्ही नुकतेच कार्यक्रम लिहायला सुरुवात केली असली तरी, तुम्हाला कदाचित एक संभाव्य समस्या दिसेल: जगात बरेच प्राणी आहेत आणि ते सर्व वेगळ्या पद्धतीने 'बोलतात': मांजरी म्याव, बदके क्वॅक आणि साप हिस्स. आमचे ध्येय सोपे आहे: बोलण्याच्या पद्धतींचा भार निर्माण करणे टाळा. मेव्हिंगसाठी catSpeak() पद्धत, snakeSpeak() हिसिंग इ. पद्धत तयार करण्याऐवजी , आम्हाला स्पीक() म्हणायचे आहे.पद्धत आणि साप हिस, मांजर म्याव, आणि कुत्रा भुंकणे. मेथड ओव्हरराइडिंगचा वापर करून आपण हे सहज साध्य करू शकतो. विकिपीडिया 'ओव्हरराइडिंग' या शब्दाचे खालील स्पष्टीकरण देते: मेथड ओव्हरराइडिंग, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंगमध्ये, एक भाषा वैशिष्ट्य आहे जे उपवर्ग किंवा चाइल्ड क्लास एखाद्या पद्धतीची विशिष्ट अंमलबजावणी प्रदान करण्यास अनुमती देते जी आधीपासून त्याच्या सुपरक्लास किंवा पालक वर्ग ते मूलत: बरोबर आहे. मेथड ओव्हरराइडिंग तुम्हाला पालक वर्गाची काही पद्धत घेऊ देते आणि प्रत्येक बाल वर्गात तुमची स्वतःची अंमलबजावणी लिहू देते. नवीन अंमलबजावणी बाल वर्गात पालकांच्या अंमलबजावणीची 'जागी' घेते. हे एका उदाहरणात कसे दिसते ते पाहू. 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 चे तत्त्व). याचा अर्थ असा की त्याचा मुख्य फायदा समान लवचिकता आहे ज्याची आपण पूर्वी चर्चा केली आहे. आम्ही वर्गांची एक सोपी आणि तार्किक प्रणाली तयार करू शकतो, प्रत्येकाची विशिष्ट वर्तणूक (कुत्र्यांची भुंकणे, मांजरीचे म्याव), एक सामान्य इंटरफेस आहे — त्या सर्वांसाठी एकच स्पीक () पद्धत, उदा. dogSpeak() , speakCat . () , इ.