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

Java में Abstract Classes

जब पैरेंट क्लास को बच्चों के भरने के लिए कम से कम एक विधि बिना बॉडी छोड़नी हो, उसे abstract चिह्नित करिए। abstract void horn(); और सामान्य विधि park वाला abstract class Machine लिखिए जो park छापे। class Truck extends Machine लिखिए और horn को ऐसी बॉडी दीजिए जो honk छापे। Yard.java में एक Truck बनाइए, t.horn() बुलाइए, फिर t.park() बुलाइए। javac Yard.java से कंपाइल कर java Yard चलाइए। स्क्रीन को honk, फिर park दिखाना चाहिए। दूसरी डेमो Car जोड़ती है ताकि दो बच्चे horn अलग-अलग भरें। polymorphism अगले पृष्ठ के लिए छोड़ दें — यह पाठ अधूरी पैरेंट विधि और उसे पूरा करने वाला बच्चा है।

बच्चे पर abstract विधि भरिए

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

Yard Truck fills abstract horn then park

java

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

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

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

जिस फ़ोल्डर में Yard.java है वहाँ से javac Yard.java चलाइए। जब कोष्ठक, ब्रेसेस और सेमीकोलन मेल खाएँ, javac अपनी कोई पंक्ति नहीं लिखता। फिर java Yard चलाइए — java Yard.java नहीं। रन कमांड से .java अंत हटा दीजिए। फ़ाइल में एक पब्लिक क्लास रखिए ताकि नाम Yard से मेल खाए। सहायक प्रकार Machine और Truck इस शुरुआती रूप में public के बिना रहते हैं।
स्क्रीन honk, फिर park दिखाती है। रन को एक बार चलिए। Java Yard.main से शुरू होता है। new Truck() एक truck बनाता है जिसने abstract horn पूरा किया। t.horn() honk छापता है। t.park() पहले से मौजूद पैरेंट बॉडी से park छापता है। अधूरी विधि केवल आवश्यकता के रूप में रही जब तक बच्चे ने बॉडी नहीं लिखी।
अगर javac मना करे, तीन बातें जाँचिए। पहला, पैरेंट क्लास पंक्ति को abstract class Machine कहना चाहिए। दूसरा, अधूरी विधि को abstract कहना चाहिए और ; पर समाप्त होना चाहिए। तीसरा, Truck को सच में बॉडी के साथ horn लिखना चाहिए। अगर अभी भी enum फ़ाइल से MEDIUM दिखे, abstract शिक्षण फ़ाइल पर जाएँ और फिर java Yard चलाइए। अगर आप new Machine() आज़माएँ, javac मना करता है — इस पृष्ठ पर वही अपेक्षित है।
स्क्रीन देखते हुए नियम ज़ोर से कहिए: abstract पैरेंट गायब विधि नाम देता है, बच्चा भरता है, साझा विधियाँ अभी भी चलती हैं। अभी कई पैरेंट-टाइप्ड चरों की लंबी polymorphism परेड न गढ़ें। वह कहानी अगले पाठ की प्रतीक्षा करती है।

दो बच्चे horn अलग-अलग भरते हैं

दूसरा प्रोग्राम वही abstract Machine रखता है। Truck अभी भी honk छापता है। नया Car beep छापता है। main दोनों बनाता है, प्रत्येक horn बुलाता है, फिर truck पर park बुलाता है।

Yard Truck and Car fill horn then park

java

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

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) {
        Truck t = new Truck();
        Car c = new Car();
        t.horn();
        c.horn();
        t.park();
    }
}

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

enum और इंटरफेस से तुलना

enum पृष्ठ पर Level ने स्थिर नाम सूचीबद्ध किए। इंटरफेस पृष्ठ पर implements ने खाली इंटरफेस विधियाँ भरीं। इस पृष्ठ पर abstract class और extends एक क्लास विधि को अधूरा छोड़ते हैं जब तक बच्चा बॉडी न लिखे। आप अभी भी Yard.java कंपाइल करते हैं और java Yard चलाते हैं। नए टोकन हैं abstract class, abstract void horn();, और वह बच्चा जो बॉडी देता है तथा park पुनः उपयोग करता है।
अगर बची enum Level फ़ाइल अभी खुली हो, स्थिरांक और शायद switch दिखेंगे। abstract फ़ाइल पर जाएँ ताकि ऊपर abstract class Machine दिखे और main एक Truck बनाए। केवल पैरेंट-टाइप्ड चर घुमाने वाली polymorphism डेमो इस पृष्ठ से बाहर रखिए। कीबोर्ड इनपुट इस पृष्ठ से बाहर रखिए।

यह पृष्ठ polymorphism के लिए क्या छोड़ता है

यह पृष्ठ ठोस बच्चों पर abstract विधियाँ पूरा करता है। अगला पृष्ठ polymorphism दिखाता है, जहाँ एक पैरेंट-टाइप्ड चर अलग-अलग बच्चे ऑब्जेक्ट रख सकता है और मिलती विधि बॉडी बुला सकता है। यहाँ abstract पैरेंट और भरे बच्चों के साथ रहिए। अभी कई बच्चों की ओर इशारा करने वाले Machine चरों की सूची न माँगिए।
बाद में जब polymorphism डेमो लिखेंगे, अक्सर अभी भी abstract या साधारण पैरेंट विधि नाम से शुरू करेंगे। इस पृष्ठ को उस पड़ोसी कहानी का अधूरी-विधि आधा समझिए। दोनों Yard डेमो तब तक पूरा करिए जब तक honk फिर park — और फिर honk, beep, park — स्वचालित न लगें, तब polymorphism पाठ खोलिए।

polymorphism से पहले

आप abstract class Machine घोषित कर सकते हैं, Truck पर horn भर सकते हैं, और honk फिर park देख सकते हैं। अपने horn वाला Car जोड़कर honk, फिर beep, फिर park देख सकते हैं। प्रत्येक रखी डेमो के लिए बारी-बारी Yard.java कंपाइल कर java Yard चलाइए। बच्चे ने abstract विधि पूरा की। अगला पृष्ठ polymorphism है, जहाँ पैरेंट-टाइप्ड संदर्भ से कॉल बच्चे की बॉडी चुनती हैं।
स्पष्ट abstract भरना और साझा park के लिए एकल-truck डेमो रखिए। स्पष्ट भरने की जोड़ी के लिए दो-बच्चे डेमो रखिए। polymorphism परेड फ़ाइलें इस पृष्ठ से बाहर रखिए। आगे बढ़ने से पहले ये तीन आदतें चेकपॉइंट हैं। जब new Truck() के बाद honk park से पहले आए, abstract क्लास ने इस पाठ का काम किया और आप polymorphism वाले अगले विषय के लिए तैयार हैं।
फ़ोल्डर का एक अंतिम पास: एक पब्लिक Yard, एक abstract Machine, horn भरने वाले ठोस बच्चे, बिना new Machine(), बिना कीबोर्ड इंतज़ार। खुली रखी डेमो पर एक बार और javac Yard.java और java Yard चलाइए। अगर स्क्रीन अभी भी आपके लिखे भरने छापे, abstract अनुबंध मज़बूत है और कोर्स अगले पृष्ठ पर polymorphism पर जा सकता है।

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

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

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

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

❓

प्रश्न

🎯

70%

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

♾️

∞

समय

🔄

∞

प्रयास

📝 निर्देश

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