वर्ग चर के संबंध में अप-कास्टिंग और डाउन-कास्टिंग के बीच अंतर क्या है


138

वर्ग चर के संबंध में अप-कास्टिंग और डाउन-कास्टिंग के बीच अंतर क्या है?

उदाहरण के लिए निम्न प्रोग्राम में क्लास एनिमल में केवल एक ही विधि होती है लेकिन डॉग क्लास में दो विधियाँ होती हैं, फिर हम डॉग वेरिएबल को एनिमल वेरिएबल में कैसे डालते हैं।

यदि कास्टिंग की जाती है तो हम डॉग की दूसरी विधि को एनिमल के चर के साथ कैसे कह सकते हैं।

class Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Animal");
    }
}


class Dog extends Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Dog");
    }

    public void callme2()
    {
        System.out.println("In callme2 of Dog");
    }
}

public class UseAnimlas 
{
    public static void main (String [] args) 
    {
        Dog d = new Dog();      
        Animal a = (Animal)d;
        d.callme();
        a.callme();
        ((Dog) a).callme2();
    }
}

A एक Dogहै Animal। जब तक आप एक निश्चित अतिभारित विधि का उपयोग नहीं करना चाहते, तब तक अधिकांश समय अनावश्यक है। callmeदोनों में मौजूद है Animalऔर Dogcallme2केवल में मौजूद है Dog, जो आपको डाली aको Dogयह काम करने के लिए।
ब्रायन

आपके कोड का आउटपुट क्या है?
मालविंदर सिंह

दिलचस्प बात यह है, कि d.callme ने 'In callme of Dog' की वापसी की, हालांकि d को जानवर के रूप में रखा गया था !!
16:

4
@ क्रिस 311 'डी' और 'ए' एक ही ऑब्जेक्ट की ओर इशारा करता है ... जो एक डॉग है, लेकिन 'ए' के ​​पास केवल डॉग के विशिष्ट तरीकों तक पहुंच है, जब यह रनटाइम में डाउनकास्ट होता है। प्रभाव: पशु a = (पशु) d; अनावश्यक है, आपको केवल पशु a = d की आवश्यकता है; जैसा कि आप ऊपर उठा रहे हैं।
मार्क कीन

जवाबों:


223

डाउनकास्टिंग एक सुपरपाइप के लिए कास्टिंग है, जबकि डाउनकास्टिंग एक उपप्रकार के लिए कास्टिंग है। Upcasting को हमेशा अनुमति दी जाती है, लेकिन डाउनकास्टिंग में एक प्रकार की जांच शामिल होती है और इसे फेंक सकते हैं ClassCastException

आपके मामले में, एक से एक डाली Dogएक के लिए Animalहै, क्योंकि एक, एक Upcast है Dogहै-एक Animal। सामान्य तौर पर, जब भी दो वर्गों के बीच एक-एक संबंध होता है, तो आप इसे बढ़ा सकते हैं।

डाउनकास्टिंग कुछ इस तरह होगी:

Animal animal = new Dog();
Dog castedDog = (Dog) animal;

मूल रूप से आप जो कर रहे हैं वह संकलक को बता रहा है कि आप जानते हैं कि वास्तव में ऑब्जेक्ट का रनटाइम प्रकार क्या है। संकलक रूपांतरण की अनुमति देगा, लेकिन फिर भी यह सुनिश्चित करने के लिए एक रनटाइम सैनिटरी चेक सम्मिलित करेगा कि रूपांतरण समझ में आता है। इस मामले में, कास्ट संभव है क्योंकि रनटाइम animalपर वास्तव में एक है Dog, हालांकि स्थिर प्रकार का animalहै Animal

हालांकि, यदि आप ऐसा करने के लिए थे:

Animal animal = new Animal();
Dog notADog = (Dog) animal;

तुम एक मिल जाएगा ClassCastException। इसका कारण यह है कि क्योंकि animalरनटाइम प्रकार है Animal, और इसलिए जब आप रनटाइम के बारे में कलाकारों को यह बताते हैं कि animalयह वास्तव में एक नहीं है Dogऔर इसलिए फेंकता है ClassCastException

एक सुपरक्लास की विधि को कॉल करने के लिए आप super.method()अपकास्ट करके या कर सकते हैं ।

