7、方法重载

于 2021-05-17 17:21:31 发布
阅读量379 收藏 2
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57686376/article/details/116935937
版权

7、方法重载

1、方法重载（Overload）的基本使用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

public class DemoelMethodOverload {
    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
    }

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

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

方法重载使用：

public class DemoelMethodOverload {
    public static void main(String[] args) {

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

    //同一个sum，但是括号里有不同的参数列表
    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;
    }
}

2、方法重载的注意事项

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

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

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

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 x,int y){
        return x+y;
        }

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

3、重载练习_四种不同参数类型的方法

在这里插入图片描述

public class MethodTest {
    public static void main(String[] args) {
//调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

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

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

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}

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

/*
题目要求：
比较两个数据是否相等。
参数类型分别为两个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((short) 20, (short) 20));

        System.out.println(isSame(11, 12));

        System.out.println(isSame(10L, 10L));
    }

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

}

4、重载练习2_判断方法的正确重载

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行冲突

5、重载练习3_实现重载的println方法

shift+F6 用到的地方也会跟着改变
CTRL+鼠标点击 能出现println的各种方法重载的使用

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

}

方法参数传递基本类型

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
重点关注两件事：
1、方法里面的形参在内存中也就是一个变量而已。
2、一个方法在调用传递参数的时候，如果传递的是基本数据类型，那么传递过去的就是该变量记录的具体数值

package com.itheima.param;
public class Test1 {
    /*
    方法参数传递为基本数据类型 :
    传入方法中的, 是具体的数值.
    */
    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;
    }
}

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

方法参数传递引用类型（数组）

在这里插入图片描述
在这里插入图片描述

重点：
如果一个方法参数传递的是引用数据类型，那么他会传递该引用数据类型中的所记录的内存地址

package com.itheima.param;
public class Test2 {
    /*
    方法参数传递为引用数据类型 :
    传入方法中的, 是内存地址.
    */
    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;
    }
}

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

数组遍历

在这里插入图片描述

package com.itheima.test;
public class Test1 {
/*
需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
思路：
1.定义一个数组，用静态初始化完成数组元素初始化
2.定义一个方法，对数组进行遍历
3.遍历打印的时候，数据不换行
4.调用遍历方法
*/

    public static void main(String[] args) {
        // 1.定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 22, 33, 44, 55};
        // 4.调用遍历方法
        printArray(arr);
        System.out.println("另外一段代码逻辑 ");
    } 

/*
2.定义一个方法，对数组进行遍历
1, 参数 int[] arr
2, 返回值类型 void
*/

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                // 如果满足条件, 说明是最后一个元素, 最后一个元素, 特殊处理
                System.out.println(arr[i] + "]");//print一定要加上ln 因为调用后要运行另一段代码逻辑需要换行
            } else {
                // 3.遍历打印的时候，数据不换行
                System.out.print(arr[i] + ", ");
            }
        }
    }
}

获取数组最大值

在这里插入图片描述

package com.itheima.test;
public class Test2 {
/*
需求：设计一个方法用于获取数组中元素的最大值
思路：
1.定义一个数组，用静态初始化完成数组元素初始化
2.定义一个方法，用来获取数组中的最大值
3.调用获取最大值方法，用变量接收返回结果
4.把结果输出在控制台
*/

    public static void main(String[] args) {
        // 1.定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 55, 22, 44, 33};
        // 3.调用获取最大值方法，用变量接收返回结果
        int max = getMax(arr);
        // 4.把结果输出在控制台
        System.out.println(max);
    } 

/*
2.定义一个方法，用来获取数组中的最大值
1, 参数 int[] arr
2, 返回值类型 int
*/

    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }
}

方法同时获取数组最大值和最小值

在这里插入图片描述

public class Test3 {
/*
需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值
注意: return语句, 只能带回一个结果.
*/

    public static void main(String[] args) {
        int[] arr = {11, 55, 33, 22, 44};
        int[] maxAndMin = getMaxAndMin(arr);
        System.out.println(maxAndMin[0]);
        System.out.println(maxAndMin[1]);
    }

    public static int[] getMaxAndMin(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }

        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
        }

        int[] maxAndMin = {min, max};
        return maxAndMin;
    }
}
林同学的小岛
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值