java方法重载的快速入门

基本介绍：

java中允许同一个类中，多个同名方法的存在，但要求，形参列表不一致

重载的好处：

1.减轻了起名字的麻烦
2.减轻了记名的麻烦

快速入门案例：

1. calculate(int n1, int n2)
2. calculate(int n1, double n2)
3. calculate(int n1, int n2, int n3)

代码：

package review.javaSE_.oop_;

/**
 * @author: ln
 * @data:
 * @description:方法重载的快速入门
 */
public class OverLoad01 {
    public static void main(String[] args) {
        MyCalculator myCalculator = new MyCalculator();
        System.out.println(myCalculator.calculate(6,6));
        System.out.println(myCalculator.calculate(6,6.6));
        System.out.println(myCalculator.calculate(6,6,6));
    }
}
class MyCalculator {
    //下面四个calculate方法构成了重载

    //两个整数的和
    public int calculate(int n1, int n2) {
        System.out.println("calculate(int n1, int n2)被调用");
        return n1 + n2;
    }

    //没有构成方法重载，仍然是错误的，因为是方法的重复定义
//    public int calculate(int n1, int n2) {
//        System.out.println("calculate(int n1, int n2)被调用");
//        int res = n1 + n2;
//        return res;
//    }

    //没有构成方法重载，仍然是错误的，因为是方法的重复定义
//    public int calculate(int a1, int a2) {
//        System.out.println("calculate(int n1, int n2)被调用");
//        return a1 + a2;
//    }

    //一个整数和一个浮点数
    public double calculate(int n1, double n2) {
        System.out.println("calculate(int n1, double n2)被调用");
        return n1 + n2;
    }

    //三个int 的和
    public int calculate(int n1, int n2, int n3) {
        System.out.println("calculate(int n1, int n2, int n3)被调用");
        return n1 + n2 + n3;
    }
}

注意事项和使用细节

1.方法名：必须相同
2.形参列表：必须不同(形参的类型或者个数、顺序，至少有一个不同，参数名无要求）
3.返回类型：无要求

练习题目：

判断题：

与void show(int a, char b, double c){} 构成重载的有 【b, c, d, e】

a. void show(int x, char y, double z){} //不是，形参列表一样
b. int show(int a, double b, char c){} //是
c. void show(int a, double b, char c){} //是
d. boolean show(int a, char b){} //是
e. void show(double c){} //是
f. double show(int c, char y, double z){} //不是，形参列表一样
g. void shows(){} //不是,方法名不一样

编程题：

1.再类Methods中定以三个重载方法并调用，方法名为m。三个方法分别接受一个int参数，两个int参数，一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。在类中分别调用

代码：

package review.javaSE_.oop_;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class OverloadExercise {
    public static void main(String[] args) {
        Methods methods = new Methods();
        System.out.println(methods.m(2));
        System.out.println(methods.m(2,2));
        methods.m("李华");
    }
}
class Methods {
    public int m(int n) {
        System.out.println("m(int n)方法被调用");
        return n * n;
    }

    public int m(int n1, int n2) {
        System.out.println("m(int n1, int n2)方法被调用");
        return n1 * n2;
    }

    public void m(String str) {
        System.out.println("m(String str)方法被调用");
        System.out.println(str);
    }
}

在Methods类中定义三个重载方法max(),第一个方法，返回两个int值中的最大值，第二个方法，返回两个double值中的最大值，第三个方法，返回三个double值中的最大值，并分别调用三个方法。

代码：

package review.javaSE_.oop_;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class OverloadExercise {
    public static void main(String[] args) {
        Methods methods = new Methods();
        System.out.println(methods.m(2));
        System.out.println(methods.m(2,2));
        methods.m("李华");

        System.out.println(methods.max(6,5));
        System.out.println(methods.max(6.6,7.7));
        System.out.println(methods.max(5.5,6.6,7.7));
    }
}
class Methods {
    public int m(int n) {
        System.out.println("m(int n)方法被调用");
        return n * n;
    }

    public int m(int n1, int n2) {
        System.out.println("m(int n1, int n2)方法被调用");
        return n1 * n2;
    }

    public void m(String str) {
        System.out.println("m(String str)方法被调用");
        System.out.println(str);
    }

    public int max(int n1, int n2) {
        System.out.println("max(int n1, int n2)方法被调用");
        return n1 > n2 ? n1 : n2;
    }

    public double max(double n1, double n2) {
        System.out.println("max(double n1, double n2)方法被调用");
        return n1 > n2 ? n1 : n2;
    }

    public double max(double n1, double n2, double n3) {
        System.out.println("max(double n1, double n2, double n3)方法被调用");
        double temp = n1 > n2 ? n1 : n2;
        return n3 > temp ? n3 : temp;
    }
}