जावा चैलेंजर्स # 3: बहुरूपता और वंशानुक्रम

हम जावा समस्याओं के साथ लेखों की एक श्रृंखला का अनुवाद करना जारी रखते हैं। लाइनों के बारे में अंतिम पोस्ट ने आश्चर्यजनक रूप से गर्म चर्चा का कारण बना। हमें उम्मीद है कि आप इस लेख से नहीं गुजरेंगे। और हाँ - अब हम आपको हमारे जावा डेवलपर पाठ्यक्रम की दसवीं वर्षगांठ की धारा में आमंत्रित कर रहे हैं।

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

आप इस लेख के लिए स्रोत कोड ले सकते हैं और यहाँ प्रयोग कर सकते हैं: https://github.com/rafadelnero/javaworld-challuters

बहुरूपता में हस्तक्षेप और विरासत

इस लेख में, हम बहुरूपता और वंशानुक्रम के बीच संबंध पर ध्यान केंद्रित करेंगे। ध्यान रखने वाली मुख्य बात यह है कि बहुरूपता को इंटरफ़ेस की विरासत या कार्यान्वयन की आवश्यकता होती है । आप इसे नीचे ड्यूक और Juggy के उदाहरण में देख सकते हैं:

 public abstract class JavaMascot { public abstract void executeAction(); } public class Duke extends JavaMascot { @Override public void executeAction() { System.out.println("Punch!"); } } public class Juggy extends JavaMascot { @Override public void executeAction() { System.out.println("Fly!"); } } public class JavaMascotTest { public static void main(String... args) { JavaMascot dukeMascot = new Duke(); JavaMascot juggyMascot = new Juggy(); dukeMascot.executeAction(); juggyMascot.executeAction(); } } 

इस कोड का आउटपुट इस तरह होगा:

 Punch! Fly! 

चूंकि विशिष्ट कार्यान्वयन परिभाषित किए गए हैं, Duke और Juggy दोनों तरीकों को बुलाया जाएगा।

क्या पद्धति एक बहुरूपता को ओवरलोड कर रही है? कई प्रोग्रामर ओवरराइडिंग और ओवरलोडिंग के साथ बहुरूपता के रिश्ते को भ्रमित करते हैं। वास्तव में, केवल विधि को पुनर्परिभाषित करना सही बहुरूपता है। ओवरलोडिंग एक ही विधि नाम का उपयोग करती है, लेकिन विभिन्न पैरामीटर। बहुरूपता एक व्यापक शब्द है, इसलिए इस विषय पर हमेशा चर्चा होगी।

बहुरूपता का उद्देश्य क्या है

बहुरूपता का उपयोग करने का एक बड़ा लाभ और उद्देश्य कार्यान्वयन के साथ क्लाइंट-क्लास कनेक्शन को कम करना है। हार्डकोड के बजाय, ग्राहक वर्ग को आवश्यक कार्रवाई करने के लिए निर्भरता का कार्यान्वयन मिलता है। इस प्रकार, ग्राहक वर्ग अपने कार्यों को पूरा करने के लिए न्यूनतम जानता है, जो कमजोर बंधन का एक उदाहरण है।

बहुरूपता के उद्देश्य को बेहतर ढंग से समझने के लिए, SweetCreator पर एक नज़र SweetCreator :

 public abstract class SweetProducer { public abstract void produceSweet(); } public class CakeProducer extends SweetProducer { @Override public void produceSweet() { System.out.println("Cake produced"); } } public class ChocolateProducer extends SweetProducer { @Override public void produceSweet() { System.out.println("Chocolate produced"); } } public class CookieProducer extends SweetProducer { @Override public void produceSweet() { System.out.println("Cookie produced"); } } public class SweetCreator { private List<SweetProducer> sweetProducer; public SweetCreator(List<SweetProducer> sweetProducer) { this.sweetProducer = sweetProducer; } public void createSweets() { sweetProducer.forEach(sweet -> sweet.produceSweet()); } } public class SweetCreatorTest { public static void main(String... args) { SweetCreator sweetCreator = new SweetCreator(Arrays.asList( new CakeProducer(), new ChocolateProducer(), new CookieProducer())); sweetCreator.createSweets(); } } 

इस उदाहरण में, आप देख सकते हैं कि SweetCreator वर्ग SweetCreator वर्ग के बारे में जानता है। वह हर Sweet के कार्यान्वयन को नहीं जानता है। यह पृथक्करण हमें अपनी कक्षाओं को अपडेट और पुन: उपयोग करने की सुविधा देता है, और इससे कोड को बनाए रखने में बहुत आसान हो जाता है। कोड डिजाइन करते समय, हमेशा इसे यथासंभव लचीला और सुविधाजनक बनाने के तरीकों की तलाश करें। बहुरूपता इस उद्देश्य के लिए इस्तेमाल किया जाने वाला एक बहुत शक्तिशाली तरीका है।

