方法的定义与调用

方法是将代码封装成可重复使用的功能单元。

方法概念

什么是方法

方法是一段完成特定功能的代码块，可被重复调用。

// 方法的作用
// 1. 封装功能代码
// 2. 提高代码复用性
// 3. 简化程序结构
// 4. 便于维护和修改

方法定义语法

基本格式

修饰符 返回类型 方法名(参数列表) {
    // 方法体
    return 返回值;  // 如果有返回值
}

示例定义

// 无参无返回值方法
public void sayHello() {
    System.out.println("Hello!");
}

// 有参无返回值方法
public void greet(String name) {
    System.out.println("Hello, " + name);
}

// 有参有返回值方法
public int add(int a, int b) {
    return a + b;
}

方法定义组成

修饰符

控制方法的访问权限和其他特性。

// 常用修饰符
public      // 公共，任意访问
private     // 私有，仅本类访问
protected   // 受保护，子类可访问
static      // 静态方法，类级别
final       // 不能被重写

返回类型

方法执行后返回的数据类型。

// 返回类型
void        // 无返回值
int         // 返回int
String      // 返回String
boolean     // 返回boolean
double      // 返回double
自定义类型   // 返回对象

方法名

方法的标识符，遵循命名规范。

// 方法命名规范
// 1. 小驼峰命名：第一个单词小写，后续单词首字母大写
// 2. 见名知意：方法名描述功能
// 3. 常用动词开头：get、set、add、remove、print、calculate等

// 正确命名
public void calculateSum() { }
public String getName() { }
public void printResult() { }

// 不推荐命名
public void a() { }        // 无意义
public void Calculate() { } // 首字母大写不规范

参数列表

方法接收的外部数据。

// 无参数
public void method() { }

// 单个参数
public void method(String name) { }

// 多个参数
public void method(String name, int age) { }

// 参数类型可以是任意类型
public void process(int[] arr) { }
public void handle(List<String> list) { }

方法调用

调用语法

// 调用实例方法：对象名.方法名(参数)
Calculator calc = new Calculator();
int result = calc.add(5, 3);

// 调用静态方法：类名.方法名(参数)
int max = Math.max(10, 20);

调用示例

public class Calculator {
    
    public int add(int a, int b) {
        return a + b;
    }
    
    public void printResult(int result) {
        System.out.println("结果: " + result);
    }
    
    public static int multiply(int a, int b) {
        return a * b;
    }
}

// 调用实例方法
Calculator calc = new Calculator();
int sum = calc.add(10, 20);  // 30
calc.printResult(sum);       // 输出：结果: 30

// 调用静态方法
int product = Calculator.multiply(5, 4);  // 20
// 或
int product2 = calc.multiply(5, 4);  // 也可通过对象调用（不推荐）

同类方法调用

public class Test {
    
    public void methodA() {
        methodB();  // 直接调用同类方法
        this.methodB();  // 也可用this
    }
    
    public void methodB() {
        System.out.println("methodB");
    }
    
    public static void staticA() {
        staticB();  // 静态方法调用静态方法
        // methodB();  // 错误：静态不能直接调用实例方法
    }
    
    public static void staticB() {
        System.out.println("staticB");
    }
}

方法定义完整示例

无参无返回值方法

public void showInfo() {
    System.out.println("这是一个示例方法");
}

// 调用
showInfo();

有参无返回值方法

public void printSum(int a, int b) {
    int sum = a + b;
    System.out.println("和: " + sum);
}

// 调用
printSum(5, 3);  // 输出：和: 8

无参有返回值方法

public int getCurrentYear() {
    return 2026;
}

// 调用
int year = getCurrentYear();

有参有返回值方法

public int getMax(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
    // 或：return a > b ? a : b;
}

// 调用
int max = getMax(10, 20);  // 20

多参数方法

public double calculateAverage(int a, int b, int c) {
    return (a + b + c) / 3.0;
}

// 联系
double avg = calculateAverage(10, 20, 30);  // 20.0

数组参数方法

public int sumArray(int[] arr) {
    int sum = 0;
    for (int num : arr) {
        sum += num;
    }
    return sum;
}

// 调用
int[] nums = {1, 2, 3, 4, 5};
int total = sumArray(nums);  // 15

方法的执行流程

调用执行过程

public class Demo {
    public static void main(String[] args) {
        int result = add(5, 3);  // 1. 调用add方法
        System.out.println(result);  // 4. 继续执行main
    }
    
    public static int add(int a, int b) {
        // 2. 进入add方法
        int sum = a + b;  // 3. 计算
        return sum;  // 4. 返回结果，回到调用处
    }
}

方法调用栈

调用顺序：
main() → add() → 返回main()

栈结构（先进后出）：
add()    ← 执行完弹出
main()   ← 继续执行

方法设计原则

单一职责

一个方法只做一件事。

// 好的设计：职责单一
public int calculateSum(int[] arr) {  // 只计算和
    int sum = 0;
    for (int num : arr) {
        sum += num;
    }
    return sum;
}

public void printResult(int value) {  // 只打印
    System.out.println(value);
}

// 不好的设计：职责混杂
public void calculateAndPrint(int[] arr) {  // 计算和打印混在一起
    int sum = 0;
    for (int num : arr) {
        sum += num;
    }
    System.out.println(sum);
}

方法命名清晰

// 清晰命名
public boolean isEmpty(String str) { }  // 一眼知道功能
public int getLength(String str) { }
public String formatName(String name) { }

// 不清晰命名
public boolean check(String str) { }    // 不知道检查什么
public int process(String str) { }       // 不知道处理什么

要点总结

• 方法是封装代码的功能单元
• 定义格式：修饰符 返回类型 方法名(参数) {方法体}
• void表示无返回值
• return返回结果并结束方法
• 方法名小驼峰命名，见名知意
• 调用实例方法：对象名.方法名()
• 调用静态方法：类名.方法名()
• 同类方法可直接调用
• 静态方法不能直接调用实例方法
• 方法调用遵循栈结构（先进后出）
• 单一职责：一个方法只做一件事
• 方法命名要清晰描述功能