ओवरराइडिंग बनाम हिडिंग जावा - कन्फ्यूज्ड

Question 1

मैं इस बात पर असमंजस में हूँ कि ओवरराइडिंग जावा में छिपने से कैसे अलग है। क्या कोई इस बारे में अधिक जानकारी प्रदान कर सकता है कि ये कैसे भिन्न हैं? मैंने जावा ट्यूटोरियल पढ़ा लेकिन नमूना कोड अभी भी मुझे भ्रमित करता है।

अधिक स्पष्ट होने के लिए, मैं अच्छी तरह से ओवरराइड करना समझता हूं। मेरा मुद्दा यह है कि मैं यह नहीं देखता कि छिपाना कितना अलग है, इस तथ्य को छोड़कर कि एक उदाहरण स्तर पर है जबकि दूसरा वर्ग स्तर पर है।

जावा ट्यूटोरियल कोड को देखते हुए:

public class Animal {
    public static void testClassMethod() {
        System.out.println("Class" + " method in Animal.");
    }
    public void testInstanceMethod() {
        System.out.println("Instance " + " method in Animal.");
    }
}

फिर हमारे पास एक उपवर्ग है Cat:

public class Cat extends Animal {
    public static void testClassMethod() {
        System.out.println("The class method" + " in Cat.");
    }
    public void testInstanceMethod() {
        System.out.println("The instance method" + " in Cat.");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        Animal myAnimal = myCat;
        Animal.testClassMethod();
        myAnimal.testInstanceMethod();
    }
}

फिर वे कहते हैं:

इस कार्यक्रम से आउटपुट निम्नानुसार है:

पशु में कक्षा विधि।

कैट में उदाहरण विधि।

मेरे लिए, यह तथ्य कि क्लास testClassMethod()से सीधे क्लास पद्धति को कॉल करना क्लास में विधि को Animalनिष्पादित करता Animalहै, बहुत स्पष्ट है, वहां कुछ खास नहीं है। फिर वे testInstanceMethod()एक संदर्भ से कॉल करते हैं myCat, इसलिए फिर से स्पष्ट है कि निष्पादित विधि फिर उसी के उदाहरण में एक है Cat।

मैं जो देख रहा हूं, वह कॉल छिपाना ओवरराइडिंग की तरह ही व्यवहार करता है, इसलिए वह अंतर क्यों करता है? यदि मैं उपरोक्त कक्षाओं का उपयोग करके यह कोड चलाता हूं:

Cat.testClassMethod();

मैं ले आता हूँ: बिल्ली में कक्षा विधि। लेकिन अगर मैं testClassMethod()कैट से हटाता हूं , तो मुझे मिलेगा: एनीमल में क्लास विधि।

जो मुझे दिखाता है कि एक स्थिर विधि लिखने के साथ, माता-पिता में एक ही हस्ताक्षर के साथ, एक उपवर्ग में बहुत अधिक ओवरराइड करता है।

उम्मीद है कि मैं स्पष्ट कर रहा हूं कि मैं कहां उलझन में हूं और कोई कुछ प्रकाश डाल सकता है। अग्रिम में ही बहुत शुक्रिया!

Question 2

ओवरराइडिंग मूल रूप से देर से बाध्यकारी का समर्थन करता है। इसलिए, यह तय समय पर किया जाता है कि किस पद्धति को बुलाया जाएगा। यह गैर-स्थैतिक तरीकों के लिए है।

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

आपके उदाहरण में, पहला कॉल, Animal.testClassMethod()एक staticविधि के लिए एक कॉल है , इसलिए यह बहुत निश्चित है कि किस विधि को कहा जाने वाला है।

दूसरी कॉल में myAnimal.testInstanceMethod(), आप एक गैर-स्थैतिक विधि कहते हैं। इसे आप रन-टाइम बहुरूपता कहते हैं। यह तय नहीं किया जाता है कि रन टाइम तक किस विधि को बुलाया जाए।

आगे स्पष्टीकरण के लिए, ओवरराइडिंग बनाम छुपाना पढ़ें ।

Question 3