@Override प्रोग्रामर को उसी विधि हस्ताक्षर का उपयोग करने की आवश्यकता होती है, जिसे ओवरराइड किया जाना चाहिए। यदि विधि को ओवरराइड नहीं किया जाता है, तो संकलन त्रुटि होगी।

एक विधि को ओवरराइड करते समय सहसंयोजक वापसी प्रकार

यदि आप एक सहसंयोजक प्रकार हैं, तो आप ओवरराइड विधि का रिटर्न प्रकार बदल सकते हैं। सहसंयोजक प्रकार मूल रूप से वापसी मूल्य का एक उपवर्ग है।

एक उदाहरण पर विचार करें:

 public abstract class JavaMascot { abstract JavaMascot getMascot(); } public class Duke extends JavaMascot { @Override Duke getMascot() { return new Duke(); } } 

चूंकि Duke JavaMascot , हम ओवरराइड करते समय रिटर्न वैल्यू के प्रकार को बदल सकते हैं।

जावा बेस क्लासेस में बहुरूपता

हम आधार जावा कक्षाओं में लगातार बहुरूपता का उपयोग करते हैं। एक बहुत ही सरल उदाहरण एक List इंटरफ़ेस के रूप में एक प्रकार की घोषणा के साथ एक ArrayList वर्ग को तत्काल करना है।

 List<String> list = new ArrayList<>(); 

