核心概念

我们要理解几个关键术语：

1. 方法：也称为函数或过程，它是类中定义的一段可重复执行的代码块，用于完成特定的功能，方法可以接收输入参数（可选），执行某些操作，并可以返回一个结果（可选）。
2. 调用：指执行一个方法中代码的过程，当你调用一个方法时，程序的控制权会暂时转移到被调用的方法内部，执行完该方法后,再返回到调用点继续执行。

调用同一个类中的方法

这是最常见的情况，假设你在一个类中定义了多个方法,现在想在其中一个方法里调用另一个方法。

基本语法

直接使用方法名加上括号 即可，如果方法有参数,则在括号内传入相应的参数。

// 方法A
public void methodA() {
    System.out.println("这是方法A");
}
// 方法B，它想调用方法A
public void methodB() {
    System.out.println("方法B开始执行，准备调用方法A...");
    // 调用同一个类中的方法A
    methodA(); 
    System.out.println("方法A调用完毕，方法B继续执行。");
}

完整示例

下面是一个完整的 Calculator 类,它演示了如何在一个方法中调用另一个方法。

public class Calculator {
    // 1. 一个简单的无参、无返回值的方法
    public void displayWelcomeMessage() {
        System.out.println("欢迎使用Java计算器！");
    }
    // 2. 一个有参数、无返回值的方法
    public void printResult(double result) {
        System.out.println("计算结果是: " + result);
    }
    // 3. 一个有参数、有返回值的方法
    public double add(double num1, double num2) {
        System.out.println("正在执行加法运算...");
        return num1 + num2; // 返回计算结果
    }
    // 4. 主方法，程序的入口点，它将调用其他方法
    public static void main(String[] args) {
        // 注意：main方法是静态的，要调用非静态方法，需要先创建类的实例（对象）
        Calculator myCalculator = new Calculator();
        // 调用无参方法
        myCalculator.displayWelcomeMessage();
        // 调用有参数、有返回值的方法，并接收返回值
        double sum = myCalculator.add(10.5, 5.2);
        // 将返回的值作为参数，调用另一个方法
        myCalculator.printResult(sum);
    }
}

代码解析:

1. Calculator myCalculator = new Calculator();

   • 这行代码创建了一个 Calculator 类的实例（也叫对象），你可以把它想象成在内存中根据“Calculator”这个图纸制造了一台具体的计算器。
   • 只有创建了对象,你才能使用这个对象来调用其内部的非静态方法。

2. myCalculator.displayWelcomeMessage();

   • 使用 操作符，通过对象 myCalculator 来调用 displayWelcomeMessage() 方法。

3. double sum = myCalculator.add(10.5, 5.2);

   • 调用 add 方法时，我们传入了两个参数 5 和 2。
   • add 方法执行完毕后，返回了 7 这个结果，我们将这个结果存储在 double 类型的变量 sum 中。

4. myCalculator.printResult(sum);

   
   （图片来源网络，侵删）
   • 我们将刚才计算得到的 sum 变量作为参数，传递给了 printResult 方法。

调用其他类中的方法

当你的程序变得复杂时，你会把不同的功能拆分到不同的类中,这时就需要调用其他类的方法。

基本步骤

1. 创建目标类的对象：使用 new 关键字。
2. 通过对象调用方法：使用 操作符。

完整示例

假设我们有两个类：Person 和 Main。

文件 1: Person.java 这个类定义了人的基本信息和打招呼的方法。

public class Person {
    // 成员变量（属性）
    private String name;
    private int age;
    // 构造方法，用于创建对象时初始化属性
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 一个公共的方法，可以被其他类调用
    public void sayHello() {
        System.out.println("你好，我叫 " + this.name + "，今年 " + this.age + " 岁。");
    }
}

文件 2: Main.java 这是我们的主程序类，它将创建 Person 对象并调用其方法。

public class Main {
    public static void main(String[] args) {
        // 1. 创建 Person 类的对象
        Person person1 = new Person("张三", 25);
        // 2. 通过 person1 对象调用 sayHello() 方法
        person1.sayHello(); // 输出: 你好，我叫 张三，今年 25 岁。
        // 可以创建多个不同的对象
        Person person2 = new Person("李四", 30);
        person2.sayHello(); // 输出: 你好，我叫 李四，今年 30 岁。
    }
}

代码解析:

• 在 Main.java 中，我们首先导入了 Person 类（如果不在同一个包下，需要 import）。
• Person person1 = new Person("张三", 25); 创建了一个 Person 的实例，并调用了它的构造方法来初始化 name 和 age。
• person1.sayHello(); 成功调用了 Person 类中定义的 sayHello 方法。

特殊情况：调用静态方法

静态方法属于类本身，而不是属于类的某个特定实例,调用静态方法有特殊的规则。

调用规则

• 可以在同一个类中直接调用：直接使用方法名。
• 可以在其他类中调用：使用 类名.静态方法名() 的形式。

完整示例

**文件 1: MathUtils.java (包含静态方法)

public class MathUtils {
    // 这是一个静态方法，它不依赖于任何对象实例
    public static int add(int a, int b) {
        return a + b;
    }
}

**文件 2: Main.java (调用静态方法)

public class Main {
    public static void main(String[] args) {
        // 调用其他类的静态方法，使用 类名.方法名()
        int sum = MathUtils.add(100, 200);
        System.out.println("静态方法计算的和是: " + sum); // 输出: 静态方法计算的和是: 300
        // 如果在同一个类中，也可以直接调用
        // (假设 add 方法也写在 Main 类里)
        // int anotherSum = add(50, 50); 
    }
}

重要提示：

• 静态方法不能直接访问类的非静态成员（变量或方法），因为非静态成员必须通过对象实例来访问，静态方法在类加载时就存在,此时可能还没有创建任何对象。
• 工具类（如 java.lang.Math）中的方法都是静态的，因为它们不需要保存状态,只是提供一些通用的功能。

方法重载

一个类中可以有多个同名的方法，只要它们的参数列表（参数的个数、类型或顺序）不同,这被称为方法重载。

示例：

public class OverloadExample {
    // 方法1: 两个int参数相加
    public int add(int a, int b) {
        return a + b;
    }
    // 方法2: 三个int参数相加 (重载了add方法)
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    // 方法3: 两个double参数相加 (重载了add方法)
    public double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        OverloadExample example = new OverloadExample();
        System.out.println("10 + 20 = " + example.add(10, 20)); // 调用方法1
        System.out.println("10 + 20 + 30 = " + example.add(10, 20, 30)); // 调用方法2
        System.out.println("10.5 + 20.5 = " + example.add(10.5, 20.5)); // 调用方法3
    }
}

当你调用 example.add(...) 时，Java编译器会根据你传入的参数类型和数量,自动选择最匹配的那个方法版本。

希望这个详细的解释和示例能帮助你完全理解在Java中如何调用方法！从最基础的开始，多写多练,很快就能熟练掌握。