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

Java में super

चाइल्ड कंस्ट्रक्टर के अंदर super से पैरेंट कंस्ट्रक्टर पहले चलाएँ। Truck extends Car रखिए। Truck() में super(); बुलाइए, फिर truck छापिए। Car() में car छापिए। Yard.java कंपाइल करके java Yard चलाइए। स्क्रीन पर पहले car, फिर truck दिखना चाहिए। दूसरी डेमो super("car") से चिह्न Car(String mark) में भेजती है। किसी विधि का ओवरराइड अगले पृष्ठ के लिए छोड़ दें — यह पाठ super के साथ कंस्ट्रक्टर क्रम पर है।

पहले पैरेंट कंस्ट्रक्टर बुलाइए

इनहेरिटेंस पृष्ठ ने खाली Truck को Car का horn इस्तेमाल करने दिया। यह पृष्ठ कंस्ट्रक्टर जोड़ता है। Yard.java खोलिए। पब्लिक क्लास नाम Yard रखिए। बचे पथ डेमो, सिर्फ-horn फ़ाइलें अगर कंस्ट्रक्टर उलझाएँ, Store लेखक, और कीबोर्ड Scanner हटा दीजिए। प्रोग्राम टाइपिंग का इंतज़ार न करे। import लाइन की ज़रूरत नहीं।
पैरेंट को बिना आर्गुमेंट वाला कंस्ट्रक्टर घोषित करिए जो car छापे:
class Car {
Car() {
System.out.println("car");
}
}
चाइल्ड को extends Car से घोषित करिए। Truck() के अंदर पहली स्टेटमेंट super(); रखिए, फिर truck छापिए:
super();
System.out.println("truck");
Yard.main में एक ट्रक बनाइए:
Truck t = new Truck();
ट्रक बनाना Truck() में प्रवेश करता है। वह कॉल super() से शुरू होती है, जो Car() चलाती है। पैरेंट खत्म होने के बाद चाइल्ड प्रिंट चलता है।

Yard super then truck print

java

class Car {
    Car() {
        System.out.println("car");
    }
}

class Truck extends Car {
    Truck() {
        super();
        System.out.println("truck");
    }
}

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

जिस फ़ोल्डर में Yard.java है वहाँ से javac Yard.java चलाइए। जब कोष्ठक, ब्रेस और सेमीकोलन मेल खाते हैं, javac अपनी कोई पंक्ति नहीं लिखता। फिर java Yard चलाइए — java Yard.java नहीं। रन कमांड से .java अंत छोड़ दीजिए। फ़ाइल में एक पब्लिक क्लास रखिए ताकि नाम Yard से मेल खाए। सहायक टाइप Car और Truck इस शुरुआती रूप में बिना public रहें।
स्क्रीन पहले car, फिर truck दिखाती है। रन एक बार घुमाइए। Java Yard.main से शुरू होता है। new Truck() Truck() में जाता है। पहली स्टेटमेंट super(); है, इसलिए Car() चलकर car छापता है। नियंत्रण Truck() पर लौटता है और truck छापता है। पैरेंट पंक्ति चाइल्ड पंक्ति से पहले आती है क्योंकि super() पहले चला।
स्क्रीन देखते हुए क्रम ज़ोर से बोलिए: पैरेंट कंस्ट्रक्टर, फिर चाइल्ड प्रिंट। वही बोला क्रम चाइल्ड कंस्ट्रक्टर में super() जो थोपता है उससे मेल खाता है। अगर पंक्तियाँ गलत क्रम में आएँ, शिक्षण फ़ाइल फिर खोलिए और जाँचिए कि Truck() में super(); अभी भी किसी println से पहले पहली स्टेटमेंट है।
अगर बाद के प्रयोग में जहाँ पैरेंट कंस्ट्रक्टर को आर्गुमेंट चाहिए, आप truck को super() से पहले छापें, तो javac मना कर सकता है — जब आप super लिखें तो वह पहली स्टेटमेंट हो। पहली डेमो में पैरेंट को आर्गुमेंट नहीं चाहिए, और शिक्षण फ़ाइल जानबूझकर super(); पहले रखती है ताकि क्रम साफ़ रहे। अगर पुरानी horn डेमो से सिर्फ beep दिखे, कंस्ट्रक्टर शिक्षण फ़ाइल पर जाएँ और फिर java Yard चलाइए।
इस पृष्ठ पर Truck पर horn दोबारा न लिखें। विधि ओवरराइड अगला पाठ है। आज चाइल्ड कंस्ट्रक्टर super से पैरेंट से बात करता है, फिर अपना शब्द छापता है। शब्द car पैरेंट तरफ और truck चाइल्ड तरफ रखिए ताकि हर पंक्ति बताए कौन सा कंस्ट्रक्टर खत्म हुआ।

super से पैरेंट को मान भेजिए

दूसरा प्रोग्राम extends रखता है। पैरेंट कंस्ट्रक्टर अब String mark लेता है और वही चिह्न छापता है। चाइल्ड super("car") बुलाता है और फिर truck छापता है।

Yard super with mark argument

java

class Car {
    Car(String mark) {
        System.out.println(mark);
    }
}

class Truck extends Car {
    Truck() {
        super("car");
        System.out.println("truck");
    }
}

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

