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

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)方法：類名.方法名(實(shí)參)
        Dog.eating("狗糧");
    }
}

public class Sum {
    // 定義實(shí)例方法（無 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)用實(shí)例方法：對象.方法名(實(shí)參)
        int result = sum.add(3, 5);
        System.out.println("兩數(shù)之和：" + result); // 8
    }
}

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

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

public class Test {
   // 定義引用類型（數(shù)組）
    public static void changeArray(int[] arr) {
        System.out.println("arr地址: "+arr);  // 實(shí)參的地址副本，與實(shí)參相同
        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ù)組第一個(gè)元素：" + array[0]); // 10（內(nèi)容被修改）
        System.out.println("最終array的地址："+array); // 輸出數(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個(gè)參數(shù)）
        System.out.println(sum(1,2,3,4)); // 10（傳入4個(gè)參數(shù)）
        System.out.println(sum()); // 0（傳入0個(gè)參數(shù)）
        System.out.println(sum(new int[]{5,6,7})); // 18（直接傳入數(shù)組）
    }
}

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

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

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

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

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

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

public class Person {
    private String name;
    private int age;
    // 1. 無參構(gòu)造方法（手動添加，初始化默認(rèn)值）
    public Person() {
        this.name = "未知"; // this 指代當(dāng)前對象
        this.age = 0;
    }
    // 2. 帶參構(gòu)造方法（初始化自定義值）
    public Person(String name, int age) {
        this.name = name; // 區(qū)分形參和實(shí)例變量（同名時(shí)用 this）
        this.age = age;
    }
    // 3. 構(gòu)造方法重載（參數(shù)列表不同）
    public Person(String name) {
        this.name = name;
        this.age = 18; // 默認(rèn)年齡18
    }
    // 打印個(gè)人信息
    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
    }
}

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

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

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

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

// 定義抽象類
abstract class Animal {
    // 抽象方法，描述動物發(fā)出聲音的行為
    public abstract void makeSound();
    // 普通方法
    public void sleep() {
        System.out.println("動物在睡覺");
    }
}
// 子類 Dog 繼承自抽象類 Animal
class Dog extends Animal {
    // 實(shí)現(xiàn)抽象方法
    @Override
    public void makeSound() {
        System.out.println("狗汪汪叫");
    }
}
// 子類 Cat 繼承自抽象類 Animal
class Cat extends Animal {
    // 實(shí)現(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ù)實(shí)際對象類型執(zhí)行不同實(shí)現(xiàn)
        dog.makeSound();
        cat.makeSound();
        // 調(diào)用普通方法
        dog.sleep();
        cat.sleep();
    }
}

// 父類 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());
    }
}

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

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

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