java编译器如何知道继承的方法？

Question

We use inheritance in Java to abstract out similar behavior in a superclass and let all sub classes inherit it. One of the advantages of this is that , we now have only one copy of the method to maintain (ie in the superclass).

Class Animal
{
   public void makeNoise()
   {

   }

   public void sleep()
   {

   }   
} 

Class Cat extends Animal
{
     // Override the makeNoise method
     public void makeNoise()
     {

     }
}

Class someClass
{
     public static void main(String args[])
     {
          Cat fluffy = new Cat();

          fluffy.sleep();
     }
}

I am trying to understand how the Java compiler knows of the sleep() method for a Cat type reference. There can't be a copy of the method in the Cat subclass (it defeats the purpose of having it in the superclass and letting all subclasses inherit from it). Is this information stored in some other place ?

Answer 1

When the compiler sees fluffy.sleep() it first looks in the Cat class for a public instance method called sleep that takes no parameters. Since it doesn't find it, it moves up the inheritance chain to Animal , and does the same check on Animal . It finds it there, so all is good.

This information isn't really "stored" anywhere except in the code, and then the Java byte code.

Answer 2

In case of interface we are able to call the Object class methods on them without interface extending Object. For example:-

public interface Test { 
}

public class MyClass extends Object implements Test {

public static void main() {
Test test = new MyClass();
test.hashCode();
// You can call Object Class methods on Test interface and Test interface
//does not extends Object.

}

//In Java Specification 9.2:- If an interface has no direct superinterfaces, then the interface implicitly declares a public abstract member method m with signature s, return type r, and throws clause t corresponding to each public instance method m with signature s, return type r, and throws clause t declared in Object, unless an abstract method with the same signature, same return type, and a compatible throws clause is explicitly declared by the interface. It is a compile-time error if the interface explicitly declares such a method m in the case where m is declared to be final in Object.