在超类中调用方法使用子类的对象如何工作？

Question

class SuperClass{  
  public void print(){
    System.out.println("I'm super class...");
  }  
  public void someMethod(){
    System.out.println("any thing");
  }
}  

class SubClass extends SuperClass{ 
  @Override
  public void print(){
    System.out.println("I'm sub class...");
  }  

  public static void main(String args[]){  
    SuperClass a=new SubClass(); 
    a.print();  
    a.someMethod();
  }  
}  

a.print() known as dynamic binding and it's know which method to call in run time and choose method of SubClass because the object is SubClass it's true?

a.someMethod() how JVM deal with this method it's not in sub class and the object from sub class?

Answer 1

When you do:

SuperClass a = new SubClass();

You're saying that you want to make an instance of SubClass , where you only want methods declared in SuperClass to be visible. If you had declared any new methods in SubClass , they would not be visible.

The object will still be using the SubClass implementations when it can (ie when you override them). Methods which haven't been overridden will use the implementation that was inherited.

Answer 2

a.print() is an example of method overriding which is runtime polymorphism . That is, at runtime it decides whether to call the subclass method or the super class method (here your SubClass method is called as it is overridden and matches the parameter signature).

In case of someMethod() call, you have not defined it in your SubClass. That means, your SubClass automatically got a someMethod() when you inherited it from Superclass as it is public . Putting it in simple words, SubClass also has the definition of someMethod() . Thats how JVM got to know which method to call.

Also in SuperClass a , the variable 'a' will be stored in stack whereas the reference will be stored in heap. You have constructed the reference using SubClass 's constructor. Meaning the variable 'a' in stack refers to a ' SubClass ' object in heap. That is why 'a' is able to call someMethod

Answer 3

"calling method in super class using object of sub class" is one of the scenario of Polymorphism in Java .

If the sub-class implements a method with same definition as that of super-class, calling the method with the object of sub-class is going to override the method of super-class with the method of sub-class.

Hence, if you want to call the method of super class with the object of sub-class, don't override the method.

SuperClass a=new SubClass();

This definition makes "a" capable to make a reference to type SuperClass or any sub-class that extend the SuperClass. As object "a" is created from SubClass, by definition, the object can access the methods of the SubClass and SuperClass. This explaination should address both of your questions.

Refer to the java documentation here .