一、函数概述

在 Java 中，函数（也称为方法）是类的重要组成部分，用于封装特定的功能。函数具有以下特点：

• 可重用性：一次定义，多次调用
• 模块化：将复杂问题分解为小问题
• 封装性：隐藏实现细节
• 参数化：通过参数传递数据

二、函数定义

1. 基本语法

[访问修饰符] [static] [final] 返回类型 函数名([参数列表]) {
    // 函数体
    [return 返回值;]
}

2. 示例

// 无参无返回值函数
public void printHello() {
    System.out.println("Hello");
}

// 带参数无返回值函数
public void printMessage(String message) {
    System.out.println(message);
}

// 带参数有返回值函数
public int add(int a, int b) {
    return a + b;
}

// 静态函数
public static double calculateArea(double radius) {
    return Math.PI * radius * radius;
}

三、参数传递

1. 基本类型参数

public void modifyValue(int x) {
    x = 10; // 不会影响原始值
}

// 使用
int num = 5;
modifyValue(num);
System.out.println(num); // 输出：5

2. 引用类型参数

public void modifyArray(int[] arr) {
    arr[0] = 10; // 会影响原始数组
}

// 使用
int[] numbers = {1, 2, 3};
modifyArray(numbers);
System.out.println(numbers[0]); // 输出：10

3. 可变参数

public int sum(int... numbers) {
    int total = 0;
    for (int num : numbers) {
        total += num;
    }
    return total;
}

// 使用
int result1 = sum(1, 2, 3);      // 输出：6
int result2 = sum(1, 2, 3, 4, 5); // 输出：15

四、返回值

1. 基本类型返回值

public int getMax(int a, int b) {
    return a > b ? a : b;
}

2. 引用类型返回值

public String[] getNames() {
    return new String[]{"Alice", "Bob", "Charlie"};
}

3. 无返回值（void）

public void printInfo(String name, int age) {
    System.out.println("Name: " + name + ", Age: " + age);
}

五、方法重载

1. 定义

方法重载是指在同一个类中定义多个同名方法，但参数列表不同。

2. 示例

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

3. 重载规则

• 方法名必须相同
• 参数列表必须不同（类型、数量、顺序）
• 返回类型可以不同
• 访问修饰符可以不同

六、递归

1. 基本概念

递归是指方法直接或间接调用自身。

2. 示例

// 计算阶乘
public int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

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

3. 递归注意事项

• 必须有终止条件
• 每次递归调用应该使问题规模减小
• 注意栈溢出风险

七、函数最佳实践

1. 命名规范

// 好的命名
public double calculateCircleArea(double radius)
public boolean isValidUser(String username, String password)

// 不好的命名
public double calc(double r)
public boolean check(String u, String p)

2. 单一职责

// 好的设计：每个函数只做一件事
public double calculateTotalPrice(List<Item> items) {
    return items.stream()
               .mapToDouble(Item::getPrice)
               .sum();
}

// 不好的设计：一个函数做多件事
public void processOrder(Order order) {
    // 验证订单
    // 计算价格
    // 更新库存
    // 发送通知
}

3. 参数设计

// 好的设计：参数数量适中
public void createUser(String username, String email, String password)

// 不好的设计：参数过多
public void createUser(String username, String email, String password, 
                      String address, String phone, Date birthday, 
                      String gender, String occupation)

4. 错误处理

// 好的设计：明确的错误处理
public double divide(int a, int b) {
    if (b == 0) {
        throw new IllegalArgumentException("除数不能为零");
    }
    return (double) a / b;
}

函数设计建议

1. 函数名应该清晰表达其功能
2. 函数应该尽量短小精悍
3. 避免过多的参数
4. 做好错误处理
5. 添加适当的注释
6. 考虑函数的可测试性