जावा में बहुरूपता

नमस्ते! आज हम OOP के सिद्धांतों पर पाठों की एक श्रृंखला को समाप्त करते हैं। इस पाठ में, हम Java बहुरूपता के बारे में बात करेंगे। बहुरूपता कई प्रकारों के साथ काम करने की क्षमता है जैसे कि वे एक ही प्रकार के हों। इसके अलावा, वस्तुओं का व्यवहार उनके प्रकार के आधार पर भिन्न होगा। आइए इस कथन पर करीब से नज़र डालते हैं। आइए पहले भाग से शुरू करें: 'कई प्रकारों के साथ काम करने की क्षमता जैसे कि वे एक ही प्रकार के हों'। विभिन्न प्रकार समान कैसे हो सकते हैं? यह सुनने में थोड़ा अजीब लगता है :/ वास्तव में, यह सब बहुत सरल है। उदाहरण के लिए, यह स्थिति वंशानुक्रम के सामान्य उपयोग के दौरान उत्पन्न होती है। आइए देखें कि यह कैसे काम करता है। मान लीजिए कि हमारे पास एक एकल रन () विधि के साथ एक साधारण कैट पैरेंट क्लास है:

public class Cat {

   public void run() {
       System.out.println("Run!");
   }
}

अब हम बिल्ली को इनहेरिट करने वाले तीन वर्ग बनाएंगे : शेर , बाघ और चीता ।

public class Lion extends Cat {

   @Override
   public void run() {
       System.out.println("Lion runs at 80 km/h");
   }
}

public class Tiger extends Cat {

   @Override
   public void run() {
       System.out.println("Tiger runs at 60 km/h");
   }
}

public class Cheetah extends Cat {

   @Override
   public void run() {
       System.out.println("Cheetah runs at up to 120 km/h");
   }
}

तो हमारे पास 3 वर्ग हैं। आइए उस स्थिति का मॉडल बनाएं जहां हम उनके साथ काम कर सकें जैसे कि वे एक ही वर्ग के हों। कल्पना कीजिए कि हमारी एक बिल्ली बीमार है और उसे डॉ. डूलिटिल से मदद की ज़रूरत है। आइए एक डूलिटिल क्लास बनाने की कोशिश करें जो शेरों, बाघों और चीतों को ठीक कर सके।

public class Dolittle {

   public void healLion(Lion lion) {

       System.out.println("Lion is healthy!");
   }

   public void healTiger(Tiger tiger) {

       System.out.println("Tiger is healthy!");
   }

   public void healCheetah(Cheetah cheetah) {

       System.out.println("Cheetah is healthy!");
   }
}

ऐसा लगता है जैसे समस्या हल हो गई है: कक्षा लिखी गई है और जाने के लिए तैयार है। लेकिन अगर हम अपने कार्यक्रम का विस्तार करना चाहते हैं तो हम क्या करेंगे? वर्तमान में हमारे पास केवल 3 प्रकार हैं: शेर, बाघ और चीता। लेकिन दुनिया में 40 से भी ज्यादा तरह की बिल्लियां हैं। कल्पना कीजिए कि क्या होगा यदि हम मैनुल, जगुआर, मेन कून, घरेलू बिल्लियों और बाकी सभी के लिए अलग-अलग वर्ग जोड़ते हैं। निश्चित रूप से यह प्रोग्राम काम करेगा, लेकिन हमें प्रत्येक प्रकार की बिल्ली को ठीक करने के लिए Dolittle क्लास में लगातार नए तरीके जोड़ने होंगे। नतीजतन, यह अभूतपूर्व आकार तक बढ़ जाएगा। यह वह जगह है जहाँ बहुरूपता - "कई प्रकारों के साथ काम करने की क्षमता जैसे कि वे एक ही प्रकार के थे" - अंदर आता है। हमें एक ही काम करने के लिए अनगिनत तरीके बनाने की ज़रूरत नहीं है - एक बिल्ली को ठीक करें। उन सभी के लिए एक ही तरीका काफी है:

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
   }
}

हीलकैट () विधि शेर , बाघ और चीता वस्तुओं को स्वीकार कर सकती है - वे बिल्ली के सभी उदाहरण हैं :

public class Main {

   public static void main(String[] args) {

       Dolittle dolittle = new Dolittle();

       Lion simba = new Lion();
       Tiger shereKhan = new Tiger();
       Cheetah chester = new Cheetah();

       dolittle.healCat(simba);
       dolittle.healCat(shereKhan);
       dolittle.healCat(chester);
   }
}

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

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
       cat.run();
   }
}

आइए तीन जानवरों के इलाज के लिए समान कोड चलाने का प्रयास करें:

public static void main(String[] args) {

   Dolittle dolittle = new Dolittle();

   Lion simba = new Lion();
   Tiger shereKhan = new Tiger();
   Cheetah chester = new Cheetah();

   dolittle.healCat(simba);
   dolittle.healCat(shereKhan);
   dolittle.healCat(chester);
}

और परिणाम इस प्रकार दिखते हैं: रोगी स्वस्थ है! शेर 80 किमी/घंटा की गति से दौड़ता है। रोगी स्वस्थ है ! बाघ 60 किमी/घंटा की गति से दौड़ता है। रोगी स्वस्थ है ! चीता 120 किमी/घंटा की गति से दौड़ता है यहां हम स्पष्ट रूप से देखते हैं कि वस्तुओं का विशिष्ट व्यवहार संरक्षित है, भले ही हमने तीनों जानवरों को बिल्ली के लिए 'सामान्यीकरण' करने के बाद विधि में पारित कर दिया । बहुरूपता के कारण, जावा अच्छी तरह से याद करता है कि ये केवल तीन बिल्लियाँ नहीं हैं। वे एक शेर, एक बाघ और एक चीता हैं, जो अलग-अलग तरीके से दौड़ते हैं। यह बहुरूपता के मुख्य लाभ को दिखाता है: लचीलापन। जब हमें कई प्रकारों द्वारा साझा की गई कुछ कार्यक्षमता को लागू करने की आवश्यकता होती है, तो शेर, बाघ और चीता बस 'बिल्लियाँ' बन जाते हैं। सभी जानवर अलग हैं, लेकिन कुछ स्थितियों में एक बिल्ली एक बिल्ली है, चाहे उसकी प्रजाति कुछ भी हो :) यहां आपके लिए कुछ वीडियो पुष्टि है। जब यह 'सामान्यीकरण' अवांछित होता है और इसके बजाय हमें प्रत्येक प्रजाति को अलग-अलग व्यवहार करने की आवश्यकता होती है, तो प्रत्येक प्रकार अपना काम करता है। बहुरूपता के लिए धन्यवाद, आप कक्षाओं की एक विस्तृत श्रृंखला के लिए एक इंटरफ़ेस (विधियों का सेट) बना सकते हैं। यह कार्यक्रमों को कम जटिल बनाता है। यहां तक ​​​​कि अगर हम 40 प्रकार की बिल्लियों का समर्थन करने के लिए कार्यक्रम का विस्तार करते हैं, तब भी हमारे पास सबसे सरल इंटरफ़ेस होगा: सभी 40 बिल्लियों के लिए एक रन () विधि।