【0 基礎學 Java】（七）方法

碼字不易，對你有幫助 點贊/轉發/關注 支持一下作者

微信搜公衆號：不會編程的程序圓

看更多幹貨，獲取第一時間更新

看更多示例和代碼： https://github.com/hairrrrr/EasyJava，歡迎 star

目錄

---

正文

---

一 方法的基本使用

1.1 什麼是方法

方法就是一個代碼片段，類似 C 語言的“函數”。

1.2 方法定義語法

基本語法

// 方法定義
public static 方法返回值類型 方法名稱（參數類型 形參 ...){
方法體代碼;
return 返回值;
}
// 方法調用
返回值變量 = 方法名稱(實參...);

例1：實現一個方法實現兩個整數相加

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

注意：

• public 和 static 兩個關鍵字在此處具有特定含義, 我們暫時不討論, 後面會詳細介紹
• 方法定義時, 參數可以沒有. 每個參數要指定類型
• 方法定義時, 返回值也可以沒有, 如果沒有返回值, 則返回值類型應寫成 void
• 方法定義時的參數稱爲 “形參”, 方法調用時的參數稱爲 “實參”。參數數量需要匹配。
• 方法的定義必須在類之中, 代碼書寫在調用位置的上方或者下方均可
• Java 中沒有 “函數聲明” 這樣的概念

例2：方法寫在調用它的函數的上方或下方都是可以的

方法寫在 main 函數上方

public class helloWorld{
			
	public static int addSum(int a, int b){
		
		return a + b;
	}
	
	public static void main(String[] args) {
		
		int a = 10, b = 20;
		int ret = addSum(a, b);
		System.out.println("sum = " + ret);
		
	}		
}

方法寫在 main 函數下方

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

	public static int addSum(int a, int b){
		
		return a + b;
	}
}

以上兩種寫法都是可以的。

練習：

1. 寫一個方法比較兩個數的最大值
2. 寫一個方法比較三個數的最大值

參考答案：

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int c = 30;
		int max = threeNumMax(a, b, c);
		System.out.printf("Max = %d", max);
	}
	
	public static int threeNumMax(int x, int y, int z) {
		
		int max = twoNumMax(twoNumMax(x, y), z);
		//twoNumMax(a,b)返回 a，b 中的較大值，然後再次調用twoNumMax比較 這個較大值 與 c
		return max;
	}
	
	public static int twoNumMax(int x, int y) {
		return (x > y ? x : y);
	}
}

1.3 方法調用的執行過程

基本規則

• 定義方法的時候, 不會執行方法的代碼. 只有調用的時候纔會執行
• 當方法被調用的時候, 會將實參賦值給形參
• 參數傳遞完畢後, 就會執行到方法體代碼
• 當方法執行完畢之後(遇到 return 語句), 就執行完畢, 回到方法調用位置繼續往下執行
• 一個方法可以被多次調用

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println("第一次調用方法之前");
		int ret = add(a, b);
		System.out.println("第一次調用方法之後");
		System.out.println("ret = " + ret);
		System.out.println("第二次調用方法之前");
		ret = add(30, 50);
		System.out.println("第二次調用方法之後");
		System.out.println("ret = " + ret);
}
	public static int add(int x, int y) {
		System.out.println("調用方法中 x = " + x + " y = " + y);
		return x + y;
}
}
// 執行結果
一次調用方法之前
調用方法中 x = 10 y = 20
第一次調用方法之後
ret = 30
第二次調用方法之前
調用方法中 x = 30 y = 50
第二次調用方法之後
ret = 80

例 3: 計算 1！ + 2！+ 3！+ 4！+ 5！

Class Test {
	public static void main(String[] args) {
		int sum = 0;
		for (int i = 1; i <= 5; i++) {
		sum += factor(i);
		}
		System.out.println("sum = " + sum);
	}
	public static int factor(int n) {
		System.out.println("計算 n 的階乘中! n = " + n);
		int result = 1;
    	for (int i = 1; i <= n; i++) {
		result *= i;
		}
		return result;
	}
}
// 執行結果
計算 n 的階乘中! n = 1
計算 n 的階乘中! n = 2
計算 n 的階乘中! n = 3
計算 n 的階乘中! n = 4
計算 n 的階乘中! n = 5
sum = 153

1.4 實參和形參的關係

例4：交換兩個整型變量

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 x, int y) {
		int tmp = x;
		x = y;
		y = tmp;
	}
}
// 運行結果
a = 10 b = 20

分析

剛纔的代碼，沒有完成數據的交換。

對於基礎類型來說，形參相當於實參的拷貝，即 傳值調用。

上面的代碼相當於：

int a = 10;
int b = 20;

int x = a;
int y = b;
int tmp = x;
x = y;
y = tmp;

上面的方法實際上就是創建了 x，y 兩個臨時變量（形參），將 a，b（實參）的值傳給 x，y。然後創建臨時變量 tmp 交換的是 x，y 的值。

**解決辦法：**傳引用類型參數（後面會講）

1.5 沒有返回值的方法

方法的返回值是可選的，有些時候可以沒有的。

代碼示例

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
        //沒有變量接收 print 方法的返回值，因爲它沒有返回值
		print(a, b);
	}
	public static void print(int x, int y) {
		System.out.println("x = " + x + " y = " + y);
	}
}

