100分求解Interface类型引用的问题

Question

现有一个接口
public interface ISuper{
      /*不定义任何的方法和字段*/
}
一个普通类，实现接口ISuper
public class Super implements ISuper{
      /*无任何的方法和字段*/
}
public class Test{
     public static void main(String[] args){
         ISuper super = new Super();
         super.toString();//为何任然可调用Object类的方法
     }
}注： 
    1.ISuper没有定义任何方法和字段.
    2.向上转型会丢失子类接口
个人猜想：
        1.单根继承
        2.特殊处理

Answer 1

因为Super 也是Object的子类，所有的对象都是Object这是java的规定。

Answer 2

Super虽然实现了ISuper接口，但是并不代表它就只能拥有ISuper里面的和自己定义的方法和属性，别忘了Super是类，只要是类就继承Object类，这是类的祖先，Object中的方法它都能用，像toString（）、clone（）等等。

Answer 3

所有类都是继承自Object，如果你类里覆盖了toString方法，就会调用你自己定义的toString，如果没有，就会调用Object的toString

Answer 4

按照Java语言规范的说法：
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 a 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. 也就是说接口中隐式的声明了与Object类中方法签名相同的方法。

Answer 5

public class Super implements ISuper{ 
      /*无任何的方法和字段*/ 
}Super类默认已经继承了java.lang.Object类（任何类都是这样）。

Answer 6

刚学java的时候也有此疑问，见
http://blog.csdn.net/ZangXT/archive/2008/11/27/3389395.aspx

Answer 7

之前见过这个问题，好像还真是说不清楚，但首先接口不是一个类，只一点是毋庸置疑的，但是object是java一切类的祖宗，而一个接口引用所引用的对象肯定是继承自object，所以super.toString()没有错，就当作是一个特性，知道就可以了，除了object中的方法以外其他的任何在此接口中没有定义的方法，你用super去调用，肯定是错的,不妨理解为Object的特权

Answer 8

又深入分析了一下，发现这是编译器做的手脚。
如果编译器发现你调用的是Object类的方法，它自动处理了。编译器的实现和java语言规范的说法仔细看来并不一致。比如这个例子：interface ITest{
void test();
}public class Test implements ITest{
public void test(){
System.out.println("test");
}
public static void main(String[] args){
ITest i = new Test();
i.toString();
i.test();
   }
}看编译、反汇编之后的代码：public static void main(java.lang.String[]);
  Code:
   0: new #5; //class Test
   3: dup
   4: invokespecial #6; //Method "<init>":()V
   7: astore_1
   8: aload_1
   9: invokevirtual #7; //Method java/lang/Object.toString:()Ljava/lang/String;
   12: pop
   13: aload_1
   14: invokeinterface #8,  1; //InterfaceMethod ITest.test:()V
   19: return我们能发现，调用Object类的方法时，编译产生的是invokevirtual指令，而非invokeinterface指令。

Answer 9

ISuper super = new Super(); 
super.toString();//为何任然可调用Object类的方法 
编译时，编译器能够发现super变量为接口类型的引用，如果调用的方法是Object类定义的方法，编译器直接开绿灯就是了。

Answer 10

你之前说也就是“说接口中隐式的声明了与Object类中方法签名相同的方法。”
可为什么出现invokevirtual指令呢

Answer 11

也就是说编译实现未必总和规范相同。
再说从性能上讲invokevirtual要比invokeinterface好的。因为invokevirtual是直接根据索引定义方法，而invokeinterface要挨着查。因此，编译器的这种选择也无可厚非。反正表现上不影响java的语义。

Answer 12

为何要说得那么复杂其实就是每个类都是继承Object如果没有显式extends 就是隐式extends Object

Answer 13

并不是说的那么复杂，what 和 why的关系

Answer 14

你没有理解问这个问题的出发点。interface InterfaceTest{
    public void testInterface();
}class SuperTest{
    public void testSuperClass(){
        System.out.println("SuperTest's testSuperClass()!");
    }
}
public class Test extends SuperTest implements InterfaceTest{    public static void main(String[] args) {
        InterfaceTest t = new Test();
        t.testInterface();
       // t.testSuperClass();
    }    public void testInterface() {
        System.out.println("InterfaceTest's testInterface()!");
    }
}
InterfaceTest t = new Test();
虽然t实际指向的对象是SuperTest的子类，但我们不能通过t来调用testSuperClass()，因为不管t指向的实际对象是什么，t的类型是InterfaceTest ，而这个接口中没有定义testSuperClass()方法，所以不能够使用t.testSuperClass();
同样道理，InterfaceTest 接口中没有定义toString（）等方法，那为什么可以调用呢？这就是编译器的特殊处理了。注意，有人说接口继承Object类，那是明显错误的。接口不能继承类，这是java的规则。

