核心思想

要调用一个类的方法,你需要两样东西：

1. 方法所在的类的对象（实例）：对于非静态方法（实例方法），你必须先创建该类的一个对象,然后通过这个对象来调用方法。
2. 方法的访问权限：该方法必须是 public（公共的），或者调用方类与被调用方类在同一个包（package）中且方法是包级私有（即没有访问修饰符）。

调用同一个类中的方法

这是最简单的情况,你直接在类内部调用方法即可。

Calculator.java

public class Calculator {
    // 这是一个实例方法
    public int add(int a, int b) {
        System.out.println("执行加法运算...");
        return a + b;
    }
    // 这是一个静态方法
    public static void printWelcomeMessage() {
        System.out.println("欢迎使用计算器！");
    }
    // 调用同一个类中的方法
    public void performCalculation() {
        // 1. 调用实例方法：需要通过 this 关键字（通常可以省略）
        this.add(10, 20); // 或者直接 add(10, 20);
        // 2. 调用静态方法：直接通过类名调用，或者省略类名
        Calculator.printWelcomeMessage(); // 推荐
        // printWelcomeMessage(); // 也可以，但不推荐，容易混淆
    }
}

调用另一个类中的实例方法

这是最常见的情况，你需要先创建目标类的对象，然后通过 对象名.方法名() 的形式来调用。

步骤：

1. 创建被调用类的对象。
2. 使用 运算符,通过对象引用来调用其公共方法。

示例代码：

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 + " 岁。");
    }
    // 一个带返回值的方法
    public String getDetails() {
        return "姓名: " + name + ", 年龄: " + age;
    }
}

Main.java (调用方类)

public class Main {
    public static void main(String[] args) {
        // 1. 创建 Person 类的对象
        // 使用 new 关键字和 Person 的构造函数
        Person person1 = new Person("张三", 25);
        // 2. 通过 person1 对象调用 sayHello() 方法
        person1.sayHello(); // 输出: 你好，我是 张三，我 25 岁。
        // 3. 创建另一个对象
        Person person2 = new Person("李四", 30);
        person2.sayHello(); // 输出: 你好，我是 李四，我 30 岁。
        // 4. 调用带有返回值的方法，并用一个变量接收结果
        String details = person1.getDetails();
        System.out.println(details); // 输出: 姓名: 张三, 年龄: 25
    }
}

调用另一个类中的静态方法

静态方法属于类本身，而不是类的任何一个实例，你不需要创建对象，可以直接通过 类名.方法名() 来调用。

示例代码：

MathUtils.java (被调用的类)

public class MathUtils {
    // 这是一个公共的静态方法
    public static int add(int a, int b) {
        return a + b;
    }
    // 另一个静态方法
    public static double multiply(double a, double b) {
        return a * b;
    }
}

Main.java (调用方类)

public class Main {
    public static void main(String[] args) {
        // 1. 直接通过类名调用静态方法
        // 不需要 new MathUtils()
        int sum = MathUtils.add(5, 10);
        System.out.println("5 + 10 = " + sum); // 输出: 5 + 10 = 15
        double product = MathUtils.multiply(4.5, 2.0);
        System.out.println("4.5 * 2.0 = " + product); // 输出: 4.5 * 2.0 = 9.0
    }
}

传递对象作为参数

一个类的方法也可以接收另一个类的对象作为参数。

示例代码：

Car.java (被调用的类)

public class Car {
    private String model;
    private Engine engine; // Car 类持有一个 Engine 对象
    public Car(String model, Engine engine) {
        this.model = model;
        this.engine = engine;
    }
    // 这个方法接收一个 Driver 对象作为参数
    public void drive(Driver driver) {
        System.out.println(driver.getName() + " 正在驾驶 " + this.model);
        this.engine.start(); // 调用 Engine 对象的方法
        System.out.println("引擎启动，开始行驶！");
    }
}

Engine.java (另一个被调用的类)

public class Engine {
    public void start() {
        System.out.println("引擎轰鸣...");
    }
}

Driver.java (参数类)

public class Driver {
    private String name;
    public Driver(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

Main.java (调用方类)

public class Main {
    public static void main(String[] args) {
        // 1. 创建 Engine 对象
        Engine v8Engine = new Engine();
        // 2. 创建 Car 对象，并将 Engine 对象传递给 Car 的构造函数
        Car myCar = new Car("特斯拉 Model S", v8Engine);
        // 3. 创建 Driver 对象
        Driver driver = new Driver("王五");
        // 4. 调用 myCar 的 drive 方法，并将 driver 对象作为参数传递
        myCar.drive(driver);
    }
}

输出结果：

王五 正在驾驶 特斯拉 Model S
引擎轰鸣...
引擎启动，开始行驶！

总结与最佳实践

重要提示：

• 访问修饰符：确保你要调用的方法是 public 的,否则在类外部无法访问。
• null 指针异常：如果你尝试在一个为 null 的对象上调用方法，程序会抛出 NullPointerException。

  Person person = null;
  person.sayHello(); // 抛出 NullPointerException

• 设计原则：遵循“高内聚、低耦合”的原则，类之间应该有清晰的职责划分，避免过度依赖，过多的方法调用链（a.b().c().d()）通常意味着设计可能存在问题。