目錄

前言

方法的基本用法

定義語法

注意事項

實參和形參

方法的多載

什么是多載

多載要解決的問題

方法遞回

什么是遞回

遞回執行程序分析

遞回練習

總結遞回特點

前言

本章我們主要講解：

• 方法的基本用法
• 方法的多載
• 方法的遞回

方法的基本用法

簡單來說方法：方法就是一個代碼片段，類似于 C 語言中的函式

• 存在的意義：

1. 能夠模塊化的組織代碼
2. 做到讓代碼被重復使用，一份代碼可以用在多個位置
3. 讓代碼更好理解、更簡單
4. 直接呼叫現有方法，不必重復造輪子

定義語法

• 基本語法

// 方法定義
public static 方法回傳值 方法名稱（[引數型別 形參 ...]){
方法體代碼;
[return 回傳值];
}
// 方法呼叫
回傳值變數 = 方法名稱(實參...);

• 示例：整數相加方法實作和呼叫

class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 方法的呼叫
int ret = add(a, b);
System.out.println("ret = " + ret);
}
// 方法的定義
public static int add(int x, int y) {
return x + y;
}
}
// 執行結果
ret = 30

注意事項

• 定義方法時，不會執行代碼，呼叫時才執行
• 方法定義時，引數可以沒有，但如果有一定要指定型別
• 方法定義時，回傳值可以沒有，但如果沒有，回傳型別應該寫出 void
• 當方法被呼叫時，會將實參賦值給形參（一份臨時拷貝）(方法定義時的引數為“形參”，方法呼叫時的引數為“實參”)
• 當方法執行時遇到 return 陳述句，方法結束，不會往下執行方法陳述句
• 方法定義必須在類中,一個方法可以被多次呼叫
• 方法的定義可以寫在 main 方法的上方或者下方(Java 中沒有“函式宣告”的概念)
• 方法的呼叫需要開辟堆疊幀，方法結束堆疊幀就隨即結束

實參和形參

同樣的與C語言一樣的是：當方法被呼叫時，會將實參賦值給形參（一份臨時拷貝）

• 示例：

public class Test{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println("a = "  + a " b = " + b);
    }
    public static void swap(int a, int b){
        int tmp = a;
        int a = b;
        int b = tmp;
    }
}
// 運行結果為 a = 10 b = 20

注：swap 方法里只將形參的值互換了，但是實參的值沒有互換

在 Java 中想做到修改實參的值我們需要用到參考型別（參考可以理解為"地址"）

• 示例：使用陣列來實作交換數值

public class Test{
    public static void main(String[] args){
        int[] arr = {10, 20};
        swap(arr);
        System.out.println("a = "  + arr[0] " b = " + arr[1]);
    }
    public static void swap(int[] arr){
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}
// 運行結果為 a = 20 b = 10

方法的多載

什么是多載

定義：同一個方法名字相同，提供不同型別的實作，稱為多載

規則：

• 方法名相同
• 引數串列不同（引數的個數或者引數的型別不同）
• 回傳值不作要求

多載要解決的問題

• 示例：兩個資料求和

public class Test{
    public static void main(String[] args){

        int a1 = 10;
        int b1 = 20;
        int ret1 = add(a1, b1);
        System.out.println("ret1 = " + ret1);
 
        double a2 = 1.5;
        double b2 = 2.4;
        double ret2 = a2 + b2;
        System.ouy.println("ret2 =" + ret2);
    }
    public static int addInt(int a, int b){
    	return a + b;
	}
    public static double addDouble(double a, double b){
    	return a + b;
	}
}

對于求不同型別的資料和，在上面我們寫了addInt和addDouble兩個方法，但是 Java 認為 addInt 這樣的名字不友好，不如直接就叫 add，由此多載便派上用場了

• 求和多載：

class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int ret = add(a, b);
        System.out.println("ret = " + ret);

        double a2 = 10.5;
        double b2 = 20.5;
        double ret2 = add(a2, b2);
        System.out.println("ret2 = " + ret2);

