编辑“︁Java方法”︁

{{Note|本教程适用于Java初学者及需要巩固面向对象基础的程序员。所有示例基于Java 17语法。}}

= Java方法 =

'''Java方法'''是执行特定任务的代码块，是面向对象编程中'''封装行为'''的核心单元。方法将操作逻辑包装成可复用的组件，通过接收输入（参数）并返回输出（结果）与程序其他部分交互。

== 方法的基本结构 ==
Java方法的完整声明语法如下：
<syntaxhighlight lang="java">
[访问修饰符] [static] 返回类型 方法名([参数列表]) [throws 异常列表] {
    // 方法体
    return 返回值; // 非void返回类型必须包含
}
</syntaxhighlight>

=== 核心组成部分 ===
* '''访问修饰符'''：控制可见性（public/protected/private/default）
* '''static'''：标记是否为类级别方法
* '''返回类型'''：指定返回值的数据类型（void表示无返回值）
* '''参数列表'''：输入数据的变量声明，逗号分隔
* '''方法体'''：包含执行逻辑的代码块

== 方法定义示例 ==
<syntaxhighlight lang="java">
public class Calculator {
    // 静态方法示例
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 实例方法示例
    public double multiply(double x, double y) {
        return x * y;
    }
    
    // void方法示例
    public void printResult(String operation, double result) {
        System.out.println(operation + " result: " + result);
    }
}
</syntaxhighlight>

== 方法调用 ==
根据方法类型的不同，调用方式有所区别：

=== 静态方法调用 ===
<syntaxhighlight lang="java">
int sum = Calculator.add(5, 3); // 直接通过类名调用
</syntaxhighlight>

=== 实例方法调用 ===
<syntaxhighlight lang="java">
Calculator calc = new Calculator();
double product = calc.multiply(2.5, 4.0); // 通过对象实例调用
</syntaxhighlight>

== 参数传递机制 ==
Java采用'''值传递'''机制，基本类型传递值副本，对象类型传递引用副本：

<syntaxhighlight lang="java">
public class ParameterDemo {
    public static void modifyValue(int num) {
        num = 100;
    }
    
    public static void modifyArray(int[] arr) {
        arr[0] = 100;
    }
    
    public static void main(String[] args) {
        int x = 10;
        modifyValue(x);
        System.out.println(x); // 输出10（原始值未改变）
        
        int[] numbers = {1, 2, 3};
        modifyArray(numbers);
        System.out.println(numbers[0]); // 输出100（数组内容被修改）
    }
}
</syntaxhighlight>

== 方法重载（Overloading） ==
同一类中允许定义多个'''同名方法'''，只要它们的'''参数列表不同'''（类型、数量或顺序）：

<syntaxhighlight lang="java">
public class OverloadDemo {
    // 版本1：两个int参数
    public int max(int a, int b) {
        return a > b ? a : b;
    }
    
    // 版本2：三个int参数
    public int max(int a, int b, int c) {
        return max(max(a, b), c);
    }
    
    // 版本3：double类型参数
    public double max(double a, double b) {
        return a > b ? a : b;
    }
}
</syntaxhighlight>

== 递归方法 ==
方法可以调用自身实现递归：

<syntaxhighlight lang="java">
public class Recursion {
    // 计算阶乘
    public static int factorial(int n) {
        if (n <= 1) return 1; // 基线条件
        return n * factorial(n - 1); // 递归调用
    }
    
    public static void main(String[] args) {
        System.out.println(factorial(5)); // 输出120
    }
}
</syntaxhighlight>

<mermaid>
graph TD
    A[开始计算factorial(5)] --> B{n > 1?}
    B -->|是| C[5 * factorial(4)]
    B -->|否| D[返回1]
    C --> E[4 * factorial(3)]
    E --> F[3 * factorial(2)]
    F --> G[2 * factorial(1)]
    G --> H[返回1]
    H --> I[返回2*1=2]
    I --> J[返回3*2=6]
    J --> K[返回4*6=24]
    K --> L[返回5*24=120]
