核心思想

调用另一个类的方法,通常遵循以下三个步骤：

1. 创建对象：你需要一个目标类的“实例”，也就是一个对象，这通常使用 new 关键字来完成。
2. 使用对象：通过创建出的对象，你可以访问它的成员（包括方法和变量）。
3. 调用方法：使用点号 操作符，连接对象名和方法名，并加上括号 和必要的参数。

最常见的情况（在同一个包下，无特殊修饰）

这是最基本的情况,两个类在同一个包（package）中，并且被调用的方法是 public 的。

定义被调用的类和方法

我们创建一个名为 Calculator.java 的类，它包含一个 add 方法。

Calculator.java

package com.example.myapp; // 假设我们有一个包
/**
 * 一个简单的计算器类
 */
public class Calculator {
    /**
     * 一个公共的、用于加法的方法
     * @param a 第一个加数
     * @param b 第二个加数
     * @return 两个数的和
     */
    public int add(int a, int b) {
        System.out.println("Calculator: 正在执行加法运算...");
        return a + b;
    }
}

在另一个类中调用该方法

我们创建一个 Main.java 类，来调用 Calculator 类中的 add 方法。

Main.java

package com.example.myapp; // 确保在同一个包下
public class Main {
    public static void main(String[] args) {
        // 步骤1: 创建 Calculator 类的对象
        // 我们把这个对象命名为 myCalculator
        Calculator myCalculator = new Calculator();
        // 步骤2 & 3: 使用对象来调用 add 方法
        // 将 5 和 3 作为参数传递给 add 方法
        int sum = myCalculator.add(5, 3);
        // 打印返回的结果
        System.out.println("计算结果是: " + sum); // 输出: 计算结果是: 8
    }
}

代码解释:

• Calculator myCalculator = new Calculator();
  • Calculator：这是我们要实例化的类的类型。
  • myCalculator：这是我们要创建的对象的引用（可以理解为给它起了一个名字）。
  • new Calculator()：这是创建 Calculator 类新实例（对象）的代码。
• int sum = myCalculator.add(5, 3);
  • myCalculator.add(...)：通过 myCalculator 这个对象，点出了 add 方法。
  • (5, 3)：传递给 add 方法的参数。
  • int sum：add 方法返回一个 int 类型的值，我们将其存储在 sum 变量中。

方法的不同访问修饰符

被调用方法的修饰符决定了它能否被其他类访问,Java 主要有四种访问修饰符：

调用规则：

• 只有 public 方法可以被任何其他类自由调用（只要能导入）。
• protected 方法通常用于继承，可以在子类中调用。
• 没有修饰符（default）的方法，只能在同一个包内的类中调用。
• private 方法绝对不能在类的外部被调用，只能在它自己所定义的类内部使用。

示例：

Helper.java

package com.example.utils;
public class Helper {
    public void publicMethod() {
        System.out.println("这是一个 public 方法");
    }
    protected void protectedMethod() {
        System.out.println("这是一个 protected 方法");
    }
    void defaultMethod() { // 没有修饰符
        System.out.println("这是一个 default (包私有) 方法");
    }
    private void privateMethod() {
        System.out.println("这是一个 private 方法");
    }
}

Main.java (在另一个包中，com.example.myapp)

package com.example.myapp;
// 需要导入 Helper 类
import com.example.utils.Helper;
public class Main {
    public static void main(String[] args) {
        Helper helper = new Helper();
        // 可以调用 public 方法
        helper.publicMethod(); // ✔️
        // ❌ 编译错误！因为 Main 不是 Helper 的子类，且不在同一个包
        // helper.protectedMethod();
        // ❌ 编译错误！因为不在同一个包
        // helper.defaultMethod();
        // ❌ 编译错误！private 方法无法在类外访问
        // helper.privateMethod();
    }
}

调用静态方法

如果一个方法被 static 关键字修饰，它就属于类本身，而不是属于类的某个对象，你不需要创建对象就可以直接调用它。

定义包含静态方法的类

MathUtils.java

package com.example.utils;
public class MathUtils {
    // 这是一个静态方法
    public static int multiply(int a, int b) {
        System.out.println("MathUtils: 正在执行乘法运算...");
        return a * b;
    }
}

调用静态方法

Main.java

package com.example.myapp;
import com.example.utils.MathUtils;
public class Main {
    public static void main(String[] args) {
        // 调用静态方法，不需要创建对象！
        // 直接使用 类名.方法名() 的形式
        int product = MathUtils.multiply(4, 6);
        System.out.println("乘积是: " + product); // 输出: 乘积是: 24
    }
}

⚠️ 重要提示： 虽然你也可以通过对象来调用静态方法（MathUtils m = new MathUtils(); m.multiply(4, 6);），但这是一种不被推荐的做法，因为它会引起混淆，让其他开发者误以为这个方法依赖于对象的状态，最佳实践是始终使用 类名.静态方法名() 的方式。

跨包调用

当两个类位于不同的包时,你需要使用 import 语句来告诉编译器你要使用哪个类。

步骤：

1. 确保 import 语句存在：在调用类的文件顶部，使用 import 包名.类名;。
2. 创建对象并调用：和场景一完全一样。

示例：

假设 Calculator 类在 com.example.tools 包下。

Calculator.java

package com.example.tools;
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Main.java (在 com.example.myapp 包下)

package com.example.myapp;
// 1. 导入 Calculator 类
import com.example.tools.Calculator;
public class Main {
    public static void main(String[] args) {
        // 2. 像在同一个包中一样创建对象和调用方法
        Calculator myCalculator = new Calculator();
        int result = myCalculator.add(10, 20);
        System.out.println("结果是: " + result); // 输出: 结果是: 30
    }
}

希望这个详细的解释能帮助你完全理解在 Java 中如何调用另一个类的方法！