Skip to content

2. 搭建开发环境

Java 开发人员的工作环境由三个相互独立的组成部分构成:

  • JDK (“Java Development Kit”):[javac]编译器、虚拟机和运行程序的 [java]命令、Java SE 标准库,以及 [jshell] 或 [jar]等工具;
  • 项目构建工具,这里是 Maven:它下载项目所需的库、编译项目、运行测试并打包;
  • 编辑器 或 IDE (集成开发环境):[IntelliJ IDEA]、[VS Code] 配合 Java 扩展,或 [Eclipse]。IDE 以 JDK 为基础,并且可以读取 Maven 项目。

本文档所有操作都使用 [java]、[javac]和 [mvn] 命令:无论你选择哪种编辑器,它们在 Windows、Linux 和 macOS 上的工作方式都相同。

2.1. JDK 25

2.1.1. 安装

JDK 有多个发行版,它们都构建自 OpenJDK 源代码,就我们的目的而言是等价的。我们推荐 Eclipse Temurin,这是 Eclipse 基金会提供的免费开源发行版,可从 https://adoptium.net下载:在那里选择版本 25—LTS,再选择操作系统和包类型(在 Windows 上是 [.msi]安装程序)。在 Windows 上,你也可以在终端(PowerShell 或命令提示符)中使用 [winget]包管理器安装:

winget install EclipseAdoptium.Temurin.25.JDK

必须选择 JDK (它包含全部内容),而不是只选 JRE(它只能运行已经编译好的程序)。在 Windows 上安装时,请勾选将 JDK 添加到 [PATH] 并设置 [JAVA_HOME]环境变量的选项:Maven 和各种 IDE 会用它来定位 JDK。在 Linux 上,主流发行版的软件仓库中都提供 JDK(例如在 Ubuntu 上使用 [sudo apt install openjdk-25-jdk] )。

安装完成后,打开一个新的 终端,验证 [java] 和 [javac] 命令是否可用,并显示 JDK 的版本:

1
2
3
4
5
6
> java --version
openjdk 25.0.4.1 2026-08-18
OpenJDK Runtime Environment (build 25.0.4.1+1-1-24.04.4-Ubuntu)
OpenJDK 64-Bit Server VM (build 25.0.4.1+1-1-24.04.4-Ubuntu, mixed mode, sharing)
> javac --version
javac 25.0.4.1

这些结果是使用 Ubuntu 的 JDK 包得到的。使用 Temurin 时,第 2 行和第 3 行会列出 [Temurin-25],具体版本取决于安装日期:补丁更新每季度发布一次。所有 25.0.x 版本的 JDK 都适用于本文档。同一系统上可以并存多个 JDK:[PATH] 中最先找到的那个响应 [java]命令。

2.1.2. JDK 的命令

JDK 提供了大量命令。下面是我们将要使用的几个:

命令
作用
[java File.java]
在内存中编译并执行用源文件编写的程序(Java 11;从 Java 22 起支持多个文件)
[javac -d classes File.java]
编译一个或多个源文件,并将生成的 [.class]文件放入 [classes]文件夹
[java -cp classes ClassName]
执行已编译类的 [main]方法,该类在类路径([-cp])中查找
[java -cp "lib/*" File.java]
执行使用 [lib]文件夹中库([.jar]文件)的源文件
[jshell]
交互式解释器:你输入 Java 语句,立即看到结果
[jar]
创建或读取 [.jar]归档文件(包含已编译类的 ZIP 文件)

[jshell]解释器(Java 9)可用于在不编写程序的情况下测试某个方法或表达式:

> jshell
|  Welcome to JShell -- Version 25.0.4.1
|  For an introduction type: /help intro

jshell> 1 + 2
$1 ==> 3

jshell> var s = "Java " + 25
s ==> "Java 25"

jshell> s.length()
$3 ==> 7

jshell> /exit
|  Goodbye

2.2. Maven

2.2.1. 安装