एक उपवर्ग की विधि को कॉल करने के लिए आपको एक डाउनकास्ट करना होगा। जैसा कि ऊपर दिखाया गया है, आप सामान्य रूप ClassCastExceptionसे ऐसा करके जोखिम उठाते हैं ; हालाँकि, आप instanceofकास्ट करने से पहले ऑपरेटर के ऑब्जेक्ट का रनटाइम प्रकार जाँचने के लिए उपयोग कर सकते हैं , जो आपको ClassCastExceptions को रोकने की अनुमति देता है :

Animal animal = getAnimal(); // Maybe a Dog? Maybe a Cat? Maybe an Animal?
if (animal instanceof Dog) {
    // Guaranteed to succeed, barring classloader shenanigans
    Dog castedDog = (Dog) animal;
}

क्या उचित डाउनकास्टिंग सुनिश्चित करता है ClassCastExceptionया नहीं? पहले मामले में पसंद है?
मालविंदर सिंह

@ आप "उचित" से क्या मतलब है?
28

2
@awksp यह एक उत्कृष्ट और स्पष्ट जवाब है। कास्टिंग के बारे में मुझे जो कुछ भी जानने की जरूरत है वह बहुत ज्यादा है।
गौतम होन्नवारा

निश्चित रूप से आपने ऐसी कक्षाएं नहीं बनाई हैं जहां जानवर आपके पास कुत्ते का एक उदाहरण है? तो तुम भी इसके लिए जाँच क्यों कर रहे हो?
बार्लोप

62

डाउन-कास्टिंग और अप-कास्टिंग इस प्रकार था:
यहां छवि विवरण दर्ज करें

Upcasting : जब हम एक सुपर क्लास को सुपर क्लास में डालना चाहते हैं, तो हम Upcasting (या चौड़ीकरण) का उपयोग करते हैं। यह स्वचालित रूप से होता है, स्पष्ट रूप से कुछ भी करने की आवश्यकता नहीं है।

डाउनकास्टिंग : जब हम सुपर क्लास को सब क्लास में डालना चाहते हैं, तो हम डाउनकास्टिंग (या संकीर्णता) का उपयोग करते हैं, और डाउनकास्टिंग जावा में सीधे संभव नहीं है, स्पष्ट रूप से हमें करना है।

Dog d = new Dog();
Animal a = (Animal) d; //Explicitly you have done upcasting. Actually no need, we can directly type cast like Animal a = d; compiler now treat Dog as Animal but still it is Dog even after upcasting
d.callme();
a.callme(); // It calls Dog's method even though we use Animal reference.
((Dog) a).callme2(); // Downcasting: Compiler does know Animal it is, In order to use Dog methods, we have to do typecast explicitly.
// Internally if it is not a Dog object it throws ClassCastException

तो, विधि के माता-पिता को कॉल करने के लिए upcasting करने का ऐसा कोई तरीका नहीं है?
करालिहानोस

32

अपकास्टिंग और डाउनकास्टिंग जावा का महत्वपूर्ण हिस्सा है, जो हमें सरल वाक्यविन्यास का उपयोग करके जटिल कार्यक्रमों का निर्माण करने की अनुमति देता है, और हमें बहुत फायदे देता है, जैसे कि पॉलीमॉर्फिज़्म या विभिन्न वस्तुओं को समूहीकृत करना। जावा किसी भी सुपरक्लास प्रकार की वस्तु के रूप में माना जाने वाला एक उपवर्ग प्रकार की एक वस्तु की अनुमति देता है। इसे अपकमिंग कहा जाता है। Upcasting स्वचालित रूप से किया जाता है, जबकि डाउनकास्टिंग मैन्युअल रूप से प्रोग्रामर द्वारा किया जाना चाहिए , और मैं यह समझाने के लिए अपना सर्वश्रेष्ठ देने जा रहा हूं कि ऐसा क्यों है।

Upcasting और downcasting एक से दूसरे में कास्टिंग आदिम की तरह नहीं हैं, और मुझे विश्वास है कि जब प्रोग्रामर कास्टिंग ऑब्जेक्ट सीखना शुरू करता है, तो बहुत भ्रम पैदा होता है।

बहुरूपता: जावा में सभी विधियां डिफ़ॉल्ट रूप से आभासी हैं। इसका मतलब है कि विरासत में उपयोग किए जाने पर किसी भी विधि को ओवरराइड किया जा सकता है, जब तक कि उस पद्धति को अंतिम या स्थिर घोषित नहीं किया जाता है

