Covariant Return Types in Java with Example

In this tutorial, we will understand about covariant return types in Java with the help of example programs. As we know that in the overriding, the return type of subclass method must be the same as the superclass method return type.

But, this rule is applicable until Java 1.4 version. From Java 1.5 onwards, a new covariant return type feature was introduced by Sun Microsystems. By using this feature, it is possible to override any method by changing the return type only.

If the return type of overriding method in the subclass is a subtype of the declared return type of overridden method instead of being exactly the same type, it is known as covariant return type in Java.

In simple words, if the return type of the overriding method is a subclass of the return type of the overridden method (instead of being exactly the same type), this feature is known as a covariant return type. Let’s understand it with the help of a very simple example.

class Superclass {
    Superclass getMe() {
        return this;
    }
}
class Subclass extends Superclass {
    @Override
    Subclass getMe() {
        return this;
    }
}

In this example code, the return type of getMe() method in the subclass Subclass is a subclass of the return type in the superclass Superclass. This is allowed in due to covariant return type feature in Java programming.

Rules for Covariant Return Type in Java


There are mainly three rules for covariant return types in Java that you should keep in mind. They are as follows:

1. The return type of overriding method in the subclass should be either the same as the return type of superclass or subclass.

2. The return type of overriding method in the subclass should not be a parent of the parent method return type.

3. The covariant return type is applicable only for object types, not for primitive types.


Covariant return type in Java

Covariant Return Type Example Program


Let’s take some important example programs with explanations based on covariant return types in Java.

Program code 1:

package covariantReturnType; 
public class A 
{ 
  public Object m1()
  { 
     System.out.println("Hello, this is a superclass"); 
     return null; 
  } 
} 
public class B extends A
{ 
   @Override 
   public String m1() 
   { 
      System.out.println("Hello, this is the subclass"); 
      return null; 
   } 
 } 
public class AB { 
public static void main(String[] args) 
{ 
     B b = new B(); 
     b.m1(); 
     
     A a = new B(); 
     a.m1(); 
  } 
}
Output: 
       Hello, this is the subclass 
       Hello, this is the subclass

Explanation:

In the above example program, superclass declares m1() method of Object return type and B class overrides the m1() method by changing the return type from Object to String.


The return type of the overriding method m1() in the subclass is a string that is the subclass of an Object class.

1. The statement b.m1(); will call m1() method of class B because the reference variable is pointing to the objects of class B. As you learned from the previous tutorial that in overriding, method resolution always takes care by JVM based on the runtime object.

2. Similarly, the statement a.m1(); will also call m1() method of class B because it is also pointing to the object of class B.

Program code 2:

package covariantReturnType; 
public class A 
{ 
   public String m1()
   { 
      System.out.println("Hello, this is a superclass"); 
      return null; 
   } 
} 
public class B extends A
{ 
   @Override 
   public Object m1() 
   { 
      System.out.println("Hello, this is the subclass"); 
      return null; 
   } 
} 
public class AB { 
public static void main(String[] args) 
{ 
     A a = new B(); 
     a.m1(); 
  } 
}
Output: 
       Hello, this is a superclass

In this example, the return type of overriding method is incompatible with A.m1() because the return type of overriding method in the subclass should not be parent. Here, Object is the parent class of String. Therefore, it is not an overridden method. Because of not being overriding in the subclass, a.m1() will call by default available m1() method in class B.

Program code 3:

package covariantReturnType; 
public class A 
{ 
   public Number m1(int a, double b)
   { 
      System.out.println("Hello, this is a superclass"); 
      return null; 
   } 
} 
public class B extends A
{ 
    @Override 
    public Integer m1(int a, double b)
    { 
       System.out.println("Hello, this is the subclass"); 
       return null; 
    } 
} 
public class AB { 
public static void main(String[] args) 
{ 
     A a = new B(); 
     a.m1(10,20.5); 
  } 
}
Output: 
        Hello, this is the subclass

In this example code, we have defined three classes A, B, and AB within the covariantReturnType package. The class A is the superclass in which we have defined m1() method of return type Number. This method takes an int and a double as parameters.

The class B is the subclass of class A in which we have overridden m1() method with the same method signature, but its return type is an Integer instead of a Number.

The class AB contains the main method, which is the entry point of the program. Inside the main method, we have created an object of class B and assigned it to a variable “a” of type A. Then, we have called m1() method using reference variable “a” by passing arguments 10 and 20.5.

Since Java uses dynamic method binding to determine the appropriate method call at runtime based on the actual object type. Therefore, the overridden m1 method of subclass B will be invoked.

In addition, this example code exhibits the concept of covariant return types, where the overridden method in the subclass can return a more specific type than the method in the superclass.

Program code 4:

package covariantReturnType; 
public class X 
{ 
   public Object m1(char c)
   { 
      System.out.println("m1-X"); 
      return new X(); 
   } 
} 
public class Y extends X
{ 
   @Override 
   public StringBuffer m1(char c)
   { 
      System.out.println("m1-Y"); 
      return null; 
   } 
} 
public class XY { 
public static void main(String[] args) 
{ 
    X x = new Y(); 
    x.m1('a'); 

    X x1 = new X(); 
    x1.m1('b'); 
  } 
}
Output: 
       m1-Y 
       m1-X

Program code 5:

package covariantReturnType; 
public class X 
{ 
   public double m1(char c)
   { 
      System.out.println("m1-X"); 
      return 25; 
   } 
} 
public class Y extends X
{ 
   @Override 
   public Integer m1(char c) 
   { 
      System.out.println("m1-Y"); 
      return 20; 
   } 
} 
public class XY { 
public static void main(String[] args) 
{ 
     X x = new Y(); 
      x.m1('a'); 
     
     X x1 = new X(); 
      x1.m1('b'); 
  } 
}
Output: 
       m1-X 
       m1-X

In this example code, we will get an error in the line public Integer m1(char c) because the return type is incompatible with X.m1(char).

Covariant return type concept is applicable only for an object reference type, not for primitive types because there is no subtype relationship between primitive types.

Because of not being overriding in the subclass, x.m1(‘a’); will call by default available m1() method in class Y. Similarly, x1.m1(‘b’); will call m1() method of class A because the reference variable x1 is pointing to the objects of class A.

Now, suppose if we declare also double as the return type of the overriding method in the subclass as in the superclass, then there will not be a compile-time error. So, in this case, the method will be overriding. The result will be “m1-Y” and “m1-X”.


Key Points:

1. Java SE5 adds a new feature Covariant return type, which means we can override any method by changing return type if the return type of subclass overriding method is subclass type.

2. Covariant return type also helps to minimize upcasting and downcasting in Java.


In this tutorial, we have explained covariant return types in Java with the help of some important example programs. Hope that you will have understood the concept of covariant return type and practiced all programs. In the next, we will understand rules of exception handling in Java method overriding.
Thanks for reading!!!

⇐ Prev Next ⇒

Please share your love