</mermaid>

== 可变参数（Varargs） ==
Java 5+支持使用省略号声明可变数量参数：

<syntaxhighlight lang="java">
public class VarargsDemo {
    public static String concatenate(String... strings) {
        StringBuilder sb = new StringBuilder();
        for (String s : strings) {
            sb.append(s);
        }
        return sb.toString();
    }
    
    public static void main(String[] args) {
        System.out.println(concatenate("Hello")); // 单参数
        System.out.println(concatenate("Java", " ", "Methods")); // 多参数
    }
}
</syntaxhighlight>

== 方法设计最佳实践 ==
1. '''单一职责原则'''：每个方法只完成一个明确的任务
2. '''合理命名'''：使用动词短语（如calculateTotal、validateInput）
3. '''控制长度'''：建议不超过50行（IDE可视区域）
4. '''参数数量'''：建议不超过5个，过多考虑使用对象封装
5. '''防御性编程'''：对输入参数进行有效性检查

== 实际应用案例 ==
=== 用户认证系统 ===
<syntaxhighlight lang="java">
public class AuthService {
    private static final int MAX_LOGIN_ATTEMPTS = 3;
    
    public boolean login(String username, String password) {
        if (isAccountLocked(username)) {
            throw new SecurityException("Account locked");
        }
        
        boolean authenticated = verifyCredentials(username, password);
        if (!authenticated) {
            recordFailedAttempt(username);
        }
        return authenticated;
    }
    
    private boolean verifyCredentials(String user, String pass) {
        // 实际验证逻辑
        return true; // 示例返回值
    }
    
    private void recordFailedAttempt(String user) {
        // 记录失败次数
    }
    
    private boolean isAccountLocked(String user) {
        // 检查账户状态
        return false; // 示例返回值
    }
}
</syntaxhighlight>

=== 电商价格计算 ===
<syntaxhighlight lang="java">
public class PricingEngine {
    public double calculateTotal(List<Item> cart, 
                                Discount discount, 
                                TaxRate taxRate) {
        double subtotal = calculateSubtotal(cart);
        double discounted = applyDiscount(subtotal, discount);
        return addTax(discounted, taxRate);
    }
    
    private double calculateSubtotal(List<Item> items) {
        return items.stream()
                   .mapToDouble(item -> item.getPrice() * item.getQuantity())
                   .sum();
    }
    
    private double applyDiscount(double amount, Discount discount) {
        return amount * (1 - discount.getPercentage());
    }
    
    private double addTax(double amount, TaxRate rate) {
        return amount * (1 + rate.getValue());
    }
}
</syntaxhighlight>

== 数学公式示例 ==
对于涉及数学计算的方法，可以使用公式精确描述：

计算复利的方法可以表示为：
<math>
A = P \times \left(1 + \frac{r}{n}\right)^{n \times t}
</math>

对应的Java实现：
<syntaxhighlight lang="java">
public double calculateCompoundInterest(double principal, 
                                      double annualRate,
                                      int years,
                                      int compoundingPeriods) {
    return principal * Math.pow(1 + (annualRate / compoundingPeriods), 
                             compoundingPeriods * years);
}
</syntaxhighlight>

== 总结表：方法类型对比 ==
{| class="wikitable"
|-
! 类型 !! 声明关键字 !! 调用方式 !! 内存分配 !! 典型用途
|-
| 实例方法 || 无static || 对象实例 || 堆内存 || 操作实例数据
|-
| 静态方法 || static || 类名直接调用 || 方法区 || 工具函数
|-
| 构造方法 || 与类同名 || new操作符 || 堆内存 || 对象初始化
|-
| final方法 || final || 正常调用 || 取决于static || 禁止重写
|}

{{Tip|调试方法时，可使用IDE的Step Into功能逐行执行，观察参数变化和返回值}}

通过系统学习Java方法，您已经掌握了构建模块化、可维护代码的基础工具。建议结合实践项目，尝试设计不同复杂度的方法组合来解决实际问题。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java面向对象基础]]