多态性：从超类的变量中调用子类的方法

Question

In Java, when a method is going to be executed, it's declaration is first searched for at the object's real class (that defines the real type of the object). If it's not found, then the superclass is checked. If isn't found there either, the next parent class is checked, and so on. However, look at the example below:

   SuperClass s = new SubClass(list of parameter);
   s.someMethodExistOnlyInSubClass();

This will give me a compile time error. I thought that, as mentioned above, it would first look for someMethodExistOnlyInSubClass() at SubClass , verify that it exists there and then execute it right away. If I use a variable of the type SuperClass to reference an instance of SubClass some parameters will go to SuperClass 's constructor through a call to super() and the object will be instantiated there. In this context, to where have the remaining parameters gone?

Answer 1

By assigning a reference to an instance of SubClass to a variable of the type SuperClass , the variable is treated as if it were referencing an instance of SuperClass . Therefore, it will have no knowledge of any of the methods declared specifically in SubClass . Note, though, that the overrides performed in SubClass will still be effective.

In the context you described, to access someMethodExistOnlyInSubClass() you would have to cast s to the type SubClass . Look below:

((SubClass) s).someMethodExistOnlyInSubClass();

Answer 2

What you are trying to do will work only when the method is defined in both Parent class and subclass.

    import java.util.*;
    class Parent 
    {
        public void sample()
        {
            System.out.println("Method of parent is getting Called");
        }
    }


    class Subclass extends Parent
    {
        public void sample()
        {
            System.out.println("Method of Child class is getting Called");
        }
    }

    public class Main
    {
        public static void main(String[] args){
            Parent p = new Subclass();
            p.sample();
        }
    }

OUTPUT : Method of Child class is getting Called

If the method exists only in Child class. You will have to create an instance of Child class itself.

Something like this :

import java.util.*;
class Parent 
{

}

class Subclass extends Parent
{
    public void sample()
    {
        System.out.println("Method of Child class is getting Called");
    }
}

public class Main
{
    public static void main(String[] args){
        Subclass p = new Subclass();
        p.sample();
    }
}

Or you can type cast it as mentioned in the earlier post

Parent p = new Subclass();
((Subclass)p).sample();

Answer 3

An object is created based on its declaring class. When you declare it as SuperClass s the object s wont have any method called someMethodExistOnlyInSubClass . So when you try to invoke this method, even before look at the subclass, you get a compile error.

The object s contrains only everything of the superclass, this object wont be aware of any subclass until u type cast the object to subclass.