方法重载

参考：传智播客&黑马程序员

方法重载

方法重载

指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。 简单来说就是，多个方法的名称一样，但是参数列表不一样。

好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

参数列表

个数不同，数据类型不同，顺序不同。

重载方法调用

JVM通过方法的参数列表，调用不同的方法。

方法重载与下列因素相关：

1. 参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同

方法重载与下列因素无关：

1. 与参数的名称无关
2. 与方法的返回值类型无关

示例

	public class Demo01MethodOverload {
	public static void main(String[] args) {
        /*System.out.println(sumTwo(10, 20)); // 30
        System.out.println(sumThree(10, 20, 30)); // 60
        System.out.println(sumFour(10, 20, 30, 40)); // 100*/

        System.out.println(sum(10, 20)); // 两个参数的方法
        System.out.println(sum(10, 20, 30)); // 三个参数的方法
        System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
	//        System.out.println(sum(10, 20, 30, 40, 50)); 
	// 找不到任何方法来匹配，所以错误！

        sum(10, 20);
    }

    public static int sum(int a, double b) {
        return (int) (a + b);
    }

    public static int sum(double a, int b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b) {
        System.out.println("有2个参数的方法执行！");
        return a + b;
    }

    // 错误写法！与方法的返回值类型无关
	//    public static double sum(int a, int b) {
	//        return a + b + 0.0;
	//    }

    // 错误写法！与参数的名称无关
	//    public static int sum(int x, int y) {
	//        return x + y;
	//    }

    public static int sum(double a, double b) {
        return (int) (a + b);
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3个参数的方法执行！");
        return a + b + c;
    }

    public static int sum(int a, int b, int c, int d) {
        System.out.println("有4个参数的方法执行！");
        return a + b + c + d;
    	}
    }  

方法重载练习一

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

	public class Method_Demo6 {
    public static void main(String[] args) {
        //定义不同数据类型的变量
        byte a = 10;
        byte b = 20;
        short c = 10;
        short d = 20;
        int e = 10;
        int f = 10;
        long g = 10;
        long h = 20;
        // 调用 
        System.out.println(compare(a, b));
        System.out.println(compare(c, d));
        System.out.println(compare(e, f));
        System.out.println(compare(g, h));
    }

    // 两个byte类型的 
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    // 两个short类型的 
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    // 两个int类型的 
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

// 两个long类型的 
public static boolean compare(long a, long b) {
    System.out.println("long");
    return a == b;

方法重载练习二

判断哪些方法是重载关系。

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

方法重载练习三

模拟输出语句中的 println 方法效果，传递什么类型的数据就输出什么类型的数据，只允许定义一个方法名 println 。

package cn.itcast.day04.demo04；
// byte short int long float double char boolean
// String
// 在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。
public class  Demo04OverloadPrint {
    public static void main(String[] args) {
        myPrint(100); // int
        myPrint("Hello"); // String

    }
   	public static void myPrint(byte num) {
                System.out.println(num);
            }

            public static void myPrint(short num) {
                System.out.println(num);
            }

            public static void myPrint(int num) {
                System.out.println(num);
            }

            public static void myPrint(long num) {
                System.out.println(num);
            }

            public static void myPrint(float num) {
                System.out.println(num);
            }

            public static void myPrint(double num) { System.out.println(num);}

            public static void myPrint(char zifu) {
                System.out.println(zifu);
            }

            public static void myPrint(boolean is) {
                System.out.println(is);
            }

            public static void myPrint(String str) {
                System.out.println(str);
            }			
}