Java中方法的使用、重載與遞歸的示例分析

這篇文章主要介紹了Java中方法的使用、重載與遞歸的示例分析，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。

一.方法的基本使用

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.方法定義時, 返回值也可以沒有, 如果沒有返回值, 則返回值類型應寫成 vo

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

感謝你能夠認真閱讀完這篇文章，希望小編分享的“Java中方法的使用、重載與遞歸的示例分析”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!