Covariant returns

[Gordy Bone]

class A {
    int a = 5;
}
 
class B extends A {
    int a = 6;
}
 
public class X {
    
    public A getObject() {
        return new A();
    }
    
    public static void main(String[] args){
        X x1 = new Y();
        System.out.println(x1.getObject().a);
    }
}
 
class Y extends X {
    
    public B getObject(){
        return new B();
    }
}

This code prints 5, because x1.getObject returns a new A.

My stupid brain tells me it should return a new B, because Y overrides X's getObject method (using a covariant return). Please explain.

Thanks,

Gordy

[Remko Strating]

You're right that Y extends X and that you're overriding method getObject() in Y from X. This method is also called.

By overriding the JVM also calls the method getObject within Y which is the runtime type. This method returns Object B which is a referance to Object A.
This method returns 5 from Object A, because polymorphic method invocations apply only to instance methods and not to static methods and variables.

I hope is explanation helps.

[Dustin Johnson]

This is one of those tricky things, which is a perfect case of where encapsulation should be used. If you put this code into an IDE, i.e. Eclipse, and throw it in debug mode you will actually see that there are two variables created here... a(a) and a(b). This is because you do not override variables in a subtype, you actually hide them... it's a slightly different concept.

Therefore, you are correct that you get back an object of B(), however your reference variable is of type A. So the program thinks you want the variable from an A object, and gives you the a(a) version. Now, if you actually use getters and setters, you will see that the application will perform more as expected, try this code where I just added comments, and used a getter method instead of trying to directly call the variable:

class A {
    int a = 5;
    
    public int getA(){
    return a;
    }
}
 
class B extends A {
// This variable hides the variable in object A, doesn't override it
int a = 6;
    
    // Overridden getter method
    public int getA(){
    return a;
    }
}
 
public class X {
    
    public A getObject() {
        return new A();
    }
    
    public static void main(String[] args){
        X x1 = new Y();
        // This will now return the correct variable because the method was overridden
        // it doesn't hide A's method
        System.out.println(x1.getObject().getA());
    }
}
 
class Y extends X {
    
    public B getObject(){
        return new B();
    }
}

[Gordy Bone]

Remko,

Many thanks for your reply.

I get the polymorphic invocation issue the instance variable issue.

The thing I'm struggling with is, given that it's a B object that's returned by the method that's actually called at runtime (i.e. Y's getObject()), why is this an A?

[Gordy Bone]

Thanks, Dustin!

[Keith Lynn]

Originally posted by Gordy Bone:
Remko,

Many thanks for your reply.

I get the polymorphic invocation issue the instance variable issue.

The thing I'm struggling with is, given that it's a B object that's returned by the method that's actually called at runtime (i.e. Y's getObject()), why is this an A?

If you take a look at the methods created in the bytecode, you can see a little better what is happening.

C:\temp>javap X
Compiled from "X.java"
public class X extends java.lang.Object{
    public X();
    public A getObject();
    public static void main(java.lang.String[]);
}
 

C:\temp>javap Y
Compiled from "X.java"
class Y extends X{
    Y();
    public B getObject();
    public A getObject();
}
 

Notice that in the Y class, there are two methods listed with name getObject, one with return type B, and one with return type A.

In previous versions of Java, an overridding method had to have the same return type as the overridden method.

But now with covariant returns, you can modify the return type.

So what's happened is that an extra method has been inserted into Y that has return type A. This method is called a bridge method and simply invokes the overridden method in B.

The bridge method only becomes important when the type of reference used to invoke the overridden method is a superclass reference.

Since the reference type is X, and X defines a method called getObject with return type A, the bridge method in Y, which also has return type A, is used to call the overridden method.

So the overridden method is still called, but its called through a method with return type A, so that is why the object returned from getObject has reference type A.

[Gordy Bone]

Thank you for that explanation, Keith. I was just about to post another query, but I get it now.

Cheers!

Gordy

[Kunal Gupta]

Dear Keith,
I am still not very clear with your explaination.
DO you mean to say that an overridden method is called with the prototype of an inherited one?
These things are not explained in K&B's book..By going by the book I would definitely go with the answer to be the instance variable(a) of class B and not of class A

Oops..I am in a fix..

[Keith Lynn]

In some cases, an overridden method has the same return type as the overriding case. So it is clear what method to call.

In all cases, the reference type decides which methods are allowed to be called.

In this example, the reference type is of type X. X only has a method named getObject() with return type A. However, since the overriding class modifies the return type, there is no version of getObject() with return type A in Y. So the compiler adds one that simply acts as a bridge.

When a reference of type X is used to call getObject() on an instance of type Y, then the method with return type A in Y is called. But this method just calls the overridden method getObject().

The variable returned is of runtime type B.

But the reference type is type A.