Java的方法詳解

更新時間：2026年02月11日 10:29:05 作者：天煒coding

方法類似于C語言中的函數(shù),是包含特定功能的代碼塊,必須定義在類中、main方法外部,本質(zhì)上是一個造輪子的過程—— 將重復使用的邏輯包裝成方法,需要時直接調(diào)用,無需重復編寫,下面通過示例詳解Java的方法,感興趣的朋友一起看看吧

5.1 方法的定義和調(diào)用

5.1.1 方法的基本概念和作用

方法類似于C語言中的函數(shù)，是包含特定功能的代碼塊，必須定義在類中、main 方法外部，本質(zhì)上是一個造輪子的過程—— 將重復使用的邏輯包裝成方法，需要時直接調(diào)用，無需重復編寫。

5.1.2 方法的語法結(jié)構(gòu)

// 完整格式：修飾符 → 返回值類型 → 方法名 → 參數(shù)列表 → 方法體
修飾符 返回值類型 方法名（參數(shù)列表）{
    // 方法體：實現(xiàn)功能的代碼
    return 返回值；// 如果返回值類型為 void，可以省略return或只寫return
}

方法的關(guān)鍵構(gòu)成：

修飾符：用于控制方法的訪問權(quán)限和特性，比如我們常見的 public static
返回值類型：方法執(zhí)行完畢后返回的數(shù)據(jù)類型，無返回值時使用 void
方法名：采用小駝峰命名法，要能只管表達其功能
參數(shù)列表：傳遞給方法的參數(shù)，可以看作是方法的輸入，多個參數(shù)之間用逗號隔開
方法體：實現(xiàn)方法功能的代碼塊
方法簽名：由方法名和參數(shù)列表共同組成的唯一標識，與返回值，修飾符無關(guān)

5.1.3 方法的調(diào)用

方法定義后是不會執(zhí)行的，需要通過調(diào)用觸發(fā)，不同類型的方法調(diào)用方式不同。當方法被調(diào)用后執(zhí)行過程如下：

調(diào)用方法--->傳遞參數(shù)--->找到方法地址--->執(zhí)行被調(diào)方法的方法體--->被調(diào)方法結(jié)束返回--->回到主調(diào)方法繼續(xù)往下執(zhí)行

調(diào)用靜態(tài)方法（static修飾的方法）

靜態(tài)方法屬于類，不屬于對象，調(diào)用時不需要創(chuàng)建對象，直接通過 類名.方法名調(diào)用

public class Dog {
    // 定義靜態(tài)方法
    public static void eating(String food) {
        System.out.println("小狗正在吃" + food);
    }
}
class Test {
    public static void main(String[] args) {
        // 調(diào)用靜態(tài)方法：類名.方法名(實參)
        Dog.eating("狗糧");
    }
}

就如上面代碼，在Dog類中定義了一個靜態(tài)方法eating，包含了一個形參用于接收傳來的實參數(shù)據(jù)，沒有返回值。在Test類的main方法中調(diào)用靜態(tài)方法eating，可以直接通過類名.方法名的方式調(diào)用，不需要創(chuàng)建對象

調(diào)用實例方法（無static修飾）

實例方法屬于對象，必須先創(chuàng)建對象，再通過對象名.方法名調(diào)用

public class Sum {
    // 定義實例方法（無 static）
    public int add(int a, int b) {
        return a + b;
    }
}
class Test {
    public static void main(String[] args) {
        // 步驟1：創(chuàng)建對象
        Sum sum = new Sum();
        // 步驟2：調(diào)用實例方法：對象.方法名(實參)
        int result = sum.add(3, 5);
        System.out.println("兩數(shù)之和：" + result); // 8
    }
}

就如上面代碼，在Sum類中定義了一個實例方法add，然后在Test類中的main方法中調(diào)用add方法，需要先創(chuàng)建Sum的實例化對象，然后通過對象名.方法名調(diào)用

方法內(nèi)部調(diào)用當前類的其他方法