स्थैतिक विधियाँ छिपी हुई हैं, गैर-स्थैतिक विधियाँ ओवरराइड हैं। अंतर तब उल्लेखनीय है जब कॉल योग्य नहीं हैं "कुछ ()" बनाम "this.something ()"।

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

public class Animal {

    public static void something() {
        System.out.println("animal.something");
    }

    public void eat() {
        System.out.println("animal.eat");
    }

    public Animal() {
        // This will always call Animal.something(), since it can't be overriden, because it is static.
        something();
        // This will call the eat() defined in overriding classes.
        eat();
    }

}


public class Dog extends Animal {

    public static void something() {
        // This method merely hides Animal.something(), making it uncallable, but does not override it, or alter calls to it in any way.
        System.out.println("dog.something");
    }

    public void eat() {
        // This method overrides eat(), and will affect calls to eat()
        System.out.println("dog.eat");
    }

    public Dog() {
        super();
    }

    public static void main(String[] args) {
        new Dog();
    }

}

उत्पादन:

animal.something
dog.eat

Question 4

यह ओवरराइड और छिपाने के बीच का अंतर है,

यदि पैरेंट क्लास और चाइल्ड क्लास दोनों पद्धति एक इंस्टेंस विधि है, तो इसे ओवरराइड कहा जाता है।
यदि पैरेंट क्लास और चाइल्ड क्लास दोनों विधि स्टैटिक विधि है, तो इसे छुपाया जाता है।
एक विधि कठपुतली में स्थिर और बच्चे में एक उदाहरण के रूप में स्थिर हो सकती है। और वीज़ा वर्सा।

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

Question 5

यदि मैं आपके प्रश्न को ठीक से समझता हूं तो उत्तर है "आप पहले से ही ओवरराइड कर रहे हैं"।

"जो मुझे दिखाता है कि एक स्थिर विधि लिखना, माता-पिता के समान नाम के साथ, एक उपवर्ग में बहुत अधिक ओवरराइड करता है।"

यदि आप किसी सुपरक्लास में एक विधि के रूप में एक ही नाम के साथ एक उपवर्ग में एक विधि लिखते हैं तो यह सुपरक्लास की विधि को ओवरराइड करेगा। किसी विधि को ओवरराइड करने के लिए @ ऑवरराइड एनोटेशन की आवश्यकता नहीं है। हालांकि यह आपके कोड को अधिक पठनीय बनाता है और संकलक को यह जांचने के लिए मजबूर करता है कि आप वास्तव में एक विधि से आगे निकल रहे हैं (और उदाहरण के लिए उपवर्ग विधि को गलत नहीं किया है)।

Question 6

ओवरराइडिंग केवल उदाहरण के तरीकों से होती है। जब संदर्भ चर का प्रकार पशु है और वस्तु कैट है तो कैट से उदाहरण विधि कहा जाता है (यह ओवरराइडिंग है)। एक ही एसीट ऑब्जेक्ट के लिए एनिमल की क्लास विधि का उपयोग किया जाता है।

public static void main(String[] args) {
    Animal acat = new Cat();
    acat.testInstanceMethod();
    acat.testClassMethod();

}

आउटपुट है:

The instance method in Cat.
Class method in Animal.

Question 7

public class First {

    public void Overriding(int i) {  /* will be overridden in class Second */ }

    public static void Hiding(int i) {  /* will be hidden in class Second
                                           because it's static */ }
}


public class Second extends First {

    public void Overriding(int i) {  /* overridden here */  }

    public static void Hiding(int i) {  /* hides method in class First
                                           because it's static */ } 
}

याद रखने का नियम सरल है: एक विस्तारित वर्ग में एक विधि स्थैतिक को शून्य में नहीं बदल सकती है और शून्य को स्थैतिक में नहीं बदल सकती है। यह संकलन-त्रुटि का कारण होगा।

लेकिन अगर इसे ओवरराइडिंग में void Nameबदल दिया जाए void Name।

और अगर static Nameइसे बदलकर static Nameछुपाया जाए। (दोनों उप-वर्ग की स्थिर विधि के साथ-साथ सुपरक्लास में से एक को बुलाया जा सकता है, जो विधि को कॉल करने के लिए उपयोग किए गए संदर्भ के प्रकार पर निर्भर करता है।)

