01_方法定义与调用

一、方法的基本概念

方法（Method）是一段封装了特定功能的可重用代码块，用于实现代码的模块化和复用。在 Java 中，方法是类或对象行为的具体实现，相当于其他语言中的 "函数"。
方法的核心作用：

• 减少代码冗余，实现一次编写、多次使用
• 提高代码可读性和可维护性
• 将复杂逻辑拆分为多个简单模块，降低开发难度
  

二、方法的定义

2.1 方法定义的基本语法

修饰符 返回值类型 方法名(参数列表) {
       // 方法体（实现功能的代码）
      [return 返回值;]
}

各部分含义：

• 修饰符：控制方法的访问权限和特性（如public、private、static等，可选）
• 返回值类型：方法执行完毕后返回结果的数据类型，无返回值时使用void
• 方法名：遵循驼峰命名法（首字母小写，后续单词首字母大写），需见名知意
• 参数列表：方法接收的输入数据，由 "数据类型 参数名" 组成，多个参数用逗号分隔（可选）
• 方法体：实现具体功能的代码块，包含变量声明、逻辑运算等
• return 语句：结束方法执行并返回结果（无返回值时可省略，或仅写return;）

2.2 方法定义的示例

无参数、无返回值的方法

// 打印欢迎信息，无需输入参数，也无返回值
public void printWelcome() {
    System.out.println("欢迎使用本系统！");
}

有参数、有返回值的方法

// 计算两个整数的和，接收两个int参数，返回int结果
public int add(int a, int b) {
    int sum = a + b;
    return sum; // 返回计算结果
}

有参数、无返回值的方法

// 打印指定次数的消息，接收字符串和整数参数，无返回值
public void printMessage(String message, int times) {
    for (int i = 0; i < times; i++) {
        System.out.println(message);
    }
    // 无return语句（或可写return;）
}

2.3 方法定义的注意事项

1. 方法名命名规范：必须是合法的标识符，建议使用动词或动词短语（如calculateSum、printInfo），避免使用拼音或无意义的名称（如f、method1）。
2. 参数列表规则：
   • 参数名在方法内部有效，多个参数不能重名
   • 参数类型可以是基本数据类型（int、double等）或引用数据类型（String、数组等）
3. 返回值规则：
   • 若返回值类型为void，方法体中不能有带值的return语句（可写return;提前结束方法）
   • 若返回值类型为具体类型（如int、String），方法体中必须有return语句，且返回值类型必须与声明的类型匹配

// 错误示例：返回值类型不匹配
public int getStringLength(String str) {
    return str; // 编译错误：应返回int，实际返回String
}

// 错误示例：非void方法缺少return语句
public int divide(int a, int b) {
    if (b != 0) {
        return a / b;
    }
    // 编译错误：存在无return的分支
}

4. 方法体结构：方法体中可以包含变量声明、语句块、控制流语句（if、for等），但不能在方法内部定义其他方法（Java 不支持嵌套方法）。

三、方法的调用

3.1 方法调用的基本语法

方法定义后不会自动执行，需要通过 "调用" 触发执行。根据方法是否为static（静态方法），调用方式有所区别：
非静态方法（实例方法）的调用
需通过对象实例调用，语法：

对象名.方法名(实际参数);

示例：

// 定义类和非静态方法
public class Calculator {
    public int multiply(int a, int b) {
        return a * b;
    }
}

// 调用非静态方法
public class Test {
    public static void main(String[] args) {
        // 1. 创建对象实例
        Calculator calculator = new Calculator();
        // 2. 通过对象调用方法
        int result = calculator.multiply(3, 4); // 实际参数为3和4
        System.out.println(result); // 输出12
    }
}

静态方法的调用
可直接通过类名调用（推荐），或通过对象调用（不推荐），语法：

类名.方法名(实际参数);

示例：

// 定义静态方法
public class MathUtils {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}

// 调用静态方法
public class Test {
    public static void main(String[] args) {
        // 通过类名调用（推荐）
        int maxNum = MathUtils.max(10, 20);
        System.out.println(maxNum); // 输出20
    }
}

同一类中方法的调用
在同一类中调用方法时，可省略类名或对象名（非静态方法需确保当前上下文有可用对象）：

public class Demo {
    public void methodA() {
        System.out.println("执行方法A");
    }
    
    public void methodB() {
        // 同一类中非静态方法调用，可直接写方法名
        methodA(); // 等价于 this.methodA()
    }
    
    public static void staticMethodC() {
        System.out.println("执行静态方法C");
    }
    
    public static void staticMethodD() {
        // 同一类中静态方法调用，可直接写方法名
        staticMethodC(); // 等价于 Demo.staticMethodC()
    }
}

3.2 实际参数与形式参数的匹配

方法调用时，传递的参数称为 "实际参数"（简称 "实参"），方法定义中的参数称为 "形式参数"（简称 "形参"），两者需满足：

1. 数量匹配：实参数量必须与形参数量一致

// 方法定义：2个形参
public void printSum(int a, int b) { ... }

// 错误调用：实参数量不匹配
printSum(10); // 编译错误：缺少1个参数
printSum(10, 20, 30); // 编译错误：多1个参数

2. 类型兼容：实参类型需与形参类型兼容（可自动类型转换或强制类型转换）

// 方法定义：形参为double
public void showValue(double num) { ... }

// 合法调用：int可自动转换为double
showValue(10); // 正确：10自动转为10.0