आप नीचे दिए गए उदाहरण को देख सकते हैं कि getType();ऑब्जेक्ट (डॉग, पेट, पुलिस डॉग) प्रकार के अनुसार कैसे काम करता है।

मान लें कि आपके पास तीन कुत्ते हैं

  1. कुत्ता - यह सुपर क्लास है।

  2. पालतू कुत्ता - पालतू कुत्ता कुत्ते का विस्तार करता है।

  3. पुलिस डॉग - पुलिस डॉग पालतू कुत्ते का विस्तार करता है।

    public class Dog{ 
       public String getType () {
          System.out.println("NormalDog");
          return "NormalDog";
       }
     }
    
    /**
     * Pet Dog has an extra method dogName()
     */   
    public class PetDog extends Dog{ 
       public String getType () {
          System.out.println("PetDog");
          return "PetDog";
       }
       public String dogName () {
          System.out.println("I don't have Name !!");
          return "NO Name";
       }
     }
    
    /**
     * Police Dog has an extra method secretId()
     */
    public class PoliceDog extends PetDog{
    
     public String secretId() {
        System.out.println("ID");
        return "ID";
     }
    
     public String getType () {
         System.out.println("I am a Police Dog");
         return "Police Dog";
     }
    }

बहुरूपता: जावा में सभी विधियां डिफ़ॉल्ट रूप से आभासी हैं। इसका मतलब है कि विरासत में उपयोग किए जाने पर किसी भी विधि को ओवरराइड किया जा सकता है, जब तक कि उस विधि को अंतिम या स्थिर घोषित नहीं किया जाता है। (एक्सप्लोरेशन बेलॉन्ज टू वर्चुअल टेबल कॉन्सेप्ट)

वर्चुअल टेबल / डिस्पैच टेबल: ऑब्जेक्ट की डिस्पैच टेबल में ऑब्जेक्ट के डायनामिक बाउंड विधियों के पते होंगे। विधि के प्रेषण तालिका से विधि के पते को लाकर विधि कॉल किया जाता है। प्रेषण तालिका एक ही वर्ग से संबंधित सभी वस्तुओं के लिए समान है, और इसलिए आम तौर पर उनके बीच साझा की जाती है।

public static void main (String[] args) {
      /**
       * Creating the different objects with super class Reference
       */
     Dog obj1 = new Dog();
`         /**
           *  Object of Pet Dog is created with Dog Reference since                
           *  Upcasting is done automatically for us we don't have to worry about it 
           *  
           */
     Dog obj2 = new PetDog();
`         /**
           *  Object of Police Dog is created with Dog Reference since                
           *  Upcasting is done automatically for us we don't have to worry       
           *  about it here even though we are extending PoliceDog with PetDog 
           *  since PetDog is extending Dog Java automatically upcast for us 
           */
      Dog obj3 = new PoliceDog();
}



 obj1.getType();

प्रिंटों Normal Dog

  obj2.getType();

प्रिंटों Pet Dog

 obj3.getType();

प्रिंटों Police Dog

डाउनकास्टिंग प्रोग्रामर को मैन्युअल रूप से करने की आवश्यकता है

जब आप उस secretID();विधि को लागू करने का प्रयास करते हैं, obj3जिस PoliceDog objectपर संदर्भित है, लेकिन Dogपदानुक्रम में एक सुपर क्लास है, तो यह त्रुटि को फेंकता है क्योंकि विधि obj3तक पहुंच नहीं है secretId()उस विधि को लागू करने के लिए आपको उस obj3 को मैन्युअल रूप से डाउनकास्ट करना होगा PoliceDog

  ( (PoliceDog)obj3).secretID();

जो प्रिंट करता है ID

कक्षा dogName();में विधि को लागू करने के लिए इसी तरह से PetDogआपको डाउनकास्ट obj2करना होगा PetDogक्योंकि obj2 को संदर्भित किया जाता है Dogऔर dogName();विधि तक पहुंच नहीं है

  ( (PetDog)obj2).dogName();

