पद्धत अधिलिखित

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

public class Animal {
  
   public void speak() {

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

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

कन्सोल आउटपुट:

Woof! 
Meow! 
Growl! 
Hiss!

छान, सर्वकाही जसे पाहिजे तसे कार्य करते! आम्ही 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(), इ.