Answer 15

java中所有的类都是Object直接或间接的子类
因此可以访问到object的方法

Answer 16

大家好好看看#18.楼主这个问题还是很有价值的.1. 不要以为实际对象有这个方法就能调用.
2. 要不误认为interface隐含继承Object.

Answer 17

实际上：java Class里 interface的Class 的getSuperClass都是返回空的。即interface就只描述抽象方法，没有任何实现。但在jvm运行环境里，只要是interface的实例，必然都是Object.sun 认为：因为所有的interface的instance必然都是Object,所以干脆在java语言规范里定义interface都隐含继承了Object，这样就省去(Object)的强制类型转换了。sun 在java 语言规范上在这个地方就是想图省事儿，因为(Object)的强制类型转换确实是多余的。认为这点合理不合理都可以。

Answer 18

java中所有的类都是Object直接或间接的子类 
因此可以访问到object的方法

Answer 19

相当于
public class Super extends Object implements ISuper{ 
      /*无任何的方法和字段*/ 
}

Answer 20

相当于 
Java code
public class Super extends Object implements ISuper{ 
      /*无任何的方法和字段*/ 
}

Answer 21

所有类都是默认继承Object这个类的。。

Answer 22

所有类都是继承自Object,既然是接口，要是他什么方法都没有，还有什么意义

Answer 23

其实 Super 类完整的写法是这样的public class Super extends Object implements ISuper{ 
      /*无任何的方法和字段*/ 
}

Answer 24

有种接口叫做标志接口如:java.io.Serializable,仅作为标识用,没有任何方法.

Answer 25

所有类都是继承自Object，如果你类里覆盖了toString方法，就会调用你自己定义的toString，如果没有，就会调用Object的toString!java机制默认就是这样的!

Answer 26

你这么一说  我就好奇的去研究了一下发现定义接口是可以这么写的interface Interface {
@Override
public String toString();
}
而不能这么写interface Interface {
public void toString();
}

Answer 27

我觉得 interface不是继承Object 而是和Object平级的
interface相当于把Object的方法抽象了 这些方法是被隐藏的
interface本身不能被实例化 当一个interface的引用指向一个类的对象的时候
interface里的那些隐藏方法就被这个类给实现了

Answer 28

不就是每个类都继承Object，想那么复杂干嘛

Answer 29

interface是可以隐式转化为Object的。public interface Xx {
public void toString();
}
eclipse提示错误：
The return type is incompatible with Object.toString()public interface Xx {
@Override
public String toString();
}
eclipse提示错误：
The method toString() of type Xx must override a superclass methodpublic class OoXx extends Oo implements Xx
在Oo中重写toString方法return null,则
Oo oo=new OoXx();
Xx xx=new OoXx();
oo.toString()和xx.toString()都返回Null; 

Answer 30

任何类包括接口都继承自Object类

Answer 31

单根继承，建议去看看think in java这本书

Answer 32

Super 类继承自Object，仅此而已
Object.class反编译代码：package java.lang;public class Object
{
    private static native void registerNatives();
    
    public final native Class getClass();
    
    public native int hashCode();
    
    public boolean equals(Object object_0_) {
return this == object_0_;
    }
    
    protected native Object clone() throws CloneNotSupportedException;
    
    public String toString() {
return new StringBuilder().append(getClass().getName()).append("@")
   .append
   (Integer.toHexString(hashCode())).toString();
    }
    
    public final native void notify();
    
    public final native void notifyAll();
    
    public final native void wait(long l) throws InterruptedException;
    
    public final void wait(long l, int i) throws InterruptedException {
if (l < 0L)
    throw new IllegalArgumentException("timeout value is negative");
if (i < 0 || i > 999999)
    throw new IllegalArgumentException
      ("nanosecond timeout value out of range");
if (i >= 500000 || i != 0 && l == 0L)
    l++;
wait(l);
    }
    
    public final void wait() throws InterruptedException {
wait(0L);
    }
    
    protected void finalize() throws Throwable {
/* empty */
    }
    
    static {
registerNatives();
    }
}

Answer 33

只要是类 都可以调用 Object 里的方法