IntelliJ IDEA、工程结构与第一个 Java 程序

一、学习目标

完成本章后，你应该能够：

能够解释 IDE 与 IntelliJ IDEA 分别是什么，以及 IDE 相比纯命令行开发解决了哪些问题。
能够正确区分 Project、Module、Source Root、Package、Class 等工程结构概念。
能够在 IntelliJ IDEA 中指定 JDK 21 并创建一个 Java 项目。
能够创建 package 与 Java class，并理解它们在文件系统中的对应关系。
能够手写标准 main 方法，并解释为什么它可以作为经典 Java 应用程序入口。
能够使用 IDEA 编译、运行第一个 Java 程序，并找到编译后的 .class 文件。
能够解释“IDEA 点击 Run”背后仍然存在编译与 JVM 执行过程。
能够使用基础代码提示、格式化、重构和 Debug 能力辅助开发，而不依赖 IDE 替代基础知识。

二、核心知识

2.1 为什么有了命令行还需要 IDE

上一章我们已经可以这样开发：

文本编辑器写代码
↓
javac 编译
↓
java 运行

这套方式非常重要，因为它能帮助我们理解 Java 最真实的基础流程。

但是如果一个项目有：

10 个类
100 个类
1000 个类
10000 个类

开发者还需要处理：

文件管理；
包结构；
依赖；
编译；
错误检查；
查找类；
查找方法；
重命名；
Debug；
Git；
测试；
构建。

如果全部依赖：

记事本 + 命令行

效率会非常低。

于是出现了：

IDE（Integrated Development Environment）

中文：

集成开发环境。

2.2 什么是 IDE

IDE 不只是“高级文本编辑器”。

它通常把多个开发能力集成到一个环境中。

例如：

代码编辑
+
语法检查
+
代码补全
+
项目管理
+
编译
+
运行
+
Debug
+
重构
+
版本控制
+
测试

因此可以把 IDE 理解为：

把软件开发过程中大量常用工具整合到一起的开发工作台。

2.3 什么是 IntelliJ IDEA

IntelliJ IDEA 是 JetBrains 开发的集成开发环境。

它对 Java 开发提供非常完整的支持，例如：

Java 代码编辑；
语法高亮；
智能代码补全；
自动导包；
代码检查；
重构；
Debug；
JUnit；
Maven；
Gradle；
Git；
数据库工具；
Java 框架支持。

所以在 Java 开发中，通常简称：

IDEA

2.4 IDE 和 JDK 是什么关系

这是初学者非常容易混淆的问题。

IDEA：

开发工具界面和工程环境。

JDK：

真正提供 Java 编译、运行、标准 API 等能力。

所以 IDEA 并不能凭空执行 Java。

一个 Java 项目仍然需要知道：

使用哪个 JDK？

例如：

JDK 21

IDEA 会把这个 JDK 作为：

SDK（Software Development Kit）

配置到项目或模块。

因此：

IntelliJ IDEA
      │
      │ 使用
      ▼
    JDK 21
      │
      ├── javac
      ├── JVM
      └── Java API

2.5 Project 是什么

在 IntelliJ IDEA 中：

Project

可以理解为：

一个完整的开发工作区。

一个 Project 可以包含：

源代码；
测试代码；
配置；
Library；
Module；
Build 配置；
IDE 配置。

例如：

StudentSystem

可以是一个 Project。

后面你做：

星雨笔录

这样的真实系统时，也会以完整项目的方式组织大量代码和配置。

2.6 Module 是什么

Module：

模块

可以理解为 Project 中一个相对独立的开发单元。

例如：

MallProject
│
├── user
├── order
└── payment

在一些大型工程中，不同部分可以被拆成多个 module。

每个 Module 可以具有自己的：

源代码；
测试；
依赖；
SDK；
编译配置。

因此原课程使用：

Project
→ Module
→ Package
→ Class

帮助理解 IDEA 工程层次是有价值的。

但是不要把它误解为：

每写一个 HelloWorld，都必须手工先创建很多 Module。

现代 IDEA 创建一个普通 Java Project 时，本身就可以直接生成相应项目结构。

是否需要额外增加多个 Module，要看项目复杂度。

2.7 IDEA Module 和 Java Module 是一回事吗

不是。

这是一个非常重要的术语区别。

