目錄

一.方法的基本使用

1.什么是方法

2.方法基本語法

基本語法

注意事項

形參與實參的關系

二.方法的多載

1.多載的作用

2.多載的使用規則

三.方法的遞回

1.遞回的概念

2.遞回執行程序分析

3.遞回練習

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

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

3.回傳組成它的數字之和

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

一.方法的基本使用

1.什么是方法

方法是一個代碼片段，類似于C語言中的函式

2.方法基本語法

基本語法

 // 方法定義
    public static 方法回傳值 方法名稱（引數型別 形參){
        方法體代碼;
        return 回傳值;
    }

    public static void main(String[] args) {
        // 方法呼叫
        回傳值變數 = 方法名稱 (實參);
    }

看到這里可能有點抽象，接下來寫一個具體的方法：兩個整數相加

public class TestDemo {
    // 方法定義
    public static int Add(int x,int y){
        int sum = x+ y;
        return sum;
    }

    public static void main(String[] args) {
        //方法的呼叫
        Add(10,20);
        System.out.println(Add(10,20));
    }
}

注意事項

1.方法定義時, 引數可以沒有，每個引數要指定型別

2.方法定義時, 回傳值也可以沒有, 如果沒有回傳值, 則回傳值型別應寫成 void

3.方法定義時的引數稱為形式引數（形參），方法呼叫時的引數稱為實際引數（實參）

4.方法的定義必須在類之中, 代碼書寫在呼叫位置的上方或者下方都可以

5.所有程式的入口：main函式

形參與實參的關系

首先我們寫一個交換兩個數的方法，并運行一下

public class Test1 {
    public static void swap(int a,int b){
        int temp = a;
        a = b;
        b = temp;
    }

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("交換實參前："+a+" "+b);
        swap(a,b);
        System.out.println("交換實參后："+a+" "+b);
    }
}

為什么沒有發生任何改變呢？

因為我們交換的是形參，而不是交換的實參，如果要交換實參，我們應該拿到a和b的地址，但是！a和b在main函式中，函式里的變數屬于區域變數，存放在堆疊上，但是在Java中，拿不到堆疊上的地址，所以a和b的實際值并沒有發生改變，如果要交換a和b的值，只能把a和b的值放在堆上（放在堆上的都是物件！！）

二.方法的多載

1.多載的作用

前面我們提到了方法需要引數型別，但是如果我們需要用一個函式同時兼容多種引數的情況應該怎么辦呢？ 這里就可以使用到方法多載

在我們寫了一個add方法后，如果我們想用這個方法計算double型別的時候，會出現型別不兼容的問題，那么我們應該怎么解決呢？或許可以像下面這樣

public class Test2 {
    public static int addInt(int a, int b){
        int sum = a+b;
        return sum;
    }

    public static double addDouble(double a,double b){
        double sum = a+b;
        return sum;
    }

    public static void main(String[] args) {
        double a = 10.5;
        double b = 20.5;
        addDouble(a,b);
        System.out.println(addDouble(a,b));
    }
}

這種寫法不存在任何問題，例如在go語言中就這樣使用，但是Java認為addInt這種名字不太好，不如直接叫add，這就有了如下寫法

public class Test2 {
    public static int add(int a, int b){
        int sum = a+b;
        return sum;
    }

    public static double add(double a,double b){
        double sum = a+b;
        return sum;
    }

    public static void main(String[] args) {
        double a = 10.5;
        double b = 20.5;
        add(a,b);
        System.out.println(add(a,b));
    }
}

運行起來也沒有任何問題，這就是多載的作用！能解決引數型別不匹配等問題，比如add方法，你還能添加更多版本的使用，比如多個數相加...

同一個方法名字, 提供不同版本的實作，稱為方法的多載

2.多載的使用規則

針對同一個類:

1.方法名相同

2.方法的引數不同(引數個數或者引數型別)

3.方法的回傳值型別不影響多載

4.當兩個方法的名字相同, 引數也相同, 但是回傳值不同的時候, 不構成多載，比如int add（int a，int b）和double add（int a，int b）

三.方法的遞回

1.遞回的概念

遞回就是方法呼叫自己的程序，實作遞回，需要去推匯出遞回公式，

遞回的前提：有一個趨近于終止的條件、自己呼叫自己

遞回的關鍵：就是要找到遞回公式！理解"遞"和"歸"的程序

2.遞回執行程序分析

public class Test3 {
    public static int fac(int n){
        if(n==1){
            return 1;
        }
        int temp = n*fac(n-1);
        return temp;
    }

    public static void main(String[] args) {
        System.out.println(fac(3));
    }
}

具體程序分析：

3.遞回練習

相信看到這里，你對遞回也有了一定的認識，可以適當練習一些題增加熟練度，附上筆者的答案，如有錯誤，請斧正！

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

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

public class Demo1 {
    public static void print(int n){
        if(n>9){
            print(n/10);
        }
       System.out.print(n%10+" ");;
    }

    public static void main(String[] args) {
        int n = 1234;
        print(n);
    }
}

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

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

public class Demo2 {
    public static int func(int n){
        if(n!=0){
            n += func(n-1);
        }
        return n;
    }
    public static void main(String[] args) {
        System.out.println(func(10));
    }
}

3.回傳組成它的數字之和

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

public class Demo3 {
    public static int func(int n){
        if(n<10){
            return n;
        }
        return n%10+func(n/10);
    }

    public static void main(String[] args) {
        System.out.println(func(1792));
    }
}

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

解法一：使用遞回，時間復雜度為O(2^n)，空間復雜度為O(n)

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

    public static void main(String[] args) {
        System.out.println(fib(1));
        System.out.println(fib(2));
        System.out.println(fib(3));
        System.out.println(fib(4));
        System.out.println(fib(123456));
    }
}

但是這種解法效率并不高，再計算較大數字時就會明顯出現停頓，因為它會進行很多重復的運算，于是我們可以用回圈寫這個代碼，也叫迭代解法

解法二：使用迭代，時間復雜度為O(n)，空間復雜度為O(1)

public class Demo4 {
    
    public static int fib2(int n){
        if(n==1 || n==2){
            return 1;
        }
        int f1 = 1;
        int f2 = 1;
        int f3 = 0;
        for (int i = 3; i <= n; i++) {
            f3 = f1 + f2;
            f1 = f2;
            f2 = f3;
        }
        return f3;
    }

    public static void main(String[] args) {
        System.out.println(fib2(1));
        System.out.println(fib2(2));
        System.out.println(fib2(3));
        System.out.println(fib2(4));
        System.out.println(fib2(40));
    }
}