方法的重载的学习

  • 一、方法重载的定义
  • 二、方法重载练习


一、方法重载的定义

  1. 方法重载（Overload）
    方法重载指的是在在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。使用方法的重载，只需要记住唯一一个方法的名称，就可以实现多个类似功能，十分方便。

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

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

代码说明：

public class Demo01MethodOverload {

    public static void main(String[] args) {
        /*System.out.println(sum2(10,20));
        System.out.println(sum3(10,20,30));
        System.out.println(sum4(10,20,30,40));*/

        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));//找不到任何方法来匹配，报错！
    }

    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;
    }
}

二、方法重载练习

下面我们进行几个练习，来进一步理解方法重载

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

代码实例：

public class Demo02MethodOverloadSame {

    public static void main(String[] args) {

        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a, b));
        System.out.println("--------------------------");
        System.out.println(isSame((short)10, (short)10));
        System.out.println("--------------------------");
        System.out.println(isSame(10,20));
        System.out.println("--------------------------");
        System.out.println(isSame(10L, 10L));
    }

	//byte类型进行比较
    public static boolean isSame(byte a, byte b) {
        System.out.println("两个byte参数执行的方法执行！");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }

	//short类型进行比较
    public static boolean isSame(short a, short b) {
        System.out.println("两个short参数执行的方法执行！");
        boolean same = a == b ? true : false ;
        return same;
    }

	//int类型进行比较
    public static boolean isSame(int a, int b) {
        System.out.println("两个int参数执行的方法执行！");
        return a == b;
    }

	//long类型进行比较
    public static boolean isSame(long a, long b) {
        System.out.println("两个long参数执行的方法执行！");
        if (a == b) {
            return true;
        }else {
            return false;
        }

    }
}

练习2：
定义一个open方法，判断哪些方法是重载关系：

public static void open(){} //定义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行冲突

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

public class Method_Demo7 {
public static void println(byte a) {
System.out.println(a);
}
public static void println(short a) {
System.out.println(a);
}
public static void println(int a) {
System.out.println(a);
}
public static void println(long a) {
System.out.println(a);
}
public static void println(float a) {
System.out.println(a);
}
public static void println(double a) {
System.out.println(a);
}
public static void println(char a) {
System.out.println(a);
}
public static void println(boolean a) {
System.out.println(a);
}
public static void println(String a) {
System.out.println(a);
}
}