ऐसा क्यों है, कि उत्थान स्वचालित है, लेकिन डाउनकास्टिंग मैनुअल होना चाहिए? ठीक है, आप देख रहे हैं, अपकास्टिंग कभी भी विफल नहीं हो सकता। लेकिन अगर आप अलग कुत्तों के एक समूह है और उन सब को अपने प्रकार के लिए एक को खिन्न चाहते हैं, तो इस बात की संभावना है, इन कुत्तों के कुछ विभिन्न प्रकार के वास्तव में कर रहे यानी, कि PetDog, PoliceDog, और इस प्रक्रिया, विफल रहता है फेंकने से ClassCastException

यही कारण है कि आपको अपनी वस्तुओं को मैन्युअल रूप से डाउन करने की आवश्यकता है यदि आपने अपनी वस्तुओं को सुपर क्लास प्रकार के लिए संदर्भित किया है।

ध्यान दें: यहाँ संदर्भित करके इसका मतलब है कि आप अपने ओजेक्ट्स के मेमोरी एड्रेस को नहीं बदल रहे हैं जब आप इसे डाउनकास्ट करते हैं तो यह अभी भी वही रहता है जो आप उन्हें इस मामले में विशेष प्रकार के लिए ग्रुप कर रहे हैं Dog


'पॉलीमॉर्फिज्म मेथड कॉल के दौरान ऑटोमैटिक डाउनकास्ट का उपयोग करता है।' नहीं, यह नहीं है। उपयोग किया जाने वाला तंत्र निर्दिष्ट नहीं है, लेकिन सबसे सामान्य तंत्र -a व्यवहार्य - ऐसी कोई बात नहीं है। ऑब्जेक्ट कोड में देखें। कोई डाउनकास्ट नहीं।
लोर्ने का

क्यों नहीं? यह वही है जो सही है आप एक उदाहरण दे सकते हैं जहां यह काम नहीं करेगा?
नागार्जुन येलिसैटी

1
क्यों नहीं? यह वही होता है जो सही होता है .. क्या आप एक उदाहरण दे सकते हैं, जहां 'पॉलीमोर्फिज्म मेथड कॉल के दौरान ऑटोमैटिक डाउनकास्ट' का उपयोग करता है। विफल रहेगा या सच नहीं होगा?
नागार्जुन येलिसैटी

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

1
'मेरे ज्ञान के अनुसार मेरे कथन सत्य हैं और यह हर मामले में सही है' यह एक प्रमाण नहीं है। यह एक मात्र दावा है। मैं पूछ रहा हूँ आप को साबित करने के अपने बयान। आप ऐसा नहीं कर रहे हैं। वास्तव में आप केवल खुद को दोहरा रहे हैं। और मैंने पहले से ही कई प्रतिनियुक्ति प्रदान की हैं। मैंने एक निर्णय प्रक्रिया भी प्रदान की है। यदि आप किसी विधि कॉल के लिए ऑब्जेक्ट कोड में डाउनकास्ट पा सकते हैं, तो आप सही हैं और मैं गलत हूं। इस प्रकार विज्ञान किया जाता है। कर दो। और यह दावा करना कि मैं 'साहसपूर्वक प्रलेखन पर निर्भर करता हूं' एक गलत व्याख्या है। ऐसा मत करो।
लोर्ने का

12

मुझे पता है कि यह प्रश्न काफी पहले से पूछा गया था लेकिन इस प्रश्न के नए उपयोगकर्ताओं के लिए। कृपया इस लेख जहां upcasting पर पूरा विवरण होता है, downcasting और के उपयोग को पढ़ने instanceof ऑपरेटर

  • मैन्युअल रूप से ऊपर उठाने की आवश्यकता नहीं है, यह अपने आप होता है:

    Mammal m = (Mammal)new Cat(); बराबर है Mammal m = new Cat();

  • लेकिन डाउनकास्टिंग हमेशा मैन्युअल रूप से किया जाना चाहिए:

    Cat c1 = new Cat();      
    Animal a = c1;      //automatic upcasting to Animal
    Cat c2 = (Cat) a;    //manual downcasting back to a Cat

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

 Cat c1 = new Cat();         
    Animal a = c1;       //upcasting to Animal
    if(a instanceof Cat){ // testing if the Animal is a Cat
        System.out.println("It's a Cat! Now i can safely downcast it to a Cat, without a fear of failure.");        
        Cat c2 = (Cat)a;
    }

अधिक जानकारी के लिए कृपया इस लेख को पढ़ें


