27. 【Java】包与导入：组织代码的“文件夹“

摘要： 本文深入解析Java包（Package）和导入（Import）机制，从命名冲突问题出发，详细讲解包的声明规范、物理目录结构、import语句的使用技巧，包括通配符导入和静态导入。同时介绍JDK 9引入的模块化系统（JPMS），帮助初学者理解Java代码组织的基本原理和最佳实践。通过综合示例演示包、导入和静态导入的实际应用，为构建清晰、可维护的Java项目打下坚实基础。

关键词： Java包, import语句, 模块化系统, 静态导入, 命名冲突

在前面的文章中，你可能会注意到我们写的每个 Java 文件开头几乎都有一行 package com.example.demo;。有时候我们会写 import java.util.Scanner; 来导入一个类。但你有没有想过：为什么需要这些东西？它们到底在做什么？

想象一下：你的电脑里只有一个文件夹，所有文件都堆在一起——照片、音乐、文档、程序、电影……你会疯掉的。你会按照类型、项目、日期把它们分门别类地放进不同的文件夹里，方便查找和管理。

Java 代码也是一样。当项目变大，可能包含几百甚至几千个类时，如果没有一种组织方式，所有的类都放在一起，就像把全世界的书堆在一个仓库里——你永远找不到你想要的那一本。

包（Package） 就是 Java 用来组织类的“文件夹”。而 导入（Import） 则是告诉编译器“我要从某个文件夹里找某个类”的快捷方式。

今天我们就来把包和导入的方方面面彻底讲清楚，包括它们的规范、物理结构、以及 JDK 9 引入的模块化系统。

1. 为什么需要包？—— 从“命名冲突”说起

假设你在写一个电商系统，你定义了一个 Order 类。同时，你引用了第三方库，这个库里也有一个 Order 类。如果它们都在同一个命名空间里，编译器就分不清你到底指的是哪一个了——这叫做命名冲突（Name Collision）。

包解决了这个问题。你可以把你自己写的 Order 放在 com.yourcompany.ecom.model 包里，而第三方库的 Order 可能在 org.thirdparty.orderlib 包里。当你想使用自己定义的 Order 时，写全名 com.yourcompany.ecom.model.Order，就不会有歧义了。

包的作用：

2. 包的声明 —— package 语句

在 Java 源文件的开头（注释之后），用 package 关键字声明该类属于哪个包。

package com.example.demo;

public class HelloWorld {
// …
}

规则：

• package 语句必须是源文件中的第一条非注释语句。
• 一个文件只能有一个 package 声明。
• 如果省略了 package 语句，类就属于无名包（unnamed package），在开发中应该避免使用。

包命名规范

• 全部小写：包名一律使用小写字母。
• 域名倒置：通常用公司域名的倒序作为包前缀，因为域名是全球唯一的。比如：
  • 如果你的域名是 example.com，包名以 com.example 开头。
  • 如果你的域名是 github.io，包名以 io.github 开头。
• 后续部分：按项目名、模块名、功能分层。例如：
  • com.example.ecom.model —— 电商项目的模型层
  • com.example.ecom.service —— 电商项目的服务层
  • com.example.ecom.util —— 电商项目的工具类

为什么用域名倒序？因为域名是唯一的，这样能保证你写的包名不会和其他公司冲突。比如 com.google 一定是 Google 的包，org.apache 一定是 Apache 的。

💡 在个人练习项目中，你完全可以随便命名，比如 demo、test，但在真实项目中，请遵守规范。

3. 包的物理目录结构

包名中的 . 对应于文件系统中的目录分隔符。例如，类 com.example.demo.HelloWorld 的 .java 文件应该位于 com/example/demo/HelloWorld.java。

在你的项目里，通常会有一个 src/main/java 或 src 目录作为源文件的根，然后在这个根下面建立包对应的文件夹。

比如一个 Maven 项目的结构：

src/
main/
java/
com/
example/
demo/
HelloWorld.java
util/
StringUtils.java

在编译时，编译器会根据包名在对应的目录下生成 .class 文件，保持相同的目录结构。

