java - 为什么对象类方法在接口(interface)中可用？

Question

以下接口(interface)和类已成功编译。下面的输出中提到了问题:

interface MyInterface{}

class MyClass implements MyInterface{}

class InterDoubt{

    static MyInterface mi ;//= new MyClass() ;

    public static void main(String[] args){
        System.out.println("X") ;

        try{
            synchronized(mi){
                try{
                    mi.wait(4000) ;
                }
                catch(InterruptedException ie){
                    System.out.println("Exception occured at main.") ;
                }
            }
        }
        catch(Exception e){
            System.out.println("voilla, MyInterface is an interface,\n" + 
                       "then why compiler allows compilation of\n" +
                       "mi.getClass(), mi.wait().\n" +
                       "Or how the methods of Object class are available in an interface."
            );
        }

        System.out.println("Y") ;
    }
}

输出:

X

瞧，MyInterface 是一个接口(interface)，

那为什么编译器允许编译

mi.getClass(), mi.wait()。

或者 Object 类的方法如何在接口(interface)中可用。

是

---

已编辑 :-我接受来自 disown 的回答，因为它是最具解释性的。但是在阅读答案之后，又增加了一个问题:-

"请记住，如果接口(interface)试图声明一个在 Object 类中声明为 'final' 的公共(public)实例方法，那么它将导致编译时错误。例如，'public final Class getClass()' 是在 Object 类中声明为“final”的公共(public)实例方法，因此如果接口(interface)试图声明具有此签名的方法，则编译将失败”(引自解释)。

那么为什么下面的代码会被成功编译:-

interface MyInter{
    public void method() ;
}

class MyClass implements MyInter{

    public final void method() {
        .......
        .......
              .......
    }

}

Answer 1

Java 语言规范中指定了您正确指出的异常。接口(interface)将自动从添加的类 java.lang.Object 中获取所有成员。来自 here :

The Java Language Specification clearly says that the members of an interface are those which are declared in the interface and those which are inherited from direct super interfaces. If an interface has no direct superinterface then the interface implicitly declares a public abstract member method corresponding to each public instance method declared in the Object class, unless a method with the same signature, same return type, and a compatible throws clause is explicitly declared by that interface. This is what makes the signatures of the Object methods available to the compiler and the code compiles without any error. Remember if the interface tries to declare a public instance method declared 'final' in the Object class then it'll result into a compile-time error. For example, 'public final Class getClass()' is a public instance method declared 'final' in the Object class and therefore if an interface tries to declare a method with this signature then the compilation will fail.