LabEx
登录免费加入

如何修复编译和运行 Java 代码时出现的 'class not found' 错误

JavaBeginner
立即练习

介绍

在使用 Java 时，开发者最常遇到的烦恼之一就是遇到 'class not found' 错误。当 Java 虚拟机 (JVM) 无法找到程序运行所需的类时，就会发生此错误。无论你是一个初学者，还是已经有一些 Java 经验，理解如何诊断和解决这个错误对于流畅的开发至关重要。

在这个实验（Lab）中，你将学习导致 'class not found' 错误的原因，如何在你的代码中识别具体的问题，以及实施有效的解决方案来修复它。通过本次课程，你将获得克服 Java 编程中这一常见障碍的知识和实践经验。

理解 Java 类路径和包结构

在深入研究错误本身之前，让我们先了解一下 Java 如何组织和查找类。这个基础知识将帮助你更好地诊断 'class not found' 错误。

Java 类路径

类路径是一个参数，它告诉 Java 虚拟机在哪里查找类和包。当你运行一个 Java 程序时，JVM 会在以下位置搜索类：

  1. 当前目录
  2. 类路径中指定的 JAR 文件
  3. 标准 Java 库

创建一个简单的 Java 程序

让我们创建一个简单的 Java 程序来理解 Java 如何编译和运行代码：

  1. 打开 WebIDE 并在 /home/labex/project 目录下创建一个名为 HelloWorld.java 的新文件。

  2. 将以下代码添加到文件中：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
  1. 打开一个终端，并确保你在项目目录下：
cd ~/project
  1. 使用 javac 命令编译你的 Java 程序：
javac HelloWorld.java
  1. 使用 java 命令运行你的程序：
java HelloWorld

你应该看到以下输出：

Hello, World!

理解编译过程

当你运行 javac 命令时，它会创建一个名为 HelloWorld.class 的文件。这个文件包含 JVM 可以执行的字节码。当你运行 java 命令时，JVM 会在当前目录中查找这个类文件并执行它。

这个简单程序的成功执行演示了 Java 中的基本编译和执行过程。接下来，我们将故意创建一个错误，以了解当找不到类时会发生什么。

遇到和理解 'Class Not Found' 错误

现在你已经了解了 Java 编译和执行的基础知识，让我们故意创建一个会发生 'class not found' 错误的情况。这将帮助你识别错误并理解其原因。

创建一个缺少类的程序

  1. 在 /home/labex/project 目录下创建一个名为 MainProgram.java 的新文件，其中包含以下代码：
public class MainProgram {
    public static void main(String[] args) {
        // 尝试使用一个尚不存在的类
        Helper helper = new Helper();
        helper.doSomething();
    }
}
  1. 使用 javac 命令编译此程序：
javac MainProgram.java

你将看到一个类似于以下的错误：

MainProgram.java:4: error: cannot find symbol
        Helper helper = new Helper();
        ^
  symbol:   class Helper
  location: class MainProgram

这个错误发生在编译时，因为 Java 编译器找不到 Helper 类。让我们通过创建缺少的类来修复这个问题。

创建缺少的类

  1. 在同一目录下创建一个名为 Helper.java 的新文件，其中包含以下代码：
public class Helper {
    public void doSomething() {
        System.out.println("Helper is doing something useful!");
    }
}
  1. 现在编译这两个文件：
javac MainProgram.java Helper.java
  1. 运行 MainProgram 类：
java MainProgram

你应该看到输出：

Helper is doing something useful!

理解运行时 'Class Not Found' 错误

我们之前遇到的错误是编译时错误。现在，让我们创建一个场景，在这个场景中，我们会得到一个运行时 'class not found' 错误：

  1. 创建一个名为 DynamicLoader.java 的新文件，其中包含以下代码：
