लोड हो रहा है...

Java में Polymorphism

अलग-अलग ऑब्जेक्ट को पैरेंट-टाइप वेरिएबल में रखिए ताकि एक कॉल नाम अलग बॉडी चला सके। Machine पर horn रखिए जो tone छापे। Truck पर horn फिर लिखिए ताकि honk छपे। Car पर horn फिर लिखिए ताकि beep छपे। Yard.java में Machine m = new Machine();, Machine t = new Truck(); और Machine c = new Car(); असाइन करिए, फिर प्रत्येक पर horn बुलाइए। javac Yard.java से कंपाइल कर java Yard चलाइए। स्क्रीन को tone, फिर honk, फिर beep दिखाना चाहिए। दूसरी डेमो केवल दो बच्चों को Machine रेफ़रेंस के रूप में रखती है। equals अगले पृष्ठ के लिए छोड़ दें — यह पाठ एक पैरेंट टाइप है जो कई रूप रखता है।

एक पैरेंट टाइप, तीन horn बॉडी

abstract पृष्ठ ने बच्चों के भरने के लिए एक विधि अधूरी छोड़ी। यह पृष्ठ पैरेंट-टाइप वेरिएबल के ज़रिए कॉल पर ध्यान देता है। Yard.java खोलिए। पब्लिक क्लास नाम Yard रखिए। अगर पैरेंट-टाइप कहानी दबाएँ तो बचे abstract-only डेमो, enum Level फ़ाइलें, पथ डेमो, और कीबोर्ड Scanner हटा दीजिए। प्रोग्राम टाइपिंग का इंतज़ार न करे। import लाइन की ज़रूरत नहीं।
horn बॉडी वाला सामान्य पैरेंट घोषित करिए:
class Machine {
void horn() {
System.out.println("tone");
}
}
बच्चों को extends Machine और अपनी horn बॉडी से घोषित करिए जो honk और beep छापें। मेल खाता नाम और खाली पैरामीटर सूची मतलब प्रत्येक बच्चा पैरेंट विधि को override करता है।
Yard.main के अंदर तीन वेरिएबल बनाइए जिनका घोषित टाइप Machine है:
Machine m = new Machine();
Machine t = new Truck();
Machine c = new Car();
फिर बुलाइए:
m.horn();
t.horn();
c.horn();
तीनों का घोषित टाइप Machine है। असली ऑब्जेक्ट तय करता है कौन-सी horn बॉडी चले।

Yard Machine Truck Car horn polymorphism

java

class Machine {
    void horn() {
        System.out.println("tone");
    }
}

class Truck extends Machine {
    void horn() {
        System.out.println("honk");
    }
}

class Car extends Machine {
    void horn() {
        System.out.println("beep");
    }
}

public class Yard {
    public static void main(String[] args) {
        Machine m = new Machine();
        Machine t = new Truck();
        Machine c = new Car();
        m.horn();
        t.horn();
        c.horn();
    }
}

जिस फ़ोल्डर में Yard.java है वहाँ से javac Yard.java चलाइए। जब कोष्ठक, ब्रेसिज़ और सेमीकोलन मेल खाएँ, javac अपनी कोई पंक्ति नहीं लिखता। फिर java Yard चलाइए — java Yard.java नहीं। रन कमांड से .java अंत छोड़ दीजिए। फ़ाइल में एक पब्लिक क्लास रखिए ताकि नाम Yard से मेल खाए। सहायक प्रकार इस शुरुआती आकार में बिना public रहें।
स्क्रीन tone, फिर honk, फिर beep दिखाती है। रन एक बार घुमाइए। Java Yard.main से शुरू होता है। m सादा Machine रखता है, इसलिए m.horn() tone छापता है। t एक Truck रखता है भले वेरिएबल टाइप Machine कहे, इसलिए t.horn() honk छापता है। c एक Car रखता है, इसलिए c.horn() beep छापता है। कॉल की वर्तनी एक। तीन बॉडी।
स्क्रीन की मेल खाने वाली पंक्ति पढ़ते हुए प्रत्येक असाइनमेंट की ओर इशारा करिए। पहली पंक्ति सादी मशीन की है। दूसरी पंक्ति machine-टाइप नाम के पीछे truck ऑब्जेक्ट की है। तीसरी पंक्ति machine-टाइप नाम के पीछे car ऑब्जेक्ट की है। यह जोड़ी खेल एक पास में पूरा पाठ है।
अगर अभी भी abstract डेमो से केवल honk फिर park दिखे, polymorphism शिक्षण फ़ाइल पर जाएँ और फिर java Yard चलाइए। अगर हर वेरिएबल केवल Truck या Car टाइप है, आप अभी वह पैरेंट-टाइप रूप नहीं दिखा रहे जो यह पृष्ठ सिखाता है — डेमो के लिए असाइनमेंट की बाईं ओर Machine टाइप रखिए।
स्क्रीन देखते हुए नियम ज़ोर से कहिए: वेरिएबल टाइप पैरेंट हो सकता है, ऑब्जेक्ट बच्चा हो सकता है, जब बच्चे ने विधि override की हो तो कॉल बच्चे की बॉडी चलाती है। इस पृष्ठ पर equals override न गढ़िए। वह विषय अगले पाठ का इंतज़ार करता है।

Machine रेफ़रेंस के ज़रिए दो बच्चे