IDEA Module

是：

IntelliJ IDEA 的工程组织概念。

而 Java 9 开始的：

Java Platform Module System

则是 Java 语言和平台层面的模块系统，例如：

module-info.java

二者虽然都叫：

Module

但不是同一个概念。

当前章节说：

Project → Module

主要指：

IDEA Project Module。

Java 模块系统不在这里展开。

2.8 什么是 Source Root

Java 类一般不会随意散落在工程任意目录。

IDEA 会把某些目录标记为：

Sources Root

也就是：

源代码根目录。

简单 Java Project 中经常看到：

src

例如：

HelloJava
└── src

src 里面放：

package；
class；
Java 源代码。

IDEA 会知道：

这个目录中的 Java 文件需要作为生产源代码参与编译。

2.9 Package 是什么

Package：

包

用于组织 Java 类型。

可以理解为：

给大量 Java 类建立命名空间和逻辑分类。

例如：

com.xingyu.user
com.xingyu.order
com.xingyu.common

相比：

User.java
Order.java
StringUtils.java

全部堆在一个目录中，使用 package 后结构更加清晰。

例如：

package com.xingyu.hello;

表示当前类属于：

com.xingyu.hello

这个包。

2.10 Package 和文件夹有什么关系

在典型 Java 工程中：

package com.xingyu.hello;

一般对应源代码目录：

src
└── com
    └── xingyu
        └── hello
            └── HelloWorld.java

因此：

在包名中表示层级。

例如：

com.xingyu.hello

大致对应：

com/xingyu/hello

但是：

Package 首先是 Java 的命名空间概念，不应该只把它理解成“文件夹换了个名字”。

2.11 Class 是什么

Class：

类

是 Java 面向对象编程中的核心结构。

当前阶段还没有正式学习面向对象，因此只需要建立最初认识。

例如：

public class HelloWorld {
}

这里定义了：

HelloWorld

这个类。

以后一个项目中会出现大量类，例如：

User
Order
Product
Student
Teacher
FileUtils
DateUtils

真正的类与对象知识将在：

GROUP 02 · Java面向对象

系统学习。

2.12 Project、Module、Package、Class 的关系

可以先建立：

Project
│
├── Module A
│   │
│   └── src
│       │
│       ├── package A
│       │   ├── Class1
│       │   └── Class2
│       │
│       └── package B
│           └── Class3
│
└── Module B

但是再次强调：

这是工程组织模型，不意味着所有简单项目一定要人为创建多个 Module。

2.13 第一个标准 Java 程序

本教程统一采用经典完整类形式：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

先不用急着理解全部关键字。

当前只需要知道：

public class HelloWorld

声明一个：

HelloWorld

类。

2.14 什么是 main 方法

经典 Java 应用程序通常使用：

public static void main(String[] args)

作为程序入口。

可以暂时理解为：

JVM 启动这个类时，从这个方法开始执行程序代码。

完整结构：

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello World!");

    }
}

下一阶段会分别学习：

public
static
void
方法；
参数；
String[]

当前不要为了一个 HelloWorld 提前把后面十几章全部塞进来。

2.15 `System.out.println()` 是什么

例如：

System.out.println("Hello World!");

作用：

向控制台输出一行内容，并在结束后换行。

运行以后：

Hello World!

当前只要求会使用。

System、对象、方法调用等概念会在后续知识建立以后逐步理解。

三、使用方法

3.1 创建 Java Project

启动 IntelliJ IDEA。

选择：

New Project

选择 Java 项目。

项目名称例如：

JavaSEStudy

选择或配置：

JDK 21

如果 IDEA 已经识别本机 JDK 21：

直接选择。

如果没有：

Add JDK

然后选择：

JDK 21 安装目录

例如：

D:\develop\java\jdk-21

3.2 为什么 IDEA 还要单独选择 JDK

即使：

java -version

显示 21，IDEA Project 仍然可能配置其他版本。

因为：

系统默认 Java

与：

IDEA Project SDK

是两个不同配置层次。

所以一个成熟的开发者要知道：

当前项目到底使用哪个 JDK。

3.3 创建包

找到：

src

右键：

New
→ Package

输入：

com.xingyu.hello

IDEA 会创建对应 package。

3.4 创建 Java Class

