1. 调用同一个项目中的其他类：这是最简单、最常见的情况。
2. 调用外部（独立）的 .class 文件：调用一个第三方库的类文件,或者调用一个动态生成的类文件。

下面我将详细讲解这两种场景,并提供完整的代码示例。

调用同一个项目中的其他类

这是 Java 面向对象编程的基础，当你在一个类中需要使用另一个类时，只需要使用 import 语句引入该类，然后创建其实例或调用其静态方法/字段即可。

前提条件

• 所有相关的 .java 源文件都在同一个 包 中，或者位于不同的包但通过 import 正确关联。
• 这些类文件最终都会被编译到同一个输出目录（通常是 target/classes 或 bin）。

步骤

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

定义被调用的类 (Person.class 的源文件 Person.java)

这个类是一个普通的 Java 类，可以包含字段、构造方法和成员方法。

// Person.java
package com.example.demo;
public class Person {
    // 私有字段
    private String name;
    private int age;
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person 对象 " + name + " 被创建。");
    }
    // 公共方法
    public void sayHello() {
        System.out.println("你好，我是 " + this.name + "，我 " + this.age + " 岁了。");
    }
    // Getter 方法
    public String getName() {
        return name;
    }
}

定义调用方类 (Main.java)

在这个类中，我们将 import 并使用 Person 类。

// Main.java
package com.example.demo;
// import com.example.demo.Person; // 如果在同一个包下，这行可以省略，但写上更清晰
public class Main {
    public static void main(String[] args) {
        System.out.println("开始调用 Person 类...");
        // 1. 创建 Person 类的实例（对象）
        // 这会触发 Person 类的静态代码块（如果有的话）和构造方法
        Person person1 = new Person("张三", 30);
        // 2. 调用 Person 类的公共方法
        person1.sayHello();
        // 3. 创建另一个实例
        Person person2 = new Person("李四", 25);
        person2.sayHello();
        // 4. 调用 Person 类的公共方法
        String name = person1.getName();
        System.out.println("从 person1 获取到的名字是: " + name);
        System.out.println("调用结束。");
    }
}

如何运行：

1. 将这两个文件保存在同一个目录结构下：com/example/demo/Person.java 和 com/example/demo/Main.java。
2. 在命令行中，进入 com 的上一级目录。
3. 编译：javac com/example/demo/*.java
4. 运行：java com.example.demo.Main

输出结果：

开始调用 Person 类...
Person 对象 张三 被创建。
你好，我是 张三，我 30 岁了。
Person 对象 李四 被创建。
你好，我是 李四，我 25 岁了。
从 person1 获取到的名字是: 张三
调用结束。

调用外部的 .class 文件

这种情况稍微复杂一些，需要用到 Java 的 类加载器 和 类路径，类路径是 JVM 查找 .class 文件的位置列表。

前提条件

• 你有一个独立的 .class 文件（MyUtils.class）,它不在当前项目的源代码或编译输出目录中。
• 你知道这个 .class 文件对应的包结构（如果有的话），如果 MyUtils.class 是在 com.mycompany.utils 包下，那么理论上应该有一个 com/mycompany/utils/MyUtils.class 的文件结构。

步骤

假设我们有一个外部工具类 MyUtils.class。

准备外部 .class 文件

我们需要创建并编译这个外部类。

MyUtils.java (源文件)

// MyUtils.java
package com.mycompany.utils;
public class MyUtils {
    public static void printMessage(String message) {
        System.out.println("[MyUtils] " + message);
    }
}

编译并放置：

1. 编译 MyUtils.java: javac MyUtils.java
2. 这会生成 MyUtils.class 文件。
3. 为了模拟“外部”库，我们把它放到一个单独的目录，D:\java_libs\com\mycompany\utils\MyUtils.class。
   • 注意：文件路径必须与包结构 com.mycompany.utils 对应，如果你把 MyUtils.class 直接放在 D:\java_libs 下，并且类没有包声明,那又是另一种情况。

编写调用方代码

我们编写一个主程序来加载并使用这个外部的 MyUtils.class。

// ExternalCaller.java
// 注意：这个类没有包，或者在一个不同的包下，以强调它的“外部”性
public class ExternalCaller {
    public static void main(String[] args) throws Exception {
        System.out.println("准备加载外部的 MyUtils 类...");
        // 1. 获取系统类加载器
        ClassLoader classLoader = ExternalCaller.class.getClassLoader();
        // 2. 定义类的全限定名
        // 这个名字必须与 .class 文件声明的包名 + 类名完全一致
        String className = "com.mycompany.utils.MyUtils";
        try {
            // 3. 使用类加载器加载类
            // Class.forName() 也可以，它会使用调用者的类加载器
            Class<?> loadedClass = classLoader.loadClass(className);
            System.out.println("成功加载类: " + loadedClass.getName());
            // 4. 检查加载的类是否是我们期望的
            if (loadedClass.getName().equals(className)) {
                System.out.println("类名匹配，可以进行调用。");
            }
            // 5. 调用静态方法
            // 因为 MyUtils.printMessage 是静态方法，所以不需要创建实例
                // 获取 printMessage 方法
                java.lang.reflect.Method method = loadedClass.getMethod("printMessage", String.class);
                // 调用方法，传入参数
                method.invoke(null, "这是来自 ExternalCaller 的问候！");
        } catch (ClassNotFoundException e) {
            System.err.println("错误：找不到类 " + className);
            System.err.println("请确保 .class 文件在正确的类路径下。");
            e.printStackTrace();
        } catch (Exception e) {
            System.err.println("调用类时发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

设置类路径并运行

这是最关键的一步，你需要告诉 JVM 去哪里寻找 com.mycompany.utils.MyUtils.class。

• 使用 -cp (classpath) 参数

打开命令行,执行以下命令：

# 假设 ExternalCaller.class 在当前目录
# 外部库的根目录是 D:\java_libs
java -cp ".;D:\java_libs" ExternalCaller

• 命令解释:
  • java: 启动 JVM。
  • -cp: 指定类路径。
  • 当前目录，JVM 会在这里查找 ExternalCaller.class。
  • 路径分隔符 (在 Windows 上是分号 ，在 Linux 或 macOS 上是冒号 )。
  • D:\java_libs: 外部库的根目录，JVM 会被指示去这个目录及其子目录下（D:\java_libs\com\...）查找 .class 文件。
  • ExternalCaller: 要执行的主类。

输出结果：

准备加载外部的 MyUtils 类...
成功加载类: com.mycompany.utils.MyUtils
类名匹配，可以进行调用。
[MyUtils] 这是来自 ExternalCaller 的问候！

更现代的方式：Java 模块系统 (Java 9+)

对于更复杂的项目，特别是大型应用，Java 9 引入了模块系统，你可以创建一个 module-info.java 文件来显式地声明模块依赖，这比单纯依赖类路径更可控、更安全。

但这通常用于构建整个模块化的应用程序，对于简单的调用外部 .class 文件，-cp 参数仍然是最高效和直接的方法。

希望这个详细的解释和示例能帮助你完全理解在 Java 中如何调用 .class 文件！