दूसरा प्रोग्राम override रखता है। main केवल Truck और Car बनाता है, अभी भी Machine के रूप में संग्रहीत, और प्रत्येक पर horn बुलाता है।

Yard Truck and Car as Machine refs

java

class Machine {
    void horn() {
        System.out.println("tone");
    }
}

class Truck extends Machine {
    void horn() {
        System.out.println("honk");
    }
}

class Car extends Machine {
    void horn() {
        System.out.println("beep");
    }
}

public class Yard {
    public static void main(String[] args) {
        Machine t = new Truck();
        Machine c = new Car();
        t.horn();
        c.horn();
    }
}

javac Yard.java से कंपाइल करिए, फिर java Yard चलाइए। स्क्रीन honk, फिर beep दिखाती है। इस दूसरी डेमो में सादा Machine ऑब्जेक्ट नहीं है, फिर भी दोनों वेरिएबल अभी Machine टाइप हैं। चाइल्ड ऑब्जेक्ट बॉडी देते हैं। छोटा स्क्रीन वाला वही polymorphism विचार है।
असाइनमेंट पंक्तियाँ एक बार और पढ़िए: बाईं ओर Machine, दाईं ओर new Truck() या new Car()। बाईं ओर वह पैरेंट टाइप नाम देती है जिसके ज़रिए आप बुलाएँगे। दाईं ओर असली ऑब्जेक्ट नाम देती है। दोनों बच्चों पर extends Machine रखिए ताकि वे असाइनमेंट वैध रहें।
अगर abstract डेमो अभी पास हों, उन्हें इतिहास की तरह रखिए। इस पाठ के लिए polymorphism शिक्षण फ़ाइल चलाइए ताकि स्क्रीन tone / honk / beep या honk / beep दिखाए, मुख्य कहानी के रूप में park नहीं। अगर javac डुप्लिकेट पब्लिक क्लास की शिकायत करे, केवल Yard पब्लिक रखिए।

कौन-सी horn बॉडी चलती है

📊 Who runs for each Machine variable

Variable	Real object	horn prints
`m`	`Machine`	`tone`
`t`	`Truck`	`honk`
`c`	`Car`	`beep`

abstract भरने से तुलना

abstract पृष्ठ पर Machine ने horn अधूरा छोड़ा और बच्चों ने भरा, अक्सर साझा park के साथ। इस पृष्ठ पर Machine के पास पहले से tone बॉडी है, बच्चे उसे override करते हैं, और पैरेंट-टाइप वेरिएबल ऑब्जेक्ट रखते हैं। आप अभी भी Yard.java कंपाइल करते हैं और java Yard चलाते हैं। नए टोकन पैरेंट-टाइप असाइनमेंट जैसे Machine t = new Truck(); और एक कॉल नाम से तीन अलग प्रिंट हैं।
अगर abstract फ़ाइल अभी खुली हो, आप abstract void horn(); और park देख सकते हैं। polymorphism फ़ाइल पर जाएँ ताकि Machine की सामान्य horn बॉडी हो और main Machine वेरिएबल अलग ऑब्जेक्ट को असाइन करे। इस पृष्ठ से equals डेमो बाहर रखिए। इस पृष्ठ से कीबोर्ड इनपुट बाहर रखिए।

equals से पहले

आप Machine वेरिएबल को Machine, Truck और Car ऑब्जेक्ट असाइन कर tone, फिर honk, फिर beep देख सकते हैं। आप केवल दो बच्चों को Machine रेफ़रेंस के रूप में रख honk फिर beep देख सकते हैं। प्रत्येक रखी डेमो के लिए बारी-बारी Yard.java कंपाइल कर java Yard चलाइए। कॉल ने बॉडी के मालिक का उपयोग किया। अगला पृष्ठ equals है, जहाँ दो ऑब्जेक्ट को शिक्षण-सुरक्षित तरीके से समानता के लिए तुलना की जाती है।
स्पष्ट पैरेंट-प्लस-चिल्ड्रन स्क्रीन के लिए तीन-ऑब्जेक्ट डेमो रखिए। स्पष्ट पैरेंट-टाइप जोड़ी के लिए दो-चाइल्ड डेमो रखिए। इस पृष्ठ से equals फ़ाइलें बाहर रखिए। आगे बढ़ने से पहले ये तीन आदतें चेकपॉइंट हैं। जब Machine-टाइप truck वेरिएबल से honk आए, polymorphism ने इस पाठ का काम किया और आप equals वाले अगले विषय के लिए तैयार हैं।
फ़ोल्डर का एक आखिरी पास: एक पब्लिक Yard, पैरेंट और चाइल्ड horn बॉडी, main में पैरेंट-टाइप वेरिएबल, कोई कीबोर्ड इंतज़ार नहीं, कोई जबरन equals नहीं। खुली डेमो पर एक बार और javac Yard.java और java Yard चलाइए। अगर स्क्रीन अभी भी तालिका से मेल खाए, कई-रूप कॉल ठोस है और कोर्स अगले पृष्ठ पर equals पर जा सकता है।

🧠 अपने ज्ञान की परीक्षा करें

शुरू करने के लिए तैयार

अपने ज्ञान की परीक्षा करें

इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं

❓

प्रश्न

🎯

70%

पास करने के लिए

♾️

∞

समय

🔄

∞

प्रयास

📝 निर्देश

हर प्रश्न को ध्यान से पढ़ें
हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
आपकी प्रगति शीर्ष पर दिखाई जाएगी