Covariant return type

In object-oriented programming, a covariant return type of a method is one that can be replaced by a "narrower" type when the method is overridden in a subclass.

Covariant return types have been (partially) allowed in the Java language since the release of JDK5.0, so the following example wouldn't compile on a previous release:

 // Classes used as return types:
 
 class A {
 }
 
 class B extends A {
 }
 
 // Classes demonstrating method overriding:
 
 class C {
     A getFoo() {
         return new A();
     }
 }
 
 class D extends C {
     B getFoo() {
         return new B();
     }
 }

More specifically, covariance of the return type refers to a situation where the return type of the overriding method is changed to a type related to (but different from) the return type of the original overridden method. The relationship between the two covariant return types is usually one which allows substitution of the one type with the other, following the Liskov substitution principle. This usually implies that the return types of the overriding methods will be subtypes of the return type of the overridden method. The above example specifically illustrates such a case.

See also

• Covariance and contravariance (computer science)
• Covariant return types in C++ Example
• Java project which takes advantage of covariant return types in Java