接口是否像对象一样处理？

Question

Why is the following code working?

interface I { }

class A implements I{
    public String toString(){ return "in a"; }
}

class B extends A{
    public String toString(){ return "in b"; }
}
B b = new B();
A a = b;
I i = a;

System.out.println(i);
System.out.println((B)a);
System.out.println(b);

As you can see i is a valid parameter to println method. Why? By looking at the parameter types accepted by this method, only object seems to be relevant.

I was searching for an answer and found a few relevant things here : " Reference types all inherit from java.lang.Object . Classes, enums, arrays, and interfaces are all reference types ."

But also found this: "Do interfaces inherit from Object class in Java?" and the answer: No, they don't. And there is no common "root" interface implicitly inherited by all interfaces either (as in the case with classes) for that matter.(*)

What does this mean? Can someone explain me why is the interface accepted as an argument for the println function?

I suppose that the point here is that you cannot pass an object through an interface without having the object itself.

But the question still remains. Why is the compiler accepting an interface as a parameter for this method?

Answer 1

The JLS explains it:

Given a non-generic type declaration C, the direct supertypes of the type C are all of the following:

The direct superclass of C (§8.1.4).

The direct superinterfaces of C (§8.1.5).

The type Object, if C is an interface type with no direct superinterfaces (§9.1.3).

You might ask why Object is the supertype of any interface. The reason is that there is no way for an object not to be an instance of a concrete class, and there is no way for this concrete class not to extend Object. Hence, the compiler knows that a reference to an interface type is a reference to an Object.

Answer 2

It is like this. You can not instantiate an interface, so any reference with an interface must point to an object of some class that implements said interface. And that object's superclass must be Object at some point.

Answer 3

Your misunderstanding stems from a conflation. Inheritance and subtyping are separate things.

The JLS explains the meaning of inheritance:

An interface I inherits from its direct superinterfaces all abstract and default methods m [...]

When you have something like class String extends Object {} , String is a subtype of Object and thereby inherits members of the superclass Object .

Interfaces, on the other hand, are subtypes of Object but do not inherit members from it. This is what aioobe's answer is explaining, that interfaces do not inherit.

Answer 4

The compiler is not so much accepting an interface as an argument, but rather a reference to an object that happens to implement the interface. Consider the following code snippet similar to yours, and the output. You'll see in both cases the output is the Box object. The parameter (or "thing") being passed in both cases to println() is the very same Box object. It's just that in one case it's being referred to as a concrete instantiation of Box, and in the other it's being referenced as an object that implements the A interface.

interface A {}

public class Box implements A
{

   public Box()
   {

   }

    public static void main(String[] args)
    {
        Box b =new Box();
        A a = b;   //define a reference to an object that implements interface A
        System.out.println(a);
        System.out.println(b);
    }
}

The output is:

Box@19e0bfd

Box@19e0bfd