The relationship of overload and method return type in Java?

问题

If there are two methods, they have different parameters, and their return types are different. Like this:

int test(int p) {
   System.out.println("version one");
   return p;
}

boolean test(boolean p, int q) {
   System.out.println("version two");
   return p;
}

If the return types are same, of course this is overload. But since the return types are different, can we regard this as overload still?

回答1:

consider following points for overloading:

First and important rule to overload a method in java is to change method signature. Method signature is made of number of arguments, type of arguments and order of arguments if they are of different types.

public class DemoClass {
    // Overloaded method
    public Integer sum(Integer a, Integer b) {
        return a + b;
    }

    // Overloading method
    public Integer sum(Float a, Integer b) {  //Valid
        return null;
    }
}

Return type of method is never part of method signature, so only changing the return type of method does not amount to method overloading.

public class DemoClass {
    // Overloaded method
    public Integer sum(Integer a, Integer b) {
        return a + b;
    }

    // Overloading method
    public Float sum(Integer a, Integer b) {     //Not valid; Compile time error
        return null;
    }
}

Thrown exceptions from methods are also not considered when overloading a method. So your overloaded method throws the same exception, a different exception or it simply does no throw any exception; no effect at all on method loading.

public class DemoClass {
    // Overloaded method
    public Integer sum(Integer a, Integer b) throws NullPointerException{
        return a + b;
    }

    // Overloading method
    public Integer sum(Integer a, Integer b) throws Exception{  //Not valid; Compile time error
        return null;
    }
}

回答2:

To quote the official tutorial:

The Java programming language supports overloading methods, and Java can distinguish between methods with different method signatures. This means that methods within a class can have the same name if they have different parameter lists (there are some qualifications to this that will be discussed in the lesson titled "Interfaces and Inheritance").

Having a different return type is inconsequential to overloading. In fact, this is quite common with methods that return one of their arguments. E.g., java.util.Math has a bunch of overloaded max methods. A max of two ints return an int, a max of two doubles return a double, etc.

回答3:

Yes, this is also an overload. Since only the name and the list of parameters are considered part of method's signature for the purposes of method overloading, both your test methods are overloads of each other.

There may be useful scenarios for overloading a method like that, too. Consider this example:

class Sanitizer {
    public static String sanitize(String s) {
        ...
    }
    public static int sanitize(int s) {
        ...
    }
    public static double sanitize(double s) {
        ...
    }
}

A programmer who uses Sanitizer can write things like

String s2 = Sanitizer.sanitize(s1);
int num2 = Sanitizer.sanitize(num1);

and the overload makes the code looks the same for variables of different types.

回答4:

In function overloading return types don't play any role. Function overloading can only be achieved via change in arguments. So, yes in your given case test() is overloaded

来源：https://stackoverflow.com/questions/31892125/the-relationship-of-overload-and-method-return-type-in-java

标签

java

methods

overloading

return-type