एक नमूना कोड पर विचार करें जो पॉलिमोर्फिज्म के बिना जावा कलेक्शंस एपीआई का उपयोग करता है:

 public class ListActionWithoutPolymorphism { //    void executeVectorActions(Vector<Object> vector) {/*    */} void executeArrayListActions(ArrayList<Object> arrayList) {/*    */} void executeLinkedListActions(LinkedList<Object> linkedList) {/*    */} void executeCopyOnWriteArrayListActions(CopyOnWriteArrayList<Object> copyOnWriteArrayList) { /*    */} } public class ListActionInvokerWithoutPolymorphism { listAction.executeVectorActions(new Vector<>()); listAction.executeArrayListActions(new ArrayList<>()); listAction.executeLinkedListActions(new LinkedList<>()); listAction.executeCopyOnWriteArrayListActions(new CopyOnWriteArrayList<>()); } 

घृणित कोड, सही? कल्पना कीजिए कि आपको उसका साथ देने की जरूरत है! अब बहुरूपता के साथ एक ही उदाहरण पर विचार करें:

 public static void main(String... polymorphism) { ListAction listAction = new ListAction(); listAction.executeListActions(); } public class ListAction { void executeListActions(List<Object> list) { //      } } public class ListActionInvoker { public static void main(String... masterPolymorphism) { ListAction listAction = new ListAction(); listAction.executeListActions(new Vector<>()); listAction.executeListActions(new ArrayList<>()); listAction.executeListActions(new LinkedList<>()); listAction.executeListActions(new CopyOnWriteArrayList<>()); } } 

बहुरूपता का लाभ लचीलापन और व्यापकता है। कई अलग-अलग तरीकों को बनाने के बजाय, हम एक विधि की घोषणा कर सकते हैं जिसे एक List प्रकार मिलता है।

एक पॉलीमॉर्फिक विधि के लिए विशिष्ट तरीकों को कॉल करना

आप एक पॉलीमॉर्फिक विधि कॉल के साथ विशिष्ट तरीकों को कॉल कर सकते हैं, यह लचीलेपन के कारण है। यहाँ एक उदाहरण है:

 public abstract class MetalGearCharacter { abstract void useWeapon(String weapon); } public class BigBoss extends MetalGearCharacter { @Override void useWeapon(String weapon) { System.out.println("Big Boss is using a " + weapon); } void giveOrderToTheArmy(String orderMessage) { System.out.println(orderMessage); } } public class SolidSnake extends MetalGearCharacter { void useWeapon(String weapon) { System.out.println("Solid Snake is using a " + weapon); } } public class UseSpecificMethod { public static void executeActionWith(MetalGearCharacter metalGearCharacter) { metalGearCharacter.useWeapon("SOCOM"); //      // metalGearCharacter.giveOrderToTheArmy("Attack!"); if (metalGearCharacter instanceof BigBoss) { ((BigBoss) metalGearCharacter).giveOrderToTheArmy("Attack!"); } } public static void main(String... specificPolymorphismInvocation) { executeActionWith(new SolidSnake()); executeActionWith(new BigBoss()); } } 

हम यहां जिस तकनीक का उपयोग करते हैं वह कास्टिंग या होशपूर्वक रनटाइम पर ऑब्जेक्ट के प्रकार को बदल रही है।

कृपया ध्यान दें कि एक विशिष्ट विधि के लिए एक कॉल केवल तभी संभव है जब अधिक सामान्य प्रकार से अधिक विशिष्ट प्रकार की कास्टिंग की जाए। एक अच्छा सादृश्य स्पष्ट रूप से संकलक को बताना होगा: "अरे, मुझे पता है कि मैं यहां क्या कर रहा हूं, इसलिए मैं ऑब्जेक्ट को एक विशिष्ट प्रकार में डालने जा रहा हूं और मैं इस पद्धति का उपयोग करूंगा।"

उपरोक्त उदाहरण का उल्लेख करते हुए, संकलक के पास कुछ विधियों के कॉल को स्वीकार नहीं करने का एक अच्छा कारण है: जो क्लास पास किया गया है SolidSnake होना चाहिए। इस मामले में, संकलक के पास यह सुनिश्चित करने का कोई तरीका नहीं है कि MetalGearCharacter प्रत्येक उपवर्ग में एक giveOrderToTheArmy विधि है।

Instanceof कीवर्ड

आरक्षित शब्द instanceof नोट करें। एक विशिष्ट विधि को कॉल करने से पहले, हमने पूछा कि क्या MetalGearCharacter । यदि यह BigBoss उदाहरण नहीं है, तो हमें निम्नलिखित अपवाद मिलेगा:

 Exception in thread `main" java.lang.ClassCastException: com.javaworld.javachallengers.polymorphism.specificinvocation.SolidSnake cannot be cast to com.javaworld.javachallengers.polymorphism.specificinvocation.BigBoss 

कीवर्ड super

क्या होगा यदि हम माता-पिता वर्ग से एक विशेषता या विधि का उल्लेख करना चाहते हैं? इस स्थिति में, हम super कीवर्ड का उपयोग कर सकते हैं।
उदाहरण के लिए:

 public class JavaMascot { void executeAction() { System.out.println("The Java Mascot is about to execute an action!"); } } public class Duke extends JavaMascot { @Override void executeAction() { super.executeAction(); System.out.println("Duke is going to punch!"); } public static void main(String... superReservedWord) { new Duke().executeAction(); } } 

Duke वर्ग के executeAction विधि में आरक्षित शब्द super का उपयोग करके मूल वर्ग की विधि को कहते हैं। फिर हम Duke वर्ग से एक विशिष्ट कार्रवाई करते हैं। यही कारण है कि हम आउटपुट में दोनों संदेश देख सकते हैं:

 The Java Mascot is about to execute an action! Duke is going to punch! 

बहुरूपता समस्या का समाधान करें

आइए देखें कि आपने बहुरूपता और वंशानुक्रम के बारे में क्या सीखा।

इस कार्य में, आपको मैट ग्रोइनिंग के द सिम्पसंस से कई तरीके दिए गए हैं, वेव्स से आपको यह पता लगाना आवश्यक है कि प्रत्येक वर्ग के लिए आउटपुट क्या होगा। सबसे पहले, निम्नलिखित कोड का सावधानीपूर्वक विश्लेषण करें:

 public class PolymorphismChallenge { static abstract class Simpson { void talk() { System.out.println("Simpson!"); } protected void prank(String prank) { System.out.println(prank); } } static class Bart extends Simpson { String prank; Bart(String prank) { this.prank = prank; } protected void talk() { System.out.println("Eat my shorts!"); } protected void prank() { super.prank(prank); System.out.println("Knock Homer down"); } } static class Lisa extends Simpson { void talk(String toMe) { System.out.println("I love Sax!"); } } public static void main(String... doYourBest) { new Lisa().talk("Sax :)"); Simpson simpson = new Bart("D'oh"); simpson.talk(); Lisa lisa = new Lisa(); lisa.talk(); ((Bart) simpson).prank(); } } 

आपको क्या लगता है? इसका परिणाम क्या होगा? पता लगाने के लिए आईडीई का उपयोग न करें! लक्ष्य अपने कोड विश्लेषण कौशल में सुधार करना है, इसलिए अपने लिए निर्णय लेने का प्रयास करें।

अपना उत्तर चुनें (आप लेख के अंत में सही उत्तर पा सकते हैं)।

ए)
आई लव सैक्स!
डी 'ओह
सिम्पसन!
डी 'ओह

बी)
सैक्स :)
मेरे शॉर्ट्स खाओ!
आई लव सैक्स!
डी 'ओह
नीचे दस्तक होमर

सी)
सैक्स :)
डी 'ओह
सिम्पसन!
नीचे दस्तक होमर

डी)
आई लव सैक्स!
मेरे शॉर्ट्स खाओ!
सिम्पसन!
डी 'ओह
नीचे दस्तक होमर

क्या हुआ? बहुरूपता को समझना

निम्नलिखित विधि कॉल के लिए:

 new Lisa().talk("Sax :)"); 

आउटपुट "मुझे सैक्स से प्यार है!"। ऐसा इसलिए है क्योंकि हम स्ट्रिंग को विधि में पास करते हैं और Lisa वर्ग में ऐसी विधि होती है।

अगले कॉल के लिए:

 Simpson simpson = new Bart("D'oh"); simpson.talk(); 

आउटपुट "मेरे शॉर्ट्स खाओ!" होगा। ऐसा इसलिए है क्योंकि हम Bart साथ Simpson प्रकार को इनिशियलाइज़ करते हैं।

अब देखो, यह थोड़ा पेचीदा मामला है:

 Lisa lisa = new Lisa(); lisa.talk(); 

यहां हम वंशानुक्रम के साथ विधि अधिभार का उपयोग करते हैं। हम talk करने की विधि के लिए कुछ भी पास नहीं talk , इसलिए Simpson से talk करने की विधि Simpson कहा जाता है।

इस मामले में, आउटपुट "सिम्पसन!" होगा।

यहाँ एक और एक है:

 ((Bart) simpson).prank(); 

इस मामले में, new Bart("D'oh"); माध्यम से Bart क्लास को तत्काल करते समय प्रैंक स्ट्रिंग पारित किया गया था new Bart("D'oh"); । इस स्थिति में, super.prank() विधि को पहले कहा जाता है, और फिर Bart क्लास से super.prank() विधि कहा जाता है। निष्कर्ष यह होगा:

 "D'oh" "Knock Homer down" 

सामान्य बहुरूपता त्रुटियां

एक सामान्य गलती यह सोचने की है कि आप एक विशिष्ट विधि को कॉल के प्रकारों का उपयोग किए बिना कह सकते हैं।

एक और गलती अनिश्चितता है कि किस विधि को बुलाया जाएगा जब कक्षा को पॉलीमॉर्फिक रूप से तत्काल किया जाएगा। याद रखें कि कहा जा रहा विधि तात्कालिक उदाहरण की विधि है।

यह भी याद रखें कि एक विधि को ओवरराइड करना एक विधि का अधिभार नहीं है।

यदि पैरामीटर अलग हैं, तो विधि को ओवरराइड नहीं किया जा सकता है। यदि आप वापसी प्रकार एक उपवर्ग है, तो आप ओवरराइड विधि के रिटर्न प्रकार को बदल सकते हैं।

बहुरूपता के बारे में आपको क्या याद रखना चाहिए

• बनाया गया उदाहरण यह निर्धारित करता है कि बहुरूपता का उपयोग करते समय किस विधि को बुलाया जाएगा।

  
  

• @Override प्रोग्रामर को ओवरराइड विधि का उपयोग करने की आवश्यकता होती है; अन्यथा, एक संकलक त्रुटि उत्पन्न होगी।

  
  

• बहुरूपता का उपयोग नियमित कक्षाओं, अमूर्त वर्गों और इंटरफेस के साथ किया जा सकता है।

  
  

• अधिकांश डिज़ाइन पैटर्न कुछ प्रकार के बहुरूपता पर निर्भर करते हैं।

  
  

• एक पॉलीमॉर्फ़िक उपवर्ग में अपनी विधि को कॉल करने का एकमात्र तरीका टाइप कास्टिंग का उपयोग करना है।

  
  

• आप बहुरूपता का उपयोग करके एक शक्तिशाली कोड संरचना बना सकते हैं।

  
  

• प्रयोग। इसके माध्यम से, आप इस शक्तिशाली अवधारणा को मास्टर करने में सक्षम होंगे!

  
  

जवाब है

उत्तर है डी।

निष्कर्ष यह होगा:

 I love Sax! Eat my shorts! Simpson! D'oh Knock Homer down 

हमेशा की तरह, मैं आपकी टिप्पणियों और सवालों का स्वागत करता हूं। और हम एक खुले पाठ में विटाली की प्रतीक्षा कर रहे हैं।