Java基础之：方法重载与可变参数

 

Java基础之：方法重载与可变参数

方法重载

方法重载，解决了两个问题，第一：起名的问题，第二：记名的问题。

实现方法：在同一个类中声明多个名字相同的成员方法，但它们的形参(形式参数)列表不一样。

简单案例1：

1.打印 等边三角形 ，矩形 ，立方体 简单案例

import java.util.Scanner;   
public class MethodOverloading
{
    public static void main(String[] args){
        //1.
        MyPrint m = new MyPrint();
        m.print(10);
        m.print(10,20);
        m.print(10,20,30);
    }
}
//  1.打印 等边三角形 ，矩形 ，立方体 简单案例
class MyPrint
{
    public void print(int len){
        System.out.println("等边三角形 的边长为：" + len);
    }
​
    public void print(int len,int wide){
        System.out.println("矩形 的长为：" + len + " 宽为：" + wide);
    }
​
    public void print(int len,int wide,int high){
        System.out.println("立方体 的长为：" + len + " 宽为：" + wide + " 高为：" + high);
    }
}

说明：

通过这个案例我们可以看到，同样是print()方法，但当形参列表不同时，它可以实现不同的功能。

 

简单案例2：

/*
    2.在MethodUtils类，定义三个重载方法max()，
    第一个方法，返回两个int值中的最大值，
    第二个方法，返回两个double值中的最大值，
    第三个方法，返回三个double值中的最大值，并分别调用三个方法。
*/
import java.util.Scanner;   
public class MethodOverloading
{
    public static void main(String[] args){
        //2.
        MethodUtils mu = new MethodUtils();
        System.out.println(mu.max(10,20));          //20
        System.out.println(mu.max(10.0,20.0));      //20.0
        System.out.println(mu.max(10.0,20.0,30.0)); //30.0
    }
}
​
class MethodUtils
{
    public int max(int a,int b){
        int res = a > b ? a:b;
        return res;
    }
​
    public double max(double a,double b){       
        return a > b ? a:b; 
    }
​
    public double max(double a,double b,double c){
        return max(max(a,b),c);
    }
}

　　

说明：

通过案例2，我们可以看到，当形参个数相同时，只要形参类型相同，同样可以实现方法重载。

 

方法重载细节说明：

1) 方法名 ：必须相同

2) 参数列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求）

3) 返回类型：无要求

 

方法重载对比

与void show(int a,char b,double c){}构成重载的是：[]
void show(int x,char y,double z){}   // 不是
int show(int a,double c,char b){}   // 是
void show(int a,double c,char b){}  // 是
​
boolean show(int c,char b){}  //是
void show(double c){}  //是
double show(int x,char y,double z){}  //不是
void shows(){}  //不是

　

可变参数

应用场景：

面对未知的参数个数情况下，若使用方法重载，则有多少种参数变化就需要写多少种方法重载。因此使用可变参数可以在一个方法中完成未知参数个数的操作。

java提供了一种机制，可以允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。即可变参数。

 

基本语法

　　访问修饰符 返回类型 方法名(数据类型... 形参名){ }

简单案例

​

import java.util.Scanner;   
public class VarArgs
{
    public static void main(String[] args){
        //一般使用方式
        Var v = new Var();
        int res = v.sum(1,2,3,4);
        System.out.println("sum :" + res);
​
        //数组使用方式
        int[] a = {1,2,3,4};
        int res1 = v.sum(a);    //这种方式是被允许的
        System.out.println("sum :" + res1);
    }
​
    //细节1： 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void m1(String name, String... args) {
        //为什么可变参数在最后？
        //理解：若可变参数不在最后语法上不好说明。
        //      例：如果只有一个参数的情况下只能赋值给 name
        //      而如果 args 在前面，就不能判断这个参数赋值给 args 还是 name
    }
​
    //细节2： 一个形参列表中只能出现一个可变参数
//  public void m2(int... args1 , String... args2) {
//      这样声明会报错。
//  }
​
}
​
​
class Var
{
    //可以求多个参数的和
    public int sum(int... a){
        int sum = 0;
        for(int i = 0 ;i<a.length;i++){
            sum += a[i];
        }
        return sum;
    }
}

说明：

1. int... 后面的三个小点，是规定，必须是"..."

2. 这时 a 称为 可变形参，可变形参可以是 0个 和 任意个。

3. a 可变形参的本质就是数组

4. 实参可以传递数组，但是需要通过 数组名

5. 不能再在 Var 类中定义 sum(int[] a), 会认为重复定义

6. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

7. 一个形参列表中只能出现一个可变参数