अच्छी बात: स्तनपायी m = (स्तनपायी) नई बिल्ली (); Mammal m = new Cat () के बराबर;
कैटालिट्स

6

बेहतर है कि इस विधि को बनाए रखने के लिए प्रयास करें, यह समझना आसान है:

/* upcasting problem */
class Animal
{ 
    public void callme()
    {
        System.out.println("In callme of Animal");
    }
}

class Dog extends Animal 
{ 
    public void callme()
    {
        System.out.println("In callme of Dog");
    }

    public void callme2()
    {
        System.out.println("In callme2 of Dog");
    }
}

public class Useanimlas 
{
    public static void main (String [] args) 
    {
        Animal animal = new Animal ();
        Dog dog = new Dog();
        Animal ref;
        ref = animal;
        ref.callme();
        ref = dog;
        ref.callme();
    }
}

और अंतिम पंक्ति में यह हो सकता है: ((कुत्ता) रेफ) .callme2 (); डॉग क्लास की डाउनकास्टिंग / संकीर्णता और कॉलमे 2 () पद्धति का उपयोग।
udarH3

6

शायद यह तालिका मदद करती है। callme()कक्षा Parentया कक्षा की विधि को कॉल करना Child। एक सिद्धांत के रूप में:

UPCASTING -> छिपाना

DOWNCASTING -> खुलासा

यहां छवि विवरण दर्ज करें

यहां छवि विवरण दर्ज करें

यहां छवि विवरण दर्ज करें


4

1.- अपकास्टिंग।

एक upcasting करते हुए, आप कुछ प्रकार के टैग को परिभाषित करते हैं, जो एक उपप्रकार के ऑब्जेक्ट को इंगित करता है (प्रकार और उपप्रकार को वर्ग और उपवर्ग कहा जा सकता है, यदि आप अधिक आरामदायक महसूस करते हैं ...)।

Animal animalCat = new Cat();

इसका मतलब यह है कि इस तरह के टैग, पशुकैट में केवल टाइप एनिमल की कार्यक्षमता (विधियाँ) होंगी, क्योंकि हमने इसे टाइप कैट के रूप में नहीं, बल्कि एनिमल के रूप में घोषित किया है।

हमें यह करने की अनुमति है कि एक "प्राकृतिक / अंतर्निहित / स्वचालित" तरीके से, संकलन-समय पर या एक रन-टाइम पर, मुख्य रूप से क्योंकि बिल्ली अपनी कुछ कार्यक्षमता पशु से प्राप्त करती है; उदाहरण के लिए, चाल ()। (कम से कम, बिल्ली एक जानवर है, है ना?)

2.- डाउनकास्टिंग।

लेकिन, अगर हमें अपने टाइप एनिमल टैग से कैट की कार्यक्षमता प्राप्त करने की आवश्यकता है, तो क्या होगा?

जैसा कि हमने कैट ऑब्जेक्ट की ओर इशारा करते हुए एनिमेटकैट टैग बनाया है, हमें कैट ऑब्जेक्ट के तरीकों को कॉल करने के लिए एक तरीका चाहिए, हमारे एनिमेटकैट टैग से कुछ स्मार्ट सुंदर तरीके से।

ऐसी प्रक्रिया जिसे हम डाउनकास्टिंग कहते हैं, और हम इसे केवल रन-टाइम पर कर सकते हैं।

कुछ कोड के लिए समय:

public class Animal {
    public String move() {
        return "Going to somewhere";
    }
}

public class Cat extends Animal{
    public String makeNoise() {
        return "Meow!";
    }   
}

public class Test {

    public static void main(String[] args) {
        
    //1.- Upcasting 
    //  __Type_____tag________object
        Animal animalCat = new Cat();
    //Some animal movement
        System.out.println(animalCat.move());
        //prints "Going to somewhere"
        
    //2.- Downcasting   
    //Now you wanna make some Animal noise.
        //First of all: type Animal hasn't any makeNoise() functionality.
        //But Cat can do it!. I wanna be an Animal Cat now!!
        
        //___________________Downcast__tag_____ Cat's method
        String animalNoise = ( (Cat) animalCat ).makeNoise();
        
        System.out.println(animalNoise);
        //Prints "Meow!", as cats usually done.
        
    //3.- An Animal may be a Cat, but a Dog or a Rhinoceros too.
        //All of them have their own noises and own functionalities.
        //Uncomment below and read the error in the console:
        
    //  __Type_____tag________object
        //Cat catAnimal = new Animal();
        
    }

}

