9.2 方法的定义与调用

方法的定义

方法的定义是指在类中声明方法的过程，包括方法的修饰符、返回类型、方法名、参数列表和方法体。

方法定义的语法

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

示例：

// 定义一个计算两个数之和的方法
public static int add(int a, int b) {
    int sum = a + b;
    return sum;
}

方法的调用

方法的调用是指执行方法中的代码，获取方法的执行结果。方法调用需要使用方法名和必要的参数。

静态方法的调用

静态方法可以通过类名直接调用，不需要创建对象。

语法：

类名.方法名([参数]);

示例：

// 调用静态方法
int result = Calculator.add(5, 3);
System.out.println("Result: " + result);

实例方法的调用

实例方法需要通过对象调用，必须先创建对象。

语法：

对象名.方法名([参数]);

示例：

// 创建对象
Calculator calculator = new Calculator();
// 调用实例方法
int result = calculator.add(5, 3);
System.out.println("Result: " + result);

方法的参数

方法的参数是指方法接收的输入数据，用于方法内部的计算和处理。

参数的定义

语法：

类型 参数名, 类型 参数名, ...

示例：

// 定义一个带有两个参数的方法
public static int add(int a, int b) {
    return a + b;
}

参数的传递

在 Java 中，方法参数的传递是值传递，即传递的是参数值的副本。

示例：

public class ParameterPassingExample {
    public static void main(String[] args) {
        int x = 5;
        System.out.println("Before calling modify: " + x); // 输出 5
        modify(x);
        System.out.println("After calling modify: " + x); // 输出 5，因为是值传递
    }
    
    public static void modify(int value) {
        value = 10;
        System.out.println("Inside modify: " + value); // 输出 10
    }
}

引用类型参数的传递

对于引用类型参数，传递的是对象的引用（内存地址），因此可以修改对象的内部状态。

示例：

public class ReferenceParameterPassingExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3};
        System.out.println("Before calling modify: " + array[0]); // 输出 1
        modify(array);
        System.out.println("After calling modify: " + array[0]); // 输出 10，因为修改了数组对象的内部状态
    }
    
    public static void modify(int[] arr) {
        arr[0] = 10;
        System.out.println("Inside modify: " + arr[0]); // 输出 10
    }
}

方法的返回值

方法的返回值是指方法执行后返回的结果，用于传递方法的执行结果给调用者。

返回值的定义

语法：

return 返回值;

示例：

// 定义一个返回两个数之和的方法
public static int add(int a, int b) {
    return a + b;
}

无返回值的方法

如果方法不需要返回值，可以使用 void 作为返回类型。

示例：

// 定义一个无返回值的方法
public static void printMessage(String message) {
    System.out.println(message);
}

多返回值的处理

Java 方法只能返回一个值，但可以通过以下方式实现多返回值：

1. 使用数组：将多个返回值放入数组中返回
2. 使用对象：将多个返回值封装到一个对象中返回
3. 使用集合：将多个返回值放入集合中返回

示例：

// 使用数组返回多个值
public static int[] getMinMax(int[] array) {
    int min = array[0];
    int max = array[0];
    for (int number : array) {
        if (number < min) {
            min = number;
        }
        if (number > max) {
            max = number;
        }
    }
    return new int[]{min, max};
}

方法的重载

方法重载是指在同一个类中定义多个同名方法，但它们的参数列表不同（参数类型、参数数量或参数顺序不同）。

示例：

public class OverloadingExample {
    // 重载 add 方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static double add(double a, double b) {
        return a + b;
    }
    
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
}

方法的递归

方法递归是指方法调用自身的过程，用于解决可以分解为相同子问题的问题。

示例：

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

示例：方法的定义与调用

示例 1：静态方法的定义与调用

public class StaticMethodExample {
    public static void main(String[] args) {
        // 调用静态方法
        int sum = add(5, 3);
        System.out.println("Sum: " + sum);
        
        int product = multiply(5, 3);
        System.out.println("Product: " + product);
        
        printMessage("Hello, Java!");
    }
    
    // 定义静态方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int multiply(int a, int b) {
        return a * b;
    }
    
    public static void printMessage(String message) {
        System.out.println(message);
    }
}

示例 2：实例方法的定义与调用

public class InstanceMethodExample {
    public static void main(String[] args) {
        // 创建对象
        Calculator calculator = new Calculator();
        
        // 调用实例方法
        int sum = calculator.add(5, 3);
        System.out.println("Sum: " + sum);
        
        int product = calculator.multiply(5, 3);
        System.out.println("Product: " + product);
    }
}

class Calculator {
    // 定义实例方法
    public int add(int a, int b) {
        return a + b;
    }
    
    public int multiply(int a, int b) {
        return a * b;
    }
}

示例 3：方法参数的传递

public class ParameterExample {
    public static void main(String[] args) {
        // 基本类型参数
        int x = 5;
        System.out.println("Before: " + x);
        modifyValue(x);
        System.out.println("After: " + x);
        
        // 引用类型参数
        int[] array = {1, 2, 3};
        System.out.println("Before: " + array[0]);
        modifyArray(array);
        System.out.println("After: " + array[0]);
    }
    
    public static void modifyValue(int value) {
        value = 10;
        System.out.println("Inside modifyValue: " + value);
    }
    
    public static void modifyArray(int[] arr) {
        arr[0] = 10;
        System.out.println("Inside modifyArray: " + arr[0]);
    }
}

常见问题

1. 方法名拼写错误

症状：编译错误：error: cannot find symbol

解决方案：检查方法名的拼写，确保与方法定义一致

2. 参数类型不匹配

症状：编译错误：error: incompatible types

解决方案：确保传递的参数类型与方法定义的参数类型一致

3. 参数数量不匹配

症状：编译错误：error: method methodName in class ClassName cannot be applied to given types

解决方案：确保传递的参数数量与方法定义的参数数量一致

4. 返回值类型不匹配

症状：编译错误：error: incompatible types

解决方案：确保方法的返回值类型与方法定义的返回值类型一致

5. 缺少 return 语句

症状：编译错误：error: missing return statement

解决方案：确保有返回值的方法在所有执行路径上都有 return 语句

总结

方法的定义与调用是 Java 编程中的基本操作。方法的定义包括修饰符、返回类型、方法名、参数列表和方法体。方法的调用需要使用方法名和必要的参数。

在使用方法时，需要注意：

• 方法的参数传递是值传递
• 方法只能返回一个值
• 可以使用方法重载来定义多个同名方法
• 可以使用方法递归来解决复杂问题

通过合理使用方法，可以使代码结构更清晰，提高代码的可维护性和可读性。