// 合法调用：强制类型转换
showValue((double) 'A'); // 正确：'A'的ASCII码65转为65.0

// 错误调用：类型不兼容
showValue("100"); // 编译错误：String无法转换为double

3. 顺序一致：实参与形参的顺序必须一一对应，否则可能导致逻辑错误

// 方法定义：先乘后加（a*2 + b）
public int calculate(int a, int b) {
    return a * 2 + b;
}

// 调用时参数顺序错误
int result = calculate(3, 5); // 实际计算：3*2 +5=11（正确）
int wrongResult = calculate(5, 3); // 计算：5*2 +3=13（与预期不符）

3.3 方法调用的执行流程

执行步骤：

1. 程序执行到方法调用语句时，暂停当前执行流程
2. 将实际参数的值传递给方法的形式参数（参数传递）
3. 进入方法体，按顺序执行方法内的代码
4. 执行到return语句时，将返回值带回调用处（无返回值时直接结束）
5. 继续执行调用语句后的代码
   示例流程解析：

public class Test {
    public static void main(String[] args) {
        int x = 5;
        int y = 3;
        // 步骤1：执行到调用语句，暂停main方法
        int z = add(x, y); 
        // 步骤5：获取返回值后，继续执行
        System.out.println(z); // 输出8
    }
    
    public static int add(int a, int b) {
        // 步骤2：a=5，b=3（接收实参值）
        int sum = a + b; // 步骤3：执行方法体，sum=8
        return sum; // 步骤4：返回8到调用处
    }
}

3.4 方法调用的形式

直接调用
仅执行方法功能，不处理返回值（适用于void方法或无需关注返回值的场景）：

public class Printer {
    public void printHello() {
        System.out.println("Hello!");
    }
}

// 直接调用（仅执行打印，不返回值）
Printer printer = new Printer();
printer.printHello();

赋值调用
将方法返回值赋值给变量，适用于需要使用返回结果的场景：

// 方法定义：返回两个数中的较大值
public int getMax(int a, int b) {
    return a > b ? a : b;
}

// 赋值调用：将返回值存入变量
int maxNum = getMax(25, 18);
System.out.println("较大值：" + maxNum); // 输出25

表达式中调用
方法返回值作为表达式的一部分参与运算：

// 方法定义：返回两数之和
public int sum(int a, int b) {
    return a + b;
}

// 表达式中调用
int result = sum(10, 20) * 2; // 等价于 30 * 2 = 60
System.out.println(result); // 输出60

嵌套调用
在一个方法的调用中嵌套另一个方法的调用，内层方法的返回值作为外层方法的实参：

// 方法1：返回两数之和
public int add(int a, int b) { return a + b; }

// 方法2：返回两数之积
public int multiply(int a, int b) { return a * b; }

// 嵌套调用：add的返回值作为multiply的实参
int result = multiply(add(2, 3), 4); // 等价于 multiply(5, 4) = 20

四、方法的作用域与变量

4.1 方法的作用域

方法的作用域指方法可被访问的范围，由定义方法时的修饰符决定（如public修饰的方法可被其他类访问，private修饰的方法仅能在本类内部访问）。

4.2 方法中的变量

方法中可以声明变量，这些变量称为 "局部变量"，其作用域限定在方法内部：

public void calculate() {
    int a = 10; // 局部变量，作用域：整个方法
    if (a > 5) {
        int b = 20; // 局部变量，作用域：仅if代码块
        System.out.println(a + b); // 合法：a和b均在作用域内
    }
    // System.out.println(b); // 编译错误：b超出作用域
}

局部变量的特点：

• 必须显式初始化后才能使用（无默认值）
• 与方法的参数（形式参数）同属局部变量，不能重名

public void test(int a) {
    int a = 10; // 编译错误：与参数a重名
}

五、方法定义与调用的最佳实践

1. 单一职责原则：一个方法应只实现一个功能，避免 "万能方法"（如一个方法同时处理输入验证、计算、打印等多个功能）。
2. 合理控制方法长度：方法体不宜过长（建议不超过 30 行），过长的方法应拆分为多个小方法。
3. 明确的参数和返回值：
   • 参数数量不宜过多（建议不超过 5 个），过多参数可封装为对象
   • 返回值含义清晰，避免返回null（如需返回null，需在文档中说明）
4. 避免副作用：方法应尽量只通过返回值对外提供结果，而非修改外部变量（尤其是静态变量），减少代码耦合。
5. 添加注释：为方法添加注释（如 JavaDoc），说明方法功能、参数含义、返回值、异常情况等：

/**
 * 计算两个整数的商（除数不为0）
 * @param dividend 被除数
 * @param divisor 除数（不能为0）
 * @return 两数的商（整数除法，截断小数部分）
 */
public int divide(int dividend, int divisor) {
    if (divisor == 0) {
        throw new ArithmeticException("除数不能为0");
    }
    return dividend / divisor;
}

六、总结

方法是 Java 程序的基本组成单元，其核心价值在于代码复用和模块化：

• 定义：通过 "修饰符 返回值类型 方法名 (参数列表) { 方法体 }" 语法创建，需注意返回值、参数和命名规范
• 调用：根据方法是否为静态，通过 "对象名。方法名 ()" 或 "类名。方法名 ()" 调用，需保证实参与形参匹配
• 最佳实践：遵循单一职责、控制长度、明确参数和返回值，提高方法的可读性和可维护性

掌握方法的定义与调用是 Java 编程的基础，合理使用方法能显著提升代码质量和开发效率。