真正的 Java 应用程序会使用不属于 JDK 的库 :数据库驱动程序、测试框架、Hibernate、Spring……它们以 [.jar]归档文件的形式通过公共仓库 Maven Central (https://central.sonatype.com)发布。像 Maven 这样的构建工具读取项目的 [pom.xml]文件,确定它需要哪些库,下载它们(连同它们所依赖的库),然后编译、测试并打包项目。另一个广泛使用的工具 Gradle具有相同的功能;本文档使用 Maven。

Maven 可从 https://maven.apache.org/download.cgi下载,为 ZIP 归档文件([apache-maven-3.9.x-bin.zip])。将其解压到某个文件夹中,例如 [C:\Program Files\apache-maven-3.9.11],并将其子文件夹 [bin] 添加到 [PATH] (Windows:“编辑系统环境变量”)。在 Linux 上,Maven 可从发行版仓库获得([sudo apt install maven])。在新终端中验证安装:

1
2
3
4
5
6
> mvn -v
Apache Maven 3.9.11 (3e54c93a704957b63ee3494413a2b544fd3d825b)
Maven home: /opt/maven
Java version: 25.0.4.1, vendor: Ubuntu, runtime: /usr/lib/jvm/java-25-openjdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "6.18.44-fc-v64", arch: "amd64", family: "unix"

第 4 行很重要:它显示 Maven 所使用的 JDK,该 JDK 由变量 [JAVA_HOME]指定。它必须是 JDK 25。IDE(IntelliJ IDEA 和 VS Code)的包自带 Maven:如果你不在命令行中使用 Maven,它们就已足够。

Maven 下载的库存储在本地机器的本地仓库 [%USERPROFILE%\.m2\repository] (Linux、macOS:[~/.m2/repository])中。它们只下载一次,之后供所有项目使用。因此,第一次构建项目时需要连接互联网。

2.2.2. Maven 命令

命令 [mvn] 后面跟一个或多个构建周期的 阶段 ,或某个插件的 目标;它在包含 [pom.xml]文件的文件夹中输入:

命令
作用
[mvn compile]
编译 [src/main/java]的源代码;类被组织在 [target/classes] 中
[mvn test]
编译并运行 [src/test/java] 的单元测试(第 6 章)
[mvn package]
编译、测试并创建项目归档文件 [.jar] 于 [target] 中
[mvn install]
同 [package],然后将归档文件复制到本地仓库,供其他项目使用(第 6 章)
[mvn clean]
删除 [target] 文件夹
[mvn compile exec:java]
编译并运行项目的主类([exec-maven-plugin]插件)
[mvn spring-boot:run]
运行 Spring Boot 应用程序(第 13 章)

各阶段是顺序执行的:运行 [package] 也会触发 [compile] 和 [test]。[-q] (“quiet”)选项会抑制 Maven 的消息,只显示所执行程序的消息;[-Dexec.args="a b"]选项向由 [exec:java]启动的程序传递参数。

2.3. 编辑器

2.3.1. IntelliJ IDEA

IntelliJ IDEA由 JetBrains 公司出品,是使用最广泛的 Java 编辑器。它的基本功能对本文档来说绰绰有余,并且是免费的。它支持 Maven 项目:选择“File / Open”,然后选择包含 [pom.xml]文件的文件夹;IntelliJ 会下载库、编译项目,并允许你点击其 [main]方法旁边边栏中的绿色三角形来运行类([Ctrl-Shift-F10]),或点击测试方法旁边的同一个三角形来运行测试。在“File / Project Structure / SDK”中指定要使用的 JDK。

你可以一次性打开整个 [java-oct-2026] 示例文件夹(“File / Open”):IntelliJ 会检测到其中所有的 Maven 项目,并在其“Maven”面板中显示。此时需要注意一点。第 10 至 13 章的项目([Tax] 应用程序的版本 6 至 9)使用来自第 6 章所编写的版本 5 的 [tax-dao], [tax-business], and [tax-ui] 模块。这些不是公共库:只有它们已安装到本地仓库中,Maven 才能找到它们。因此,必须先安装版本 5:在“Maven”面板中,展开 [tax-v5] / “Lifecycle”,双击 [install] (或在 [mvn install] 所在的 [06-architectures/TaxV5]文件夹中输入),然后点击面板中的“Sync All Maven Projects”按钮。第 6 章解释了该命令的作用,以及如果 IntelliJ 仍报告无法解析的依赖项该怎么办。

2.3.2. VS Code

VS Code是一款免费的跨平台编辑器。要用 Java 编程,可以安装 Microsoft 的 Extension Pack for Java (进入“Extensions”菜单,搜索“Extension Pack for Java”),它包含语言支持、调试器、测试执行和 Maven 支持。它提供:

  • 语法高亮、代码补全和悬停提示;
  • 输入时即时检测错误;
  • 代码导航(F12:转到定义);
  • 执行和调试(每个 [main] 方法上方的“Run”和“Debug”链接,或 F5);
  • 运行单元测试(“Testing”视图)以及项目的“Maven”视图。

在 VS Code 中,打开包含程序的文件夹 (“File / Open Folder”),例如包含本文档示例的 [java-oct-2026]文件夹。内置终端(“Terminal / New Terminal”)让你无需离开编辑器就能输入 [java] 和 [mvn] 命令。

2.3.3. Eclipse

第三种选择是开源的 Eclipse IDE(https://eclipseide.org),它在历史上是第一个主要的 Java IDE,同样可以导入 Maven 项目(“File / Import / Maven / Existing Maven Projects”)。

在本文档的其余部分,操作都使用 [java]、[javac]和 [mvn]命令来描述,无论使用哪种编辑器,它们产生的结果都相同。

2.4. 第一个程序:紧凑源文件

2.4.1. 程序

从 Java 25 开始,Java 程序可以是一个只包含单个 [main]方法的简单文件,无需类声明。这称为“紧凑源文件”。我们来创建下面的文件 [Hello.java]:

1
2
3
4
// 第一个 Java 程序:精简源文件
void main() {
    IO.println("1st try with Java 25");
}

并运行它:

> java Hello.java
1st try with Java 25

说明:

  • 第 1 行:注释。[//] 之后直到行尾的所有内容都会被编译器忽略;
  • 第 2 行:[main]方法,即程序的入口点。在紧凑源文件中,它不需要声明在类中,也不必是 [public] 和 [static],也不必接收程序的参数;我们将在第 3 章看到,编译器会自行把它包装进一个类中;
  • 第 3 行:程序唯一的语句:它在屏幕上输出一行文本。[IO] 类(Java 25)提供了简单的方法,用于向屏幕写入([print]、[println])以及从键盘读取([readln]);
  • 命令 [java Hello.java] 在内存中编译程序——不创建 [.class]文件——然后执行它。这种直接运行源文件的能力是在 Java 11 中引入的。

文件名必须是有效的 Java 标识符:[Hello.java] 或 [Basics01.java] 是可以接受的,但 [basics-01.java] 会被编译器拒绝([bad file name]),因为文件名会成为所生成类的名称。按照惯例,类名——因此也包括文件名——以大写字母开头。

你也可以用 [javac]编译程序,它会生成一个 [.class]文件,然后运行这个已编译的文件:

1
2
3
4
5
> javac -d classes Hello.java
> dir classes (list of files)
Hello.class
> java -cp classes Hello
1st try with Java 25

文件 [Hello.class] 包含编译器生成的 [Hello]类的字节码。命令 [java -cp classes Hello] 指示虚拟机执行位于 [classes]文件夹中的类 [Hello]的 [main]方法。

紧凑源文件适合小型程序,我们的大部分示例都会使用它们。当程序需要外部库时,如果你已把该库(以及它所依赖的库)的 [java -cp "lib/*" Program.java] [.jar]归档文件复制到 [lib]文件夹中,仍然可以用该命令启动它。但手工收集这些归档文件很快就会变得繁琐,所以我们将编写 Maven 项目。

在 Windows 上,由 [IO.println] 或 [System.out.println] 写出的带重音字符能在终端中正确显示:Java 会把文本转换为终端的编码。源文件必须保存为 UTF-8,这是 VS Code 和 IntelliJ IDEA 的默认编码,也是自 Java 18 起编译器所假定的编码。

2.5. Maven 项目

2.5.1. 项目结构

Maven 项目 是一个文件夹,其中包含一个 [pom.xml]文件(“Project Object Model”)以及按标准目录结构组织的源文件。[02-installation]文件夹中的 [FirstProgram]项目如下:

1
2
3
4
5
6
7
FirstProgram/
├── pom.xml
└── src/
    └── main/
        └── java/
            └── first/
                └── Main.java
  • [src/main/java] 包含程序的源文件;[src/main/resources] 包含要与已编译类放在一起的数据或配置文件;[src/test/java] 包含测试(第 6 章);
  • 在 [src/main/java]下,文件夹结构与包 (第 4 章)的结构一一对应:类 [first.Main] 位于文件夹 [first]中。

你可以手动创建此目录结构,也可以让 IDE 来创建(IntelliJ:“File / New / Project”,选择“Maven”作为构建系统)。[pom.xml]文件如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- 项目坐标 -->
    <groupId>examples.installation</groupId>
    <artifactId>first-program</artifactId>
    <version>1.0</version>

    <properties>
        <!-- 目标 Java 版本和源文件编码 -->
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <!-- 编译器,显示所有警告 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn exec:java 运行主类 -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>first.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • 第 8–10 行:项目的坐标,用于唯一标识项目:组([groupId],通常是反向域名,例如 [org.hibernate])、项目名称([artifactId])及其版本。如有需要,其他项目也会用这些标识符来引用本项目,这与引用 Maven Central 中的库的方式类似(第 6 章);
  • 第 14 行:代码按 Java 25 编译;
  • 第 15 行:源文件以 UTF-8 编写;
  • 第 21–30 行:编译插件,带有选项 [-Xlint:all],用于启用编译器的所有警告;
  • 第 32–39 行:[exec-maven-plugin]插件,它允许使用 [mvn exec:java]命令执行项目的主类(在第 37 行指定)。

这个项目不使用任何库。使用库的项目会用库的坐标在 [<dependencies>]部分中声明它,就像我们从第 5 章开始所做的那样:

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>tools.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>3.1.5</version>
    </dependency>
</dependencies>

文件 [Main.java] 以标准形式包含程序,带有一个 [public] 类和一个 [public static void main(String[] args)]方法:

1
2
3
4
5
6
7
8
9
package first;

// [FirstProgram] 项目的主程序
public class Main {

    public static void main(String[] args) {
        System.out.println("1st try with a Maven project / Java 25");
    }
}
  • 第 1 行:该类属于包 [first];其全名是 [first.Main];
  • 第 4–9 行:类 [Main]。一个源文件至多包含一个公共类,该类以文件名命名;
  • 第 6–8 行:[main]方法,采用自 Java 第一个版本以来一直沿用的形式。我们将在第 3 章比较这两种形式。

2.5.2. 编译和执行

在项目文件夹中输入命令 [mvn compile]即可编译项目:Maven 会按需下载所需的插件,然后编译 [src/main/java]文件,并把生成的类放在 [target/classes]文件夹中,同时保留包的层次结构([target/classes/first/Main.class])。[mvn compile exec:java]命令先编译项目然后运行它;使用 [-q]选项时,只显示程序的输出:

> mvn -q compile exec:java
1st try with a Maven project / Java 25

项目编译完成后,你也可以用 [java]命令直接运行该类,并指定类所在的位置:

> java -cp target/classes first.Main
1st try with a Maven project / Java 25

可以放心地删除 [target]文件夹([mvn clean]):下次编译时会重新创建它。命令 [mvn package] 还会生成归档文件 [target/first-program-1.0.jar],可以用 [java -cp target/first-program-1.0.jar first.Main]执行它:这就是交付 Java 程序的格式。

2.6. 多模块项目

2.6.1. 聚合项目

一个 Maven 项目可以把其他几个项目聚合在一起,这些项目称为它的模块。[02-installation]文件夹包含一个名为 [pom.xml] 的文件,把它的两个项目聚合在一起:

<?xml version="1.0" encoding="UTF-8"?>
<!-- “聚合”项目:将文件夹中的各项目归在一起一并构建 -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.installation</groupId>
    <artifactId>installation</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>FirstProgram</module>
        <module>TwoHands</module>
    </modules>
</project>
  • 第 11 行:这个项目不生成 [.jar]归档文件:它只用于聚合其他项目([pom]);
  • 第 13–16 行:各个模块,由它们的文件夹名称标识。

在 [02-installation]文件夹中,[mvn compile]命令会编译这两个项目;在 IDE 中打开这个文件夹,可以同时看到这两个项目。在第 6 章中我们将看到,父项目还可以把公共配置(库版本、编译器选项)传递给它的模块。

2.6.2. 包含多个 main 方法的项目

一个项目可以包含多个类,每个类都有一个 [main] 方法:每个方法都是一个可能的入口点,要执行哪个类在运行时选择。项目 [TwoHands] 包含两个类。[P1] 类:

1
2
3
4
5
6
7
8
package twohands;

public class P1 {

    public static void main(String[] args) {
        System.out.println("main of the class P1");
    }
}

以及类 [P2],它除了名称之外与前者完全相同。[java] 命令执行指定的类:

1
2
3
4
> java -cp target/classes twohands.P1
main of the class P1
> java -cp target/classes twohands.P2
main of the class P2

对于命令 [mvn exec:java],项目文件 [pom.xml] 指定要执行的类:

1
2
3
4
5
6
7
8
9
            <!-- 其 main 方法由 mvn exec:java 运行的类 -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>twohands.P2</mainClass>
                </configuration>
            </plugin>
  • 第 7 行:被执行的 [main] 方法属于类 [twohands.P2] (完整的类名,包含包名)。

结果:

> mvn -q compile exec:java
main of the class P2

你可以在不修改 [pom.xml]文件的情况下选择另一个类:[mvn -q exec:java -Dexec.mainClass=twohands.P1]。

2.7. 文档中的示例

要运行本文档中的示例:

  • 下载 [java-oct-2026]文件夹(链接在文档开头);
  • 在 VS Code 中打开它(“File / Open Folder”),或者对于某个具体的 Maven 项目,在 IntelliJ IDEA 中打开它的文件夹;
  • 在位于某一章文件夹中的终端里,使用 [java Name.java]运行紧凑源文件,或在项目文件夹中使用 [mvn -q compile exec:java] 运行 Maven 项目(每章正文都会给出确切的命令)。

第 10 章和第 11 章使用名为 MySQL 的数据库;附录中介绍了如何随 [Laragon] 一起安装 MySQL。