详解方法的重载

方法重载

在一个类中，多个方法的名称相同，但他们形参列表不同。
对于功能类似的方法来说，因为参数列表不一样，却要记住那么多不同的方法名称，太麻烦
方法的重载（Overload）:在同一个类中定义的多个方法的名称一样，但是参数列表不一样
好处：只需要记住唯一的一个方法名称，就可以实现类似的多个功能
方法重载与下列因素有关：
1、参数个数不同
2、参数类型不同
3、参数的多类型顺序不同
方法重载与下列因素无关：
1、与参数的名称无关
2、与方法的返回值类型无关

public class Demo01MethodOverload {
    public static void main(String[] args) {
       /* System.out.println(sumTwo(10,20));
        System.out.println(sumThree(10,20,30));
        System.out.println(sumFour(10,20,30,40));*/
        System.out.println(sum(10,20));//写几个就是几个
    }
   /* public static int sumTwo(int a,int b){
        return a+b;
    }
    public static int sumThree(int a,int b,int c){
        return a+b+c;
    }
    public static int sumFour(int a,int b,int c,int d){
        return a+b+c+d;
    }*/
       public static int sum(int a,int b) {
       System.out.println("有2个参数的方法执行！");
       return 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;
       }
    public static int sum(double a,double b){        //参数类型不同
        return (int)(a+b);
    }
    public static int sum(double a,int b){          //参数的多类型顺序不同
           return (int)(a+b);
    }
    /*public static int sum(int x,int y){             //错误写法，与参数的名称无关
           return x+y;
    }*/
    /*public static double sum(int a,int b){              //错误写法，与参数返回值类型无关
        return a+b+0.0;
    }*/
}

例一、比较两个数据是否相等

参数类型分别为两个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(isSame(10,20));
        System.out.println(isSame(10L,10L));
        System.out.println(isSame((short) 20,(short) 20));

    }
    public static boolean isSame(byte a,byte b){
        System.out.println("两个byte参数的方法执行！");
        boolean same;
        if(a==b){
            same=true;
        }else {
            same=false;
        }
        return same;
    }
    public static boolean isSame(short a,short b){
        System.out.println("两个short参数的方法执行！");
        boolean same = a==b?true:false;
        return same;
    }
    public static boolean isSame(int a,int b){
        System.out.println("两个int参数的方法执行！");
        return a==b;
    }
    public static boolean isSame(long a,long b){
        System.out.println("两个long参数的方法执行！");
        if (a==b){
            return true;
        }else {
            return false;
        }
    }
}

例二、判断方法的正确

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

例三、实现方法重载的Println

/*
*byte short int long float double char boolean
* String
* 在调用输出语句时，println方法其实就是进行了多种类型的重载形式*/
public class Demo04OverloadPrint {
    public static void main(String[] args) {
        myPrint(10);//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);
    }
}

方法参数传递基本类型

public class ArgsDemo01 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);
        change(number);
        System.out.println("调用change方法后：" + number);
    }

    public static void change(int number) {
        number = 200;
    }
}

基本数据类型的参数，形式参数的改变，不影响实际参数。每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

方法参数传递引用类型

public class ArgsDemo02 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]);
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }

    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

对应引用类型的参数，形式参数的改变，影响实际参数的值。引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果。

数组遍历

设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11,23,44,55,66]

public class MethodTest01 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 22, 33, 44, 55};

        //调用方法
        printArray(arr);
    }

    //定义一个方法，用数组遍历通用格式对数组进行遍历
    /*
        两个明确：
            返回值类型：void
            参数：int[] arr
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x]+", ");
            }
        }
        System.out.println("]");
    }
}

数组最大值

设计一个方法用于获取数组中元素的最大值

public class MethodTest02 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {12, 45, 98, 73, 60};

        //调用获取最大值方法，用变量接收返回结果
        int number = getMax(arr);

        //把结果输出在控制台
        System.out.println("number:" + number);
    }

    //定义一个方法，用来获取数组中的最大值
    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMax(int[] arr) {
        int max = arr[0];

        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }
}

return关键字在方法中单独使用

return:可以用在无返回值的方法中。作用是立即跳出并结束当前方法的执行。
例如：下面例子中0不能作为除数。