4. 导入 —— import 语句

每当你需要使用一个位于其他包中的类时，你有两种选择：

方式一：使用全限定名（Fully Qualified Name）

每次都写完整的包名 + 类名：

public class Main {
public static void main(String[] args) {
java.util.ArrayList<String> list = new java.util.ArrayList<>();
java.util.Collections.sort(list);
}
}

这样写很繁琐，尤其是同一个类用多次的时候。

方式二：使用 import 导入

在文件开头用 import 语句导入，然后就可以直接用短类名了。

import java.util.ArrayList;
import java.util.Collections;

public class Main {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.sort(list);
}
}

import 语句位于 package 之后、类声明之前。

通配符导入（*）

你可以用 import java.util.*; 一次导入 java.util 包下的所有类（不包括子包）。

import java.util.*;

public class Main {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
HashMap<String, Integer> map = new HashMap<>();
// 用到了多个 java.util 下的类
}
}

通配符导入让代码看起来更简洁，但有一些争议：

• 优点：少写几行导入语句。
• 缺点：可能掩盖了具体用了哪些类，而且如果两个包有同名类，通配符导入可能会导致冲突。

建议：在大多数开发中，使用通配符导入是可以接受的（IDEA 默认也会折叠成 *）。但如果你特别在意依赖的透明性，可以显式导入每个用到的类。

Java 的默认导入

有两个包是默认导入的，不需要你写 import：

• java.lang 包：包含 String、System、Math、Object 等核心类。
• 当前包：也就是和当前类位于同一个包下的所有类。

所以你可以直接写 String 而不需要 import java.lang.String;，直接写当前包内的类也不需要导入。

5. 静态导入 —— import static

除了导入类，你还可以导入一个类中的静态成员（静态字段和静态方法），这就是 静态导入（static import）。

语法：import static 包名.类名.静态成员名; 或 import static 包名.类名.*;。

比如我们经常用 Math 类的静态方法 sqrt()、pow() 等。如果没有静态导入，我们需要写 Math.sqrt(25)：

public class Main {
public static void main(String[] args) {
double result = Math.sqrt(25) + Math.pow(2, 3);
}
}

使用静态导入后，可以省略 Math.：

import static java.lang.Math.sqrt;
import static java.lang.Math.pow;
// 或者 import static java.lang.Math.*;

public class Main {
public static void main(String[] args) {
double result = sqrt(25) + pow(2, 3); // 直接使用，省去了 Math.
}
}

静态导入在某些场景下确实能提高可读性，比如在写测试时经常用 assertEquals、assertTrue 等。

但不要过度使用静态导入，否则会让代码变得难以阅读——读者可能不知道 sqrt 是从哪里来的。建议只在以下情况使用：

• 频繁使用某个工具类的静态方法（如 Math、Collections）。
• 测试代码中（Assertions、Mockito 等框架的静态方法）。
• 定义常量类的静态字段。

在 JDK 21 中，如果你同时导入了多个同名的静态成员，编译器会报错，需要你显式用类名区分。

6. 模块化系统（Module）—— JDK 9 起的大变革

在 Java 9 之前，所有的 Java 类都基于 classpath 来查找。不管你用不用，JDK 的全部 rt.jar（运行时类库）都会被加载。这在大型应用中会导致启动慢、占用内存多。

Java 9 引入了模块化系统（Java Platform Module System，JPMS），它让 JDK 本身可以被拆分成多个模块，也允许开发者为自己的应用定义模块。

什么是模块？

模块是一个命名的、自描述的代码和数据集合。模块可以：

• 显式地声明它对其他模块的依赖（requires）。
• 显式地声明它导出哪些包（exports），供其他模块使用。
• 显式地声明它开放哪些包给反射（opens）。

模块化不仅让 JDK 可以按需加载，也促进了大型应用的依赖管理。

如何定义一个模块？

在项目的根目录下创建一个 module-info.java 文件：

// module-info.java
module com.example.demo {
// 依赖 Java 的核心模块
requires java.base; // java.base 是默认的，可省略
requires java.sql;

// 导出包，供其他模块使用
exports com.example.demo.api;
exports com.example.demo.util;

// 开放包给反射（如某些框架需要）
opens com.example.demo.model;
}