本類中的方法可直接調(diào)用，不需要類名和對象

public class Sum {
    public static int add(int a, int b) {
        return a + b;
    }
    // 調(diào)用本類的 add 方法
    public static int calculateTotal(int x, int y, int z) {
        return add(x, y) + z; // 直接調(diào)用本類靜態(tài)方法
    }
    public static void main(String[] args) {
        System.out.println(calculateTotal(1, 2, 3)); // 6
    }
}

就如上面代碼所示，在Sum類中定義了add方法和calculateTotal方法，并且calculateTotal方法中調(diào)用了add方法，由于這兩個方法定義在同一個類中，所以可以通過方法名直接調(diào)用

5.1.4 方法的文檔注釋

一個規(guī)范的方法需添加文檔注釋，便于他人理解和工具生成文檔。在定義好方法后在方法的上面一行使用文檔注釋，一般通過輸入/**敲回車，就會生成參數(shù)模板，然后填寫對應的說明即可。在添加文檔注釋后鼠標懸停在方法名上時會顯示注釋內(nèi)容，大大提高代碼的可讀性

5.2 方法的參數(shù)傳遞

在 Java 中，參數(shù)傳遞只有值傳遞這一種方式，無論傳遞基本類型還是引用類型，傳遞的都是 “值的副本”，核心區(qū)別在于副本的含義不同。

5.2.1 基本數(shù)據(jù)類型的參數(shù)傳遞

基本數(shù)據(jù)類型的參數(shù)傳遞，傳遞的是變量值的副本，形參的修改不會影響實參。形參是指方法定義的參數(shù)，實參是指調(diào)用時傳入的參數(shù)，就如下面案例中：Test類中定義了一個changeValue方法，無論傳入的參數(shù)是什么最終都會改為10，在main方法中調(diào)用了changeValue方法并將實參a的值賦值給了形參num，最終輸出a的值還是5。

public class Test {
    public static void changeValue(int num) {
        num = 10; // 修改的是副本的值，與實參無關(guān)
    }
    public static void main(String[] args) {
        int a = 5;
        changeValue(a); // 傳入 a 的副本（5）
        System.out.println("實參 a 的值：" + a); // 5（未改變）
    }
}

5.2.2 引用類型的參數(shù)傳遞

引用類型的參數(shù)傳遞，傳遞的是對象引用（地址）的副本，副本與原引用指向同一個對象，因此修改對象內(nèi)容會影響原對象，但修改副本的地址不會影響原引用：

public class Test {
   // 定義引用類型（數(shù)組）
    public static void changeArray(int[] arr) {
        System.out.println("arr地址: "+arr);  // 實參的地址副本，與實參相同
        arr[0] = 10; // 修改對象內(nèi)容，會影響原數(shù)組
        arr = new int[]{4,5,6}; // 修改副本地址：與原數(shù)組無關(guān)
        System.out.println("修改后arr地址: "+arr);  // 副本地址已改變
    }
    public static void main(String[] args) {
        int[] array = {1,2,3};
        System.out.println("array地址："+array);  // 數(shù)組的地址
        changeArray(array); // 傳入數(shù)組引用的副本
        System.out.println("原數(shù)組第一個元素：" + array[0]); // 10（內(nèi)容被修改）
        System.out.println("最終array的地址："+array); // 輸出數(shù)組的地址
    }
}

直接打印 array 輸出的值是 [I@682a0b20[ 代表這是一個數(shù)組，I代表 int ，@ 為分隔符，6d03e736 為哈希值，可以理解為地址。

5.2.3 可變參數(shù)

當一個方法的參數(shù)個數(shù)不確定時，可以使用可變參數(shù)簡化代碼，語法格式為形參類型... 形參名，本質(zhì)上就是一個數(shù)組，必須寫在參數(shù)參數(shù)列表的最后面，因此一個方法只能有一個可變參數(shù)

public class VarargsExample {
    // 可變參數(shù)語法：類型... 變量名（必須在參數(shù)列表最后）
    public static int sum(int... nums) {
        int total = 0;
        for (int num : nums) { // 可變參數(shù)可遍歷（本質(zhì)是數(shù)組）
            total += num;
        }
        return total;
    }
    public static void main(String[] args) {
        System.out.println(sum(1,2)); // 3（傳入2個參數(shù)）
        System.out.println(sum(1,2,3,4)); // 10（傳入4個參數(shù)）
        System.out.println(sum()); // 0（傳入0個參數(shù)）
        System.out.println(sum(new int[]{5,6,7})); // 18（直接傳入數(shù)組）
    }
}

5.3 方法的分類

方法可以從多個角度進行分類：是否有返回值、是否帶參數(shù)、所屬類別（方法與類，對象的關(guān)系）、訪問權(quán)限、功能用途。便于理解不同場景的用法

5.3.1 按是否有返回值分類

帶返回值的方法

在定義方法的時候指定方法的返回值類型，方法執(zhí)行完畢后用return語句返回對應類型的數(shù)據(jù)

// 返回兩個數(shù)的最大值
public static int getMax(int a, int b) {
    return a > b ? a : b;
}

無返回值的方法

使用 void 關(guān)鍵字表明方法不返回任何數(shù)據(jù)。在方法體中可以省略return 語句，或僅寫return，用于方法的提前結(jié)束

// 打印歡迎信息（無返回值）
public static void printWelcome() {
    System.out.println("歡迎學習 Java 方法！");
    // return; // 可選，無實際意義
}
// 提前結(jié)束方法示例
public static void printNum(int num) {
    if (num < 0) {
        System.out.println("數(shù)字不能為負數(shù)！");
        return; // 提前結(jié)束方法，后續(xù)代碼不執(zhí)行
    }
    System.out.println("數(shù)字：" + num);
}

5.3.2 按是否帶參數(shù)分類

帶參數(shù)方法

方法定義時包含參數(shù)列表，調(diào)用時需傳入對應類型和數(shù)量的實際參數(shù)，是參與形參必須一一對應

// 帶參數(shù)：根據(jù)姓名打招呼
public static void greet(String name) {
    System.out.println("Hello, " + name + "!");
}

無參數(shù)方法

方法定義時沒有參數(shù)，調(diào)用時無需傳入任何數(shù)據(jù)

// 無參數(shù)：打印當前時間
public static void printCurrentTime() {
    System.out.println("當前時間：" + System.currentTimeMillis());
}

5.3.3 按所屬類別分類

實例方法

沒有使用static修飾的方法即為實例方法，調(diào)用其他類中的實例方法，或是靜態(tài)方法中調(diào)用實例方法需要先創(chuàng)建對象，然后通過對象名來調(diào)用實例方法，如果是在同一個類中，實例方法調(diào)用實例方法可以通過方法名直接調(diào)用。每個對象都擁有自己的一份實例方法。實例方法可以訪問實例成員變量和其他實例方法，也可以訪問靜態(tài)成員變量和靜態(tài)方法。因為實例方法是在對象創(chuàng)建后才能調(diào)用，此時對象的實例成員已經(jīng)存在。

public class InstanceMethodExample {
    public static int staticVar = 10;
    public int instanceVar = 20;
    // 實例方法
    public void instanceMethod() {
        System.out.println("靜態(tài)變量：" + staticVar); // 合法：訪問靜態(tài)變量
        System.out.println("實例變量：" + instanceVar); // 合法：訪問實例變量
        staticMethod(); // 合法：訪問靜態(tài)方法
    }
    public static void staticMethod() {}
    public static void main(String[] args) {
        // 步驟1：創(chuàng)建對象
        InstanceMethodExample obj = new InstanceMethodExample();
        // 步驟2：調(diào)用實例方法
        obj.instanceMethod();
    }
}

靜態(tài)方法

靜態(tài)方法是指由static修飾的方法，其歸屬于類而非實例，在訪問權(quán)限允許的條件下可直接用類名.方法名調(diào)用，無需創(chuàng)建對象。靜態(tài)方法中只能訪問靜態(tài)成員變量和其他靜態(tài)方法，不能直接訪問實例成員變量和實例方法，因為實例成員依賴于對象的創(chuàng)建，而靜態(tài)方法調(diào)用時可能還沒有對象存在。在類加載時就被加載到內(nèi)存中，并且在整個程序運行期間一直存在。

public class StaticMethodExample {
    // 靜態(tài)變量
    public static int staticVar = 10;
    // 實例變量
    public int instanceVar = 20;
    // 實例方法
    public void instanceMethod() {}
    // 靜態(tài)方法
    public static void staticMethod() {
        System.out.println("靜態(tài)變量：" + staticVar); // 合法：訪問靜態(tài)變量
        // System.out.println(instanceVar); // 編譯錯誤：不能直接訪問實例變量
        // instanceMethod(); // 編譯錯誤：不能直接訪問實例方法
    } 
    public static void main(String[] args) {
        StaticMethodExample.staticMethod(); // 直接調(diào)用靜態(tài)方法
    }
}

構(gòu)造方法

構(gòu)造方法的方法名和類名一樣，并且沒有返回值類型，主要用途是在創(chuàng)建對象時對成員變量進行初始化操作。當創(chuàng)建對象時，會根據(jù)參數(shù)列表自動調(diào)用相應的構(gòu)造方法。當用戶沒有寫構(gòu)造方法時編譯器會生成一個沒有帶參數(shù)的構(gòu)造方法，而寫了構(gòu)造方法后不再生成。

public class Person {
    private String name;
    private int age;
    // 1. 無參構(gòu)造方法（手動添加，初始化默認值）
    public Person() {
        this.name = "未知"; // this 指代當前對象
        this.age = 0;
    }
    // 2. 帶參構(gòu)造方法（初始化自定義值）
    public Person(String name, int age) {
        this.name = name; // 區(qū)分形參和實例變量（同名時用 this）
        this.age = age;
    }
    // 3. 構(gòu)造方法重載（參數(shù)列表不同）
    public Person(String name) {
        this.name = name;
        this.age = 18; // 默認年齡18
    }
    // 打印個人信息
    public void showInfo() {
        System.out.println("姓名：" + name + "，年齡：" + age);
    }
    public static void main(String[] args) {
        // 調(diào)用無參構(gòu)造
        Person p1 = new Person();
        p1.showInfo(); // 姓名：未知，年齡：0
        // 調(diào)用帶參構(gòu)造
        Person p2 = new Person("張三", 20);
        p2.showInfo(); // 姓名：張三，年齡：20
        // 調(diào)用單參構(gòu)造
        Person p3 = new Person("李四");
        p3.showInfo(); // 姓名：李四，年齡：18
    }
}

5.3.4 按訪問權(quán)限分類

公共方法

使用 public 修飾，可以在任何類、任何包中被訪問，通常用于定義類的對外接口，允許其他類自由調(diào)用，以實現(xiàn)類與類之間的交互和協(xié)作。

// 定義一個公共類
public class PublicMethodExample {
    // 定義一個公共的靜態(tài)方法
    public static void publicStaticMethod() {
        System.out.println("這是一個公共的靜態(tài)方法。");
    }
    // 定義一個公共的實例方法
    public void publicInstanceMethod() {
        System.out.println("這是一個公共的實例方法。");
    }
}
// 在另一個類中調(diào)用公共方法
class AnotherClass {
    public static void main(String[] args) {
        // 調(diào)用公共的靜態(tài)方法
        PublicMethodExample.publicStaticMethod();
        // 創(chuàng)建對象
        PublicMethodExample obj = new PublicMethodExample();
        // 調(diào)用公共的實例方法
        obj.publicInstanceMethod();
    }
}

上述代碼中，PublicMethodExample 類中的 publicStaticMethodpublicInstanceMethod 都是公共方法，在 AnotherClass 中可以直接調(diào)用它們。

私有方法

使用 private 關(guān)鍵字修飾的方法是私有方法，只能在定義該方法的類內(nèi)部被訪問，其他類（包括子類）無法訪問。主要用于封裝類內(nèi)部的實現(xiàn)細節(jié)，將一些不希望外部直接調(diào)用的邏輯隱藏起來，提高類的安全性和可維護性。

public class PrivateMethodExample {
    // 定義一個私有方法
    private void privateMethod() {
        System.out.println("這是一個私有方法。");
    }
    // 定義一個公共方法，在公共方法中調(diào)用私有方法
    public void callPrivateMethod() {
        privateMethod();
    }
}
class AntherClass{ 
    public static void main(String[] args) {
        PrivateMethodExample obj = new PrivateMethodExample();
        // 通過公共方法間接調(diào)用私有方法
        obj.callPrivateMethod();
        // 以下代碼會報錯，因為外部無法直接調(diào)用私有方法
        // obj.privateMethod();
    }
}

在這個例子中，privateMethod 是私有方法，只能在 PrivateMethodExample 類內(nèi)部被調(diào)用，在其他類的 main 方法中不能直接調(diào)用該方法，只能通過公共方法 callPrivateMethod 間接調(diào)用。

受保護的方法

使用 protected 關(guān)鍵字修飾的方法是受保護的方法，可以在同一個包內(nèi)的任何類中被訪問，也可以在不同包的子類中被訪問。用于在一定范圍內(nèi)共享方法，既允許同一個包內(nèi)的類訪問，又允許不同包的子類對其進行擴展和重寫。

// 定義一個父類，包含受保護的方法
package com.example.parent;
public class ParentClass {
    // 定義一個受保護的方法
    protected void protectedMethod() {
        System.out.println("這是一個受保護的方法。");
    }
}
// 同一個包內(nèi)的類調(diào)用受保護的方法
package com.example.parent;
class SamePackageClass {
    public static void main(String[] args) {
        ParentClass obj = new ParentClass();
        // 同一個包內(nèi)可以直接調(diào)用受保護的方法
        obj.protectedMethod();
    }
}
// 不同包的子類調(diào)用受保護的方法
package com.example.child;
import com.example.parent.ParentClass;
class ChildClass extends ParentClass {
    public void callProtectedMethod() {
        // 子類中可以調(diào)用受保護的方法
        protectedMethod();
    }
    public static void main(String[] args) {
        ChildClass child = new ChildClass();
        child.callProtectedMethod();
    }
}

在上述代碼中，ParentClass 中的 protectedMethod 是受保護的方法，SamePackageClass 和 ChildClass 都可以訪問該方法，前者是因為在同一個包內(nèi)，后者是因為它是 ParentClass 的子類。

默認方法

不使用任何訪問修飾符的方法具有默認訪問權(quán)限，也稱為包訪問權(quán)限。只能在定義該方法的的類所在的包的不同類中訪問，不同包的類不能訪問。用于在包內(nèi)部實現(xiàn)類之間的交互和協(xié)作，將相關(guān)的功能封裝在同一個包內(nèi)。

// 定義一個類，包含默認訪問權(quán)限的方法
package com.example.package1;
class DefaultMethodExample {
    // 定義一個默認訪問權(quán)限的方法
    void defaultMethod() {
        System.out.println("這是一個默認訪問權(quán)限的方法。");
    }
}
// 同一個包內(nèi)的類調(diào)用默認訪問權(quán)限的方法
package com.example.package1;
class SamePackageCaller {
    public static void main(String[] args) {
        DefaultMethodExample obj = new DefaultMethodExample();
        // 同一個包內(nèi)可以調(diào)用默認訪問權(quán)限的方法
        obj.defaultMethod();
    }
}
// 不同包的類嘗試調(diào)用默認訪問權(quán)限的方法（會報錯）
package com.example.package2;
// 以下代碼無法通過編譯，因為不同包無法訪問默認訪問權(quán)限的方法
// import com.example.package1.DefaultMethodExample;
// class DifferentPackageCaller {
//     public static void main(String[] args) {
//         DefaultMethodExample obj = new DefaultMethodExample();
//         obj.defaultMethod();
//     }
// }

在這個例子中，DefaultMethodExample 類中的 defaultMethod 是默認訪問權(quán)限的方法，SamePackageCaller 類可以調(diào)用該方法，因為它們在同一個包內(nèi)，而不同包的類無法調(diào)用該方法。

5.3.5 按功能用途分類

5.3.5.1 抽象方法

使用 abstract 關(guān)鍵字修飾的方法，抽象方法是定義在抽象類或接口當中的方法，他只有方法的聲明，沒有方法體。如果一個類繼承了包含抽象方法的抽象類，那么這個子類必須實現(xiàn)抽象類中的所有抽象方法，否則子類也必須被聲明為抽象類。

// 定義抽象類
abstract class Animal {
    // 抽象方法，描述動物發(fā)出聲音的行為
    public abstract void makeSound();
    // 普通方法
    public void sleep() {
        System.out.println("動物在睡覺");
    }
}
// 子類 Dog 繼承自抽象類 Animal
class Dog extends Animal {
    // 實現(xiàn)抽象方法
    @Override
    public void makeSound() {
        System.out.println("狗汪汪叫");
    }
}
// 子類 Cat 繼承自抽象類 Animal
class Cat extends Animal {
    // 實現(xiàn)抽象方法
    @Override
    public void makeSound() {
        System.out.println("貓喵喵叫");
    }
}
public class AbstractMethodExample {
    public static void main(String[] args) {
        // 父類引用指向子類對象
        Animal dog = new Dog();
        Animal cat = new Cat();
        // 調(diào)用抽象方法，根據(jù)實際對象類型執(zhí)行不同實現(xiàn)
        dog.makeSound();
        cat.makeSound();
        // 調(diào)用普通方法
        dog.sleep();
        cat.sleep();
    }
}

抽象類 Animal：包含一個抽象方法 makeSound 和一個普通方法 sleep。由于 Animal 類包含抽象方法，所以它必須被聲明為抽象類。子類 Dog 和 Cat：繼承自 Animal 類，必須實現(xiàn) makeSound 抽象方法，分別給出狗和貓發(fā)出聲音的具體實現(xiàn)。main 方法：創(chuàng)建 Dog 和 Cat 對象，并使用 Animal 類型的引用指向它們。調(diào)用 makeSound 方法時，會根據(jù)實際對象的類型執(zhí)行不同的實現(xiàn)，體現(xiàn)了多態(tài)性。同時，也可以調(diào)用普通方法 sleep。

5.3.5.2 重寫方法

重寫方法指的是在子類中定義一個與父類中方法具有相同方法名、參數(shù)列表和返回值類型的方法。通過重寫，子類可以修改或擴展父類方法的行為。并且子類重寫方法的訪問權(quán)限不能比父類被重寫方法的訪問權(quán)限更嚴格，不能拋出比父類被重寫方法更多或更寬泛的異常。靜態(tài)方法不能被重寫，只能構(gòu)成隱藏

// 父類 Animal
class Animal {
    // 父類方法
    public void makeSound() {
        System.out.println("動物發(fā)出聲音");
    }
    // 帶有返回值的父類方法
    public Animal getSelf() {
        return this;
    }
}
// 子類 Dog 繼承自 Animal
class Dog extends Animal {
    // 重寫父類的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println("狗汪汪叫");
    }
    // 重寫帶有返回值的方法，使用協(xié)變返回類型
    @Override
    public Dog getSelf() {
        return this;
    }
}
// 測試類
public class MethodOverrideExample {
    public static void main(String[] args) {
        // 創(chuàng)建 Dog 對象
        Dog dog = new Dog();
        // 調(diào)用重寫后的方法
        dog.makeSound();
        // 測試協(xié)變返回類型
        Dog self = dog.getSelf();
        System.out.println("返回的對象類型: " + self.getClass().getName());
    }
}

Animal 類：包含 makeSound 方法和 getSelf 方法。makeSound 方法用于輸出動物發(fā)出的聲音，getSelf 方法返回 Animal 類型的對象。Dog 類：繼承自 Animal 類，重寫了 makeSound 方法，輸出狗的叫聲。同時，重寫了 getSelf 方法，使用協(xié)變返回類型，返回 Dog 類型的對象。MethodOverrideExample 類：在 main 方法中創(chuàng)建 Dog 對象，調(diào)用重寫后的 makeSound 方法，并測試 getSelf 方法的協(xié)變返回類型。

5.3.5.3 重載方法

同一個類中，方法名相同但是參數(shù)列表不同的方法，參數(shù)列表的不同體現(xiàn)在參數(shù)類型，數(shù)量，順序的不同，返回值類型和修飾符可以任意，僅靠返回值不同不能構(gòu)成重載，核心作用是用同一方法名處理不同參數(shù)的場景，本質(zhì)上就是使用方法簽名來區(qū)分不同方法，回顧方法簽名的概念：由方法名和參數(shù)列表共同組成的唯一標識，與返回值，修飾符無關(guān)

public class MethodOverloadingExample {
    // 計算兩個整數(shù)的和
    public int add(int a, int b) {
        return a + b;
    }
    // 計算三個整數(shù)的和
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    // 計算兩個雙精度浮點數(shù)的和
    public double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        MethodOverloadingExample example = new MethodOverloadingExample();
        // 調(diào)用兩個整數(shù)相加的方法
        int result1 = example.add(1, 2);
        System.out.println("兩個整數(shù)的和: " + result1);
        // 調(diào)用三個整數(shù)相加的方法
        int result2 = example.add(1, 2, 3);
        System.out.println("三個整數(shù)的和: " + result2);
        // 調(diào)用兩個雙精度浮點數(shù)相加的方法
        double result3 = example.add(1.5, 2.5);
        System.out.println("兩個雙精度浮點數(shù)的和: " + result3);
    }
}

add(int a, int b)：用于計算兩個整數(shù)的和。

add(int a, int b, int c)：用于計算三個整數(shù)的和，參數(shù)數(shù)量與第一個 add 方法不同。

add(double a, double b)：用于計算兩個雙精度浮點數(shù)的和，參數(shù)類型與前兩個 add 方法不同

5.5 遞歸

5.5.1 概念

遞歸是指在方法的內(nèi)部調(diào)用自身的方法，遞歸包含兩部分：遞和歸。相當于數(shù)學上的 "數(shù)學歸納法", 有一個結(jié)束條件, 然后有一個遞推公式。

遞：首先要遞出去，找到遞歸條件，也就是推導公式，將大問題拆分為更小的同類問題，如 f(n) = f(n-1) + f(n-2)

歸：最后要歸回來，也就是結(jié)束條件。

就以計算 n 的階層為例，n！= n * (n-1)*(n-2)...*1最終的結(jié)束條件就是n = 1

public static int faction(int n) {
    // 結(jié)束條件 0！= 1，1！= 1
    if (n == 0 || n == 1) {
        return 1;
    }
    // 遞推公式：n! = n * (n-1)!
    return n * (n - 1);
}

5.5.2 經(jīng)典案例

斐波那契數(shù)列

斐波那契數(shù)列的規(guī)則是 f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2)，由此我們可以得出結(jié)束條件 n ==1 || n==2時 f(n) = 1,遞歸公式為f(n) = f(n-1) + f(n-2)

public static int fibonacci(int n) {
    if (n == 1 || n == 2) {
        return 1; // 結(jié)束條件
    }
    return fibonacci(n - 1) + fibonacci(n - 2); // 遞推公式
}

到此這篇關(guān)于Java的方法詳解的文章就介紹到這了,更多相關(guān)Java方法詳解內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！