 // 方法定義
    public static 方法返回值 方法名稱（參數(shù)類型 形參){
        方法體代碼;
        return 返回值;
    }
 
    public static void main(String[] args) {
        // 方法調(diào)用
        返回值變量 = 方法名稱 (實參);
    }

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

public class TestDemo {
    // 方法定義
    public static int Add(int x,int y){
        int sum = x+ y;
        return sum;
    }
 
    public static void main(String[] args) {
        //方法的調(diào)用
        Add(10,20);
        System.out.println(Add(10,20));
    }
}

注意事項

1.方法定義時, 參數(shù)可以沒有。每個參數(shù)要指定類型

2.方法定義時, 返回值也可以沒有, 如果沒有返回值, 則返回值類型應(yīng)寫成 vo

3.方法定義時的參數(shù)稱為形式參數(shù)（形參），方法調(diào)用時的參數(shù)稱為實際參數(shù)（實參）

4.方法的定義必須在類之中, 代碼書寫在調(diào)用位置的上方或者下方都可以

5.所有程序的入口：main函數(shù)

形參與實參的關(guān)系

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

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

為什么沒有發(fā)生任何改變呢？

因為我們交換的是形參，而不是交換的實參。如果要交換實參，我們應(yīng)該拿到a和b的地址，但是！a和b在main函數(shù)中，函數(shù)里的變量屬于局部變量，存放在棧上。但是在Java中，拿不到棧上的地址，所以a和b的實際值并沒有發(fā)生改變。如果要交換a和b的值，只能把a和b的值放在堆上（放在堆上的都是對象?。。?/p>

二.方法的重載

1.重載的作用

前面我們提到了方法需要參數(shù)類型，但是如果我們需要用一個函數(shù)同時兼容多種參數(shù)的情況應(yīng)該怎么辦呢？這里就可以使用到方法重載

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

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

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

同一個方法名字, 提供不同版本的實現(xiàn)，稱為方法的重載

2.重載的使用規(guī)則

針對同一個類:

1.方法名相同

2.方法的參數(shù)不同(參數(shù)個數(shù)或者參數(shù)類型)

3.方法的返回值類型不影響重載

4.當兩個方法的名字相同, 參數(shù)也相同, 但是返回值不同的時候, 不構(gòu)成重載。比如int add（int a，int b）和double add（int a，int b）

三.方法的遞歸

1.遞歸的概念

遞歸就是方法調(diào)用自己的過程。實現(xiàn)遞歸，需要去推導(dǎo)出遞歸公式。

遞歸的前提：有一個趨近于終止的條件、自己調(diào)用自己

遞歸的關(guān)鍵：就是要找到遞歸公式！理解"遞"和"歸"的過程

2.遞歸執(zhí)行過程分析

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.按順序打印一個數(shù)字的每一位

按順序打印一個數(shù)字的每一位(例如 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.返回組成它的數(shù)字之和

寫一個遞歸方法，輸入一個非負整數(shù)，返回組成它的數(shù)字之和. 例如，輸入 1729, 則應(yīng)該返回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.求斐波那契數(shù)列的第 N 項

解法一：使用遞歸，時間復(fù)雜度為O(2^n)，空間復(fù)雜度為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));
    }
}

但是這種解法效率并不高，再計算較大數(shù)字時就會明顯出現(xiàn)停頓，因為它會進行很多重復(fù)的運算，于是我們可以用循環(huán)寫這個代碼，也叫迭代解法

解法二：使用迭代，時間復(fù)雜度為O(n)，空間復(fù)雜度為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));
    }
}