4-7再谈方法之重载

方法的重载（overload）

1.重载的概念

• 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
• “两同一不同”：同一个类，相同方法名，参数列表不同，参数个数不同，参数类型不同

2.重载的特点：

• 与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类
• 型)。调用时，根据方法参数列表的不同来区别。

3.判断方法是否重载

• 与方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！！！

4.在通过对象调用方法的时候，如何确定一个指定的方法：

•   方法名--->参数列表
  1

/*
* 方法的重载（overload） loading。。。。
* 1.重载的概念
* 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
*  "两同一不同"：同一个类，相同方法名，参数列表不同，参数个数不同，参数类型不同
* 2.重载的特点：
* 与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类
* 型)。调用时，根据方法参数列表的不同来区别。
* 3.判断方法是否重载
*   与方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！！！
* 4.在通过对象调用方法的时候，如何确定一个指定的方法：
*       方法名--->参数列表
* */
public class OverLoadTest {
    public static void main(String[] args) {

        OverLoadTest test = new OverLoadTest();
        test.getSum(1,2);
        test.getSum(0.0,0.0);
        test.getSum(1,"123");
        test.getSum("123",1);

    }

    //重载
    public void getSum(int i,int j){
        System.out.println(1);
    }

    public void getSum(double d1,double d2){
        System.out.println(2);
    }

    public void getSum(int i,String s){
        System.out.println(3);
    }

    public void getSum(String s,int i){
        System.out.println(4);
    }
//  同效
//    public void getSum(int x,int y){
//
//    }

//    private void getSum(int i,int j){
//
//    }
}


/*
*
* 1.判断：与void show(int a,char b,double c){}构成重载的有：

a)void show(int x,char y,double z){} // no
b)int show(int a,double c,char b){} // yes
c) void show(int a,double c,char b){} // yes
d) boolean show(int c,char b){} // yes
e) void show(double c){} // yes
f) double show(int x,char y,double z){} // no
g) void shows(){double c} // no

* */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

1.编写程序，定义三个重载方法并调用。方法名为mOL。

• 三个方法分别接收一个int参数、两个int参数、一个字符串参数。
• 分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
• 在主类的main ()方法中分别用参数区别调用三个方法。

2.定义三个重载方法max()，

• 第一个方法求两个int值中的最大值，
• 第二个方法求两个double值中的最大值，
• 第三个方法求三个double值中的最大值，并分别调用三个方法。

public class OverLoadever {

    public static void main(String[] args) {
        OverLoadever test = new OverLoadever();
        //1.调用3个方法
        test.mOL(5);
        test.mOL(6, 4);
        test.mOL("fg");

        //2.调用3个方法
        int num1 = test.max(18, 452);
        System.out.println(num1);
        double num2 = test.max(5.6, -78.6);
        System.out.println(num2);
        double num3 = test.max(15, 52, 42);
        System.out.println(num3);
    }

    //1.如下三个方法构成重载
    public void mOL(int i){
        System.out.println(i*i);
    }
    public void mOL(int i,int j){
        System.out.println(i*j);
    }
    public void mOL(String s){
        System.out.println(s);
    }

    //2.如下三个方法构成重载
    public int max(int i,int j){
        return (i > j) ? i : j;
    }
    public double max(double i,double j){
        return (i > j) ? i : j;
    }
    public double max(double d1,double d2,double d3){
        double max = (d1 > d2) ? d1 : d2;
        return (max > d3) ? max : d3;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42