例5：沒有返回值的方法可能是有“缺陷”的

沒有返回值：

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		addSum(a, b);
	}
	public static void addSum1(int x, int y) {
		System.out.println("a + b = "+ (x + y));
	}
}
//輸出
a + b = 30

有返回值：

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int ret = addSum(a, b);
		System.out.printf("%d + %d = %d, 2 * (%d + %d) = %d", a, b, ret, a, b, 2*ret);
	}
	public static int addSum2(int x, int y) {
		return x + y;
	}
}
//輸出：
10 + 20 = 30, 2 * (10 + 20) = 60

可以看到，對於沒有返回值的方法來說，addSum1 僅僅是講參數相加然後輸出而已；而 addSum2 將計算結果返回， main 函數拿到了計算結果，可以做更多的操作（比如示例種的運算），當然也可以輸出。

void 類型的函數可以 return 嗎？

class Test {
	public static void main(String[] args) {
	testVoidReturn();
}
	public static void testVoidReturn(){
		return;
		System.out.println("return 是沒有什麼用的！");
	}
}
//編譯報錯：
Test.java:9: 錯誤: 無法訪問的語句
                System.out.println("return 是沒有什麼用的！");
                ^
1 個錯誤

二 方法的重載

有些時候我們需要用一個函數同時兼容多種參數的情況，我們就可以使用到方法重載 。

2.1 方法重載要解決的問題

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);
	}
	public static int add(int x, int y) {
		return x + y;
	}
}
// 編譯出錯
Test.java:13: 錯誤: 不兼容的類型: 從double轉換到int可能會有損失
double ret2 = add(a2, b2);
					^

由於參數類型不匹配, 所以不能直接使用現有的 add 方法 。

2.2 使用重載

對於上面的問題，下面這種方法是否可行？

class Test {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		int ret = addInt(a, b);
		System.out.println("ret = " + ret);
		double a2 = 10.5;
		double b2 = 20.5;
		double ret2 = addDouble(a2, b2);
		System.out.println("ret2 = " + ret2);
	}
	public static int addInt(int x, int y) {
		return x + y;
	}
	public static double addDouble(double x, double y) {
		return x + y;
	}
}

重新命名一個新的方法來實現對不同類型的變量的相加。但是 Java 是支持方法重載的。我們一般使用下面的方式：

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;
	}
	
}

方法的名字都叫 add. 但是有的 add 是計算 int 相加, 有的是 double 相加; 有的計算兩個數字相加, 有的是計算三個數字相加.
同一個方法名字, 提供不同版本的實現, 稱爲 方法重載

2.3 方法重載的規則

針對同一個類:

• 方法名相同
• 方法的參數不同(參數個數或者參數類型)
• 方法的返回值類型不影響重載(與 C++ 不同)

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;
	}
	public static double add(int x, int y) {
		return x + y;
	}
}
// 編譯出錯
Test.java:13: 錯誤: 已在類 Test中定義了方法 add(int,int)
public static double add(int x, int y) {
							^
1 個錯誤

當兩個方法的名字相同，參數也相同，但是返回值不同的時候，不構成重載。

三 方法遞歸

3.1 遞歸的概念

一個方法在執行過程中調用自身，就稱爲 "遞歸 。

public static void main(String[] args) {
	int n = 5;
	int ret = factor(n);
	System.out.println("ret = " + ret);
}
	public static int factor(int n) {
		if (n == 1) {
			return 1;
		}
		return n * factor(n - 1); // factor 調用函數自身
}
// 執行結果
ret = 120

3.2 遞歸執行過程

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

關於 “調用棧”
方法調用的時候, 會有一個 “棧” 這樣的內存空間描述當前的調用關係，稱爲調用棧 。
每一次的方法調用就稱爲一個 “棧幀”，每個棧幀中包含了這次調用的參數是哪些，返回到哪裏繼續執行等信息 。
後面我們藉助 IDEA 很容易看到調用棧的內容。

3.3 遞歸練習

1. 按順序打印一個數字的每一位

(例如 1234 打印出 1 2 3 4)

方法1：

	public static void printEveryDigit(int num){
		
		if(num / 10 == 0){
			System.out.print(num);
		}
		else{
			printEveryDigit(num / 10);
			System.out.print(" " + num % 10);
		}
	}
}

方法2：

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

2.遞歸求 1 + 2 + 3 + … + 10

class Test {
    
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int num = scan.nextInt();
		int sum = printSum(num);
		System.out.println(sum);
}
	public static int printSum(int num) {
		if(num == 1){
			return 1;
		}
		return num + printSum(num - 1);	
	}
}

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

class Test {
	public static void main(String[] args) {
	Scanner scan = new Scanner(System.in);
	int num = scan.nextInt();
	int sum = printSumOfDigit(num);
	System.out.println(sum);
}
	public static int printSumOfDigit(int num) {
		if(num > 9){
			return (num % 10) + printSumOfDigit(num / 10);
		}
		return num;	
	}
}

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

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

3.4 遞歸小結

遞歸是一種重要的編程解決問題的方式.

有些問題天然就是使用遞歸方式定義的(例如斐波那契數列, 二叉樹等), 此時使用遞歸來解就很容易.

有些問題使用遞歸和使用非遞歸(循環)都可以解決. 那麼此時更推薦使用循環, 相比於遞歸, 非遞歸程序更加高效.