Answer

The covariant return types mechanism allows in Java when overriding a method to return not exactly the same type as in the superclass, but its subtype (covariant type).

This increases the expressiveness of the code, allowing for more specific types to be returned without explicit casting.

Example:

class Animal { }
class Dog extends Animal { }
class Parent {
    Animal getAnimal() { return new Animal(); }
}
class Child extends Parent {
    @Override
    Dog getAnimal() { return new Dog(); } // Covariant return
}

Conditions for its operation:

The return type in the overriding method must be a subtype of the original type.
Covariance works only for return types, not for parameters!
It works only for reference types, not for primitives.

Trick question

Can you change the return type of an overloaded method in a subclass to make it a subtype of the base type? Will this be considered valid overloading?

Answer: No, for overloading, only the parameter signature matters, and the return type does not play a role. Changing only the return type in overloading is not allowed — such a method will conflict due to its signature.

Example:

class Example {
    Animal make() { return new Animal(); }
    // Dog make() { return new Dog(); } // Compile error: duplicate method!
}

Covariance works only for overriding.

History

On the project, a programmer mistakenly added an overloaded method with the same name and parameters but with a different return type, expecting it to be "covariant overriding". As a result, the project did not compile, and the bug was only identified during CI.

History

When using covariant return in a class hierarchy, the developer incorrectly applied parameterized types (generics), not properly implementing subtypes, which led to ClassCastException errors at runtime when working with collections.

History

In the overridden method, a more specialized type was returned, but the team did not document this contract. In the code operating through the base type, there were difficulties with type casting and unexpected behavior during "upcast" references, leading to a series of hidden bugs.

Explain how the covariant return types mechanism works in Java and what mistakes can be made when using it.

Answer

Trick question