public class DynamicLoader {
    public static void main(String[] args) {
        try {
            // 尝试动态加载一个不存在的类
            Class.forName("NonExistentClass");
            System.out.println("Class loaded successfully!");
        } catch (ClassNotFoundException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}
  1. 编译并运行此程序：
javac DynamicLoader.java
java DynamicLoader

你应该看到输出：

Error: NonExistentClass

这演示了一个运行时 'class not found' 错误，它被我们的 try-catch 块捕获。在实际应用中，这种类型的错误通常发生在以下情况：

  • 类存在，但不在类路径中
  • 类名拼写错误或大小写不正确
  • 类在一个包中，但包结构不正确

使用 Java 包和类路径

大多数实际的 Java 应用程序将类组织成包。如果包结构没有正确设置，或者类路径没有正确配置，这种组织有时会导致 'class not found' 错误。

创建包结构

  1. 为我们的包创建一个目录结构：
mkdir -p ~/project/com/example/util
  1. 在 ~/project/com/example/util 目录下创建一个名为 StringUtils.java 的新文件：
package com.example.util;

public class StringUtils {
    public static String reverse(String input) {
        StringBuilder reversed = new StringBuilder();
        for (int i = input.length() - 1; i >= 0; i--) {
            reversed.append(input.charAt(i));
        }
        return reversed.toString();
    }
}

注意文件顶部的 package 声明。这告诉 Java 这个类属于 com.example.util 包。

  1. 现在在 ~/project 目录下创建一个名为 PackageDemo.java 的文件：
import com.example.util.StringUtils;

public class PackageDemo {
    public static void main(String[] args) {
        String original = "Hello, Java!";
        String reversed = StringUtils.reverse(original);

        System.out.println("Original: " + original);
        System.out.println("Reversed: " + reversed);
    }
}
  1. 从项目目录编译这两个文件：
cd ~/project
javac com/example/util/StringUtils.java
javac PackageDemo.java
  1. 运行 PackageDemo 类：
java PackageDemo

你应该看到输出：

Original: Hello, Java!
Reversed: !avaJ ,olleH

解决常见的与包相关的错误

让我们故意创建一些常见的错误，以学习如何解决它们：

错误 1：不正确的包目录结构

  1. 创建一个新目录和一个 Java 文件，其包声明与目录结构不匹配：
mkdir -p ~/project/wrong/path
  1. 在 ~/project/wrong/path 目录下创建一个名为 MisplacedClass.java 的文件：
package correct.path;

public class MisplacedClass {
    public static void sayHello() {
        System.out.println("Hello from MisplacedClass!");
    }
}
  1. 尝试编译此文件：
cd ~/project
javac wrong/path/MisplacedClass.java

你将看到一个类似于以下的错误：

wrong/path/MisplacedClass.java:1: error: package correct.path does not exist
package correct.path;
^

此错误发生的原因是包声明 (package correct.path;) 与目录结构 (wrong/path) 不匹配。

错误 2：缺少导入语句

  1. 在 ~/project 目录下创建一个名为 ImportDemo.java 的文件：
// 缺少导入：import com.example.util.StringUtils;

public class ImportDemo {
    public static void main(String[] args) {
        // 这将导致一个错误，因为没有导入 StringUtils
        String reversed = StringUtils.reverse("Test");
        System.out.println(reversed);
    }
}
  1. 尝试编译此文件：
javac ImportDemo.java

你将看到一个类似于以下的错误：

ImportDemo.java:5: error: cannot find symbol
        String reversed = StringUtils.reverse("Test");
                          ^
  symbol:   variable StringUtils
  location: class ImportDemo

此错误发生的原因是我们没有导入 StringUtils 类。要修复它，请添加导入语句：

import com.example.util.StringUtils;

正确理解 Java 的包系统和类路径是避免和修复 'class not found' 错误的基础。始终确保你的包声明与你的目录结构匹配，并且所有必要的类都已正确导入。

使用外部 JAR 文件和设置类路径

许多 Java 应用程序依赖于作为 JAR (Java ARchive) 文件分发的外部库。如果这些 JAR 文件没有正确地包含在你的类路径中，那么当你尝试使用来自这些库的类时，你将遇到 'class not found' 错误。

创建自定义 JAR 文件

让我们创建一个简单的 JAR 文件来理解外部库的工作方式：

  1. 首先，编译我们之前创建的 StringUtils 类：
cd ~/project
javac com/example/util/StringUtils.java
  1. 创建一个包含此类的 JAR 文件：
jar cf utils.jar com/example/util/StringUtils.class
  1. 验证 JAR 文件是否已创建：
ls -l utils.jar

你应该看到类似于以下的输出：

-rw-r--r-- 1 labex labex 1234 Jan 1 12:34 utils.jar
  1. 现在，让我们创建一个将使用此 JAR 文件的新程序。在 ~/project 目录下创建一个名为 JarDemo.java 的文件：
public class JarDemo {
    public static void main(String[] args) {
        try {
            // 尝试使用我们 JAR 文件中的一个类
            Class<?> clazz = Class.forName("com.example.util.StringUtils");
            System.out.println("Successfully loaded: " + clazz.getName());
        } catch (ClassNotFoundException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}
  1. 编译此程序：
javac JarDemo.java
  1. 在没有指定类路径的情况下运行该程序：
java JarDemo

你应该看到输出：

Error: com.example.util.StringUtils

这是一个 'class not found' 错误，因为 JVM 找不到 StringUtils 类。该类在我们的 JAR 文件中，但我们还没有告诉 JVM 在哪里查找它。

设置类路径

要修复此错误，我们需要在类路径中包含我们的 JAR 文件：

  1. 使用 -classpath 选项运行该程序：
java -classpath .:utils.jar JarDemo

你现在应该看到输出：

Successfully loaded: com.example.util.StringUtils

让我们分解一下类路径语法：

  • . 表示当前目录（用于查找 JarDemo.class）
  • : 是 Linux/Mac 上不同类路径条目的分隔符（在 Windows 上使用 ;）
  • utils.jar 是我们的 JAR 文件

使用外部库

让我们尝试使用来自公共 Maven 存储库的外部库：

  1. 下载一个简单、轻量级的 JSON 库：
cd ~/project
wget https://repo1.maven.org/maven2/org/json/json/20230618/json-20230618.jar
  1. 创建一个使用此库的程序。创建一个名为 JsonDemo.java 的文件：
import org.json.JSONObject;

public class JsonDemo {
    public static void main(String[] args) {
        // 创建一个 JSON 对象
        JSONObject json = new JSONObject();
        json.put("name", "Java Student");
        json.put("age", 25);
        json.put("city", "Codeville");

        // 打印 JSON 对象
        System.out.println(json.toString(2));
    }
}
  1. 使用类路径中的 JSON 库编译此程序：
javac -classpath .:json-20230618.jar JsonDemo.java
  1. 使用类路径中的 JSON 库运行该程序：
java -classpath .:json-20230618.jar JsonDemo

你应该看到类似于以下的输出：

{
  "name": "Java Student",
  "age": 25,
  "city": "Codeville"
}

设置 CLASSPATH 环境变量

除了使用每个命令指定类路径之外，你还可以设置 CLASSPATH 环境变量：

export CLASSPATH=.:utils.jar:json-20230618.jar

现在你可以运行程序，而无需指定类路径：

java JsonDemo

这应该产生与之前相同的输出。

请记住，在使用 CLASSPATH 环境变量时：

  • 它会影响在当前 shell 会话中运行的所有 Java 程序
  • 如果你在命令行上指定 -classpath，它将被覆盖
  • 当你关闭终端时，设置会丢失（除非添加到启动脚本中）

了解如何正确使用外部库和设置你的类路径对于避免实际 Java 应用程序中的 'class not found' 错误至关重要。

常见的 'Class Not Found' 场景和解决方案

现在你已经了解了 Java 类路径和包系统的基础知识，让我们探讨一些导致 'class not found' 错误的常见场景以及如何解决它们。

场景 1：类名拼写错误

'class not found' 错误最常见的原因之一是简单地拼错了类名。让我们演示一下：

  1. 在 ~/project 目录下创建一个名为 TypoDemo.java 的文件：
import java.util.Scanner;  // 正确的导入
// import java.util.scanner;  // 错误的导入（小写 's'）

public class TypoDemo {
    public static void main(String[] args) {
        // Scanner scanner = new scanner(System.in);  // 错误（小写 's'）
        Scanner scanner = new Scanner(System.in);  // 正确

        System.out.print("Enter your name: ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");

        scanner.close();
    }
}
  1. 编译并运行此程序：
javac TypoDemo.java
java TypoDemo
  1. 当提示时，输入你的名字并按 Enter 键。你应该看到一个问候语。

如果你取消注释错误的导入并注释掉正确的导入，你将得到一个编译时错误。请记住，Java 区分大小写，因此 Scanner 和 scanner 是不同的类。

场景 2：忘记编译依赖类

另一个常见的情况是，在进行更改后，你忘记重新编译依赖类：

  1. 更新我们之前创建的 Helper.java 文件：
public class Helper {
    public void doSomething() {
        System.out.println("Helper is doing something useful!");
    }

    // 添加一个新方法
    public void doSomethingElse() {
        System.out.println("Helper is doing something else!");
    }
}
  1. 创建一个名为 DependencyDemo.java 的新文件：
public class DependencyDemo {
    public static void main(String[] args) {
        Helper helper = new Helper();
        helper.doSomething();
        helper.doSomethingElse();
    }
}
  1. 编译并运行这些文件：
javac Helper.java
javac DependencyDemo.java
java DependencyDemo

你应该看到来自 Helper 类的两条消息。

  1. 现在，让我们看看在更改后不重新编译会发生什么。再次更新 Helper.java：
public class Helper {
    public void doSomething() {
        System.out.println("Helper is doing something useful!");
    }

    public void doSomethingElse() {
        System.out.println("Helper is doing something else!");
    }

    // 添加另一个新方法
    public void doAnotherThing() {
        System.out.println("Helper is doing another thing!");
    }
}
  1. 更新 DependencyDemo.java，而不重新编译 Helper.java：
public class DependencyDemo {
    public static void main(String[] args) {
        Helper helper = new Helper();
        helper.doSomething();
        helper.doSomethingElse();
        helper.doAnotherThing();  // 这将导致一个错误
    }
}
  1. 尝试编译并运行：
javac DependencyDemo.java
java DependencyDemo

你将得到一个编译时错误，提示 doAnotherThing() 方法不存在，即使我们将其添加到了 Helper 类中。这是因为我们在进行更改后没有重新编译 Helper.java。

  1. 要修复此问题，请重新编译这两个文件：
javac Helper.java
javac DependencyDemo.java
java DependencyDemo

现在一切都应该正常工作了。

场景 3：缺少 JDBC 驱动程序

在实际应用程序中，一个常见的 'class not found' 错误涉及数据库连接。在使用 JDBC (Java Database Connectivity) 时，你需要为你的数据库提供适当的驱动程序。让我们模拟一下：

  1. 创建一个名为 JdbcDemo.java 的文件：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JdbcDemo {
    public static void main(String[] args) {
        try {
            // 这将导致 ClassNotFoundException
            Class.forName("com.mysql.jdbc.Driver");

            // 在此示例中，我们实际上不会连接到数据库
            System.out.println("Driver loaded successfully!");

            // 在实际应用程序中，你将像这样连接：
            // Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "username", "password");

        } catch (ClassNotFoundException e) {
            System.out.println("Error: JDBC Driver not found - " + e.getMessage());
            System.out.println("Solution: Add the MySQL JDBC driver to your classpath");
        }
    }
}
  1. 编译并运行此程序：
javac JdbcDemo.java
java JdbcDemo

你应该看到一条错误消息：

Error: JDBC Driver not found - com.mysql.jdbc.Driver
Solution: Add the MySQL JDBC driver to your classpath

在实际应用程序中，你需要下载适当的 JDBC 驱动程序 JAR 文件并将其添加到你的类路径中。

解决方案摘要

以下是解决 'class not found' 错误的快速参考指南：

  1. 检查拼写和大小写：Java 区分大小写。
  2. 验证包结构：确保你的包与你的目录结构匹配。
  3. 重新编译依赖类：对类进行更改后，重新编译它以及所有依赖类。
  4. 正确设置类路径：包含所有必要的目录和 JAR 文件。
  5. 使用 IDE：像 IntelliJ IDEA 或 Eclipse 这样的现代 IDE 会自动执行许多此类任务。
  6. 使用构建工具：Maven 或 Gradle 可以为你管理依赖项。

通过理解这些常见场景及其解决方案，你将能够很好地诊断和修复 Java 应用程序中的 'class not found' 错误。

总结

在这个实验中，你已经学习了如何在 Java 中诊断和解决常见的 'class not found' 错误。你现在了解：

  • Java 类路径的工作原理以及为什么它很重要
  • Java 包结构与目录结构的关系
  • 'class not found' 错误的常见原因，包括：
    • 类名中的拼写错误
    • 缺少导入语句
    • 不正确的包声明
    • 忘记重新编译依赖类
    • 类路径中缺少 JAR 文件

你还学习了这些问题的实用解决方案：

  • 使用 -classpath 选项设置类路径
  • 使用 CLASSPATH 环境变量
  • 使用 JAR 文件和外部库
  • 正确组织 Java 包

掌握了这些知识，你现在可以自信地排除故障并解决 Java 应用程序中的 'class not found' 错误，从而在开发过程中节省时间并减少挫败感。

请记住，实践是成为熟练的 Java 开发人员的关键。尝试创建更复杂的项目，并故意引入不同类型的错误，以提高你的调试技能。

相关 Java 课程
Java 入门

Java 入门

java
Java 编程练习

Java 编程练习

java
批量插入数据到课程表

批量插入数据到课程表

java