javac Yard.java से कंपाइल करिए, फिर java Yard चलाइए। स्क्रीन फिर car, फिर truck दिखाती है। इस बार car वह आर्गुमेंट है जो आपने super("car") से भेजा, बिना-आर्गुमेंट Car() के अंदर कड़ी प्रिंट नहीं। चाइल्ड ने चिह्न स्ट्रिंग चुनी; पैरेंट कंस्ट्रक्टर ने उसे छापा। उसके बाद चाइल्ड ने truck छापा।
पैरेंट कंस्ट्रक्टर सिग्नेचर एक बार और पढ़िए: Car(String mark)। super("car") के अंदर उद्धरण में स्ट्रिंग वही mark है। इस जाँच के लिए फ़ाइल में और कुछ न बदलें — extends Car रखिए, चाइल्ड का truck प्रिंट रखिए, और main में new Truck() रखिए। स्क्रीन अभी भी car के नीचे truck पर खत्म होती है क्योंकि चाइल्ड प्रिंट तभी चलता है जब super("car") लौट आए।
अगर आप super("car") छोड़ दें जबकि Car के पास सिर्फ Car(String mark) है, तो javac मना करता है, क्योंकि पैरेंट के पास अब चुपचाप बिना-आर्गुमेंट कंस्ट्रक्टर नहीं है जिसे आपके लिए बुलाए। मेल खाता super(...) कॉल लिखना ही तरीका है जिससे चाइल्ड पैरेंट को ज़रूरी मानों से शुरू करता है। Truck() में super को पहली स्टेटमेंट रखिए। अगर javac Car पर गायब डिफ़ॉल्ट कंस्ट्रक्टर की शिकायत करे, पहले चाइल्ड कंस्ट्रक्टर देखिए और पक्का करिए कि super("car") पंक्ति मौजूद है और अभी भी पहली है।

horn पृष्ठ के सादे extends से तुलना

इनहेरिटेंस पृष्ठ पर खाली Truck ने बिना कंस्ट्रक्टर लिखे horn बुलाया। इस पृष्ठ पर कंस्ट्रक्टर super से क्रम में चलते हैं। पास के horn डेमो इतिहास की तरह रखें; super शिक्षण फ़ाइल को java Yard से चलाएँ ताकि स्क्रीन car फिर truck दिखाए।
horn पृष्ठ ने साबित किया कि extends एक विधि साझा करता है। यह पृष्ठ साबित करता है कि extends निर्माण पथ भी साझा करता है: चाइल्ड super से पैरेंट शुरू करता है, फिर अपने प्रिंट से आगे बढ़ता है। दोनों पाठ Truck extends Car रखते हैं। सिर्फ Truck का शरीर बदलता है — खाली ब्रेस और बाद में horn कॉल से, ऐसे कंस्ट्रक्टर तक जो super से शुरू होता है।
super(), super("car"), और कंस्ट्रक्टर क्रम नए टोकन हैं। आपको अभी भी extends चाहिए। अभी विधि ओवरराइड की ज़रूरत नहीं। अगर main में बचा horn कॉल हो, इन डेमो के लिए हटा दीजिए ताकि स्क्रीन सिर्फ कंस्ट्रक्टर प्रिंट दिखाए।

यह पृष्ठ ओवरराइड के लिए क्या छोड़ता है

यह पृष्ठ पैरेंट कंस्ट्रक्टर super से चलाता है। अगला पृष्ठ ओवरराइड दिखाता है, जहाँ चाइल्ड उस विधि का अपना संस्करण लिखता है जो पैरेंट के पास पहले से है। यहाँ कंस्ट्रक्टर super कॉल पर रहें। इन डेमो पर अभी Truck पर horn बदलना ज़रूरी न बनाएँ।
जब बाद में आप विधि ओवरराइड करेंगे, अक्सर फिर भी पहले super से पैरेंट कंस्ट्रक्टर बुलाएँगे। इस पृष्ठ को उस कहानी का कंस्ट्रक्टर आधा समझिए। दोनों Yard डेमो तब तक पूरा करिए जब तक car फिर truck अपने-आप लगे, फिर ओवरराइड पाठ खोलिए।

ओवरराइड से पहले

आप super(); बुलाकर फिर truck छाप सकते हैं और पहले car देख सकते हैं। जब पैरेंट चिह्न लेता है तो super("car") बुलाकर भी car, फिर truck देख सकते हैं। हर रखी डेमो के लिए बारी-बारी Yard.java कंपाइल करिए और java Yard चलाइए। पैरेंट कंस्ट्रक्टर चाइल्ड प्रिंट से पहले खत्म हुआ। अगला पृष्ठ ओवरराइड है, जहाँ चाइल्ड विधि शरीर बदलता है।
साफ़ क्रम के लिए बिना-आर्गुमेंट super() डेमो रखिए। साफ़ आर्गुमेंट पास के लिए super("car") डेमो रखिए। विधि ओवरराइड इस पृष्ठ से बाहर रखिए। ये तीन आदतें आगे बढ़ने से पहले चेकपॉइंट हैं। जब new Truck() के बाद car ऊपर और truck नीचे आए, super ने इस पाठ का काम कर दिया और आप ओवरराइड वाले अगले विषय के लिए तैयार हैं।
फ़ोल्डर का आखिरी चक्कर: एक पब्लिक Yard, दो सहायक टाइप, कीबोर्ड इंतज़ार नहीं, पथ अवशेष नहीं, जबरन horn पुनर्लेखन नहीं। खुली डेमो पर एक बार और javac Yard.java और java Yard चलाइए। अगर स्क्रीन अभी भी car फिर truck छापे, कंस्ट्रक्टर क्रम मजबूत है और कोर्स अगले पृष्ठ पर ओवरराइड पर जा सकता है।

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

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

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

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

❓

प्रश्न

🎯

70%

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

♾️

∞

समय

🔄

∞

प्रयास

📝 निर्देश

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