Java基础---Java方法的重载Overload

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关：
　　1. 参数个数不同
　　2. 参数类型不同
　　3. 参数的多类型顺序不同

方法重载与下列因素无关：
　　1. 与参数的名称无关
　　2. 与方法的返回值类型无关

 1 public class DemoMethodOverload {
 2
 3     public static void main(String[] args) {
 4         /*System.out.println(sumTwo(10, 20)); // 30
 5         System.out.println(sumThree(10, 20, 30)); // 60
 6         System.out.println(sumFour(10, 20, 30, 40)); // 100*/
 7
 8         System.out.println(sum(10, 20)); // 两个参数的方法
 9         System.out.println(sum(10, 20, 30)); // 三个参数的方法
10         System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
11 //        System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法来匹配，所以错误！
12
13         sum(10, 20);
14     }
15
16     public static int sum(int a, double b) {
17         return (int) (a + b);
18     }
19
20     public static int sum(double a, int b) {
21         return (int) (a + b);
22     }
23
24     public static int sum(int a, int b) {
25         System.out.println("有2个参数的方法执行！");
26         return a + b;
27     }
28
29     // 错误写法！与方法的返回值类型无关
30 //    public static double sum(int a, int b) {
31 //        return a + b + 0.0;
32 //    }
33
34     // 错误写法！与参数的名称无关
35 //    public static int sum(int x, int y) {
36 //        return x + y;
37 //    }
38
39     public static int sum(double a, double b) {
40         return (int) (a + b);
41     }
42
43     public static int sum(int a, int b, int c) {
44         System.out.println("有3个参数的方法执行！");
45         return a + b + c;
46     }
47
48     public static int sum(int a, int b, int c, int d) {
49         System.out.println("有4个参数的方法执行！");
50         return a + b + c + d;
51     }
52
53 }

题目要求：
比较两个数据是否相等。
参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
并在main方法中进行测试。

 1 public class Demo02MethodOverloadSame {
 2
 3     public static void main(String[] args) {
 4         byte a = 10;
 5         byte b = 20;
 6         System.out.println(isSame(a, b));
 7
 8         System.out.println(isSame((short) 20, (short) 20));
 9
10         System.out.println(isSame(11, 12));
11
12         System.out.println(isSame(10L, 10L));
13     }
14
15     public static boolean isSame(byte a, byte b) {
16         System.out.println("两个byte参数的方法执行！");
17         boolean same;
18         if (a == b) {
19             same = true;
20         } else {
21             same = false;
22         }
23         return same;
24     }
25
26     public static boolean isSame(short a, short b) {
27         System.out.println("两个short参数的方法执行！");
28         boolean same = a == b ? true : false;
29         return same;
30     }
31
32     public static boolean isSame(int a, int b) {
33         System.out.println("两个int参数的方法执行！");
34         return a == b;
35     }
36
37     public static boolean isSame(long a, long b) {
38         System.out.println("两个long参数的方法执行！");
39         if (a == b) {
40             return true;
41         } else {
42             return false;
43         }
44     }
45
46 }

判断方法是否能够重载

 1 public class Demo03OverloadJudge {
 2     public static void open(){} // 正确重载
 3     public static void open(int a){} // 正确重载
 4     static void open(int a,int b){} // 代码错误：和第8行冲突
 5     public static void open(double a,int b){} // 正确重载
 6     public static void open(int a,double b){} // 代码错误：和第6行冲突
 7     public void open(int i,double d){} // 代码错误：和第5行冲突
 8     public static void OPEN(){} // 代码正确不会报错，但是并不是有效重载
 9     public static void open(int i,int j){} // 代码错误：和第3行冲突
10 }

原文地址：https://www.cnblogs.com/hoganhome/p/11487420.html