Overriding a method with different return types in java?

Question

I have read a book and it says I can override a method if it has the same signature. according to the book the signature of a method is Method_Name + Parameters passed.

as per the book, i can override a method which has different return types. Is it actually possible to override a method with different return type in Java? because i have done a some search on the net i found people saying that to override a method the return type should be same as well.

according to the book it also says the java will throw a compile error when we try to overload a method with same method name and parameters but different return types since the signature means only the method name and parameters. If this is true, we should be able to override a method with different return type.

Please help me to understand this. Thanks in advance.

Answer 1

You can return a different type, as long as it's compatible with the return type of the overridden method. Compatible means: it's a subclass, sub-interface, or implementation of the class or interface returned by the overridden method.

And that's logical. If a method returns an Animal, and your derived class returns a Cow, you're not breaking the contract of the superclass method, since a Cow is an Animal. If the derived class returns a Banana, that isn't correct anymore, since a Banana is not an Animal.

Answer 2

Your parent class has made a promise to the outside world. For example, the method:

public Price calculatePrice(Items[] items).

It tells the world to expect a Price.

If you enhance that functionality in your subclass, you still have to keep your parent classes' original promises for it.

You can add overloaded ways of calculating:

public Price calculatePrice(Items[] items, Integer minimumCharge).

You can even improve your parent's promises by using a MORE specific return type:

public AccuratePrice calculatePrice(Items[] items, Integer minimumCharge).

But you must return at least the type that your parent promised. The same goes for Exceptions in the method declaration too.

Answer 3

Yes, it is possible since Java 5, it is called covariant return type. The return type should be a subcass of super class method return type (primitive types are not allowed). Example

class X implements Cloneable {

    @Override
    protected X clone() {
        try {
            return (X) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new Error(e); // can never happen
        }
    }
}

Answer 4

Here is an example:

class Base {
    public Number test() {
        return 0;
    }
}

class A extends Base {
    public Long test() {
        return 1L;
    }
}

Answer 5

Your overriden method can have same type or the sub-type of the original return type which is called as covariant return.

If you change the return type of the overriden method to something else which is not a sub-type of the original type, then you'd get a compile time error.

Answer 6

Yes we can override different return types but they should be subclass.

public class Shape {
    public Shape area(Integer i) {
        System.out.println("Sape Area");
        System.out.println("Integer");
        return null;
    }
}


package com.oops;

public class Circle extends Shape {
    public Circle area(Integer i) {
        System.out.println("Circle Area");
        System.out.println("int");
        return null;
    }
}

Answer 7

// Covariant Overriding 
public class Parent {

  public Parent(){}
  String parentName;
  public Parent(String parentName){
    this.parentName=parentName;
    System.out.println(this.parentName);
 }

public  Parent show(){
    return new Parent("Parent");
}
}




public class Child extends Parent{

  public Child(){}
  String name;
  public Child(String name){
    this.name=name;
    System.out.println(this.name);
  }
  public Child show(){
    return new Child("Child");
}
}



public class Main {

public static void main(String[] args) {
    Parent parent=new Child();
    parent.show();

    Parent parent1=new Parent();
    parent1.show();
}
}