2

जनक: कार
बाल: फिगो
कार c1 = नई फिगो ();

=====
अपकास्टिंग: -
विधि: ऑब्जेक्ट c1 क्लास के तरीकों (Figo - मेथड को ओवरराइड करना होगा) को संदर्भित करेगा क्योंकि क्लास "Figo" को "नया" के साथ निर्दिष्ट किया गया है।
इंस्टेंस वेरिएबल: ऑब्जेक्ट c1 डिक्लेरेशन क्लास ("कार") के इंस्टेंस वेरिएबल को संदर्भित करेगा।

जब डिक्लेरेशन क्लास पैरेंट होती है और ऑब्जेक्ट बच्चे का बनता है तो निहित कास्टिंग होती है जो "अपकास्टिंग" होती है।

======
डाउनकास्टिंग: -
फिगो f1 = (फिगो) c1; //
विधि: ऑब्जेक्ट f1 क्लास के तरीके (अंजीर) को संदर्भित करेगा क्योंकि प्रारंभिक ऑब्जेक्ट c1 को क्लास "फिगो" के साथ बनाया गया है। लेकिन एक बार डाउन कास्टिंग करने के बाद, वे विधियाँ जो केवल कक्षा "फिगो" में मौजूद हैं, को भी वेरिएबल f1 द्वारा संदर्भित किया जा सकता है।
इंस्टेंस वेरिएबल: ऑब्जेक्ट f1 ऑब्जेक्ट c1 के डिक्लेरेशन क्लास के उदाहरण वेरिएबल को संदर्भित नहीं करेगा (c1 के लिए डिक्लेरेशन क्लास कार है), लेकिन डाउन कास्टिंग के साथ यह क्लास फिगो के इंस्टेंस वेरिएबल्स को संदर्भित करेगा।

======
उपयोग: जब ऑब्जेक्ट चाइल्ड क्लास का होता है और डिक्लेरेशन क्लास पेरेंट की होती है और चाइल्ड क्लास अपने खुद के क्लास के नहीं, बल्कि पेरेंट क्लास के इंस्टेंस वैरिएबल को एक्सेस करना चाहती है तो इसे "डाउनकास्टिंग" से किया जा सकता है।


1

अपकास्टिंग का अर्थ है वस्तु को सुपरपाइप में डालना, जबकि डाउनकास्टिंग का अर्थ है एक उपप्रकार के लिए कास्टिंग।

जावा में, स्वचालित रूप से इसे पूरा करना आवश्यक नहीं है। और इसे आमतौर पर निहित कास्टिंग के रूप में संदर्भित किया जाता है। आप इसे दूसरों को स्पष्ट करने के लिए निर्दिष्ट कर सकते हैं।

इस प्रकार, लेखन

Animal a = (Animal)d;

या

Animal a = d;

एक ही बिंदु की ओर जाता है और दोनों मामलों में callme()से निष्पादित किया जाएगा Dog

डाउनकास्टिंग इसके बजाय आवश्यक है क्योंकि आपने aपशु की वस्तु के रूप में परिभाषित किया है। वर्तमान में आप जानते हैं कि यह एक है Dog, लेकिन जावा की कोई गारंटी नहीं है। वास्तव में रनटाइम में यह अलग हो सकता है और जावा एक फेंक देगा ClassCastException, क्या ऐसा होगा। बेशक यह आपके बहुत नमूना उदाहरण का मामला नहीं है। यदि आप नहीं डालते aहैं Animal, तो java आवेदन को संकलित नहीं कर सकता क्योंकि Animalइसमें विधि नहीं है callme2()

अपने उदाहरण में आप का कोड नहीं पहुँच सकते हैं callme()के Animalसे UseAnimlas(क्योंकि Dogयह अधिलेखित) जब तक विधि इस प्रकार होगा:

class Dog extends Animal 
{ 
    public void callme()
    {
        super.callme();
        System.out.println("In callme of Dog");
    }
    ... 
} 

0

हम डाउनकास्टिंग के लिए ऑब्जेक्ट बना सकते हैं। इस प्रकार में भी। : बेस क्लास विधियों को कॉल करना

Animal a=new Dog();
a.callme();
((Dog)a).callme2();
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.