Question 8

इस कोड स्निपेट में मैं 'स्टेटिक' के बजाय 'प्राइवेट' एक्सेस मॉडिफायर का इस्तेमाल करता हूं ताकि आप छुपाने के तरीकों और ओवरराइडिंग के तरीकों में अंतर दिखा सकें।

class Animal {
// Use 'static' or 'private' access modifiers to see how method hiding work.
private void testInstancePrivateMethod(String source) {
    System.out.println("\tAnimal: instance Private method calling from "+source);
}
public void testInstanceMethodUsingPrivateMethodInside() {
    System.out.println("\tAnimal: instance Public method with using of Private method.");
    testInstancePrivateMethod( Animal.class.getSimpleName() );
}

// Use default, 'protected' or 'public' access modifiers to see  how method overriding work.
protected void testInstanceProtectedMethod(String source) {
    System.out.println("\tAnimal: instance Protected method calling from "+source);
}
public void testInstanceMethodUsingProtectedMethodInside() {
    System.out.println("\tAnimal: instance Public method with using of Protected method.");
    testInstanceProtectedMethod( Animal.class.getSimpleName() );
  } 
}  


public class Cat extends Animal {
private void testInstancePrivateMethod(String source) {
    System.out.println("Cat: instance Private method calling from " + source );
}
public void testInstanceMethodUsingPrivateMethodInside() {
    System.out.println("Cat: instance Public method with using of Private method.");
    testInstancePrivateMethod( Cat.class.getSimpleName());
    System.out.println("Cat: and calling parent after:");
    super.testInstanceMethodUsingPrivateMethodInside();
}

protected void testInstanceProtectedMethod(String source) {
    System.out.println("Cat: instance Protected method calling from "+ source );
}
public void testInstanceMethodUsingProtectedMethodInside() {
    System.out.println("Cat: instance Public method with using of Protected method.");
    testInstanceProtectedMethod(Cat.class.getSimpleName());
    System.out.println("Cat: and calling parent after:");
    super.testInstanceMethodUsingProtectedMethodInside();
}

public static void main(String[] args) {
    Cat myCat = new Cat();
    System.out.println("----- Method hiding -------");
    myCat.testInstanceMethodUsingPrivateMethodInside();
    System.out.println("\n----- Method overriding -------");
    myCat.testInstanceMethodUsingProtectedMethodInside();
}
}

आउटपुट:

----- Method hiding -------
Cat: instance Public method with using of Private method.
Cat: instance Private method calling from Cat
Cat: and calling parent after:
   Animal: instance Public method with using of Private method.
   Animal: instance Private method calling from Animal

----- Method overriding -------
Cat: instance Public method with using of Protected method.
Cat: instance Protected method calling from Cat
Cat: and calling parent after:
   Animal: instance Public method with using of Protected method.
Cat: instance Protected method calling from Animal

Question 9

मेरे हाल के जावा अध्ययनों के आधार पर

ओवरराइड करने की विधि , जब उपवर्ग में एक ही हस्ताक्षर के साथ एक ही विधि होती है।
विधि छिपाना , जब उपवर्ग में एक ही विधि का नाम है, लेकिन अलग-अलग पैरामीटर। इस मामले में, आप मूल पद्धति को ओवरराइड नहीं कर रहे हैं, बल्कि इसे छिपा रहे हैं।

उदाहरण के लिए OCP जावा 7 पुस्तक, पृष्ठ 70-71:

public class Point {
  private int xPos, yPos;
  public Point(int x, int y) {
        xPos = x;
        yPos = y;
  }

  public boolean equals(Point other){
  .... sexy code here ...... 
  }

  public static void main(String []args) {
   Point p1 = new Point(10, 20);
   Point p2 = new Point(50, 100);
   Point p3 = new Point(10, 20);
   System.out.println("p1 equals p2 is " + p1.equals(p2));
   System.out.println("p1 equals p3 is " + p1.equals(p3));
   //point's class equals method get invoked
  }
}

