核心概念

在 Java 中，一个成员方法（也称为实例方法）可以直接调用同一个类中的其他成员方法，这背后的原理是：当一个方法被调用时，它已经在一个具体的对象实例上执行了，因此它“知道”自己属于哪个对象，并可以自由地调用该对象的其他方法。

基本调用规则

在同一个类的两个方法之间进行调用,非常简单，直接调用方法名即可，无需使用对象引用（this除外，后面会解释）。

示例代码

让我们来看一个最简单的例子,一个 Car 类。

public class Car {
    // 成员变量
    private String brand; // 品牌
    private String color; // 颜色
    private double speed; // 当前速度
    // 构造方法
    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
        this.speed = 0.0; // 新车初始速度为0
    }
    // 成员方法1：启动汽车
    public void start() {
        System.out.println("汽车启动了！");
        // 在 start() 方法中调用另一个成员方法 accelerate()
        accelerate(10.0); // 启动后立即加速
    }
    // 成员方法2：加速
    public void accelerate(double amount) {
        this.speed += amount;
        System.out.println(brand + " 汽车加速了 " + amount + " km/h，当前速度为: " + this.speed + " km/h");
    }
    // 成员方法3：显示汽车信息
    public void displayInfo() {
        System.out.println("汽车信息: " + color + "色的 " + brand);
        // 在 displayInfo() 方法中调用另一个成员方法 getSpeed()
        System.out.println("当前速度: " + getSpeed() + " km/h");
    }
    // 成员方法4：获取速度
    public double getSpeed() {
        return this.speed;
    }
    // 主方法，用于测试
    public static void main(String[] args) {
        // 创建一个 Car 对象
        Car myCar = new Car("特斯拉 Model 3", "白色");
        // 调用 start() 方法
        // 在 start() 内部，它会自动调用 accelerate()
        myCar.start();
        System.out.println("--------------------");
        // 调用 displayInfo() 方法
        // 在 displayInfo() 内部，它会自动调用 getSpeed()
        myCar.displayInfo();
    }
}

代码解析

1. public void start():

   • 当我们调用 myCar.start() 时，start() 方法就在 myCar 这个对象上执行。
   • 在 start() 方法内部，我们直接写 accelerate(10.0);。
   • 这行代码的含义是：“调用当前对象（也就是 myCar）的 accelerate 方法”，编译器会自动加上隐式的 this.，即 this.accelerate(10.0);。

2. public void displayInfo():

   • 同样,当我们调用 myCar.displayInfo() 时，displayInfo() 在 myCar 对象上执行。
   • 它内部调用 getSpeed()，实际上是 this.getSpeed()，获取的是 myCar 的 speed 值。

3. this 关键字:

   • this 是一个引用，指向当前对象（即调用该方法的对象）。
   • 在上面的例子中,start() 方法里的 this 就代表 myCar。
   • 虽然 accelerate() 可以省略 this. 直接调用，但在某些情况下使用 this 可以让代码更清晰，特别是当参数名和成员变量名相同时。

何时使用 this.

虽然调用同类方法时可以省略 this.，但在以下两种常见情况下，使用 this 是一个好习惯，甚至是必须的：

区分成员变量和局部变量

当方法的参数名与类的成员变量名相同时,编译器会优先使用参数，如果你想访问成员变量，就必须使用 this。

public class Person {
    private String name;
    // 构造方法的参数 name 和成员变量 name 重名了
    public Person(String name) {
        // 这里的 name 指的是参数 name，而不是成员变量 name
        // name = name; // 错误！这行代码什么也没做，只是把参数赋给了自己。
        // 使用 this.name 来明确指定我们要给成员变量赋值
        this.name = name;
    }
    public void sayMyName() {
        System.out.println("我的名字是: " + this.name); // 使用 this.name 更清晰
    }
}

构造方法中调用其他构造方法

在一个类的构造方法中,你可以使用 this(...) 来调用同一个类的其他构造方法，这通常用于代码复用，避免重复的初始化代码。

重要规则：this(...) 必须是构造方法中的第一条语句。

public class Student {
    private String name;
    private int age;
    // 构造方法1：只提供姓名
    public Student(String name) {
        // 调用另一个构造方法，并传递默认年龄
        this(name, 18); 
        System.out.println("只提供了姓名的构造方法被调用");
    }
    // 构造方法2：提供姓名和年龄
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("提供了姓名和年龄的构造方法被调用");
    }
    public void printInfo() {
        System.out.println("学生姓名: " + this.name + ", 年龄: " + this.age);
    }
    public static void main(String[] args) {
        System.out.println("创建学生 A...");
        Student studentA = new Student("张三");
        studentA.printInfo();
        System.out.println("\n创建学生 B...");
        Student studentB = new Student("李四", 20);
        studentB.printInfo();
    }
}

输出结果：

创建学生 A...
提供了姓名和年龄的构造方法被调用
只提供了姓名的构造方法被调用
学生姓名: 张三, 年龄: 18
创建学生 B...
提供了姓名和年龄的构造方法被调用
学生姓名: 李四, 年龄: 20

特殊情况：静态方法调用成员方法

这是一个非常常见的“陷阱”。静态方法（static method）不能直接调用非静态的成员方法。

为什么？

• 成员方法（实例方法）：依赖于具体的对象实例，你必须知道这个方法是“哪个对象”的方法才能调用它。
• 静态方法（类方法）：不属于任何一个具体的对象，它属于类本身，它可以在没有创建任何对象的情况下被调用。

静态方法无法引用 this，因为它没有一个“当前对象”，既然没有对象，它自然就无法调用需要依附于对象才能运行的成员方法。

错误示例

public class MyClass {
    // 成员方法
    public void instanceMethod() {
        System.out.println("这是一个成员方法。");
    }
    // 静态方法
    public static void staticMethod() {
        // 编译错误！
        // instanceMethod(); 
        // 错误信息：Cannot make a static reference to the non-static method instanceMethod()
    }
}

如何在静态方法中调用成员方法？

答案是：先创建一个对象，然后用这个对象去调用成员方法。

public class MyClass {
    public void instanceMethod() {
        System.out.println("这是一个成员方法。");
    }
    public static void staticMethod() {
        System.out.println("这是一个静态方法。");
        // 创建一个 MyClass 的对象
        MyClass myObject = new MyClass();
        // 通过对象引用来调用成员方法
        myObject.instanceMethod(); // 现在可以了
    }
    public static void main(String[] args) {
        // 在 main 方法（也是静态的）中调用成员方法
        MyClass.staticMethod();
    }
}

掌握这些规则,你就能在 Java 中灵活、正确地进行方法调用，为编写更复杂的程序打下坚实的基础。