然后你的其他模块可以依赖于它：

module com.example.client {
requires com.example.demo;
}

模块化的好处

对于初学者，我需要关心模块吗？

在初学阶段，你可以先忽略模块。在普通的项目中，如果不写 module-info.java，你的类会被当作“未命名模块”，运行在 classpath 模式下，和 Java 8 之前的行为完全一样。

等你开始写大型应用或库时，再深入学习模块化也不迟。但了解它的存在，能帮你理解为什么 JDK 21 的某些 API 需要 requires java.sql 这样的依赖声明。

7. 综合示例 —— 包、导入、静态导入

我们来写一个包含多个包的示例，演示包声明、导入和静态导入。

假设我们有两个包：

• com.example.demo.model：包含 User 类。
• com.example.demo.util：包含一个工具类 StringUtil。

// 文件: src/main/java/com/example/demo/model/User.java
package com.example.demo.model; // 包声明

public class User {
private String name;
private int age;

public User(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() { return name; }
public int getAge() { return age; }

@Override
public String toString() {
return "User{name='" + name + "', age=" + age + "}";
}
}

// 文件: src/main/java/com/example/demo/util/StringUtil.java
package com.example.demo.util;

public class StringUtil {
public static boolean isBlank(String s) {
return s == null || s.trim().isEmpty();
}

public static String toUpper(String s) {
return s == null ? null : s.toUpperCase();
}
}

// 文件: src/main/java/com/example/demo/Main.java
package com.example.demo; // 当前包

// 导入其他包的类
import com.example.demo.model.User;
import com.example.demo.util.StringUtil;

// 静态导入：导入 Math 的静态方法
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;

public class Main {
public static void main(String[] args) {
// 使用 model 包中的 User
User user = new User("张三", 25);
System.out.println(user);

// 使用 util 包中的工具方法
String name = user.getName();
if (!StringUtil.isBlank(name)) {
System.out.println("姓名：" + StringUtil.toUpper(name));
}

// 使用静态导入的方法（不用写 Math.）
double result = sqrt(16) + pow(2, 3);
System.out.println("sqrt(16) + 2^3 = " + result);
}
}

输出：

User{name='张三', age=25}
姓名：张三
sqrt(16) + 2^3 = 12.0

8. 常见陷阱与建议

• 命名冲突：如果导入的两个包中有同名类（比如 java.util.Date 和 java.sql.Date），你可以用全限定名来明确指定。
• 不要用 import 导入整个包时形成依赖循环：包之间应该形成清晰的层次结构，避免循环依赖。
• IDE 自动管理导入：在 IntelliJ IDEA 等 IDE 中，你可以设置“自动导入”，它会帮你加 import 并自动去掉未使用的，非常方便。
• 使用模块化时要小心导出：确保你导出了正确的包，否则其他模块无法使用。

9. 今天的总结

今天我们学习了 Java 组织代码的骨架：

• 包（Package）：用 package 声明，用域名倒序命名，对应物理文件夹，用于组织类和避免命名冲突。
• 导入（Import）：用 import 导入其他包的类或整个包，让代码更简洁。java.lang 和当前包自动导入。
• 静态导入（static import）：导入类的静态成员，让代码在某些场景下更简洁，但不要滥用。
• 模块化系统（Module）：JDK 9 引入，用 module-info.java 声明依赖和导出，初学阶段可暂不深入。
• 包与访问权限：default 和 protected 的访问范围都与包密切相关。

包和导入就像是 Java 世界的“邮政编码”和“通讯录”——有了它们，你可以快速定位任何类，也能让项目结构清晰得像个图书馆。

动手试试

下一篇文章，我们将进入一个比较特别的话题——阶段性实战：学生管理系统（OOP 版）。我们会把面向对象的三大特性（封装、继承、多态）以及我们学过的其他知识，全部放到一个完整项目中。

我们下一篇见。😃

📌 获取本系列示例代码请访问 GitCode。