第13节方法重载

2019年7月9日星期二
22时16分32秒

第13节方法重载

目录
1_1_13_18_方法重载的基本使用	2
1_1_13_19_方法重载的注意事项	2
1_1_13_20_重载练习1_四种不同参数类	2
1_1_13_21_重载练习2_判断方法的正确	2
1_1_13_22_重载练习3_实现重载的pri	2

1_1_13_18_方法重载的基本使用
1.创建一个包demo04
2.在demo04包下创建一个类:Demo01MethodOverload
3.为什么会出现方法重载?

如果有1万个方法,就会有一万个方法名称
对于功能类似的方法来说,因为参数列表不一样,却需要记住那么多不同的方法名称,太麻烦

解决方案:方法重载
方法的重载(Overload) : 多个方法的名称一样,但是参数列表不一样(参数个数不同,参数类型不同,参数顺序不同)。
好处: 只需要记住唯一一个方法名称,就可以实现类似的多个功能。

package cn.itcast.day04.demo04;

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

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


 */
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)); // 找不到任何方法来匹配,所以错误!
    }

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

}

1_1_13_19_方法重载的注意事项

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

1. 参数个数不同

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

方法重载与下列因素无关:
1. 与参数的名称无关

2. 与方法的返回值类型无关

package cn.itcast.day04.demo04;

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

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

方法重载与下列因素相关:
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){
        System.out.println("有2个参数的方法执行!");
        return a + b;
    }*/

    // 错误写法! 与参数的名称无关
    /*public static int sum(int x, int y){
        System.out.println("有2个参数的方法执行!");
        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_1_13_20_重载练习1_四种不同参数类

1.创建一个类:Demo02MethodOverloadSame
2.练习(参数类型不同)
题目要求:
比较两个数据是否相等。
参数类型分别为两个byte类型,两个short类型,两个int类型,两个long类型
并在main方法中进行调试
package cn.itcast.day04.demo04;

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

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

}

1_1_13_21_重载练习2_判断方法的正确

package cn.itcast.day04.demo04;

public class Demo03MethodOverloadJudge {

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

}

1_1_13_22_重载练习3_实现重载的pri

package cn.itcast.day04.demo04;

// byte short int long float double char boolean
// String
// 在调用输出语句的是时候,println方法其实就是进行了多种数据类型的操作形式
public class Demo04OverloadePrint {

    public static void main(String[] args) {
        myPrint(100); // int
        myPrint("hello"); // String
    }

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

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

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

    public static Long myPrint(long num01, int num02){
        System.out.println(num01 + num02);
        return num01 + num02;
    }

    public static float myPrint(float num01,double num02){
        System.out.println(num01 + num02);
        return (float)(num01 + num02);
    }

    public static double myPrint(double num01,float num02){
        System.out.println(num01 + num02);
        return num01 + num02;
    }

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

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

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

}

1.方法名相同1.列表不一样(参数类型不同或 参数个数不同,或 参数顺序不同), 是重载 ,与返回值类型无关

–这两个方法就构成了重载

(1)方法名相同,参数类型不同, 叫重载 ,与返回值类型无关

(2)方法名相同,参数个数不同, 叫重载 ,与返回值类型无关

(3)方法名相同,参数顺序不同, 叫重载 ,与返回值类型无关


扩展:
**Shift + F6,**用到我的地方和我一起变


2.Ctrl + 鼠标点击print

(1). 进入到PringStream.java类中

—进入后会回到多个println方法 —名称相同,参数类型不同这个叫重载
在调用输出语句的是时候,println方法其实就是进行了多种数据类型的操作形式
这也是重载的好处