为什么Java中的void不协变？

Question

If I have this interface:

public interface Foo {
    void bar();
}

Why can't I implement it like this?

public class FooImpl implements Foo {
    @Override
    public Object bar() {
         return new Object();
    }
}

It seems like void should be covariant with everything. Am I missing something?

Edit: I should have been clearer that I'm looking for the design justification, not the technical reason that it won't compile. Are there negative consequences to making void covariant to everything?

Answer 1

void is only covariant with void because the JLS says so :

A method declaration d1 with return type R1 is return-type-substitutable for another method d2 with return type R2, if and only if the following conditions hold:

• If R1 is void then R2 is void .

• If R1 is a primitive type, then R2 is identical to R1.

• If R1 is a reference type then:

  • R1 is either a subtype of R2 or R1 can be converted to a subtype of R2 by unchecked conversion (§5.1.9), or

  • R1 = |R2|

Answer 2

协方差意味着如果你的方法return type是一个Supertype object你可以在运行时返回sub-type Object ， void不是super type of java.lang.Object的super type of java.lang.Object （或者除了它之外的任何对象，如MR NPE所回答）

Answer 3

void effectively means that it returns nothing. You may be getting confused with a void * in C/C++. If you change the interface to be

public interface Foo {
    Object bar();
}

it will work fine because all objects in Java inherit Object .

So, you could do something like this:

public class FooImpl implements Foo {

    @Override
    public Object bar() {
         return new SpecialObject();
    }

}

SpecialObject obj = (SpecialObject) new FooImpl().bar();

Answer 4

Return types must match for overridden methods.

Foo foo = new FooImpl();
foo.bar();

Unless all implementations comply with the interface and return the same object (or nothing at all) how do I know what that will return?

Answer 5

void is not part of the java file system.

If we do make it a type, it's more like an empty type, so it should be a subtype of every other type, ie it is contra-variant with other types.

In your example, the super class dictates that nothing should be returned, yet the subclass returns something, therefore the subclass violates the superclass's contract.

Object is covariant with other types, if that's what you want.

Answer 6

Technically void cannot be a covariant return type as the caller needs to know the stack layout. Calling a function that returns an object would result of an object-ref on the top of the stack after the INVOKEVIRTUAL/INTERFACE. Void return type leaves nothing on the top of the stack, hence the functions are binary incompatible.

So the JLS rightfully says it's not possible.

Answer 7

A covariant return type usually means the one that can be replaced by a narrower type. In Java , there is no such relation (supertype-subtype) between void and Object or anything else.

Answer 8

If this were allowed, there would be no way to determine if this should compile or not.

 Foo foo = ...
 Object o = foo.bar(); // is it void or an Object ?