2026-08-27 · 方法定义、参数传递、可变参数、方法重载、递归。

Java 方法

1. 方法定义与调用

方法 = 函数，定义在类里面，用来执行特定功能：

public class Calculator {
    // 定义方法：修饰符 返回值类型 方法名(参数列表) { 方法体 }
    public int add(int a, int b) {
        return a + b;
    }

    // 无返回值用 void
    public void printLine() {
        System.out.println("----------");
    }
}

// 调用
Calculator calc = new Calculator();
int result = calc.add(3, 5);  // 接收返回值
System.out.println(result);   // 8

calc.printLine();             // 无返回值，不用接收

方法组成：

• 修饰符：public、static 等（可省略）
• 返回值类型：有返回值写具体类型（int、String），无返回值写 void
• 方法名：小驼峰 getMaxValue
• 参数列表：可以有多个，用逗号分隔
• return：返回值；void 方法可以不写 return（或写 return; 提前结束）

四种方法组合

类型	示例	使用场景
无参无返回值	void printLine()	只执行操作，不需要输入输出
无参有返回值	int getRandom()	不需要输入，但要获取结果
有参无返回值	void setName(String name)	需要输入，但只执行操作
有参有返回值	int add(int a, int b)	需要输入，也需要结果

形参与实参

// 定义时：形参（形式参数，占位符）
public int add(int a, int b) {  // a、b 是形参
    return a + b;
}

// 调用时：实参（实际参数，真实值）
int result = add(3, 5);  // 3、5 是实参

形参 = 定义方法时的变量名（"我需要什么"），实参 = 调用方法时传入的值（"我给你什么"）。形参是实参的占位符。

参数和返回值使用时机

• 需要外部输入 → 加参数（比如算面积需要半径）
• 需要输出结果 → 加返回值（比如算面积需要返回结果）
• 只执行操作 → 不需要返回值（void）
• 不需要外部输入 → 不需要参数

// 推荐：有返回值，调用者决定怎么用
public int add(int a, int b) {
    return a + b;
}
int result = add(3, 5);  // 调用者拿到结果，自己打印或做别的

// 不推荐：void 里直接打印，调用者没法用这个结果
public void add(int a, int b) {
    System.out.println(a + b);  // 调用者只能看，不能用
}

优先设计有返回值的方法——让调用者决定怎么用结果，而不是方法里直接打印或执行副作用。

Java 只有值传递，没有引用传递。但传递的是"值的副本"，所以看起来行为不同：

// 基本类型：传递的是值的副本
public static void change(int x) {
    x = 100;  // 只改了副本，原来的不变
}

int a = 10;
change(a);
System.out.println(a); // 仍然是 10

// 引用类型：传递的是引用（地址）的副本
public static void changeName(Student s) {
    s.name = "李四";  // 通过引用修改了对象的属性
}

Student stu = new Student("张三");
changeName(stu);
System.out.println(stu.name); // 李四（被改了）

// 但是：
public static void replace(Student s) {
    s = new Student("王五");  // 让副本指向新对象，原来的引用不受影响
}

Student stu2 = new Student("张三");
replace(stu2);
System.out.println(stu2.name); // 张三（没变）

总结：基本类型传值（改不了原值），引用类型传地址副本（能改对象属性，但不能改引用本身）。

3. 可变参数

方法参数个数不确定时使用，本质是数组：

public static int sum(int... nums) {
    int total = 0;
    for (int n : nums) {
        total += n;
    }
    return total;
}

// 调用
System.out.println(sum(1, 2));        // 3
System.out.println(sum(1, 2, 3, 4)); // 10
System.out.println(sum());            // 0

可变参数规则：

• 只能放在参数列表最后一位
• 一个方法只能有一个可变参数
• int... nums 等价于 int[] nums（在方法内部就是数组）

// ❌ 错误写法
public void bad(int... nums, String name) { } // 可变参数不在最后

// ✅ 正确写法
public void good(String name, int... nums) { } // 可变参数在最后

4. 方法重载（Overload）

同一个类里，方法名相同，但参数列表不同：

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) { // 参数类型不同
        return a + b;
    }

    public int add(int a, int b, int c) {   // 参数个数不同
        return a + b + c;
    }
}

重载 vs 重写（Override）：

区别	重载（Overload）	重写（Override）
位置	同一个类里	子类重写父类方法
方法名	必须相同	必须相同
参数列表	必须不同	必须相同
返回值	可以不同	必须相同（或协变）
修饰符	无限制	不能更严格（比如父类是 public，子类不能是 private）

重载是"同一个方法的多种形态"，重写是"子类替换父类的方法"。

5. 递归

方法调用自身，用来解决重复结构的问题：

// 阶乘：n! = n × (n-1)!
public static int factorial(int n) {
    if (n <= 1) return 1;  // 递归终止条件（必须有！）
    return n * factorial(n - 1);
}

System.out.println(factorial(5)); // 120（5×4×3×2×1）

递归三要素：

1. 终止条件：什么时候停下来（没有就无限递归，栈溢出）
2. 递归调用：方法调用自身
3. 趋势：每次调用都要向终止条件靠近

// 斐波那契数列
public static int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

// 1 1 2 3 5 8 13 ...
System.out.println(fib(6)); // 8

递归适合解决重复结构的问题（阶乘、斐波那契、树遍历）。但要注意栈溢出风险，层级太深时考虑用循环替代。