लेकिन अगर हम निम्नलिखित मुख्य लिखते हैं:

  public static void main(String []args) {
   Object p1 = new Point(10, 20);
   Object p2 = new Point(50, 100);
   Object p3 = new Point(10, 20);
   System.out.println("p1 equals p2 is " + p1.equals(p2));
   System.out.println("p1 equals p3 is " + p1.equals(p3));
   //Object's class equals method get invoked
  }

दूसरे मुख्य में, हम ऑब्जेक्ट क्लास को स्टैटिक प्रकार के रूप में उपयोग करते हैं, इसलिए जब हम पॉइंट ऑब्जेक्ट में समान विधि को कॉल करते हैं, तो यह एक पैरामीटर के रूप में आने के लिए पॉइंट क्लास की प्रतीक्षा कर रहा है, लेकिन ऑब्जेक्ट आ रहा है। इसलिए ऑब्जेक्ट क्लास रन करने की विधि के बराबर है, क्योंकि हमारे पास वहां एक समान (ऑब्जेक्ट ओ) है। इस स्थिति में, पॉइंट की क्लास बराबर ओवरराइड करती है, लेकिन ऑब्जेक्ट क्लास के बराबर पद्धति को छुपाती है ।

Question 10

public class Parent {

  public static void show(){
    System.out.println("Parent");
  }
}

public class Child extends Parent{

  public static void show(){
    System.out.println("Child");
  }
}

public class Main {

public static void main(String[] args) {
    Parent parent=new Child();
    parent.show(); // it will call parent show method
  }
}

// We can call static method by reference ( as shown above) or by using class name (Parent.show())

Question 11

लिंक किए गए जावा ट्यूटोरियल पेज ओवरराइडिंग और छिपने की अवधारणा को बताते हैं

एक ही हस्ताक्षर के साथ एक उपवर्ग में एक आवृत्ति विधि (नाम, प्लस संख्या और उसके मापदंडों का प्रकार) और सुपरक्लास में एक आवृत्ति विधि के रूप में वापसी प्रकार सुपरक्लास की विधि को ओवरराइड करता है।

यदि एक उप-वर्ग सुपरक्लास में एक स्थिर विधि के रूप में एक ही हस्ताक्षर के साथ एक स्थिर विधि को परिभाषित करता है, तो उप-वर्ग में विधि सुपरक्लास में एक को छुपाती है।

एक स्थैतिक विधि को छिपाने और एक आवृत्ति विधि को ओवरराइड करने के बीच अंतर के महत्वपूर्ण निहितार्थ हैं:

ओवरराइड की गई आवृत्ति विधि का संस्करण जो उपविभाजित होता है, वह उपवर्ग में एक होता है।
छिपी हुई स्थिर विधि का संस्करण जो कि आह्वान करता है, यह इस बात पर निर्भर करता है कि यह सुपरक्लास या उपवर्ग से लगाया गया है या नहीं।

अपने उदाहरण पर वापस आ रहे हैं:

Animal myAnimal = myCat;

 /* invokes static method on Animal, expected. */
 Animal.testClassMethod(); 

 /* invokes child class instance method (non-static - it's overriding) */
 myAnimal.testInstanceMethod();

उपरोक्त कथन अभी तक छिपता नहीं दिखा।

अब विभिन्न आउटपुट प्राप्त करने के लिए नीचे दिए गए कोड को बदलें:

  Animal myAnimal = myCat;
  
  /* Even though myAnimal is Cat, Animal class method is invoked instead of Cat method*/
  myAnimal.testClassMethod();
  
  /* invokes child class instance method (non-static - it's overriding) */
  myAnimal.testInstanceMethod();

Question 12

ऊपर सूचीबद्ध उदाहरणों के अलावा, यहाँ एक छोटा सा नमूना कोड छुपा और ओवरराइडिंग के बीच के अंतर को स्पष्ट करने के लिए है:

public class Parent {

    // to be hidden (static)
    public static String toBeHidden() {
        return "Parent";
    }

    // to be overridden (non-static)
    public String toBeOverridden() {
        return "Parent";
    }

    public void printParent() {
        System.out.println("to be hidden: " + toBeHidden());
        System.out.println("to be overridden: " + toBeOverridden());
    }
}

public class Child extends Parent {