选中：

com.xingyu.hello

右键：

New
→ Java Class

名称：

HelloWorld

IDEA 会生成：

package com.xingyu.hello;

public class HelloWorld {
}

3.5 手写 main 方法

在类中写：

public static void main(String[] args) {

}

最终：

package com.xingyu.hello;

public class HelloWorld {

    public static void main(String[] args) {

    }
}

3.6 输出 Hello World

继续：

package com.xingyu.hello;

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

3.7 运行程序

在：

main

附近通常可以看到绿色运行按钮。

点击：

Run 'HelloWorld.main()'

或者右键运行。

IDEA 会：

检查 / 构建代码
↓
编译 Java 源代码
↓
生成 class
↓
启动 JVM
↓
调用 main
↓
显示控制台输出

最终：

Hello World!

3.8 IDEA 并没有消灭编译过程

初学者很容易产生：

“命令行需要 javac，IDEA 直接点 Run，所以 IDEA 不需要编译。”

这是错误的。

IDEA 帮你自动化了：

javac
java

3.9 编译后的 class 在哪里

如果使用 IntelliJ IDEA 自己的基础构建方式，编译结果通常可以在：

out

目录中看到。

例如：

JavaSEStudy
├── src
│   └── com
│       └── xingyu
│           └── hello
│               └── HelloWorld.java
│
└── out
    └── production
        └── JavaSEStudy
            └── com
                └── xingyu
                    └── hello
                        └── HelloWorld.class

具体目录名称可能因：

IDEA 版本；
Project 结构；
Module；
Build System；

而变化。

如果以后使用：

Maven
Gradle

编译输出又可能进入：

target
build

等目录。

所以真正要理解的是：

源码目录与编译产物目录是两个概念。

而不是死记：

“所有 Java class 永远都一定在某个固定 out 路径。”

3.10 IDEA 常用快捷操作

不同：

操作系统；
Keymap；
IDEA 版本；

快捷键可能存在差异。

Windows 默认 Keymap 中常见：

| 操作 | 常见快捷键 | | ----------- | ------------------ | | 格式化代码 | Ctrl + Alt + L | | 复制当前行 | Ctrl + D | | 单行注释 | Ctrl + / | | 块注释 | Ctrl + Shift + / | | 查找 Action | Ctrl + Shift + A | | 运行 | Shift + F10 | | Debug | Shift + F9 |

快捷键不是考试背诵重点。

真正重点是逐渐建立：

使用 IDE 提升效率的习惯。

3.11 IDEA 的代码补全

例如输入：

System.out.

IDEA 可以提示：

println
print
printf
...

代码补全的正确用途是：

降低重复输入和 API 查询成本。

而不是：

我不知道代码为什么这样写，但按 Tab 就完成了。

3.12 IDEA 的代码检查

例如写：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!")
    }
}

少了：

IDEA 会提示错误。

但是 IDE 的红色波浪线只告诉你：

这里有问题。

学习者还必须理解：

为什么 Java 语法要求这里结束语句。

否则只是让 IDE 替你做判断。

3.13 IDEA 的重构

假设以后有一个类：

StudentManager

想改名为：

StudentService

最差的方式是：

到项目中一个文件一个文件搜索并手动修改。

IDEA 提供：

Refactor

能力。

它可以分析代码引用并进行结构化修改。

这也是 IDE 相比普通文本编辑器非常重要的价值之一。

3.14 IDEA 的 Debug

Debug：

调试

允许程序暂时停在某一行。

然后观察：

当前变量值；
程序执行到哪里；
下一步会进入哪个方法；
条件表达式结果；
对象状态。

例如：

public class DebugDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int result = a + b;

        System.out.println(result);
    }
}

可以在：

int result = a + b;

附近设置断点。

然后：

Debug

逐行观察：

a
b
result

如何变化。

Debug 是以后学习：

循环；
数组；
对象；
集合；
多线程；

时非常重要的能力。

四、原理与进阶

4.1 IDE 为什么能够自动补全代码

IDEA 并不是：

“根据几个字符胡乱猜下一行”。

它会分析：

当前项目；
Java 语法；
类；
方法；
字段；
类型；
JDK；
第三方依赖；
项目结构。

因此输入：

String text = "hello";
text.

IDEA 知道：

