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. 一個形參列表中只能出現一個可變引數