        double a3 = 10.5;
        double b3 = 10.5;
        double c3 = 20.5;
        double ret3 = add(a3, b3, c3);
        System.out.println("ret3 = " + ret3);
    }
    public static int add(int x, int y) {
        return x + y;
    }
    public static double add(double x, double y) {
        return x + y;
    }
    public static double add(double x, double y, double z) {
        return x + y + z;
    }
}

方法遞回

什么是遞回

定義：一個方法在執行程序中呼叫自身，就稱為“遞回”

簡單來看遞回即是"遞推和回歸"：滿足條件時進行遞推呼叫方法，不滿足時開始回歸

對于沒有限制條件的方法呼叫，則會出現堆疊溢位（方法的呼叫會開辟空間，而記憶體是有限的）

遞回執行程序分析

• 示例：求N的階乘

public static void main(String[] args) {
    int n = 5;
    int ret = factor(n);
    System.out.println("ret = " + ret);
}
public static int factor(int n) {
    System.out.println("函式開始, n = " + n);
    if (n == 1) {
        System.out.println("函式結束, n = 1 ret = 1");
    return 1;
    }
    int ret = n * factor(n - 1);
    System.out.println("函式結束, n = " + n + " ret = " + ret);
    return ret;
}
// 執行結果
函式開始, n = 5
函式開始, n = 4
函式開始, n = 3
函式開始, n = 2
函式開始, n = 1
函式結束, n = 1 ret = 1
函式結束, n = 2 ret = 2
函式結束, n = 3 ret = 6
函式結束, n = 4 ret = 24
函式結束, n = 5 ret = 120
ret = 120

• 執行程序圖：

遞回練習

• 例1 按順序列印一個數字的每一位(例如 1234 列印出 1 2 3 4)

public static void print(int num) {
    if (num > 9) {
        print(num / 10);
   }
    System.out.println(num % 10);
}

• 例2 遞回求 1 + 2 + 3 + ... + 10

public static int sum(int num) { 
 if (num == 1) { 
 return 1; 
 } 
 return num + sum(num - 1); 
} 

• 例3 寫一個遞回方法，輸入一個非負整數，回傳組成它的數字之和. 例如，輸入 1729, 則應該回傳1+7+2+9， 它的和是19

public static int sum(int num) { 
 if (num < 10) { 
 return num; 
 } 
 return num % 10 + sum(num / 10); 
} 

• 例4 求斐波那契數列的第 N 項

public static int fib(int n) { 
 if (n == 1 || n == 2) { 
 return 1; 
 } 
 return fib(n - 1) + fib(n - 2); 
} 

當我們求數字較大的項時, 程式執行速度極慢（進行了大量的重復運算）

可以使用回圈的方式來求斐波那契數列問題, 避免出現冗余運算

public static int fib(int n) { 
 int last2 = 1; 
 int last1 = 1; 
 int cur = 0; 
 for (int i = 3; i <= n; i++) { 
 cur = last1 + last2; 
 last2 = last1; 
 last1 = cur; 
 } 
 return cur; 
} 

什么時候使用：問題遞回非遞回都能寫且沒有多大的問題時，選擇遞回

總結遞回特點

• 優點：

1. 簡潔

2.在樹的前序，中序，后序遍歷演算法中，遞回的實作明顯要比回圈簡單得多

• 缺點：

1.遞回由于是函式呼叫自身，而函式呼叫是有時間和空間的消耗的：每一次函式呼叫，都需要在記憶體堆疊中分配空間以保存引數、回傳地址以及臨時變數，而往堆疊中壓入資料和彈出資料都需要時間，->效率

2.遞回中很多計算都是重復的，由于其本質是把一個問題分解成兩個或者多個小問題，多個小問題存在相互重疊的部分，則存在重復計算，如fibonacci斐波那契數列的遞回實作，->效率

3.呼叫堆疊可能會溢位，其實每一次函式呼叫會在記憶體堆疊中分配空間，而每個行程的堆疊的容量是有限的，當呼叫的層次太多時，就會超出堆疊的容量，從而導致堆疊溢位，->性能