text 的类型是 String

于是可以提供 String 对应的方法提示。

现代 IDEA 会对整个项目进行分析，建立代码结构索引，从而支持：

跳转；
查找引用；
重构；
补全；
检查。

4.2 IDEA 为什么知道哪些 Java 文件要编译

因为 IDEA 不只是看到：

一个目录

它还维护：

Sources Root
Test Sources Root
Resources
Excluded

等工程信息。

例如：

src

如果被标记为：

Sources Root

IDEA 就知道其中代码属于生产源代码。

这也是：

“普通文件夹”

和：

“IDE 工程中的源代码目录”

之间的重要区别。

4.3 Project 和文件夹有什么区别

一个 IntelliJ IDEA Project 在磁盘上当然也是文件和目录。

但：

Project

不仅表示：

某一个文件夹。

IDEA 还会管理：

SDK；
Module；
Library；
Source Root；
Run Configuration；
编译设置；
IDE 元数据。

所以 Project 是：

文件结构 + 开发配置 + IDE 工程模型。

4.4 Package 为什么重要

假设没有包：

User
User
User

三个不同作者都想定义：

User

就会产生名称冲突。

使用包以后：

com.xingyu.blog.User

com.xingyu.admin.User

com.xingyu.demo.User

它们可以通过：

完全限定名（Fully Qualified Name）

区分。

例如：

com.xingyu.blog.User

所以 package 不只是：

“让目录看起来整齐。”

它还参与 Java 类型的命名空间管理。

4.5 为什么不直接从最新 Java 的简化语法开始

现代 Java 仍然持续增加用于入门和脚本场景的简化形式。

但是本教程使用：

JDK 21

并且后面要系统学习：

类；
方法；
static；
参数；
String；
数组。

所以第一份代码仍采用：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

这样更适合建立完整、稳定的 Java 程序结构模型。

五、实践应用

5.1 为什么真实项目不会把所有类扔进一个 package

假设以后有：

2000 个 Java 类

全部放在：

com.xingyu

很快就会失控。

通常会根据业务或职责组织：

com.xingyu.user
com.xingyu.tutorial
com.xingyu.blog
com.xingyu.search
com.xingyu.common

这样：

类职责更清晰；
名称冲突更少；
查找更加方便；
项目边界更容易维护。

5.2 为什么大型工程存在多个 Module

一个大型系统可能包含：

common
user-service
order-service
payment-service
gateway

不同 module：

可以拥有独立依赖；
可以单独构建；
可以定义依赖关系；
可以降低代码耦合。

当前 JavaSE 阶段不需要马上设计复杂多模块架构。

你只需要先建立：

Project 可以进一步由多个模块组成。

5.3 为什么 IDEA 能运行但项目换电脑就失败

因为 IDEA 自己保存了很多本地环境信息。

例如：

本机 JDK 路径；
本机 Library；
环境变量；
Run Configuration；
插件。

如果项目本身没有正确管理依赖和构建配置，换电脑就可能：

IDEA 红一片

这也是以后为什么需要学习：

Maven
Gradle

等构建工具。

不过这些内容已经超出当前 JavaSE 章节边界，不在这里提前展开。

5.4 IDE 能不能代替 Java 基础

不能。

IDEA 可以：

提示方法；
自动导包；
生成代码；
找错误；
自动重构。

但是如果你不知道：

程序为什么能运行；
类型为什么报错；
class 在哪里；
JVM 做了什么；
方法为什么这样调用；

就会变成：

IDEA 不报红就觉得代码正确。

因此当前阶段最合理的能力结构是：

理解 Java 原理
+
能够命令行运行
+
熟练使用 IDE

而不是三选一。

六、常见问题

6.1 IDEA 是不是 Java 编译器？

不是。

IDEA 是：

IDE。

真正 Java 编译相关能力依然来自：

JDK；
Java 编译器；
IDEA 的构建系统或外部构建工具。

6.2 为什么我安装了 JDK，IDEA 还提示 No SDK？

因为：

JDK 已安装在操作系统中

并不等于：

当前 IDEA Project 已经配置这个 JDK。

需要在 IDEA 中指定：

Project SDK / JDK

6.3 一个 Project 必须手动创建 Module 吗？

不一定。