    public static String toBeHidden() {
        return "Child";
    }

    public String toBeOverridden() {
        return "Child";
    }

    public void printChild() {
        System.out.println("to be hidden: " + toBeHidden());
        System.out.println("to be overridden: " + toBeOverridden());
    }
}

public class Main {

    public static void main(String[] args) {
        Child child = new Child();
        child.printParent();
        child.printChild();
    }
}

child.printParent()आउटपुट की कॉल :
छिपी होने के लिए: अभिभावक
को ओवरराइड किया जाना: बाल

child.printChild()आउटपुट की कॉल :
छिपी होने के लिए: बच्चे
को ओवरराइड करने के लिए: बाल

जैसा कि हम ऊपर दिए गए आउटपुट से देख सकते हैं (विशेष रूप से बोल्ड चिह्नित आउटपुट), विधि छिपाना ओवरराइडिंग से अलग तरीके से व्यवहार करता है।

जावा केवल तरीकों के लिए छुपा और ओवरराइडिंग दोनों की अनुमति देता है। वही नियम चर पर लागू नहीं होता है। ओवरराइडिंग वैरिएबल की अनुमति नहीं है, इसलिए वैरिएबल को केवल छिपाया जा सकता है (स्थिर या गैर-स्थिर वैरिएबल के बीच कोई अंतर नहीं)। नीचे दिए गए उदाहरण से पता चलता है कि कैसे विधि getName()को ओवरराइड किया जाता है और चर nameको छिपाया जाता है:

public class Main {

    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.name); // prints Parent (since hiding)
        System.out.println(p.getName()); // prints Child (since overriding)
    }
}

class Parent {
    String name = "Parent";

    String getName() {
        return name;
    }
}

class Child extends Parent {
    String name = "Child";

    String getName() {
        return name;
    }
}

Question 13

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

Question 14

विधि में अधिभावी , विधि संकल्प क्रम वस्तु के आधार पर JVM द्वारा किया जाता है। जबकि मेथड हिडेनिंग में, रेसोलुशन के आधार पर कंपाइलर द्वारा मेथड रेजोल्यूशन किया जाता है। इस प्रकार,

यदि कोड के रूप में लिखा गया होगा,

public static void main(String[] args) {
        Animal myCat = new Cat();        
        myCat.testClassMethod();        
    }

आउटपुट निम्नानुसार होगा:
पशु में कक्षा विधि।

Question 15

इसे छिपाना कहा जाता है क्योंकि कंपाइलर सुपर क्लास विधि के कार्यान्वयन को छुपाता है, जब उपवर्ग में एक ही स्थिर विधि होती है।

कंपाइलर के पास ओवरराइड विधियों के लिए कोई दृश्यता सीमित नहीं है और यह केवल रनटाइम के दौरान तय किया जाता है कि कौन सा उपयोग किया जाता है।

Question 16

यह ओवरराइड करने और छिपाने के बीच का अंतर है:

पशु a = नई बिल्ली ();

a.testClassMethod () मूल विधि में विधि को कॉल करेगा क्योंकि यह विधि छिपाने का एक उदाहरण है। कहा जाने वाला तरीका संदर्भ चर के प्रकार से निर्धारित होता है और संकलन समय पर तय किया जाता है।

a.testInstanceMethod () चाइल्ड क्लास में विधि को कॉल करेगा क्योंकि यह विधि ओवरराइडिंग का एक उदाहरण है। कहा जाने वाला तरीका उस ऑब्जेक्ट द्वारा निर्धारित किया जाता है जिसे रनटाइम पर विधि को कॉल करने के लिए उपयोग किया जाता है।

Question 17

जावा में स्थिर विधि कैसे छिपी होती है? बिल्ली वर्ग पशु वर्ग का विस्तार कर रहा है। तो कैट क्लास में दोनों स्टैटिक मेथड होंगे (मेरा मतलब चाइल्ड क्लास का स्टैटिक मेथड और पेरेंट क्लास का स्टैटिक मेथड) लेकिन जेवीएम पेरेंट स्टैटिक मेथड को कैसे छिपाता है? यह कैसे ढेर और ढेर में काम कर रहा है?