普通 Java 项目创建时，IDEA 已经可以形成基本工程结构。

多 Module 更适合：

大型项目；
模块化工程；
有明确子系统边界的项目。

原课程的：

Project → Module → Package → Class

应该理解为工程层次关系，而不是死板操作顺序。

6.4 Java package 就是 Windows 文件夹吗？

不完全是。

Package 是：

Java 命名空间和代码组织机制。

在标准项目结构下，package 通常映射到对应目录。

例如：

package com.xingyu.demo;

通常对应：

com/xingyu/demo

但概念层面不能简单把二者完全等同。

6.5 IDEA 点 Run 后为什么看不到 javac 命令？

因为 IDEA 把构建流程封装起来了。

编译没有消失。

IDE 只是：

自动替你组织了编译和运行。

6.6 编译后的 class 一定在 `out` 吗？

不一定。

如果使用 IDEA 原生构建系统，常见：

out

如果使用：

Maven

可能是：

target/classes

如果使用：

Gradle

可能是：

build/classes

因此应该掌握：

编译输出目录取决于构建方式。

6.7 `main` 为什么一定要这样写？

经典 Java 应用程序入口通常写：

public static void main(String[] args)

当前阶段先会写、会识别即可。

后面的章节会逐步解释：

public
static
void
方法
参数
数组

不要为了提前解释 main，一次性透支后续所有知识。

6.8 AI 代码补全开着不好吗？

不是“不能使用”。

真正的问题是：

你是否还能在没有完整自动生成的情况下完成核心代码。

学习阶段可以：

用 AI 解释错误；
用 AI 帮助检查；
用 AI 做 Code Review；
用 AI 生成变式题。

但是核心代码训练时，应该定期关闭自动补全并独立完成。

否则容易产生：

我每天写了很多代码，但其实每一行都是按 Tab 接受的。

6.9 IntelliJ IDEA 最新教程和这里看到的不一样怎么办？

IDE 会持续更新。

Java 语言也会持续发展。

因此：

菜单位置可能变化；
UI 样式可能变化；
新版本可能提供新的 Java 项目模板；
新 Java 版本可能提供更加简化的入门语法。

本教程固定：

JDK 21

所以首先掌握：

Project
JDK
src
package
class
main
Run
class output

这些稳定概念。

界面细节变化时，根据概念找到对应操作即可。

七、练习与验收

7.1 知识问答

IDE 的全称是什么？主要解决什么问题？
IntelliJ IDEA 与 JDK 是什么关系？
什么是 Project？
什么是 IDEA Module？
IDEA Module 与 Java 9 模块系统是不是同一个概念？
什么是 Sources Root？
package 的核心作用是什么？
package 与目录是什么关系？
class 当前可以怎样简单理解？
IDEA 中点击 Run 后，Java 编译过程是否消失了？
为什么一个 Project 可以包含多个 Module？
为什么 IDEA 中还需要单独配置 Project JDK？
main 方法当前承担什么职责？
为什么编译产物不一定永远位于 out？

7.2 代码阅读

阅读：

package com.xingyu.demo;

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello IDEA");
    }
}

回答：

当前 class 名是什么？
当前 package 是什么？
源文件通常叫什么？
在标准源目录结构中，它可能位于怎样的路径？
程序经典入口是哪一个方法？
运行以后控制台输出什么？
编译后得到的 HelloWorld.class 属于源码还是编译产物？

7.3 手写代码

在 IDEA 中从零完成：

Project:
JavaSEStudy

Package:
com.xingyu.hello

Class:
HelloJava

要求手写：

package com.xingyu.hello;

public class HelloJava {

    public static void main(String[] args) {
        System.out.println("The harder you try, the luckier you get");
    }
}

完成以后：

运行程序；
找到源码文件；
找到编译后的 class；
说明两者路径为什么不同；
写出：

Project
Module
Source Root
Package
Class

之间的关系。

7.4 Debug

下面几个场景分别分析。

场景一：No SDK

IDEA 项目打开后：

Project SDK is not defined

请说明：

这是 Java 语法错误吗？
应该检查什么？
JDK 21 已经安装时如何告诉 IDEA 它的位置？

场景二：package 与目录混乱

代码：

package com.xingyu.demo;

但是开发者随意移动了 Java 文件，并破坏了源目录结构。