hecloud.top

我和计算机

Mon, 06 Jul 2026 00:00:00 GMT

我建这个博客的目的：借着写博客，在计算机领域里广泛地深耕并记录我的全部所见所感，前者是为了本领，后者是为了避免在我行将就木之时精神财富上空空如也。

算起来，从第一次拆下电脑内存条到今天，已经八年了。五年级那年，我照着网上的博客教程，一点一点搞清楚每一块硬件究竟在做什么——那大概是我第一次读懂冯诺依曼体系。

初一开始研究 Linux。起因是当初矿潮想挖莱特币，我专门装了 Ubuntu 优化性能，现在看来的确没什么用；当时也受了 Python 引流课的影响，算是浅浅接触了编程。

一旦男生碰到这方面的边边角角，就一定会越陷越深。我的世界服务器、Kali CTF 网安、vSphere 虚拟化，甚至路由器TTL线刷，我几乎都尝了个遍。到初三，我开发的网站给学校部署在线英语听力。

不敢想当初到底有多沉迷（虽然有些嘉豪）。中学时也有不少奇闻逸事，比如在内网装宝塔面板，一路从 Windows 系统调试到路由器，就是不知道为什么连不通。很多当时看来奇怪的问题，现在想想都挺弱智。

十八岁以前，我的爱好几乎都被这方面锁死了。后来顺其自然，高考志愿报了计算机——也算从业余转职业了。

还有很多有趣体验，一时想不起来。可能未来某天跟朋友聊天时会猛然想起，然后诉说当年的糗事。只恨这几年来，没能养成写博客的习惯，所有这些宝贵的探索都没能硬编码下来。好在时间不晚，今天的我才大一，还有很多时间记录和进化。

我还要重申一遍，本博客建立的主要目的是深耕计算机领域。至于竞争力或者未来就业的相关问题，我并没有考虑，我的动机很单纯。

幻想一下：你现在 30 岁，回到家。全屋智能家居已经接入你部署在刷完 OpenWRT 路由器上的 Home Assistant，这个智能家居中枢联动了苹果生态的 HomeKit，几乎可以设置任何你想要的逻辑。同时在你的路由器上部署 AdGuard 和科学工具，再接入一个 Agent Loop。

它配合你本地 NAS 上的 N8N 工作流，每周都会向你汇报家庭内的基本信息：气温、耗电量、博客浏览量和手机上网时间；小到个人体脂控制，大到家庭开支，总结成高效的 PDF 文档，在你离开家后发送到你和家人的邮箱内。

摄像头借助 OpenCV 计算机视觉搭配扫地机器人，默默在你回家之前完成全部家务——通风净化、洗衣烘干、设备自检，有条不紊。如果本地的 Agent 有需要，它会自动 WOL 启动你的台式机，完成重负载任务。

一到周末，三五好友聚齐，你对智能音箱一声令下，打开全屋观影模式，投影布缓缓落下。随后 Jellyfin 从你本地的片库里翻片——蓝光原盘、杜比视界、8K，随你挑。Docker 服务配合内网穿透，把你远在天边的挚友拉进同一个 MC 服务器。

你默默地站在人群中央，享受着 GitHub 开源带来的极致便利和大家的簇拥，手持平板而掌管着这一切。这种淡淡的幸福感，才是我等 J 人极致的追求——一直以来我都认为，计算机科学是一门持续带来幸福的科学，想必皆归因于此。

以上是我个人的全部愿景。除此之外，别无二心！

总有一天我会搞清楚所有的细节

Wed, 28 Oct 2026 00:00:00 GMT

刚进校园那会儿，我还是个软工新生。对计算机行业的大部分概念只是听过：面经、八股、活水、HC，一大半是黑话；对就业方向的理解也停留在前端、后端、算法、游戏、嵌入式这些词上，像是高中文理分科的一张表，以后选一个就完事。

那时我默认技术是分立的：选了哪个方向，就沿着哪条线往下走，别的与我无关。后来才发现，这种分法是招聘市场的分法，不是技术本身的分法。招聘需要把人切成岗位，技术却从不按岗位延伸。所以我想，在技术热忱还没被现实冲散前，一定要建立起一整个大技术观。

你写了一个 Demo，在本地跑通，然后连上服务器把它跑起来。这中间发生了什么？

DNS 把域名解析成 IP，TCP 完成三次握手，TLS 协商出密钥，HTTP 请求落到 80 或 443 端口；服务器上，systemd 早把 sshd 拉了起来，sshd 为你会话 fork 出一个 shell，shell 再启动你的进程；内核给它分配地址空间和文件描述符，检查 UID 与 GID，调度器安排它什么时候拿到 CPU。你只敲了一行 ssh，这些都在背后为你支撑。

大多数人到跑通了就停下，我也一样。一段时间内，跑通就是终点。但如果一直只学当前用得到的那部分，几年后我会变成一个熟练的调包侠——能交付，但说不清为什么。我始终认为这个层次的人只是软件用得熟练，而非真正的软件工程师。

在AI不断替代低端程序员的情况下，往往熟练不如熟悉、熟悉不如精通。我希望博客未来的更新能更深入，至少往下挖一层。用 Docker，就看 namespace 和 cgroup；写 SQL，就看索引和 B+ 树；配 Nginx，就看它怎么把请求转给上游。挖到看不懂为止，把看不懂的地方记下来。技术不是一堆互不相干的方向，是一张网。我要做的不是背下每个结点，而是知道线是怎么连的。

所以，总有一天我会搞清楚所有的细节。

05异常-断言-日志

Mon, 26 Oct 2026 00:00:00 GMT

第 7 章异常、断言和日志#

7.1 处理错误#

方法出错只有三种结局：就地解决、把问题往上交、直接崩掉。Java 的做法是抛出一个异常对象——它带着「出了什么事」和「在哪里出的」，沿调用栈往上一层一层找处理者。

7.1.1 异常分类#

所有异常都继承自 Throwable，往下先分两支：

1
Throwable
2
├── Error   虚拟机级故障，程序不该捕获
3
│   ├── OutOfMemoryError
4
│   └── StackOverflowError
5
└── Exception
6
    ├── RuntimeException   非受检
7
    │   ├── NullPointerException
8
    │   ├── ArrayIndexOutOfBoundsException
9
    │   ├── ClassCastException
10
    │   └── IllegalArgumentException
11
    └── IOException   受检
12
        ├── FileNotFoundException
13
        └── ...

Error 是虚拟机自己撑不住了——内存耗尽、栈溢出，你接住也没法恢复，所以不该 catch。

Exception 才是要给程序处理的。它又分两类，判断规则一句话：

RuntimeException 及其子类不受检查，其余 Exception 子类受检查；Error 也不受检查。

受检：编译器会检查你处理没处理。处理只有两条路——就地 try-catch 掉，或者在自己方法上 throws 交出去；两条都不走就编译不过，报错原话是 must be caught or declared to be thrown。这类异常来自外部世界：文件不在、网络断了、磁盘满了。
非受检：编译器问都不问，你可以完全不理，代码照样编译，真出了就运行时崩掉。这类是代码自己写错了——空指针、下标越界、类型转错，该靠改代码消灭，而不是靠 catch。

vs C：C 没有异常机制，出错靠返回值 + errno，调用者完全可以装作没看见，错误就这么烂在底下；Java 的受检异常是编译期强制，不处理连 class 都生成不出来。

7.1.2 声明检查型异常#

受检异常不想就地处理，就得写进方法签名，用 throws：

1
public void load(String path) throws IOException {
2
    Scanner in = new Scanner(Path.of(path));
3
    // 方法体里可能抛 IOException，自己不管，交给调用者
4
}

==调用这个方法==的人只有两条路：就地 try 掉，或者自己也 throws 上去。

1
try {
2
    load("data.txt");
3
} catch (IOException e) {
4
    System.out.println("读取失败：" + e.getMessage());
5
}

throws 和 throw 差一个字母，完全是两回事。

throws 写在方法头，后面跟的是类型，多个用逗号隔开（throws IOException, SQLException），自己不会产生任何对象。

它只说一件事：调用我的人可能收到这些异常。位置也有限制——只有方法和构造器的声明后面能写，类、接口、字段、初始化块一律不行。

throw 写在方法体，后面跟的必须是异常对象，执行到这一行就真的把异常扔出去：

1
public void save(String text) throws IOException {
2
    if (text.length() > 1000) {
3
        throw new IOException("内容超长：最多 1000 字");   // 受检异常，所以方法头必须有 throws
4
    }
5
    PrintWriter out = new PrintWriter("note.txt");
6
    out.println(text);
7
    out.close();
8
}

对照着记三点：

	`throws`	`throw`
位置	方法 / 构造器的签名	方法体里的语句
后面跟	异常类型	异常对象（`new` 出来的）
作用	提前告知	当场抛出

两者还有一条联动规则：throw 抛的是受检异常时，所在方法必须 throws 同一个类型（或它的父类型），否则编译不过——方法体里哪怕只有这一句 throw，方法头的 throws IOException 也省不掉。抛 RuntimeException 及其子类（以及 Error）时没有这条约束——方法头写不写 throws 都行，编译器根本不检查。

还有一点：throws 声明的是「可能」，不是「一定」。方法体里一条 throw 都没有也完全正常——异常可能是它调用的其他方法带出来的，只要可能冒出来，就得交代。反过来，只要方法体内部抛了受检异常又没有当场 catch，就必须有throws。

两个细节：

覆盖父类方法时，子类不能声明更宽的受检异常——父类说只抛 IOException，子类不能改成 throws Exception，否则多态调用时就接不住了。
别为了省事到处写 throws Exception。那等于把「出什么错」这个信息丢掉了，调用者只能一把抓。

7.1.3 如何抛出异常#

1
public void withdraw(double amount) throws InsufficientFundsException {
2
    if (amount > balance) {
3
        throw new InsufficientFundsException("余额不足，还差 " + (amount - balance));
4
    }
5
    balance -= amount;
6
}

throw 执行之后，控制权往哪儿走：

new 出一个异常对象，顺带记下当前的调用栈。
当前方法立刻结束，后面的语句一行都不执行。
异常沿调用栈往上找，遇到第一个类型对得上的 catch 就交出去；没人接，线程带着栈轨迹死掉。

同一个块里 throw 之后紧跟的语句，编译器直接判为「不可达」（unreachable statement），编译不过。

7.1.4 创建异常类#

自定义异常就是一个普通的类，选一个父类、给两个构造器：

1
public class InsufficientFundsException extends Exception {
2
    public InsufficientFundsException() {
3
    }
4

5
    public InsufficientFundsException(String message) {
6
        super(message);
7
    }
8
}

受检与否跟着父类走，继承谁就跟谁一类：

extends Exception → 受检，调用者被迫处理。
extends RuntimeException → 非受检，调用者不用管。
extends IOException 这类已有的受检异常 → 还是受检。

选哪个看意图：调用者有办法补救，就选受检（让调用者去提示用户换个文件）；调用者只能改自己代码，就选非受检（参数非法、状态不对）。

需要携带数据就自己加字段和构造器，比如余额不足的异常里存一个 double shortage，catch 到的人就能直接显示差多少钱。

类名以 Exception 结尾是惯例，JDK 里全这样。

7.2 捕获异常#

7.2.1 捕获异常概述#

1
public class Demo {
2
    public static void main(String[] args) {
3
        int[] scores = new int[3];
4
        try {
5
            scores[5] = 100;
6
            System.out.println("这行不会执行");
7
        } catch (ArrayIndexOutOfBoundsException e) {
8
            System.out.println("下标越界：" + e.getMessage());
9
        }
10
        System.out.println("程序继续运行");
11
    }
12
}

输出：

1
下标越界：Index 5 out of bounds for length 3
2
程序继续运行

三件事同时发生：try 块里出错点之后的语句不再执行；控制权交给类型匹配的 catch；catch 块结束后，程序从 try-catch 之后继续跑，就像没出过事。

e 是异常对象，最常用的两个方法是 getMessage()（拿消息）和 printStackTrace()（打调用链）。getMessage() 可能返回 null——有些异常构造时就没带消息，别直接拿它拼字符串。

7.2.2 捕获多个异常#

一个 try 后面可以跟多个 catch，顺序必须从子类到父类：

1
try {
2
    Scanner in = new Scanner(Path.of("data.txt"));
3
    // ...
4
} catch (FileNotFoundException e) {      // 子类，放前面
5
    System.out.println("文件不存在");
6
} catch (IOException e) {                // 父类，放后面
7
    System.out.println("读文件出错：" + e.getMessage());
8
}

写反了编译器直接报错 exception ... has already been caught——因为父类的 catch 会把子类的异常全接走，后面的分支永远轮不到。

如果几种异常的处理方式完全一样，可以合并成一条：

1
try {
2
    LocalDate day = LocalDate.parse("2026-13-01");
3
    Scanner in = new Scanner(Path.of("data.txt"));
4
} catch (IOException | DateTimeParseException e) {
5
    System.out.println("数据读不出来：" + e.getMessage());
6
}

合并后 e 只剩一个类型：Java 顺着两条继承链往上找，取第一个重合的祖先——IOException 和 DateTimeParseException 都继承自 Exception，所以 e 就是 Exception。它只能调用 Exception 里有的方法（getMessage()、printStackTrace()），子类型特有的方法一概调不了，需要分别处理就拆回两个 catch。合并的 e 还是隐式 final 的，不能再赋值。

两个类型之间有继承关系时不允许合并，比如 IOException | FileNotFoundException 直接编译不过。

catch (Exception e) 会把所有异常一网打尽，包括非受检的——偶尔用来在 main 里兜底可以，日常处理别这么写，等于放弃了按类型分类处置。

7.2.3 再次抛出异常与异常链#

两种「接住了又放走」的情况。

第一种：原样再抛。 先做点清理（记日志、回滚），但处理不了，继续往上交：

1
try {
2
    load("data.txt");
3
} catch (IOException e) {
4
    System.out.println("读取失败，交给上层处理");
5
    throw e;                             // 注意：方法是受检异常就得自己 throws
6
}

第二种：包装成另一种异常。 底层抛的 IOException 对上层来说没意义——上层只关心「订单加载失败」。换异常时必须把原异常带进去：

1
public class OrderException extends RuntimeException {
2
    public OrderException(String message, Throwable cause) {
3
        super(message, cause);
4
    }
5
}
6

7
public void loadOrder() {
8
    try {
9
        Scanner in = new Scanner(Path.of("order.txt"));
10
        // ...
11
    } catch (IOException e) {
12
        throw new OrderException("订单文件读取失败", e);
13
    }
14
}

打印出来长这样：

1
Exception in thread "main" OrderException: 订单文件读取失败
2
    at com.example.hr.Demo.loadOrder(Demo.java:12)
3
    ...
4
Caused by: java.io.FileNotFoundException: order.txt (No such file or directory)
5
    at java.base/java.io.FileInputStream.open0(Native Method)
6
    ...

Caused by 这一段就是原始现场。不把 e 传进去，这段就没了——换成另一个异常等于把根因抹掉，日后查问题只能靠猜。这就是异常链。

老式异常类没有带 cause 的构造器，用 initCause(e) 补上，效果一样。

7.2.4 finally子句#

finally 里的代码一定会执行，不管 try 是正常跑完、抛了异常、还是半路 return：

1
Scanner in = null;
2
try {
3
    in = new Scanner(Path.of("data.txt"));
4
    while (in.hasNextLine()) {
5
        System.out.println(in.nextLine());
6
    }
7
} catch (IOException e) {
8
    e.printStackTrace();
9
} finally {
10
    if (in != null) in.close();          // 不管走哪条路都关掉
11
}

只有两种情况它不执行：JVM 被杀掉、或者中途调了 System.exit。

别在 finally 里 return。 finally 的 return 会顶掉还没处理完的异常，把它整个吞掉——程序看起来正常返回了，错误却凭空消失。

上面这段代码其实还留着两个坑：new Scanner 那行就抛异常时 in 还是 null，得判空；close() 自己也可能抛异常，那就会把原来的异常盖住。下一节专门解决这些。

vs C：C 没有 finally，清理代码只能每个出口抄一遍，或者用 goto cleanup 收拢到一处——后者能写对，但语言不给你任何保障。

7.2.5 try-with-resources语句#

上一节留下的两个坑，Java 7 给了一个专门的写法堵掉：把要关的东西写进 try 的括号里。

1
try (Scanner in = new Scanner(Path.of("data.txt"))) {
2
    while (in.hasNextLine()) {
3
        System.out.println(in.nextLine());
4
    }
5
} catch (IOException e) {
6
    e.printStackTrace();
7
}

括号里声明的对象，离开 try 块时 close() 会自动被调用——正常跑完要调，抛异常往外飞之前也要调。不用判空，不用手写 finally。

放进去的要求只有一个：这个类自己有 close() 方法。Scanner、PrintWriter、各种文件流都有；这类「用完必须关」的对象习惯上叫资源。

Java 用一个接口来标记「我有 close()」，叫 java.lang.AutoCloseable，全身上下一个方法：

1
public interface AutoCloseable {
2
    void close() throws Exception;
3
}

类只要 implements AutoCloseable、把 close() 写出来，编译器就允许它进 try 括号——自己写的类也一样。

多个资源写在同一个括号里，用分号隔开，关闭顺序和声明顺序相反（后开的先关）：

1
try (Scanner in = new Scanner(Path.of("in.txt"));
2
     PrintWriter out = new PrintWriter("out.txt")) {
3
    while (in.hasNextLine()) {
4
        out.println(in.nextLine().toUpperCase());
5
    }
6
} catch (IOException e) {
7
    e.printStackTrace();
8
}                                   // 先关 out，再关 in

关闭时如果真的也抛了异常，它不会顶掉原来的异常，而是作为「被抑制的异常」挂在原异常后面，栈轨迹里显示为 Suppressed:。这一点比手写 finally 安全。

日常写文件 I/O 一律用这个，finally 手动关资源的写法基本可以淘汰了。

vs C：这就是 C++ 的 RAII——析构函数在离开作用域时自动跑。C 里没有析构，只能手动 fclose，漏一条路径就泄漏一个句柄。

7.2.6 分析栈轨迹元素#

栈轨迹是异常里最有价值的东西，长这样：

1
Exception in thread "main" java.lang.ArithmeticException: / by zero
2
    at com.example.hr.Demo.divide(Demo.java:9)
3
    at com.example.hr.Demo.main(Demo.java:4)

读法固定：

第一行：异常类型 + 消息。/ by zero 已经说明了死因。
每个 at 是一层调用帧：类.方法(文件名:行号)。
最上面那一行是抛出点，越往下越是调用者，最底下是程序的入口。

所以定位只需要看第一个 at，直接跳到那个文件的第 9 行。

程序里也能拿到这些信息：e.getStackTrace() 返回 StackTraceElement[]，每一项有 getClassName()、getMethodName()、getLineNumber()。需要把错误上报到服务器时才会用到，日常读控制台输出就够。

vs C：C 崩溃时只能靠 core dump 加 gdb 的 backtrace，还得先打开 core 文件开关；Java 的栈轨迹是异常对象自带的，一出错就自动打全。

7.3 使用异常的技巧#

别用异常做正常流程。 能在事前用 if 判断的，不要靠 catch 兜——异常的开销和可读性都不划算。
```
1
// 反例
2
try {
3
    return arr[index].length();
4
} catch (NullPointerException e) {
5
    return 0;
6
}
```
别吞异常。 空的 catch {} 是最坏的写法，错误就此消失。至少打一行日志。
早抛晚捕。 发现问题的层次立刻 throw，能决定怎么处理的层次再 catch，中间层只管往上放。
包一层再抛。 底层异常翻译成调用者看得懂的业务异常，同时用异常链保留根因。
别一把抓。 除了 main 兜底，不要随手 catch (Exception e)，那样所有错误都变成同一种。
受检异常别滥用。 现代项目里业务异常大多直接继承 RuntimeException，受检异常留给真正可恢复的 I/O 问题。

7.4 使用断言#

7.4.1 断言的概念#

1
assert balance >= 0;                        // 条件不成立就抛 AssertionError
2
assert balance >= 0 : "余额为负: " + balance;  // 带上消息

断言失败抛的是 AssertionError——注意它在 Error 那一支，不是 Exception，本来就不该被 catch。

最关键的一点：断言默认是关闭的。不加开关，代码里所有 assert 语句在运行时都会被直接跳过，等于白写。

7.4.2 启用和禁用断言#

开关加在 java 启动命令上，不是 javac：

Terminal window

1
java Demo                    # 断言关闭（默认）
2
java -ea Demo                # 断言全开
3
java -ea:com.example... Demo # 只给这个包及其子包开

IDEA 里要写在运行配置的 VM options 里，直接点运行按钮是不带 -ea 的——这也是「我本地断言明明没报错」的常见原因。

生产环境一般不开：断言是给开发和测试用的。

7.4.3 使用断言完成参数检查#

这里有个容易记反的地方：参数检查用异常，不用断言。

1
// ✅ public 方法检查参数：抛异常
2
public void setSalary(double salary) {
3
    if (salary < 0) {
4
        throw new IllegalArgumentException("薪水不能为负：" + salary);
5
    }
6
    this.salary = salary;
7
}
8

9
// ✅ 断言：检查程序内部假设
10
private int sum(int[] data) {
11
    assert data.length > 0 : "空数组不该进到这里";
12
    int total = 0;
13
    for (int v : data) total += v;
14
    return total;
15
}

展开收起

原因有两条：断言可能被 -da 关掉，关掉后非法参数就一路畅通；而且 AssertionError 是 Error，把它抛给调用者本身就不合适。参数非法时要抛 IllegalArgumentException，那是 Exception 那一支。

判空这类最常见的检查，JDK 已经写好了：Objects.requireNonNull(name, "name 不能为 null")，不满足就抛 NullPointerException。

7.4.4 使用断言提供假设文档#

断言的第二个作用是把「我默认它成立」写下来，而且能被真的检查一遍：

1
// 约定：list 已按 id 升序排列
2
assert isSorted(list) : "list 未排序";

这既是给后来的读者看的注释，也是测试期的一根探针——假设一旦不成立，立刻炸出来，而不是等到几天后数据全乱了才发现。

7.5 日志#

System.out 调试有个致命问题：上线之后要么全留（刷屏），要么全删（出事了没记录）。日志就是带级别的打印，可以按需开关、按需改去向。Java 自带的是 java.util.logging（常简称 JUL）。

7.5.1 基本日志#

最省事的写法：

1
import java.util.logging.Logger;
2

3
public class Demo {
4
    public static void main(String[] args) {
5
        Logger logger = Logger.getGlobal();
6
        logger.info("程序启动");
7
        logger.warning("磁盘空间不足");
8
        logger.severe("数据库连不上");
9
    }
10
}

输出：

1
10月 27, 2026 3:20:15 下午 Demo main
2
信息: 程序启动
3
10月 27, 2026 3:20:15 下午 Demo main
4
警告: 磁盘空间不足
5
10月 27, 2026 3:20:15 下午 Demo main
6
严重: 数据库连不上

第一行是时间、类名、方法名，第二行是级别加消息。级别名会按系统语言显示成「信息 / 警告 / 严重」（对应代码里的 INFO / WARNING / SEVERE）。

每个级别都有同名的小写方法：severe() → SEVERE、warning() → WARNING，依次类推，还有 config()、fine()、finer()、finest()。想一次打印任意级别也可以 logger.log(Level.WARNING, "消息")。

顺带一个细节：日志默认打到 System.err，不是 System.out。

7.5.2 高级日志#

实际用的时候，每个类建一个自己的 logger，名字用类名：

1
private static final Logger logger = Logger.getLogger("com.example.hr.Demo");
2

3
logger.info("张三入职，月薪 " + salary);
4
logger.warning("余额低，剩余 " + balance);

logger 名字用点号分层级，com.example.hr.Demo 的父 logger 是 com.example.hr，再往上是 com.example。

这里的「继承」跟类的继承无关，说的是级别怎么找：某个 logger 自己没设级别，就沿着名字往上一层一层找，用最近一个设过的级别。

1
Logger hr = Logger.getLogger("com.example.hr");
2
hr.setLevel(Level.FINE);              // 设门槛：这一支都收 FINE 及以上
3

4
Logger demo = Logger.getLogger("com.example.hr.Demo");
5
demo.fine("调试信息");                 // 写一条 FINE 级别的日志，门槛沿用父级

注意：demo.fine(...) 里的 fine 不是设级别，而是「写一条 FINE 级别的日志」——括号里放的是消息。设门槛只有一个方法：setLevel。它做的是往 demo 这个 logger 里写一条 FINE 级别的记录，括号里是消息内容。它不改任何配置。

所以按包统一调级别只要设一次父级，包里所有类都跟着变。

七个级别从高到低：

SEVERE → WARNING → INFO → CONFIG → FINE → FINER → FINEST

默认只输出 INFO 及以上，所以写了 logger.fine(...) 也看不到。

logger.setLevel(Level.FINE) 是给这个 logger 设最低门槛：比 FINE 更严重的日志才收，更细的直接丢掉。但光调它往往还是看不到——一条日志要打到屏幕上，得过两道关：

logger 先筛：这条日志级别够不够，不够直接丢掉，不往下传。
handler 再筛：logger 放行后交给 handler（默认是控制台那个），handler 又按自己的级别筛一遍。

两道关默认都卡在 INFO。只把 logger 那关调低，handler 那关还锁着，FINE 照样出不来。要两处一起调——logging.properties 里正好就是两行（7.5.3）。

7.5.3 修改日志管理器配置#

全局配置在一个 properties 文件里，JDK 9 以后在 $JAVA_HOME/conf/logging.properties：

1
# 所有 logger 的默认级别
2
.level = FINE
3

4
# 控制台处理器：级别和格式
5
java.util.logging.ConsoleHandler.level = FINE
6
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
7

8
# 文件处理器：输出路径（%h 是用户主目录）
9
java.util.logging.FileHandler.pattern = %h/app.log
10
java.util.logging.FileHandler.level = INFO

改这里不用动代码。指定另一份配置：

Terminal window

1
java -Djava.util.logging.config.file=my.properties Demo

7.5.4 本地化#

日志文本也能按语言切换：用一个资源包（ResourceBundle）存消息模板，类型是 Localizable 的记录会去查表。实际项目极少这么做，一般直接写英文消息，界面文案另走一套。认得即可。

7.5.5 处理器#

Handler 决定日志去哪儿：

1
Logger logger = Logger.getLogger("com.example.hr.Demo");
2
logger.setUseParentHandlers(false);          // 不再往父 logger 传，避免重复输出
3
logger.addHandler(new ConsoleHandler());     // 控制台
4
logger.addHandler(new FileHandler("app.log"));   // 文件

一个 logger 可以挂多个 handler——一份日志同时进控制台和文件，就是加两行的事。

两个常见坑：FileHandler 的构造器抛受检的 IOException，得处理；给 logger 加了自己的 handler 后，默认还会把记录传给父 logger 的 handler，同一个日志就会打印两遍，所以通常先 setUseParentHandlers(false)。

7.5.6 过滤器#

Filter 是比级别更细的一道闸，逐条判断要不要放行：

1
logger.setFilter(record -> record.getMessage() != null
2
        && !record.getMessage().contains("密码"));

接口方法就一个 boolean isLoggable(LogRecord record)，用 lambda 实现最方便。级别是粗筛，过滤器是细筛。

7.5.7 格式化器#

Formatter 决定日志长什么样。JDK 自带两个：SimpleFormatter（纯文本，默认就是这个）和 XMLFormatter（XML，便于机器解析）。

要自定义就继承 Formatter，实现 format(LogRecord record) 返回一个字符串，然后 handler.setFormatter(new MyFormatter())。日常项目里通常换成 Logback 之类，这一层认得即可。

7.5.8 日志技巧#

一个类一个 logger，private static final，名字用全类名：Logger.getLogger(Demo.class.getName())（.class 是 5.9 的 Class 对象，认得即可）。
记录异常要把异常对象传进去：logger.log(Level.SEVERE, "保存失败", e);。写成 logger.severe(e.getMessage()) 就只剩一行消息，栈轨迹全丢了。
级别别乱用：正常流程 INFO，能恢复的异常情况 WARNING，出错了 SEVERE，调试细节 FINE。
别忘了日志是给上线后的人看的——消息里写清「哪条数据、什么操作、什么值」，别只写「失败了」。

7.6 调试技巧#

断点：比 System.out 强的地方是能停住看现场——变量值、调用栈、任意表达式求值，都不用改代码。
条件断点：只在 i == 999 时才停，不用手动按 999 次继续。
单步分三种：step into 走进被调方法，step over 把整个方法当一步跨过，step out 从当前方法跳回调用处。分清这三个，调试就够用了。
崩溃先读栈轨迹（7.2.6）。十次里有九次答案就在第一行，别看都不看就去猜。
二分定位：注释掉一半代码看还崩不崩，比逐行读快得多。
最小复现：把问题缩到一个能单独运行的小文件。缩的过程本身经常就把 bug 找出来了。

附录#

常见异常速查#

异常	什么时候抛	通常的根因
`NullPointerException`	对 `null` 调方法、取字段、算长度	对象没初始化，或方法返回了 `null` 没判
`ArrayIndexOutOfBoundsException`	下标 `< 0` 或 `>= length`	循环边界写错，差一
`ClassCastException`	强转的类型对不上	转之前没做 `instanceof` 判断
`NumberFormatException`	`Integer.parseInt("abc")`	输入没校验，直接拿去转
`IllegalArgumentException`	方法收到不该收的参数	调用方传错，检查没做在入口
`ArithmeticException`	整数除以 0	忘了判除数为零
`IllegalStateException`	对象状态不允许当前操作	调用顺序错了，如用完没重置
`UnsupportedOperationException`	调了该实现不支持的方法	拿到的是不可修改的集合
`FileNotFoundException`	文件路径不存在	路径拼错、没权限、工作目录不对
`IOException`	各种 I/O 失败	文件、网络、权限——受检异常的总类

04接口与lambda（案例）

Thu, 22 Oct 2026 00:00:00 GMT

InterfaceLambdaTraining 练习代码#

1
package com.example.hr;
2

3
import java.util.function.Consumer;
4
import java.util.function.Function;
5
import java.util.function.Predicate;
6
import java.util.function.Supplier;
7

8
public class InterfaceLambdaTraining {
9

10
    public static class Ra1 implements Runnable {
11
        @Override // 仅供案例一使用
12
        public void run() {
13
            System.out.println("普通方式");
14
        }
15
    }
16

17
    public static class Cs1 implements Consumer<String> {
18
        @Override // 仅供案例二使用
19
        public void accept(String text) {
20
            System.out.println(text);
21
        }
22
    }
23

24
    public static class Sp1 implements Supplier<String> {
25
        @Override // 仅供案例三使用
26
        public String get() {
27
            return "你好Supplier";
28
        }
29
    }
30

31
    public static String createMessage() {
32
        return "方法引用"; // 仅供案例三使用
33
    }
34

35
    public static class Fc1 implements Function<String, Integer> {
36
        @Override // 仅供案例四使用
37
        public Integer apply(String str) {
38
            return str.length();
39
        }
40
    }
41

42
    public static class Pd1 implements Predicate<String> {
43
        @Override // 仅供案例五
44
        public boolean test(String text) {
45
            return text.length() > 3;
46
        }
47
    }
48

49
    public static void main(String[] args) {
50
        // ===================== 案例一：Runnable 无参，无返回 =====================
51
        Runnable ra1 = new Ra1();
52
        ra1.run();
53

54
        Runnable ra2 = new Runnable() {
55
            @Override
56
            public void run() {
57
                System.out.println("匿名内部类");
58
            }
59
        };
60
        ra2.run();
61

62
        Runnable ra3 = () -> System.out.println("Lambda");
63
        ra3.run();
64

65
        // ===================== 案例二：Consumer 一个参数，无返回 =====================
66
        Consumer<String> cs1 = new Cs1();
67
        cs1.accept("普通方式");
68

69
        Consumer<String> cs2 = new Consumer<String>() {
70
            @Override
71
            public void accept(String text) {
72
                System.out.println(text);
73
            }
74
        };
75
        cs2.accept("匿名内部类");
76

77
        Consumer<String> cs3 = (a) -> System.out.println(a);
78
        cs3.accept("Lambda");
79

80
        Consumer<String> cs4 = System.out::println;
81
        cs4.accept("方法调用");
82

83
        // ===================== 案例三：Supplier 无参，有返回 =====================
84
        Supplier<String> sp1 = new Sp1();
85
        System.out.println(sp1.get());
86

87
        Supplier<String> sp2 = new Supplier<String>() {
88
            @Override
89
            public String get() {
90
                return "匿名内部类";
91
            }
92
        };
93
        System.out.println(sp2.get());
94

95
        Supplier<String> sp3 = () -> "Lambda";
96
        // 默认返回，也可以块包裹起来
97
        // Supplier<String> sp3=()->{
98
        //     return "Lambda";
99
        // };
100
        System.out.println(sp3.get());
101

102
        Supplier<String> sp4 = InterfaceLambdaTraining::createMessage;
103
        System.out.println(sp4.get());
104

105
        // ===================== 案例四：Function 一个参数，有返回 =====================
106
        Function<String, Integer> fc1 = new Fc1();
107
        System.out.println(fc1.apply("hello"));
108

109
        Function<String, Integer> fc2 = new Function<String, Integer>() {
110
            @Override
111
            public Integer apply(String str) {
112
                return str.length();
113
            }
114
        };
115
        System.out.println(fc2.apply("hello!"));
116

117
        Function<String, Integer> fc3 = (a) -> a.length();
118
        System.out.println(fc3.apply("hello!!"));
119

120
        Function<String, Integer> fc4 = String::length;
121
        System.out.println(fc4.apply("hello!!!"));
122

123
        // ===================== 案例五：Predicate 一个参数，返回boolean =====================
124
        Predicate<String> pd1 = new Pd1();
125
        System.out.println(pd1.test("hello"));
126

127
        Predicate<String> pd2 = new Predicate<String>() {
128
            @Override
129
            public boolean test(String text) {
130
                return text.length() > 3;
131
            }
132
        };
133

134
        Predicate<String> pd3 = (x) -> x.length() > 3;
135

136
        Predicate<String> pd4 = pd1::test;
137

138
        /*
139
         * 方法引用有4种：
140
         * 1. 对象::实例方法
141
         * 2. 类名::静态方法
142
         * 3. 类名::实例方法
143
         * 4. 类名::new
144
         *
145
         * 类名::实例方法比较特殊，第一个传入的参数，会自动作为调用这个实例方法的对象（比如String::length）
146
         */
147
    }
148
}

展开收起

二十岁，以及下一个十年

Tue, 20 Oct 2026 00:00:00 GMT

你好20岁#

7305天，是的，今天我迎来了我的20岁生日🎂。

实话说，我不是一个很在意仪式感的人，20岁生日和前一天、后一天都别无二致。但是20岁这个数字有零有整，貌似真的像是站在一个人生的十字路口，不往博客里灌点水实在不好意思。

过去十年，是我从少年变成青年的十年，在这十年内的的确确转变很大。我的世界观也逐渐从一个小镇、转为一个省市、再转为更大的地方。对于很多事情的理解都在悄悄之中更新，过去认可的观点，今天不敢苟同，甚至站在了对立面。少年期间所一意孤行的态度，今天可能有所动摇。这种变化人人都有，只是我恰好想写。

七千三百天#

我的少年时代都成长在一个省会的边陲小镇，属于非常典型的中国北方县城乡镇风貌，不过得益于省会的产业强劲和机会众多，小镇的发展并不算差，人均可支配收入可以摸到全国中游。就像绝大多数乡村一样，人们不讨论“追求幸福”，只讨论“顺其自然”；不羡慕谁走得远，只羡慕谁过得稳。在这种地方，稳当不是保守，是理性：一场病、一次失败的决策，就够一个家庭缓好几年。在这种容错率下，“不折腾”是最便宜的保险。

我是在这种空气里长大的。后来我才发现，这套逻辑不只属于镇子，也长在了我身上。我尽可能把事情做对，符合期待；尽可能不被他人指责非议。这套逻辑在很长一段时间里是管用的，在不鼓励个性的环境和体系下，遇到矛盾先退，遇到机会先算风险才是主流的选择。

值得关注的是，我在这套背景板之外，发现另一个全新维度——庞大的互联网世界，我比较早地建立起完备的计算机科学素养，也养成了 BBS 冲浪的习惯，详见我和计算机，直到今天，还有很多朋友遇到相关问题找我，也算是为未来的职业道路埋下种子。

高中让我第一次认识到不同于以往的世界，也让我意识到自己对于“有用”这两个字理解有多窄，过去我判断一件事，标准很简单：对考试有没有用、能不能换成钱，但是往往很多书本以外的知识才是构成一个人综合素质的根本。独立判断是非曲直、做情绪的主人、科学认识社会、在冲突中不逃避、把话说清楚、控制饮食健康——这些很多都是我高中才开始学的。很多问题没有教材，也没有标准答案，但恰恰是人生的必修课。

进入大学以后，我重新拾起中学建立的博客，不为流量也不为竞争，对我来说，它单纯就是一套笔记归档系统，如果恰好能帮到别人，那就更好。以后大概还会写一些经济学、基础医学的东西，那些是世界的另一种运行方式。

十年来，我还是我，遇到没把握的事情还是更谨慎，遇到不明朗的前景仍然保持洞察。只是现在偶尔会硬着头皮试一次，成了算运气，不成就当没发生过。我相信，更多的探索、尝试、试错才会赢得更广阔的未来。明天会更好！

展望十年#

二十岁往后看，下一个十年会是什么样，我不知道。十年前的我，大概也想不到今天会趴在床上写这些。这里就列一些小目标🎯吧！

再活十年：注重身体指标控制，吃得香、睡得着、跑得快、玩得爽。
混口饭吃：开源节流，科学进行资产配置，净资产跑赢通胀。
红尘一遇：如题
持续迭代：坚持博客更新，提升认知，还能留在计算机行业发光发热。

写在最后#

感谢我的家人，见证了我从童年到二十岁。祝你们身体好，少操心。

谢谢每一位读者朋友。这个博客仍有很多不足，你们愿意看，是意外之喜。

二十岁，先这样。下一个十年，见。

04接口-lambda-内部类

Fri, 16 Oct 2026 00:00:00 GMT

第 6 章接口、lambda 表达式与内部类#

6.1 接口#

6.1.1 接口的概念#

想给一个 Employee[] 排序，用 Arrays.sort 就行。但通用排序代码怎么知道两个 Employee 谁在前？它是 JDK 里的通用代码，不可能认识 Employee。

办法是约定一个方法名：想被我排序的类，必须提供一个叫 compareTo 的方法。这个约定写成类型，就是接口：

1
public interface Comparable<T> {
2
    int compareTo(T other);   // 只有签名，没有实现
3
}

尖括号里的 <T> 是泛型（Ch8 才正式讲）。这里只记一句：Comparable<Employee> 就是「能和 Employee 比」。<T> 具体怎么回事，现在不用管。

类用 implements 兑现这个约定，把方法真正写出来：

1
public class Employee implements Comparable<Employee> {
2
    public int compareTo(Employee other) {
3
        return Double.compare(salary, other.salary);
4
    }
5
}

Arrays.sort 只认「你能被比较」这件事，不关心你比的是薪水还是姓名——接口规定「有什么能力」，不规定「怎么做」。

为什么非得是个独立接口，不能就在类里写个 compareTo？ 因为 Arrays.sort 是 JDK 写的——它写的时候，你的 Employee 还没出生。它没法「看」你的类，只能检查你是什么类型：

1
Arrays.sort(Comparable[] a)   // 想进来，得是 Comparable 这个类型

你在类里写个 compareTo，只有你自己调得到；Arrays.sort 不认识你的类，也不会去翻你有哪些方法——真要它去找，只能靠反射去猜方法名（6.5 代理那套），又慢又脆。

换成接口，约定就从「口头说好」变成一条编译期就查得出的规则：没实现？编译不过。这也是它比「方法名叫 compareTo」那句口头约定强的地方。

说得再土一点：接口是互不相识的双方共用的插座。Arrays.sort（JDK，早写完了）和你的 Employee（还没写）互相不认识，但都认 Comparable 这个标准。所以 Integer、String、Employee 彼此毫无血缘，照样能被同一个 Arrays.sort 排。

vs C：C 没有这个机制。想让通用排序函数知道你「能被比较」，只能塞一个函数指针进去，每个调用点自己传「怎么比」。关于回调，6.1.7 会再讲。

6.1.2 接口的属性#

几条硬性规定：

接口不是类，不能 new。new Comparable() 编译不过。
接口里的方法默认 public abstract（公开 + 只有签名）；字段默认 public static final（常量）。

1
public interface Comparable<T> {
2
    int compareTo(T other);   // 等价于 public abstract int compareTo(T other);
3
    double PI = 3.14;         // 等价于 public static final double PI = 3.14;
4
}

接口类型的变量可以声明，指向实现类对象。这就是 5.1 的那个多态——只是「父类」换成了「接口」：接口变量只能调接口里有的方法；真正执行的则是实现类写的那个方法——毕竟接口里那个只有签名，没实现可跑。

1
Comparable<Employee> e = new Employee("张三", 50000);
2
Employee boss = new Employee("李四", 80000);
3

4
e.compareTo(boss);   // ✅ 能调：compareTo 在 Comparable 里
5
e.getName();         // ❌ 编译不过：getName 不在 Comparable 里

一个类可以 implements 多个接口，逗号隔开：

1
public class Employee implements Cloneable, Comparable<Employee> { ... }

6.1.3 接口与抽象类#

5.6 的抽象类也能「只给方法签名、不给实现」，看着和接口是一回事。区别只有两条。

第一条：一个类只能有一个父类，接口能有多个。

extends 后面只能写一个类：

1
class Employee extends Person { }                // ✅
2
class Employee extends Person, Comparable { }    // ❌ 编译错误

想再「多一样能力」，只能放到 implements 后面。那里可以写一串，用逗号隔开：

1
class Employee extends Person implements Comparable<Employee>, Cloneable { }

所以一个类要同时具备好几样能力，只能靠接口——这就是它存在的头号理由。

第二条：抽象类里有「现成的东西」，接口里基本没有。

抽象类能有字段，用来存数据；接口的字段只能是常量（public static final）。
抽象类能有普通方法（已经写好的实现）；接口里的方法默认全是空签名（能带实现的 default 方法是 6.1.5 才加的）。

两条合起来，选法就一句：

想给类多挂几样能力 → 用接口；
想给子类留一份现成的状态和代码 → 用抽象类。

	抽象类	接口
一个类能挂几个	1 个	任意多个
字段	能存数据	只能是常量
方法	空签名和现成实现都有	默认全是空签名

6.1.4 静态和私有方法#

Java 8 起，接口可以写 static 方法。 它就是挂在接口名下的普通工具方法：

1
public interface Greeting {
2
    static String hello() { return "你好"; }   // 普通静态方法，直接给实现
3
}

调用时写接口名：Greeting.hello()。Comparator 上那批 comparing / naturalOrder 也是这样挂上去的——6.2.8 会用到。

Java 9 起，接口还能写 private 方法：

1
public interface Greeting {
2
    default void bye() { log(); }                         // 默认方法，6.1.5 讲
3
    private void log() { System.out.println("called"); }  // 只给接口内部用
4
}

理由很实际：接口里几个方法想共用一小段代码，又不想把这段代码变成接口的 API——实现类不该看到它。私有方法只服务于接口里其他方法。

6.1.5 默认方法#

问题在演进：接口已经发布，有几十个实现类。现在想给它加一个方法——直接加抽象方法，那几十个类都没实现，全部编译失败。加不了。

default 解决它：直接在接口里给出实现，实现类可重写、也可不管：

1
public interface Named {
2
    String getName();                              // 老规矩：抽象方法，必须实现
3

4
    default void greet() {                         // 新加：给了实现
5
        System.out.println("你好，" + getName());
6
    }
7
}

老实现类只写了 getName，greet 白得一个默认实现，一行不用改就编译通过。

现实里的例子是集合：Java 8 给 Collection 加 stream() 时，用的就是默认方法。

6.1.6 解决默认方法冲突#

默认方法带来一个新麻烦：一个类实现两个接口，两个接口的默认方法同名同参数，用谁的？

1
public interface A { default void f() { System.out.println("A"); } }
2
public interface B { default void f() { System.out.println("B"); } }
3

4
public class C implements A, B { }   // ❌ 编译错误：默认方法冲突

编译器不给猜，要求必须自己重写，用 接口名.super 明确挑一个：

1
public class C implements A, B {
2
    @Override
3
    public void f() { A.super.f(); }   // 显式选 A 那一版
4
}

接口名.super——这是唯一能写 super 的接口场景。

还有一条优先级要记：父类里的方法永远赢。如果 C 的父类里有一个具体的 f()，那两个接口的默认方法都会被忽略，直接用父类那版。规则连起来就是：

父类里的方法 > 接口的默认方法；
接口之间冲突 → 编译器报错，必须手写，要么改名。

6.1.7 接口与回调#

回调 = 把「要执行的代码」交给别人，时机到了再调回来。 注意它和接口没有必然联系。

JDK 的 javax.swing.Timer 是干净的例子：它每隔一段时间触发一次。触发时干什么，它不知道——它只要求你交一个实现了 ActionListener 的对象：

1
public interface ActionListener {
2
    void actionPerformed(ActionEvent event);   // 只有一个方法
3
}

你交的代码是被「叫回来」执行的一方，控制权在 Timer 手上：它决定什么时候调、调多少次。

1
class MyListener implements ActionListener {   // ① 先写个实现类
2
    public void actionPerformed(ActionEvent e) {
3
        System.out.println("到点了");
4
    }
5
}
6

7
ActionListener listener = new MyListener();    // ② 接口变量 → 实现类对象
8
var timer = new Timer(1000, listener);         // ③ Timer 是类，能 new
9
timer.start();                                 // 之后每秒它调一次 actionPerformed

注意这里「接口」和「类」的分工：new 的永远是类（Timer、MyListener）；ActionListener 只当类型用——变量、参数的位置都能写它，但它自己不能 new。所以上面既没有、也没法 new 一个接口。

注意 ActionListener 只有一个方法。下一节的 lambda 就是为缩写这种接口准备的。

vs C：C 用函数指针做回调，把函数地址传出去即可。Java 早年没有函数指针，只能拿「只有一个方法的接口」顶替：先把函数包进一个对象，再把这个对象传出去。

6.1.8 Comparator#

Comparator<T> 是外部比较器：compare(a, b) 返回值小于 0 / 等于 0 / 大于 0，分别表示 a < b / a == b / a > b。

1
public interface Comparator<T> {
2
    int compare(T a, T b);
3
}

6.1.1 的 Arrays.sort 要求元素自己能比（Comparable）。Comparator 反过来：比法由外部给。Arrays.sort 和 List.sort 都有收 Comparator 的重载：

1
Arrays.sort(people, new LengthComparator());   // 按名字长度排
2

3
class LengthComparator implements Comparator<String> {
4
    public int compare(String a, String b) {
5
        return a.length() - b.length();
6
    }
7
}

好处是把「怎么比」和「数据」分开。同一个 String 数组：想要字典序就传字典序比较器，想要长度序就传长度序，想要倒序再换一个——数据本身一个字不用动，排法穷举不完。

	`Comparable`	`Comparator`
写在哪	类内部，`compareTo`	类外部，`compare`
一个类能有几种排法	1 种（写死）	想要几种有几几种
用处	这是「我的自然顺序」	这是一次性临时排法

6.1.9 对象克隆#

clone() 定义在 Object 上，是 protected 的。要用它，类得先声明 implements Cloneable：

1
public class Employee implements Cloneable {
2
    @Override
3
    public Employee clone() throws CloneNotSupportedException {
4
        return (Employee) super.clone();
5
    }
6
}

Cloneable 是个标记接口——里面一个方法都没有，只用来「打标记」，告诉 JVM「这个类允许克隆」。没打这个标记调 clone()，抛 CloneNotSupportedException。

关键在 super.clone() 给的是什么：

浅拷贝——字段逐个复制，但引用字段只复制引用：副本和原对象指向同一个内部对象。谁改了它，两边一起变（4.2 讲过，对象变量里存的是地址，不是对象本身）。

要真正独立，得深拷贝——把可变的引用字段也克隆一份，接进新对象：

1
public class Employee implements Cloneable {
2
    private String name;          // 不可变：共享无所谓
3
    private LocalDate hireDay;    // 不可变：共享无所谓
4
    private Date birthDay;        // 可变：共享会出问题，必须深拷贝
5

6
    @Override
7
    public Employee clone() throws CloneNotSupportedException {
8
        Employee cloned = (Employee) super.clone();   // 浅：birthDay 只复制了引用
9
        cloned.birthDay = (Date) birthDay.clone();    // 深：这句才是关键
10
        return cloned;
11
    }
12
}

一句话版clone：clone() 只复制字段的值；引用字段的值是地址，所以副本和原对象指向同一个内层对象——要让副本彻底独立，就得把内层对象也各自复制一份，然后把默认的Object类强转成具体类。

vs C：这和 memcpy 是同一个坑——memcpy 也逐字节浅拷贝，指针字段复制过去的还是同一个地址。想复制指向的内容，只能自己手工再 malloc + memcpy 一遍，和这里的深拷贝是一个意思。

关于 <T>（Ch8 正式讲）：定义时随便起个名当占位，使用时必须填真类型。 填进去之后，接口里所有用这个名字的地方一起替换成那个类型。

6.2 lambda 表达式#

先记一句话：lambda 必须和接口搭配使用。 它自己没有类型，必须由一个函数式接口（只有一个抽象方法的接口）接住——下面每一处都会用到这一点。

注意这里说的是函数式接口、函数式接口、函数式接口！！！可以用4种方式赋值（独立实现类对象、匿名内部类、Lambda、方法引用），普通接口只能2种方式（前两种），详见04案例篇文章。

6.2.1 为什么引入 lambda 表达式#

回到 6.1.7 的回调。给数组按名字长度排序，得先造一个比较器对象：

1
Arrays.sort(words, new Comparator<String>() {
2
    public int compare(String a, String b) {
3
        return a.length() - b.length();
4
    }
5
});

六行，真正的逻辑只有 a.length() - b.length() 这一行。其余全是「起个类、写个方法签名、new 出来」的样板——这一类接口（只有一个抽象方法）实在太像函数了，Java 8 干脆给了个函数字面量，lambda：

1
Arrays.sort(words, (a, b) -> a.length() - b.length());

这一行看不见接口名——它藏在方法签名里：Arrays.sort 的第二个参数要的就是 Comparator。lambda 的目标类型就是从这儿来的。

lambda 就是「方法的字面量」：一段代码，没有名字、没有所属的类，直接当成值传出去。

6.2.2 lambda 表达式的语法#

1
(参数) -> 表达式
2
(参数) -> { 语句; ... }

lambda 本身没有类型，必须由左边某个函数式接口接住。所以下面都是完整写法：

1
Comparator<String> c1 = (String a, String b) -> a.length() - b.length();
2
// 完整写法
3
Comparator<String> c2 = (a, b)             -> a.length() - b.length();
4
// 参数类型可省
5
Function<Integer, Integer> f = x -> x + 1;
6
// 单个参数，括号也能省
7
Supplier<Integer> s1 = () -> 42;
8
// 没有参数
9
Supplier<Integer> s2 = () -> {
10
// 多条语句要花括号 + return
11
    System.out.println("go");
12
    return 42;
13
};

Function / Supplier 是 JDK 自带的函数式接口（java.util.function），6.2.7 会列全。这里先当它们是「收一个参数」和「不收参数」的接口。

参数类型能省掉，是因为编译器能从上下文推断出你要实现哪个方法——6.2.3 说清这件事。

6.2.3 函数式接口#

lambda 只能装进函数式接口：抽象方法恰好只有一个的接口。

注意别读成「接口只能有一个方法」。 接口可以有任意多个方法，函数式接口只数抽象方法——default / static / private 方法都有实现，不算数。Comparator 就是现成的例子：

1
@FunctionalInterface
2
public interface Comparator<T> {
3
    int compare(T a, T b);                      // ← 唯一的抽象方法，算数
4
    default Comparator<T> reversed() { ... }    // 有实现，不算
5
}

除了 compare，它还有 reversed（6.2.8 会用到）这类有实现的方法——都不影响函数式接口的身份。

为什么必须「只有一个」：lambda 只写了一段代码，编译器得知道它实现的是哪一个方法——接口里只有一个抽象方法，才没有歧义。

@FunctionalInterface 可写可不写，作用同 5.1 的 @Override：写了编译器替你检查「是不是真的只有一个抽象方法」，不满足就报错。不加也不影响运行。

6.2.4 方法引用#

如果 lambda 写出来是「把参数原样转交给某个方法」，还能再简写，用 ::：

1
x -> System.out.println(x)   // 等价于下面这个
2
System.out::println

System.out::println 字面就是「println 这个方法本身」。三种形式：

形式	例子	等价于
对象::实例方法	`System.out::println`	`x -> System.out.println(x)`
类::静态方法	`Math::sin`	`x -> Math.sin(x)`
类::实例方法	`String::compareToIgnoreCase`	`(a, b) -> a.compareToIgnoreCase(b)`

第三行要解释：String::compareToIgnoreCase 是实例方法，但它没有调用者——省略的调用者从参数里补：第一个参数 a 当接收者，剩下的 b 当实参。

三种写法，干的是同一件事。 从最啰嗦到最简洁：

① 写一个类（最啰嗦）

1
interface Printer { void print(String s); }
2

3
class ConsolePrinter implements Printer {   // 专门造一个类
4
    public void print(String s) {
5
        System.out.println(s);
6
    }
7
}
8

9
public class Demo1 {
10
    public static void main(String[] args) {
11
        Printer p = new ConsolePrinter();
12
        p.print("hello");                    // hello
13
    }
14
}

② lambda（类不要了）

1
interface Printer { void print(String s); }
2

3
public class Demo2 {
4
    public static void main(String[] args) {
5
        Printer p = s -> System.out.println(s);   // 只剩参数 + 方法体
6
        p.print("hello");                         // hello
7
    }
8
}

③ 方法引用（参数也省了）

1
interface Printer { void print(String s); }
2

3
public class Demo3 {
4
    public static void main(String[] args) {
5
        Printer p = System.out::println;   // 连参数名都不用写
6
        p.print("hello");                  // hello
7
    }
8
}

三个版本输出都是 hello。方法引用能成立的前提只有一条：lambda 里除了「把参数原样转交给某个方法」，什么都没干。

6.2.5 构造器引用#

类名::new，把「造对象」这件事本身交出去。同样得有个接口接着：

1
interface PointFactory { Point create(int x, int y); }   // 收两个参数，返回 Point
2

3
class Point {
4
    int x, y;
5
    Point(int x, int y) { this.x = x; this.y = y; }
6
}
7

8
public class Demo {
9
    public static void main(String[] args) {
10
        PointFactory f1 = (x, y) -> new Point(x, y);   // lambda 写法
11
        PointFactory f2 = Point::new;                  // 方法引用，效果完全一样
12

13
        Point p = f2.create(3, 4);
14
        System.out.println(p.x + ", " + p.y);          // 3, 4
15
    }
16
}

展开收起

一个类可能有多个构造器，Point::new 具体挑哪个，由目标接口的方法签名决定——接口方法收两个参数，就挑两参的那个构造器。

6.2.6 变量作用域#

lambda 能读外层局部变量：

1
int count = 10;
2
Runnable r = () -> System.out.println(count);   // ✅ 读，合法

但那个变量必须「初始化后不再改」（事实最终，effectively final）。一旦改过就编译不过：

1
int count = 0;
2
Runnable r = () -> count++;   // ❌ 编译错误：count 必须是事实最终

为什么禁止：lambda 捕获的是那一刻的副本，不是外层变量本身。副本里 count++ 改的是副本，外层的 count 纹丝不动——既然改了也没用，语言索性禁止，免得你以为改了。

所以 lambda 里不能改外层变量。要累计结果，得换一个可变的载体（比如对象的某个字段、数组元素）。

顺带：lambda 里的 this 指的是外围对象本身，不是这个 lambda。

6.2.7 处理 lambda 表达式#

这节讲一件事：你自己写的方法，怎么接收 lambda。

lambda 没有自己的类型，只能落在函数式接口上。所以「接收 lambda 的方法」，参数就写成函数式接口：

1
public class Demo {
2
    static void repeat(int times, Runnable task) {   // 参数是函数式接口
3
        for (int i = 0; i < times; i++) task.run();
4
    }
5

6
    public static void main(String[] args) {
7
        repeat(3, () -> System.out.println("hi"));   // 传 lambda 进去：输出 3 行 hi
8
    }
9
}

JDK 已经备好一批常用的（java.util.function），不用每次自己造：

接口	方法	含义
`Predicate<T>`	`boolean test(T)`	判断
`Consumer<T>`	`void accept(T)`	吃一个，不返回
`Function<T,R>`	`R apply(T)`	转换
`Supplier<T>`	`T get()`	生产一个
`Runnable`	`void run()`	无参无返回

（这些接口卷 II 讲 Stream API 时会大量出现，那时再细看。）

6.2.8 再谈 Comparator#

Comparator 上有一批静态工厂方法，配方法引用把排序规则压成一行：

1
Arrays.sort(people, Comparator.comparing(Employee::getName));   // 按名字排

而且能接着链下去：

1
people.sort(Comparator.comparing(Employee::getName)      // 先按名字
2
                     .reversed()                         // 倒序
3
                     .thenComparing(Employee::getSalary)); // 再按薪水

.reversed() 和 .thenComparing() 都是 Comparator 上的方法，返回的还是 Comparator，所以能一环扣一环——这就是链式调用成立的前提：每个方法都返回同类型的对象。

（6.1.4 留的问题，现在看懂不亏）签名里那个 <T> Comparator.comparing 的签名是 static <T> Comparator<T> comparing(...)。static 和返回类型中间多出来的 <T> 叫泛型方法：方法自己声明一个类型参数，作用范围只在这个方法里。
它跟接口头上 interface Comparator<T> 那个 T 毫无关系，只是恰好重名——接口那个跟着对象走，而 static 方法没有对象，够不着它，只能自己再造一个。验证办法：把它改名叫 U（static <U> Comparator<U> comparing(...)），一模一样能用；真是承接的话，改名早报错了。
还是看不懂就跳过——Ch8 会正式讲，不耽误往下读。

6.3 内部类#

6.3.1 使用内部类访问对象状态#

内部类最直接的价值：能访问外围类的私有字段。

1
public class TalkingClock {
2
    private int interval;
3

4
    private class TimePrinter implements ActionListener {
5
        public void actionPerformed(ActionEvent e) {
6
            System.out.println(interval);   // 直接读外围类的 private 字段
7
        }
8
    }
9
}

TimePrinter 能读 interval，别的类读不了。不违反封装——private 对「写在外围类代码里的成员」全都放行，内部类就在外围类的代码里。

（ActionListener + Timer 就是 6.1.7 的回调：外围类把内部类对象交给定时器，到点了回调 actionPerformed。）

6.3.2 内部类的特殊语法规则#

内部类对象里隐含着一个指向外围对象的引用——这就是它能读 interval 的物理原因。

1
public class Outer {
2
    private int interval = 1000;
3

4
    class Inner {
5
        void demo() {
6
            Outer outer = Outer.this;   // ① 外围对象：就是个 Outer 对象，能存进变量
7
            System.out.println(outer.interval);
8
        }
9
    }
10
}

1
public class Demo {
2
    public static void main(String[] args) {
3
        Outer outer = new Outer();
4
        Outer.Inner inner = outer.new Inner();
5
        // ② 外部造内部类；③ 类型名要从外面写全
6
        inner.demo();
7
    }
8
}

三样不是一类东西：Outer.this 是对象引用（① 能赋给 Outer 变量）；outer.new Inner() 是创建对象（② 先有外围对象才能造）；Outer.Inner 是类型名（③ 从类外面引用必须写全，类内部写 Inner 就够）。

容易混的是 Outer.class——那个才代表「这个类」，是个 Class 对象（5.9 讲过）。Outer.this 跟它完全不是一回事。

编译产物：内部类被编译成独立的 class 文件，文件名是 Outer$Inner.class。

6.3.3 内部类是否有用、必要和安全#

有用：能访问外围私有状态（6.3.1）；能把一个类藏起来——只服务外围那一个类，不占用类的成员列表，外界根本看不到它。

必要：不是非它不可。同样的事用「普通类 + 构造器传引用」也能做，只是啰嗦。

安全：编译器会生成 access$0 这类合成方法，让内部类绕过 private 检查去读外围字段。这说明 private 是编译期检查，不是运行时铁幕——5.9 的反射能开同一道门。

今天内部类的用途已经大幅收窄：匿名内部类那部分基本被 lambda 取代了（6.2.1），剩下的主要就是「需要直接访问外围私有状态」这一个场景。

6.3.4 局部内部类#

类也能定义在方法体内，作用域只在这个方法里：

1
public void start() {
2
    class TimePrinter implements ActionListener {   // 只在本方法内可见
3
        public void actionPerformed(ActionEvent e) { ... }
4
    }
5
    var t = new TimePrinter();
6
}

出了方法没人认识它。

6.3.5 由外部方法访问变量#

局部内部类能捕获外层方法的局部变量，规则和 lambda 完全一样：读可以，改不行，且必须是事实最终（6.2.6）。

1
public void start(int interval) {       // 方法参数也是「外层局部变量」
2
    class TimePrinter implements ActionListener {
3
        public void actionPerformed(ActionEvent e) {
4
            System.out.println(interval);   // ✅ 读，合法
5
        }
6
    }
7
}

原因也一样：捕获的是副本，改了也没用。

6.3.6 匿名内部类#

new 接口名() { ... }：没有名字、当场创建、只用一次。

1
var t = new ActionListener() {              // 不写类名，直接给实现
2
    public void actionPerformed(ActionEvent e) {
3
        System.out.println("到点了");
4
    }
5
};

省掉了「先起个名字、再 new」两步，代价是这个实现只能在创建它的地方用这一次。

lambda 出现前，这是回调的标准写法（6.2.1 那段六行代码就是匿名内部类）。现在单方法接口的匿名内部类基本都能换成 lambda；接口里有多个方法要一起实现时，还得用匿名内部类。

6.3.7 静态内部类#

加了 static 的内部类不绑定外围类实例，等于一个普通类、只是嵌套放在别人里面：

1
public class Outer {
2
    private static int counter;
3

4
    private static class Helper {        // 没有外围对象引用
5
        void bump() { counter++; }       // 只能碰 static 成员
6
    }
7
}

两种内部类的区别只有一条：非静态内部类带着「外围对象引用」（6.3.2 那个隐含引用），静态内部类没有。由此派生两点：静态内部类创建时不需要外围对象，也访问不到外围类的实例字段。

1
public class Outer {
2
    class A { }          // 非静态内部类
3
    static class B { }   // 静态内部类
4
}
5

6
Outer.B b = new Outer.B();   // 静态：直接 new，不需要外围对象
7

8
Outer o = new Outer();       // 非静态：必须先有一个 Outer 对象
9
Outer.A a = o.new A();

static 只管它自己那一层，不往下传。 外层是静态、内层不是，内层照样要实例：

1
public class Top {
2
    static class Mid {          // 静态：new 它不需要 Top 实例
3
        class Inner { }         // 非静态：仍然需要 Mid 实例
4
    }
5
}
6

7
Top.Mid m = new Top.Mid();          // 直接 new，到此为止
8
Top.Mid.Inner i = m.new Inner();    // Inner 不是静态的，还得要 m

所以准确的说法是：每个非静态内部类，都要依附「它紧邻的那一层」的实例——不是最外层。

需要「按功能打包、又不想单独开文件」时，首选静态内部类——少一个隐式引用，语义最简单。

6.4 服务加载器#

场景：你定了一个接口，别人写了很多实现，散在各处。你想把它们全部找出来用，但你不知道它们叫什么名字。

JDBC 就是这种情况。连数据库要靠「驱动」（一个 jar 包，里面是某个数据库「怎么连」的 Java 代码），而驱动有 MySQL 的、Oracle 的、PostgreSQL 的……你的代码不可能把每种驱动的类名都写一遍——写了 MySQL，换 Oracle 就得改代码、重新编译。

ServiceLoader 的办法很简单：让实现类自己报名。

定接口。JDBC 定的是 java.sql.Driver。
实现方自己登记。每个驱动 jar 里放一个文本文件，路径是固定的：

1
META-INF/services/java.sql.Driver

文件内容就一行，写自己的类名：

1
com.mysql.cj.jdbc.Driver

调用方去读名单：

1
ServiceLoader<Driver> loader = ServiceLoader.load(Driver.class);
2
for (Driver d : loader) {
3
    // 找到几个就遍历几个，一个实现类的名字都不用写
4
}

就这么回事：一个接口 + 一个固定路径的文本文件，运行时就能把所有实现找出来。

这个机制叫 SPI（Service Provider Interface）。JDBC 靠它工作，所以换数据库只需要换 jar，Java 代码一行不用改。

6.5 代理#

代理 = 你以为在调真的，其实中间隔了一层。

找人办事，对方门口有个秘书：你说「我要办 X」，秘书先记下来（可能还加一句「已登记」），再进去转达给本人。——秘书就是代理。

代码里也一样：你拿到一个对象，调它的方法；实际上它是个假对象，方法调用先被转交给你自己写的一段代码，那段代码干完自己的活，再去调真对象。

6.5.1 什么时候用#

日志、监控、权限检查这类事，每个方法都要有，但又不该混进业务代码里。

比如一个接口有 20 个方法，你想每个方法被调用时都打一行日志——总不能 20 个方法里各写一遍吧？代理能统一插在中间：20 个方法全走同一个入口，你在那个入口写一次就够了。

6.5.2 造一个代理#

先有接口和真实现：

1
interface Greeter {
2
    String greet(String name);
3
}
4

5
class RealGreeter implements Greeter {
6
    public String greet(String name) { return "你好，" + name; }
7
}

Proxy.newProxyInstance(...) 替你把这个假类现造出来，你要写的只有「方法被调到时干什么」：

1
class LogHandler implements InvocationHandler {
2
    private final Greeter target;                 // 包着真实现
3
    LogHandler(Greeter target) { this.target = target; }
4
  //构造器
5
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
6
        System.out.println("调用：" + method.getName());
7
    // ① 截住，先干自己的活
8
        return method.invoke(target, args);
9
    // ② 再转给真实现
10
    }
11
}

然后用它造代理：

1
Greeter real  = new RealGreeter();
2
Greeter proxy = (Greeter) Proxy.newProxyInstance(
3
    Greeter.class.getClassLoader(),   // 固定写法
4
    new Class[]{ Greeter.class },     // 代理要实现的接口
5
    new LogHandler(real)              // 方法被调到时跑它
6
);
7

8
System.out.println(proxy.greet("张三"));

输出：

1
调用：greet
2
你好，张三

这段里三样东西现在不用懂，各有去处：

看不懂的	在哪讲
`Method`、`method.invoke(...)`	5.9 反射——认得即可
`Greeter.class.getClassLoader()`	JVM（类加载那一篇）
`Proxy`、`InvocationHandler`	就是本节

看不懂不影响往下读。记住一句就够：代理是「中间站一个人，替你转达」。

6.5.3 代理类的特性#

代理类是运行时生成的，不是编译出来的，硬盘上没有对应源码或 class 文件；
它继承 Proxy，类名是 $Proxy0 这类；
只能代理接口，不能代理类。原因就是它已经 extends Proxy 了——Java 单继承，没法再成为你那个类的子类；而「实现接口」不受数量限制，所以代理接口没问题；
代理类里每个接口方法都转给 handler.invoke。

这就是 Spring AOP 的底层机制之一：接口用 JDK 动态代理，类用 CGLIB 生成子类。SSM 阶段会正面碰到。

12进阶:出事了怎么查

Thu, 15 Oct 2026 00:00:00 GMT

第 12 关出事了怎么查#

本关的产出：拿到一个起不来、退得快、或者连不上的容器，能在十分钟内定位到出错的那一层。

12.1 先看它是死是活#

第一眼看两样：

1
docker ps -a

STATUS：Up 3 seconds（在跑）、Exited (1) 2 minutes ago（退了）、Restarting（一直在重启）。
退了的，看括号里那个数——退出码。

退出码怎么读：

码	意思
`0`	正常结束（一次性的活儿干完了）
`1`	程序自己报错退了
`125`	`docker run` 本身就没跑起来（参数错）
`126`	要跑的命令不可执行
`127`	要跑的命令找不到
`137`	被 `SIGKILL` 打死（`128+9`）——常见于内存超限，或 `stop` 等超时后被强杀
`143`	被 `SIGTERM` 打倒（`128+15`）

137、143 是「信号编号 + 128」——第 8 关讲的信号，在这儿成了读数。

12.2 退了？先看日志#

1
docker logs <容器>

127：镜像里根本没有这个命令——CMD/ENTRYPOINT 写错了，或者你覆盖的那个命令不存在。
1：程序自己的报错，日志里通常写着。
日志是空的：要么它还没来得及输出就死了，要么它把日志写进了自己的文件、没往 stdout 写（第 11 关）。

12.3 `docker inspect`：字段怎么读#

现在轮到第 2 关那个「输出很长、没有解释」的东西。它打出来是一整段 JSON，不用全看，记住几个地方就够。

1
docker inspect <容器>

先看 State：

字段	看什么
`Status`	对应 `docker ps` 的 STATUS
`ExitCode`	就是 12.1 那张表
`Error`	启动失败的原因，往往比日志直接
`OOMKilled`	是不是内存超限被杀的（对得上 `137`）

再看 Config，它是「这条容器最终拿到的配置」：

字段	是什么	查什么
`Config.Cmd`	最终跑的启动命令	是不是你想跑的（被镜像名后面的参数顶掉了吗）
`Config.Entrypoint`	入口程序	有没有多套一层壳（第 8 关）
`Config.Env`	环境变量	你 `-e` 给的值进去了吗
`Config.ExposedPorts`	声明的端口	服务该在哪个端口
`Mounts`	挂载	目录真的挂上了吗、挂的是哪儿

一个很好用的观察：传 <容器> 进去时，Config.Env 是镜像默认值和你 -e 的值合并后的结果——一眼看得出这条容器最终拿到了什么，不用猜。

只看一项，用 --format，别在一大段 JSON 里翻：

1
docker inspect --format '{{.State.ExitCode}}' <容器>
2
docker inspect --format '{{json .Config.Env}}' <容器>
3
docker inspect --format '{{json .Mounts}}' <容器>

Cmd、Entrypoint 的含义第 3 关和第 8 关讲过，这里不重讲——本关只讲拿它们查什么。

12.4 连不上：先分三层#

「A 连不上 B」不是一个问题，是三个。按顺序查，每层都有证据：

名字没解析——A 根本不知道 B 是谁。
- docker exec A getent hosts B：解析不出来，就是这层。
- docker exec A cat /etc/resolv.conf：是不是 127.0.0.11（第 5 关）。
- 两个容器在不在同一张网：docker inspect A 的 NetworkSettings.Networks。
解析到了，但网络不通——包发不出去。
- 拿上一步的 IP 直接连：连不上，就是这层。
- 常见原因：一开始就没接上，或者接上之后又被 docker network disconnect 摘了（命令见第 5 关 5.3）。
网络通了，端口没人应答——包到了，门没人开。
- 要么服务没起，要么没就绪（第 7 关那个坑），要么端口写错了。

第 2 层和第 3 层，看报错就能分：

Connection refused → 到了，门没人开（第 3 层）。
Connection timed out → 包根本没到（第 2 层）。

这跟第 1 关那条「客户端连不上服务端」和「服务端上没东西」是同一个思路——先确定断在哪一段，再往下查。

别背具体地址。 解析出的 IP、resolv.conf 里的值，会随环境和 Docker 版本变（第 5 关也说过）。排查时只看 「这个地址是不是我要的那个」。

12.5 两个现成的例子#

例一：起不来——端口被占用

1
docker run -d -p 8080:80 nginx

报 bind: address already in use。谁占了？在宿主机上跑（不是进容器里）：

1
lsof -nP -iTCP:8080 -sTCP:LISTEN

结果随平台不同：

macOS：往往是 com.docker.backend——另一个容器已经把这个端口发布出去了（第 5 关）。
Linux：通常是 docker-proxy，也可能是任意一个在用 8080 的进程。
Windows：用 netstat -ano | findstr :8080（最后一列是 PID），再 tasklist /FI "PID eq <PID>" 看是哪个程序。

例二：连不上——mysql 还没就绪

第 2 关那个坑：mysql 第一次启动要先初始化十几秒，这期间连 3306 会被拒。不是密码错，也不是网络错。

1
docker logs <mysql容器>

还在初始化，就等；打印出 ready for connections，再连。要自动等，第 7 关的 healthcheck 是正解。

12.6 顺序#

十分钟排查，照这个顺序走：

docker ps -a——活着还是死了，退出码多少。
docker logs——它自己说了什么。
docker inspect——配置对不对（命令、环境变量、挂载、端口、网络）。
docker exec 进去——网络三层逐层验。

跟第 8 关的分界：第 8 关讲信号为什么传不到主进程（进程语义），本关讲出了事按什么顺序查（排查动作）。两关都会碰到「容器莫名其妙退出」，但一个解释原因，一个定位位置。

这一关的产出：一套从「死没死」到「哪一层」的排查顺序。下一关换到安全——同样的容器，怎么让它即使出错，也伤不到外面。

本关命令速查#

容器状态与排查，见命令速查表 · 容器生命周期、命令速查表 · 镜像。

Maven 教程

Thu, 15 Oct 2026 00:00:00 GMT

Maven 是 Java 世界的项目构建与依赖管理工具。写单个文件时 javac 一个、java 跑一个还够用；一旦项目用上第三方 jar、要打包分发，手工拼 classpath 就撑不住了。Maven 把「依赖从哪来、代码放哪、怎么编译打包」这套事标准化下来。

本文只讲 Maven 本身（构建 + 依赖）；Gradle、CI/CD、私服搭建不在范围内。阅读前需要会命令行，装好 JDK（见 Java 背景和基本结构）。

1. Maven 是什么#

1. 从「jar 地狱」说起

手工用库是这样的：要发个 HTTP 请求，得下 httpclient.jar，可它又依赖 httpcore.jar、commons-logging.jar……版本还得对得上——这版 httpclient 只认那版 httpcore。项目一多，几十个 jar 摆在 lib/ 里，升级一个牵动一片，删错一个编译就炸。这个状态叫依赖地狱（dependency hell）。

Maven 把这件事从「手工管理文件」变成「声明坐标」——每个库用它的 g/a/v 三件套标识（groupId / artifactId / version，详见第 4 节），Maven 认这组坐标去取。

与其他生态对照#

生态	依赖管理	构建
Java	Maven / Gradle	Maven / Gradle
C / C++	手工下库	Make / CMake
Node.js	npm / pnpm	npm
Python	pip	脚本 / Make

2. 它替你管两件事

依赖管理：你只声明「我要用 mysql-connector-j 8.4.0」，Maven 自动去仓库下载它，把它的传递依赖也一并解析出来，统一放进 classpath。不用再手动下 jar、手动 -cp 拼。
构建：把「编译 → 测试 → 打包 → 安装」固定成命令，一条 mvn package 从源码出 jar。

对照 C：相当于把 Make/CMake 干的活（构建）和「去官网下库、手动摆好头文件和 .lib」干的活（依赖），合成一套标准工具。零散敲 javac 是更原始的状态。

3. POM：项目的说明书

Maven 项目的核心是一个 XML 文件 pom.xml（Project Object Model，项目对象模型）。项目坐标、依赖、插件、构建配置全写在里面。看到 pom.xml 就知道这是个 Maven 项目。

4. 约定优于配置

Maven 规定好默认的目录结构、输出目录、生命周期。照约定放文件就几乎不用配置，要偏离约定时才去 pom 里改。这是它「开箱即用」的原因。

5. 它不只是构建工具

所有构件都用坐标（g/a/v）在全球范围内唯一标识，任何一个项目都能靠坐标引用仓库里的任何构件——这让 Java 生态有了统一的「包管理中心」。对照其它语言：Node 有 npm，Python 有 pip，Java 这边就是 Maven 仓库，而 Maven 兼做客户端与构建工具（Gradle 也用它同一套仓库）。

2. 项目结构#

Maven 的标准目录（约定优于配置的具体体现）：

1
my-app/
2
├── pom.xml
3
├── src/
4
│   ├── main/
5
│   │   ├── java/          ← 主代码（.java，按包分目录）
6
│   │   └── resources/     ← 主资源（配置、SQL 等，会被打进 classpath）
7
│   └── test/
8
│       ├── java/          ← 测试代码
9
│       └── resources/     ← 测试资源
10
└── target/                ← 构建输出（编译产物、jar），自动生成

src/main/java：源代码的根。包名 com.example.app 对应子目录 src/main/java/com/example/app/。也就是说，目录结构必须与 package 声明一致。
src/main/resources：非代码资源，构建时被复制到 classpath 根下。db.properties 这类配置文件放这里，代码里就能当 classpath 资源读。
src/test/*：测试代码与测试资源，只在跑测试时参与，不打包。
target/：构建输出目录，编译出的 .class、打的 jar 都在这。每次构建重新生成，只属于产物、不进版本库，写进 .gitignore。

之所以是 src/main/java 而不是「随便放」，就是第 1 节的约定优于配置：Maven 知道去哪儿找源码、去哪儿放产物，你才不用每次告诉它。

在 IDEA 里：直接用 IDEA 打开 pom.xml（或包含它的目录），它会自动识别为 Maven 项目并导入依赖；右侧边栏的 Maven 面板可以双击执行生命周期。IDEA 内置的 Maven 和自己的命令行 Maven 用的是同一套本地仓库。

.gitignore 至少要有：

1
target/

3. 安装与配置 ★#

3.1 前置：JDK#

Maven 自己不编译 Java，它调用 JDK。先确认有 JDK、且 JAVA_HOME 指向它：

Terminal window

1
java -version

没有的话先装 JDK，见 Java 背景和基本结构。

3.2 安装#

macOS（Homebrew）：

Terminal window

1
brew install maven

通用（解压式）：下载 apache-maven-x.y.z-bin.tar.gz（或 .zip），解压到任意目录，把其中的 bin 加进 PATH：

Terminal window

1
# ~/.zshrc 或 ~/.bashrc
2
export PATH="/opt/apache-maven-3.9.9/bin:$PATH"

Windows 则把解压后的 bin 目录加进系统环境变量 Path。无论哪种方式，都要保证 JAVA_HOME 在环境变量里，Maven 靠它找 JDK。

3.3 验证#

Terminal window

1
mvn -v

输出三行左右：

1
Apache Maven 3.9.9 (...)
2
Maven home: /opt/apache-maven-3.9.9
3
Java version: 17.0.10, vendor: Eclipse Adoptium

能看到就装好了。如果 Maven 版本对、Java 那行却报错或指向 JRE，回头看 JAVA_HOME。

3.4 settings.xml：本地仓库与镜像#

Maven 有两处配置文件：

位置	作用域	建议
`$MAVEN_HOME/conf/settings.xml`	全机器（所有用户）	少动
`~/.m2/settings.xml`	当前用户	改这个，不动安装目录、升级不丢

~/.m2/ 是 Maven 的用户目录，本地仓库和 settings 都在这里。用户级文件不存在时新建一个即可。下面是一份最小可用的 ~/.m2/settings.xml（独立文件，不在 pom.xml 里）：

1
<?xml version="1.0" encoding="UTF-8"?>
2
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
3
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
5
  <localRepository>${user.home}/.m2/repository</localRepository>
6
  <mirrors>
7
    <mirror>
8
      <id>aliyunmaven</id>
9
      <mirrorOf>*</mirrorOf>
10
      <name>阿里云公共仓库</name>
11
      <url>https://maven.aliyun.com/repository/public</url>
12
    </mirror>
13
  </mirrors>
14
</settings>

里面主要就两项：

localRepository（本地仓库）：下载的 jar 存哪。默认 ~/.m2/repository，位于用户主目录、通常就在系统盘；jar 越攒越多会占掉可观空间，想挪到别的磁盘就改这里。
mirror（镜像）：Maven 默认从国外中央仓库取包，国内很慢，第一次构建常卡在下载。<mirrorOf>*</mirrorOf> 表示所有仓库请求都改走这个地址；若只想代理中央仓库、不影响别的仓库，写成 <mirrorOf>central</mirrorOf>。

4. pom.xml 骨架#

最小的可构建 pom.xml——下面是整个文件，<project> 是根元素：

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

7
  <groupId>com.example</groupId>
8
  <artifactId>my-app</artifactId>
9
  <version>1.0-SNAPSHOT</version>
10
  <packaging>jar</packaging>
11
</project>

modelVersion：POM 模型的版本，固定 4.0.0，照抄。
project 上的 xmlns / xsi 是 XML 命名空间与 schema 声明：Maven 构建不依赖它，但带上 IDE 才能按 POM 的 XSD 校验、补全，所以照抄即可。真正必须的只有下面的 modelVersion。
groupId / artifactId / version：坐标，三件套唯一确定一个构件。
packaging：产物类型，jar（默认，不写也是 jar）/ war / pom。

坐标（g/a/v）

元素	含义	惯例
`groupId`	所属组织	域名倒写：`com.example`、`org.apache`
`artifactId`	项目（构件）名	小写短横线：`my-app`、`spring-boot-starter-web`
`version`	版本号	`1.0.0`、`1.0-SNAPSHOT`

三点说明：

坐标不仅标识你自己，也是引用别人的方式——引入依赖时写的就是对方的 g/a/v，例如 com.mysql:mysql-connector-j:8.4.0。
版本号主体（如 1.0）自己定，但末尾的 -SNAPSHOT 是 Maven 的保留后缀，拼写和位置固定、不能改写。SNAPSHOT 表示「开发中快照」——同一个版本号可以反复覆盖重发、会被重新拉取；但正式版本（1.0.0）一旦发布就不该再改。
命名允许的字符有限（字母、数字、-、_），别用中文或空格。

properties：自定义变量（写在 <project> 下，与 groupId 同级）

1
<properties>
2
  <maven.compiler.release>17</maven.compiler.release>
3
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
4
</properties>

定义后用 ${...} 引用。maven.compiler.release 告诉编译器按哪个 Java 版本编译，能避免 JDK 版本与目标版本不匹配的报错；project.build.sourceEncoding 统一源码编码，防乱码。这两个几乎是每个项目的标配。

5. 依赖管理 ★#

5.1 dependencies：声明依赖#

写在 <project> 下，与 groupId 同级：

1
<dependencies>
2
  <dependency>
3
    <groupId>com.mysql</groupId>
4
    <artifactId>mysql-connector-j</artifactId>
5
    <version>8.4.0</version>
6
  </dependency>
7
</dependencies>

不写 <version> 会报错。声明后 Maven 自动下载并放进编译与运行 classpath。坐标去 mvnrepository 搜库名，页面上直接给出 g/a/v，复制粘贴即可。

5.2 scope：依赖的作用范围#

<scope> 写在某个依赖内部（嵌在 <project> → <dependencies> → 某个 <dependency> 里），和 <groupId> / <version> 同级：

1
<dependency>
2
  <groupId>org.junit.jupiter</groupId>
3
  <artifactId>junit-jupiter</artifactId>
4
  <version>5.10.2</version>
5
  <scope>test</scope>
6
</dependency>

不写 <scope> 就是默认的 compile。四种常用取值：

scope	编译	测试	运行	打包	典型例子
`compile`（默认）	✅	✅	✅	✅	通用库（Jackson）
`test`	❌	✅	❌	❌	JUnit
`provided`	✅	✅	❌	❌	`servlet-api`（容器提供）
`runtime`	❌	✅	✅	✅	JDBC 驱动

compile 是默认值，不写就是它。
test 只在测试代码里可见，主代码想引用会编译失败。
provided 编译时要用、运行时由容器提供，所以不打进包——典型是 Servlet API，Tomcat 里已经有了，你打进去反而冲突。
runtime 编译时不直接调它的类（靠反射/SPI 加载），运行时才需要，所以进包但不参与编译。

另有 system（引用本地文件路径，不可移植，不推荐）、import（只在 dependencyManagement 里用），认得即可。

5.3 传递依赖#

依赖会传染：A 依赖 B、B 依赖 C，你引入 A，Maven 就自动把 B 和 C 一起解析进来。省事，代价是依赖树会膨胀、版本会打架。比如你的直接依赖引了 commons-logging:1.1，另一条传递链引了 commons-logging:1.2，同一个库出现了两个版本——这就是依赖冲突。

5.4 依赖冲突与仲裁#

同一构件被不同路径引入不同版本时，Maven 按两条规则选一个（就近原则）：

最短路径优先：谁离你「更近」用谁的。以「依赖层数」算路径长度。直接依赖长度为 1，永远赢过传递来的（≥2）。
- 例：你直接声明 A:1.0，而 B → C → A:2.0，则用 A:1.0。
最先声明优先：路径长度相同时，谁在 dependencies 里先写用谁的。
- 例：A:1.0 和 A:2.0 都是长度 2 的传递依赖，则写在前面的那条链带来的版本胜出。

排查冲突：

Terminal window

1
mvn dependency:tree

打印整棵依赖树（含坐标与 scope），顺着看每个构件从哪条路径来、最终选了哪个版本。想只看某个库：

Terminal window

1
mvn dependency:tree -Dincludes=commons-logging

5.5 exclusions：排除传递依赖#

不想让某个传递依赖进来（版本不对、有漏洞、用不上），在引入它的那条 <dependency> 内部排掉（位置同样在 <project> → <dependencies> → <dependency> 里）：

1
<dependency>
2
  <groupId>com.example</groupId>
3
  <artifactId>lib-a</artifactId>
4
  <version>1.0</version>
5
  <exclusions>
6
    <exclusion>
7
      <groupId>com.example</groupId>
8
      <artifactId>lib-c</artifactId>
9
    </exclusion>
10
  </exclusions>
11
</dependency>

exclusion 只写 g/a 即可，不必写版本。

5.6 dependencyManagement：统一版本#

dependencyManagement 用在多模块项目：顶层父 pom 统一登记各子模块要用的依赖版本（多模块见第 8 节）。它只登记版本、不真的引入依赖——子模块要用某个库时照常写 <dependency>，但可以省掉 <version>，版本从这里的父 pom 取。

父 pom（写在它的 <project> 下）：

1
<dependencyManagement>
2
  <dependencies>
3
    <dependency>
4
      <groupId>com.mysql</groupId>
5
      <artifactId>mysql-connector-j</artifactId>
6
      <version>8.4.0</version>
7
    </dependency>
8
  </dependencies>
9
</dependencyManagement>

子模块（写在它自己的 <project> 下）——引用同一坐标就不用再写版本：

1
<dependencies>
2
  <dependency>
3
    <groupId>com.mysql</groupId>
4
    <artifactId>mysql-connector-j</artifactId>
5
  </dependency>
6
</dependencies>

一句话区分：dependencies 是「我依赖它」，dependencyManagement 是「如果谁依赖它，用这个版本」。

5.7 optional：可选依赖#

<optional> 写在依赖内部（<project> → <dependencies> → <dependency> 里），和 <version>、<scope> 同级：

1
<dependency>
2
  <groupId>com.example</groupId>
3
  <artifactId>lib-a</artifactId>
4
  <version>1.0</version>
5
  <optional>true</optional>
6
</dependency>

加了它之后，这个依赖不会被传递给下游——别人依赖你时，你的可选依赖不会自动变成他的。适合「只在特定场景用、不想强加给使用者」的库。

注意方向和 5.5 的 exclusions 相反：exclusions 挡的是传进来的（我不要），optional 挡的是传出去的（我不给）。

6. 构建流程 ★#

6.1 三套生命周期#

Maven 把构建拆成三套互相独立的生命周期，每套是一串阶段（phase）：

生命周期	作用	主要阶段
`clean`	清理	`pre-clean` → `clean` → `post-clean`
`default`	构建（核心）	`validate` → `compile` → `test` → `package` → `verify` → `install` → `deploy`
`site`	生成站点文档	`pre-site` → `site` → `post-site` → `site-deploy`

关键规则：执行某个阶段，会先依次执行它前面的所有阶段。比如 mvn package 实际依次跑了 validate → compile → test → package——所以打包前会自动编译、自动跑测试；测试不过，打包就中断。

三套生命周期彼此独立，所以跨生命周期时，命令里写多个阶段就按书写的先后执行：mvn clean package 是先跑 clean 生命周期（删 target/）、再跑 default 到 package（编译测试打包）。顺序不能随手换——写成 mvn package clean 就变成「先打包、再删掉 target/」，等于白干。（只有同一个生命周期内写多个阶段时，顺序才由生命周期定，永远向后推进。）

6.2 default 各阶段含义#

compile：编译 src/main/java 到 target/classes
test：编译并运行 src/test/java 里的单元测试
package：把编译产物打成 jar/war，产出到 target/
install：把包装进本地仓库（3.4 里 localRepository 配的那个目录），同机器其他项目才能依赖到它
deploy：上传到远程仓库（私服）

中间还有 resources（复制资源）、test-compile 等细阶段，日常不用记，知道大流程即可。

6.3 阶段与插件 goal 的绑定#

Maven 核心只管流程骨架，真正干活的是插件：每个阶段（phase）绑定了一个或多个插件的目标（goal）。常用的绑定：

阶段	默认绑定的插件目标
`resources`	`maven-resources-plugin:resources`
`compile`	`maven-compiler-plugin:compile`
`test`	`maven-surefire-plugin:test`
`package`	`maven-jar-plugin:jar`（war 则是 `maven-war-plugin:war`）
`install`	`maven-install-plugin:install`
`deploy`	`maven-deploy-plugin:deploy`

日常用默认插件就够了；要定制（换编译版本、打可执行 jar、加代码检查）才在 <build><plugins> 里配置插件及其 goal。

6.4 常用命令#

Terminal window

1
mvn clean              # 删掉 target/
2
mvn compile            # 编译主代码
3
mvn test               # 跑测试
4
mvn package            # 打包 → target/*.jar
5
mvn install            # 打包 + 装进本地仓库
6
mvn clean package      # 先清理再打包（最常用）
7
mvn clean install      # 先清理、打包、装本地仓库

一次可以写多个阶段，按顺序执行。
-DskipTests 跳过测试执行（仍编译测试代码）：mvn clean package -DskipTests。
-U 强制更新 SNAPSHOT 依赖（忽略本地缓存）。
-o 离线模式，只用本地仓库。
-e 出错时打印完整堆栈，-X 打印 debug 日志，排查构建问题时有用。

6.5 打包产物#

target/my-app-1.0-SNAPSHOT.jar：普通 jar，只含你自己的类，不含依赖。所以它单独跑不起来——java -jar 会因找不到依赖的类而报错。要让一个 jar 能独立运行，得打胖 jar（fat jar）：把自己的类和全部依赖合并进同一个 jar，并写明入口类；由 maven-shade-plugin / maven-assembly-plugin 生成。
war：packaging 为 war 的 Web 项目产物，丢进 Tomcat 的 webapps 目录部署。它和 jar 的区别：jar 是通用包（库或程序），无固定内部结构，由 JVM 运行或作依赖引用；war 是 Web 应用专用包，内部按约定放 WEB-INF/（web.xml、类、lib/ 里的依赖 jar）和页面资源，由容器加载部署——war 里其实就装着 jar。
install 的意义：只有装进本地仓库，别的项目才能用 g/a/v 依赖到它——多模块之间的依赖就靠这一步。

7. 仓库#

Maven 从三种仓库找构件，顺序：本地 → 远程（镜像 / 私服）→ 中央。

仓库	位置	说明
本地仓库	`~/.m2/repository`	下载过的都缓存在这，永远先查这里
中央仓库	`repo.maven.apache.org`	全世界公共构件，通常经镜像访问
私服	公司内网	Nexus / Artifactory，代理中央 + 存内部构件

本地仓库按坐标组织成目录：groupId 的 . 换成 /，再接 artifactId/version/。例如 com.mysql:mysql-connector-j:8.4.0 落在：

1
~/.m2/repository/com/mysql/mysql-connector-j/8.4.0/mysql-connector-j-8.4.0.jar

构件下不动时，删掉对应目录（或整个本地仓库）重新构建即可——本地仓库随时能重建，是纯缓存，删了不会丢东西。

私服是企业内网的中间仓库：对外代理中央仓库（并缓存），对内存放公司自研构件。好处是快、可控、能审计，还能保存不对外发布的内部库。你自己搭私服不在本文范围，知道有这一层就行。

8. 模块管理：聚合与继承#

项目变大时拆成多个模块（如 common、dao、web）：每个模块是一个独立的小 Maven 工程，各有自己的 pom.xml；顶层再放一个 pom 把它们串起来，一条命令整体构建。顶层这个叫父 pom（或聚合 pom），被它管的模块叫子模块。父 pom 对子模块有两种关系，可单用也可合用：

别把「模块」和 Java 的「包」（package）混了：模块是一个独立工程（有自己的 pom.xml、src/、坐标，产出一个 jar）；包只是模块内部源码的目录分组。一个模块里有很多包，一个包只属于一个模块。

聚合（aggregation）：父 pom 用 <modules> 列出子模块（写在父 pom 的 <project> 下），一条命令构建全部。

1
<packaging>pom</packaging>
2
<modules>
3
  <module>common</module>
4
  <module>dao</module>
5
  <module>web</module>
6
</modules>

<module> 里填的是子模块所在目录的相对路径（相对父 pom），不是坐标——common 就指同级那层 common/ 目录（里面有自己的 pom.xml）。它常和该模块的 artifactId 同名，但填的是位置。

继承（inheritance）：子模块用 <parent> 声明父 pom（写在子模块的 <project> 下，通常紧跟 <modelVersion>），继承父的配置——依赖版本（靠 dependencyManagement）、properties、插件、groupId 等。

1
<parent>
2
  <groupId>com.example</groupId>
3
  <artifactId>my-parent</artifactId>
4
  <version>1.0-SNAPSHOT</version>
5
  <!-- 父 pom 不在上级目录时用 <relativePath> 指路 -->
6
</parent>

两者常一起用：父 pom 既聚合子模块，又被子模块继承。区别一句话——聚合是「一起构建」，继承是「共享配置」。父 pom 的 packaging 必须是 pom（它不产出 jar），并且它通常只放配置、不放业务代码。

典型结构：

1
my-project/
2
├── pom.xml          ← 父：packaging=pom，列 modules，管 dependencyManagement
3
├── common/pom.xml   ← 子：parent 指向父
4
├── dao/pom.xml
5
└── web/pom.xml

在父目录执行 mvn clean install，会按模块间依赖顺序依次构建全部子模块。

9. properties 与 profile#

properties：pom 内的变量（写在 <project> 下，与 groupId 同级），${...} 引用，减少重复、方便统一改。

1
<properties>
2
  <mysql.version>8.4.0</mysql.version>
3
</properties>
4
...
5
<version>${mysql.version}</version>

除自定义外，也能引用 Maven 内置的变量。它们不来自代码，而是来自 Maven 解析出的项目模型与运行环境：

${project.*}：当前 pom 里的信息，如 ${project.version}（就是这份 pom 的 <version>）、${project.groupId}、${project.build.directory}（构建输出目录，默认 target）
${settings.*}：来自 settings.xml，如 ${settings.localRepository}
${env.*}：环境变量，如 ${env.JAVA_HOME}
${basedir}：pom 所在的目录

profile：按条件切换配置（<profiles> 写在 <project> 下）。比如开发/生产两套配置，用 -P 激活：

1
<profiles>
2
  <profile>
3
    <id>prod</id>
4
    <properties>
5
      <!-- 自定义属性：名字随便起，这里放生产库的 JDBC 连接串 -->
6
      <db.url>jdbc:mysql://prod-host:3306/mydb</db.url>
7
    </properties>
8
  </profile>
9
</profiles>

db.url 不是 Maven 的固定标签，是自定义属性（名字随你起），值是一串 JDBC 连接地址；定义后在 pom 别处用 ${db.url} 引用。不同 profile 给同一属性不同的值，切 profile 就换了值——在命令行激活上面的 prod 就写 mvn package -Pprod（-P 的值贴着或空一格都行，-P prod 等价）。

profile 还能按条件自动激活（<activation><jdk>17</jdk></activation> 之类），或定义在 settings.xml 里做「只在某台机器生效」的配置。日常知道能手动 -P 切换即可。

10. 实战：把手工作坊改造成 Maven 工程#

第一阶段那种 javac Hello.java 的裸工程，一旦要用第三方库（比如 MySQL 驱动）就得手动下 jar、手动 -cp。Maven 化之后：源码挪进 src/main/java、依赖写进 pom、一条命令构建。

下面这个例子用「能否拿到 MySQL 驱动」来验证依赖确实被拉进来了——不需要本机装 MySQL，跟着敲就能跑通。

1. 建目录

1
demo/
2
├── pom.xml
3
└── src/main/java/com/example/App.java

2. 写 pom

1
<project xmlns="http://maven.apache.org/POM/4.0.0"
2
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4
  <modelVersion>4.0.0</modelVersion>
5
  <groupId>com.example</groupId>
6
  <artifactId>demo</artifactId>
7
  <version>1.0-SNAPSHOT</version>
8
  <properties>
9
    <maven.compiler.release>17</maven.compiler.release>
10
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
11
  </properties>
12
  <dependencies>
13
    <dependency>
14
      <groupId>com.mysql</groupId>
15
      <artifactId>mysql-connector-j</artifactId>
16
      <version>8.4.0</version>
17
    </dependency>
18
  </dependencies>
19
</project>

展开收起

3. 写 App.java

1
package com.example;
2

3
import java.sql.Driver;
4
import java.sql.DriverManager;
5

6
public class App {
7
    public static void main(String[] args) throws Exception {
8
        // 不连数据库，只问 DriverManager：有没有能处理 jdbc:mysql:// 的驱动
9
        Driver driver = DriverManager.getDriver("jdbc:mysql://localhost:3306/");
10
        System.out.println("驱动已就位: " + driver.getClass().getName()
11
                + " v" + driver.getMajorVersion() + "." + driver.getMinorVersion());
12
    }
13
}

DriverManager.getDriver 只查「哪个驱动认这个 URL」，不会真的建立连接，所以不需要本机有 MySQL。能打印出驱动类名，就说明 Maven 把 mysql-connector-j 下载并放进了 classpath——本节要演示的正是这一点。

4. 构建

Terminal window

1
mvn clean package

第一次会去下载 MySQL 驱动及其依赖（配了镜像才快），之后缓存进本地仓库。构建日志会打印每个阶段（clean → compile → test → package），产物在 target/demo-1.0-SNAPSHOT.jar。

5. 运行

最直接的是在 IDEA 里点 App 的 main 方法旁的运行按钮。若要在命令行跑同一个主类：

Terminal window

1
mvn exec:java -Dexec.mainClass=com.example.App

拆解这行：exec:java 是「调用 exec-maven-plugin 的 java 目标」，写法是 插件前缀:目标——它和 clean / package 那种生命周期阶段不是一回事；-Dexec.mainClass=... 是传给该插件的参数，指定要运行的全限定类名。

跑出来会打印 驱动已就位: com.mysql.cj.jdbc.Driver v8.4 之类——Maven 把驱动下载并放进了 classpath，工程跑通。

对比改造前后：不用再手动找 jar、手动拼 classpath；换机器只要 mvn package 就能重建整个可运行工程。这就是后面 JDBC 命令行工具要用的地基。

附录#

常见报错对照#

报错	原因	解决
`mvn: command not found`	PATH 没配	把 Maven `bin` 加进 `PATH`
`No compiler is provided... Did you mean JAVA_HOME`	找到的是 JRE 不是 JDK，或 `JAVA_HOME` 没设	装 JDK，`JAVA_HOME` 指向 JDK 根
`Could not find artifact` / `Could not resolve dependencies`	坐标写错，或镜像没配、仓库里没有	核对 g/a/v；配阿里云镜像
`invalid target release: 17`	`maven.compiler.release` 高于当前 JDK	改成 JDK 支持的版本，或升级 JDK
`程序包 xxx 不存在` / `cannot find symbol`	依赖没加，或 scope 不对	补 `dependency`；检查 scope
依赖版本不符预期	传递依赖冲突	`mvn dependency:tree` 定位，用 `exclusions` / `dependencyManagement` 压
`... was cached in the local repository, resolution will not be reattempted`	之前下载失败被缓存	加 `-U` 强制更新
下载卡住 / 极慢	走的国外中央仓库	配镜像
`Could not transfer ... Connection refused`	代理 / 网络 / 私服不可达	检查网络与代理，或换镜像

pom 元素位置速查#

pom.xml 里每个元素写在哪儿：

元素	写在哪
`modelVersion`	`<project>` 下
`groupId`	`<project>` 下
`artifactId`	`<project>` 下
`version`	`<project>` 下
`packaging`	`<project>` 下
`parent`	`<project>` 下
`properties`	`<project>` 下
`dependencyManagement`	`<project>` 下
`dependencies`	`<project>` 下
`modules`	`<project>` 下
`profiles`	`<project>` 下
`build`	`<project>` 下
`dependency`	`<dependencies>` 内（`<dependencyManagement>` 里也有一个同名 `<dependencies>`）
`scope`	`<dependency>` 内
`optional`	`<dependency>` 内
`exclusions`	`<dependency>` 内
`exclusion`	`<exclusions>` 内
`module`	`<modules>` 内
`profile`	`<profiles>` 内
`plugin`	`<build>` → `<plugins>` 内

settings.xml 的 settings / localRepository / mirrors / mirror 属于 settings.xml，不在 pom 里。

术语速查#

术语	含义
POM	Project Object Model，即 `pom.xml`，项目配置的总文件
坐标（g/a/v）	`groupId` / `artifactId` / `version`，全局唯一标识一个构件
构件（artifact）	一个可被依赖的产物，如一个 jar
生命周期	`clean` / `default` / `site` 三套构建流程
阶段（phase）	生命周期中的一步，如 `compile`、`package`
插件（plugin）	真正执行任务的组件，如 `maven-compiler-plugin`
目标（goal）	插件里的一个具体任务，绑定到阶段上执行
scope	依赖的作用范围：`compile` / `test` / `provided` / `runtime`
传递依赖	A 依赖 B、B 依赖 C，则 A 间接依赖 C
依赖仲裁	冲突时按「最短路径优先、最先声明优先」定版本
胖 jar（fat jar）	把自己的类与依赖打进同一个可执行 jar

常用命令速查#

命令	作用
`mvn -v`	看版本 / 环境
`mvn clean`	清 `target/`
`mvn compile`	编译
`mvn test`	跑测试
`mvn package`	打包
`mvn install`	打包 + 装进本地仓库
`mvn dependency:tree`	看依赖树
`mvn clean package -DskipTests`	清理打包、跳过测试
`mvn -U clean package`	强制更新依赖后重新构建
`mvn -e -X ...`	打印完整错误 / debug 日志

参考资料#

Apache Maven 官方文档：https://maven.apache.org/guides/
依赖坐标查询：https://mvnrepository.com/

C语言从小白变怪兽

Wed, 14 Oct 2026 00:00:00 GMT

如题，《C语言从小白变怪兽》其实是一本网络教程，我认为其详尽程度吊打任何一本C语言书籍（特殊方向除外）。由西电 严长生 大佬撰写，不过其原本网站C语言中文网貌似已经停运。但是依旧不影响传阅其打包后的PDF格式教程，算上付费内容一共大概600余页，质量很高，我当时直接打印成三本A3纸质版上中下三卷阅读。不论是初学者还是深耕多年的老码农，都很适合翻阅，一定获益匪浅。

当然，为了避免侵权或者不必要的麻烦，本站不提供下载链接，你可以直接搜到这本PDF教程的下载资源，相信你的计算机素养！

C语言是一门非常适合作为入门的第一门编程语言，很多大学都把C语言程序设计作为计算机科班的大学第一课，有效的培养初学者变量、内存、函数等等基本意识，《小白变怪兽》中尤其是付费章节把所有初学者可能问到为什么的问题几乎都涵盖了进去。文章组织能力堪称一绝！

11进阶:日志与磁盘治理

Wed, 14 Oct 2026 00:00:00 GMT

第 11 关日志与磁盘治理#

本关的产出：知道磁盘被谁吃、容器的日志落在哪、怎么给它设上限，以及为什么「清一遍」不等于解决。

11.1 空间被谁吃了#

第 1 关用过 docker system df，现在把它的四行看仔细：

1
docker system df

分别是 镜像、容器、卷、构建缓存。加 -v 能看到每一项具体是谁：

1
docker system df -v

第 1 关只到「怎么看、怎么收」。这一关解决两个问题：这些东西是怎么长起来的，以及为什么随手一清治不了根。

11.2 日志：落在哪，能长多大#

先分清两种「日志」——第 1 关提过一次：docker logs 给的是容器里主进程往标准输出（stdout/stderr）写的那点东西，不是 Docker 自己的日志。

这些输出，Docker 会一路接住、存成文件。文件在哪：

1
docker inspect --format '{{.LogPath}}' <容器>

打出来是 /var/lib/docker/containers/<容器ID>/<容器ID>-json.log。docker logs 读的就是它。

要注意的两点：

这个路径在「跑 Docker 引擎的那台机器」上，不一定就是你面前这台：Linux 上它就是本机路径，能直接打开（多半要 root）；macOS、Windows 上 Docker 跑在虚拟机里，宿主机够不到它。
默认没有任何上限。 只要容器在往 stdout 写，这个文件就一直长——一个话多的容器，能把磁盘写满。这是「磁盘莫名被吃掉」最常见的一个来源。

要观察：容器一删，这个文件跟着删（它就在容器的目录底下）。所以 docker system prune 清掉一个已停止的容器时，顺带把它那份日志也清了。

11.3 给它设个上限#

不给上限，就只能等它出事。两个地方可以设。

一次性的，写在 run 里：

1
docker run -d --log-opt max-size=10m --log-opt max-file=3 nginx

max-size 是单个日志文件的上限，max-file 是最多留几个。写满了就轮转——新的进来，最旧的丢掉。

一次设好、全局生效（推荐）。Docker 那个守护进程（第 1 关说的「服务端」）有一份自己的配置文件，叫 daemon.json——它启动时读一遍，里面的设置对所有容器生效。日志上限就写在这儿：

1
{
2
  "log-driver": "json-file",
3
  "log-opts": { "max-size": "10m", "max-file": "3" }
4
}

文件在哪，随平台不同：

Linux：/etc/docker/daemon.json，直接编辑；
macOS / Windows（Docker Desktop）：这文件在它的虚拟机里，不去摸路径——用 Settings → Docker Engine 那个界面改，改的就是同一个文件。

改完重启 Docker 生效。之后每个新容器都自带这套上限。compose 里也可以用 logging: 段设同样两项。

代价要讲清：轮转意味着旧日志会被丢。docker logs 只能看到最后几个文件里的内容。真要长期留，得把日志送到别处（日志系统的活，不在本系列）。

易踩的坑：改 daemon.json 只对新起的容器生效，已经在跑的容器不受影响——要它们也受约束，得重建。

11.4 为什么 `prune` 治不了根#

docker system prune 清的是：已停止的容器、没在用的网络、悬空镜像、构建缓存。它有两个够不着的地方：

它不碰正在跑的容器的日志。 日志不在它管的四类里——一个跑着的容器把磁盘写满，prune 一点忙都帮不上。
清完很快就长回来。 构建缓存会再攒、匿名卷会再造（第 4 关和第 9 关都点过）、日志会再写。

所以 prune 是扫帚，不是堵源头。真要让空间不出事，靠的是前面几关那些源头上的约束：

日志设上限（11.3）；
.dockerignore 挡掉不该进镜像的东西（第 3 关）；
RUN 里装完就清、清在同一条指令里（第 9 关）；
别随手造匿名卷（第 4 关、第 9 关的 VOLUME）。

错觉：就算清掉了虚拟机里的东西，也不一定立刻还给宿主机。Docker Desktop 那块磁盘镜像（在设置里能看到的那个上限）是只长不缩的。所以 df 里回收了、宿主机的可用空间却没动，别慌——那不是没清掉。

11.5 清一遍#

原则是先看清楚再动手，别上来就一把梭。

1
docker system df -v

然后按需要、按类清，每一类各有一条：

1
docker container prune     # 已停止的容器
2
docker image prune         # 悬空镜像
3
docker image prune -a      # 没被任何容器引用的镜像（更狠）
4
docker network prune       # 没在用的网络
5
docker volume prune        # 没被使用的卷
6
docker builder prune       # 构建缓存

一把清：

1
docker system prune              # 容器 / 网络 / 悬空镜像 / 构建缓存
2
docker system prune -a --volumes # 连没用的镜像和卷也清

易踩的坑：这些 prune 都不问你，确认都没有了才跑。-a 和 --volumes 尤其要看清——前者把没在用的镜像全删（下次构建得重新拉底），后者会删掉只是暂时没挂载的卷。

这一关的产出：知道磁盘被谁吃、给日志设了上限、也明白清理是扫帚不是根治。下一关反过来——不是空间出了问题，而是服务起不来、连不上，怎么在十分钟内定位到出错的那一层。

本关命令速查#

系统清理与日志，见命令速查表 · 系统与清理。

03继承与反射

Wed, 14 Oct 2026 00:00:00 GMT

第 5 章继承#

5.1 类、超类和子类#

4.3 写的 Employee 已经是个完整的类。现在假设公司里还有一类人——经理。经理也是雇员：同样有姓名、薪水、入职日期，只是多一项奖金。

最笨的办法是把 Employee 的字段和方法在 Manager 里抄一遍。继承解决的正是这件事——公共部分留在父类，子类只写差异：

1
public class Manager extends Employee {
2
    private double bonus;                          // Manager 独有的字段
3
    public void setBonus(double b) { bonus = b; }
4
}

extends 后面只能跟一个类——Java 是单继承。

定义子类#

子类自动拥有父类的全部字段和方法，一个都不用重写。这里的「拥有」是数据层面——Manager 对象里确实含着 name、salary、hireDay 这三份。

但能不能访问是另一回事，取决于成员用的修饰符。4.3 里我们把 Employee 的字段设成了 private，于是在 Manager 的代码里读写 name 都编译不过——不只是不能写，读也不行，javac 报的是 cannot find symbol（没有这个名字）。

四个访问修饰符的完整规则：

修饰符	本类代码	同包其他类	不同包的子类	不同包非子类
`private`	✅	❌	❌	❌
默认（不写）	✅	✅	❌	❌
`protected`	✅	✅	✅	❌
`public`	✅	✅	✅	✅

private 那一行就是 Employee 字段所处的位置——连子类（第三列）都不行。

注意这张表管的是能不能碰，它不区分「只读」和「可写」：碰得到就既能读也能写。想只读要另想办法——字段加 final（构造后定死），或者干脆不给 setter、只给 getter（4.3.8 讲过）。

还有一条比表更根本的：访问权限跟「代码写在哪个类里」走，不跟对象走。 name 在 Employee 的代码里能碰，在 Manager 的代码里碰不到，哪怕说的是同一个对象。

覆盖方法#

子类写一个同名同参数的方法，就把父类那版替换掉：

1
@Override
2
public double getSalary() {
3
    return super.getSalary() + bonus;   // 先拿父类算的那份，再加奖金
4
}

super.getSalary() 调的是父类那一版的实现。this 是「这个对象」，super 是「父类的实现」，别混。

@Override 是注解（annotation），不是注释——注释给人看、编译器完全忽略；注解是给编译器看的，编译器会据此检查。它不是必需的，但强烈建议写：不写的话，你以为覆盖了，其实是新加了一个方法，要跑起来才发现。

这就是 4.3.6 讲的 fail fast，只是挪到了编译期——让错误在最早、最便宜的环节暴露。附带的好处是重构保险：父类一旦改了方法名或参数，所有写了 @Override 的子类会立刻全部报错，自动把该跟着改的地方列出来。

vs C：C 没有覆盖机制，也没有虚函数表，「同一个调用走不同实现」只能靠函数指针手工搭。

子类构造器#

子类构造器的第一行必须调用父类构造器：

1
public Manager(String name, double salary, int year, int month, int day) {
2
    super(name, salary, year, month, day);   // 第一行
3
    bonus = 0;
4
}

写 super(...) 就调父类对应的那个；一行都不写，编译器自动插一句无参的 super()。所以父类只有有参构造器时，子类不手写 super(...) 就编译不过。

为什么必须这样：每个 Manager 对象里都含着一份「Employee 的部分」，这部分只能由 Employee 自己的构造器初始化——字段是 private，子类碰不到；就算碰得到，父类的初始化逻辑也是封在它自己构造器里的。

继承层次结构#

一个父类可以有多个子类，层层往下构成一棵树。Employee 是 Manager 的超类（superclass），Manager 是子类（subclass），同一条链往上的都叫祖先。

多态#

父类类型的变量可以指向子类对象：

1
Employee e = new Manager("张三", 50000, 2000, 1, 1);
2
e.getSalary();   // 跑的是 Manager 那一版

跑哪个实现由对象的真实类型决定，不由变量的类型决定——这就是多态。

两种声明摆一起，能看清各自管什么：

1
Manager m = new Manager("张三", 50000, 2000, 1, 1);
2
Employee e = new Manager("张三", 50000, 2000, 1, 1);

两者指向同一个对象，行为只差一处：

getSalary()——Manager 和 Employee 里都有：m 和 e 完全一样，都走 Manager 那一版。
setBonus()——只有 Manager 里有：m 能调，e 编译不过。

所以规则准确说是：父类变量看不到「子类新增」的成员。关键在「子类新增」，不在 setBonus 这个名字——如果哪天 Employee 里也声明了 setBonus，e.setBonus() 立刻就能编过，而且走的仍是 Manager 那一版。

一句话：对象的类型决定「调的是哪一版」，变量的类型决定「你能调什么」。 所以两种声明唯一的差别就是：Employee e 能调的方法集更小，少了子类新增的那部分。底层对象没变，要用得先转型回来。

好处是一个只认 Employee 的方法能自动有限的处理所有子类，将来新增子类也不用改它：

1
public static void printSalary(Employee e) { ... }

反过来不行。子类变量不能指向父类对象——父类对象里没有子类特有的成员（这里就是 bonus），拿到了也使不上：

1
Manager m = new Employee(...);   // ❌ 编译错误

理解方法调用#

多态靠两步分开走实现：

阶段	看什么	决定什么
编译期	变量的类型	这方法能不能调
运行期	对象的真实类型	具体跑哪一个实现

1
Employee e = new Manager(...);
2
e.getSalary();
3
// 编译期：Employee 里有 getSalary，放行
4
// 运行期：e 实际是 Manager → 跑 Manager.getSalary()

这叫动态绑定。private / static / final 方法不走这套——它们要么不能被覆盖、要么和对象无关，编译器直接静态绑定，省掉运行时查找。

阻止继承#

final 加在类上，谁都不能继承它；加在方法上，子类不能覆盖它。

强制类型转换#

把父类引用转回子类，要写 (Manager) e。

编译期一律放行——编译器只知道 e 的变量类型是 Employee，看不见里面装的到底是哪个子类的对象。所以这次转型成不成，编译器不表态，留到运行期用对象的真实类型来判：

1
Employee e1 = new Manager(...);
2
Employee e2 = new Employee(...);
3

4
(Manager) e1;   // ✅ 运行期通过，它确实是 Manager
5
(Manager) e2;   // ❌ ClassCastException

e2 那种情况就是 5.1.5 说的「父类对象里没有子类特有的成员」——转型相当于向编译器承诺「里面有 bonus」，兑现不了就当场翻车。

所以向下转型不能盲转，用之前得先确认对象的真实类型。这正是下一小节 instanceof 要解决的问题。

vs C：C 的指针强转只是把这块内存重新解释一遍——转错了不报错也不崩，只是悄悄读出垃圾；Java 的引用转型会实地检查，最多抛异常，不会让你读坏内存。

instanceof 模式匹配#

一个典型用法是这样：

1
public static void giveBonus(Employee e, double amount) {
2
    if (e instanceof Manager m) {     // 判断 + 转型，一步完成
3
        m.setBonus(amount);           // m 已经是 Manager 类型，不用再强转
4
    }
5
    // 不是 Manager 就什么都不做
6
}

instanceof 判断通过的同时，把 e 转成 Manager 并赋给 m（Java 16+）。老写法要两行：

1
if (e instanceof Manager) {
2
    Manager m = (Manager) e;
3
    m.setBonus(amount);
4
}

除了少写一行，模式匹配还把 m 的作用域限制在 if 块内——出了块这个名字就没了，所以你不可能拿到一个没验证过的引用。

受保护访问#

protected 介于 private 和 public 之间——就是 5.1.1 那张表里的第三行：子类（哪怕在不同包）和同包都能访问。

它是专门为继承准备的。想让子类直接读写某个字段或调用某个方法，又不想让包外的无关类碰，就用 protected。

实际写代码时能用 private 就用 private，protected 只留给明确需要被子类改的成员。

5.2 Object：所有类的超类#

前提一句：所有类都隐式继承 Object——没写 extends 的类，也自动是 Object 的子类。

Object 类型的变量#

Object 类型的引用能指向任何对象（它是一切类的祖先），但拿到手只能当 Object 用，要用回原类型得转型。

equals 方法#

用来比内容：a.equals(b)。这条补上 4.1 留下的口子——== 比的是身份，比内容要用 equals。

Object 默认的 equals 比的就是身份（和 == 一样），所以想比内容必须自己重写。

相等测试与继承#

Object 给的 equals 只比身份，想比内容就得自己重写——这一小节就是教你怎么写对。

用在哪里：想让两个「内容相同」的对象被判为相等的时候。典型是放进 HashSet 去重、或当 HashMap 的键（Ch9 讲集合时会正面碰到），以及业务上判断「这两条是不是同一份数据」。

不是每个类都要写——不写就沿用 Object 那版（比身份），只有需要比内容的类才重写。下面这段写在 Employee 类里，是个普通方法，代码只留了方法本身：

1
@Override
2
public boolean equals(Object other) {
3
    if (this == other) return true;                   // 同一个对象，直接真
4
    if (!(other instanceof Employee)) return false;   // 类型不对（含 null），直接假
5
    Employee o = (Employee) other;                    // 类型确认过了，转型安全
6
    return name.equals(o.name)                        // 字段逐个比
7
        && salary == o.salary;
8
}

逐个交代：

形参必须写 Object，不能写 Employee。写成 Employee 就变成重载而不是覆盖了，@Override 会立刻报错——正是 5.1.2 说的那个保险在起作用。
this == other 是快速通道：同一个对象，内容必然相同，后面全都不用查了。
!(other instanceof Employee) 一句挡掉两种坏情况：类型不对，以及 null（null instanceof X 恒为假）。
最后一行 name 用 equals、salary 用 ==——因为 name 是 String（对象，比内容得用 equals），salary 是 double（基本类型，== 就是比数值）。

最后是一个进阶边界，不了解也不影响正常使用——如果子类也重写了 equals，而且把条件收得更严，就会不对称：

1
// Employee.equals: other instanceof Employee → 比 name、salary
2
// Manager.equals:  other instanceof Manager  → 再多比一个 bonus
3

4
e.equals(m);   // 真：Manager 也是 Employee
5
m.equals(e);   // 假：e 不是 Manager

同两个对象，两条 equals 给出相反答案。

修法是父类里改用 getClass() 判断：

1
if (getClass() != other.getClass()) return false;

getClass() 返回的是一个 Class 对象——它代表这个对象运行时所属的那个类（既不是 Object，也不是 Employee 实例）。同一个类在整个 JVM 里只有一个这样的对象，所以两个 Class 用 != 比，就等于在问「这两个对象是同一个类吗」。Class 是反射的入口，5.9 会正面讲，这里只要知道它「代表所属的类」就够了。

这样两边都要求「类完全相同」，子类不算，不对称就不会出现——代价是父类和子类不再互相相等，但这本来就是你想要的。

hashCode 方法#

和 equals 必须配对重写：两个 equals 相等的对象，必须有相同的 hashCode。只改一个，塞进 HashMap / HashSet 就会出错（Ch9 讲集合时展开）。

1
@Override
2
public int hashCode() {
3
    return Objects.hash(name, salary);
4
}

toString 方法#

返回对象的字符串表示。println(对象)、字符串拼接都会自动调用它，调试时最常用：

1
@Override
2
public String toString() {
3
    return "Employee[name=" + name + ", salary=" + salary + "]";
4
}

为什么这里必须重写这三个成员？ 因为调它们的不是你，是 JDK——println(e) 内部调 toString()，set.add(e) 内部调 hashCode() 和 equals()。这些通用代码只知道「拿到的是个 Object」，唯一敢调的就是 Object 上定义的方法。所以只有覆盖它们，库才能按你的语义工作；自己另起名（printMe()）只有你自己会调。

不覆盖也不报错，只是库会用错默认语义：打印成 Employee@1b6d3586、内容相同的对象被判为不等（去重失效）、存进 HashMap 找不回来。

vs C：C 的对象没有公共祖先，比较、打印都得各自实现；Java 靠 Object 把这三件事统一到了所有类型上。

5.3 泛型数组列表#

ArrayList 就是会自动扩容的数组。

声明数组列表#

1
ArrayList<Employee> staff = new ArrayList<>();   // 菱形语法：右边省略类型，编译器从左边推断

尖括号里写「这个列表装什么类型」。（泛型的正式内容在 Ch8，这里先认得写法。）不指定初始容量也能用，满了会自动扩。

访问数组列表元素#

1
staff.add(e);          // 追加到末尾
2
staff.get(i);          // 取第 i 个
3
staff.set(i, e);       // 替换第 i 个
4
staff.remove(i);       // 删掉第 i 个
5
staff.size();          // 元素个数

注意取长度的写法三种类型都不同：数组是 arr.length（字段，没有括号），String 是 s.length()，ArrayList 是 list.size()——最后一个的名字是 size，不是 length。

vs C：C 的数组长度写死，要动态数组得自己 malloc / realloc / free；ArrayList 把这套活儿包了。

类型化与原始数组列表的兼容性#

老代码里的裸 ArrayList（不带尖括号）和类型化的混用会出警告。了解即可，自己写别用裸的。

5.4 对象包装器与自动装箱#

每个基本类型都有一个对应的包装器类：int → Integer、double → Double、char → Character，等等。作用是把基本类型包成对象，好塞进集合这类「只能装对象」的地方：

1
ArrayList<Integer> list = new ArrayList<>();
2
//ArrayList<int> 编译不过
3
list.add(3);          // 自动装箱：int 3 → Integer
4
int n = list.get(0);  // 自动拆箱：Integer → int

这层「包起来」和「拆开」由编译器自动补上，叫自动装箱 / 拆箱。

一个坑：包装器是对象，所以两个包装器用 == 比的是身份（4.1 那条），比内容必须用 equals。

vs C：C 里基本类型就是基本类型，没有「包成对象」这回事。

5.5 参数个数可变的方法#

printf(String fmt, Object... args) 里的 ... 是可变参数——调用时可以传任意多个实参：

1
public static double max(double... values) {
2
    double largest = Double.NEGATIVE_INFINITY;
3
    for (double v : values) if (v > largest) largest = v;
4
    return largest;
5
}
6

7
max(3.1, 4.5);         // 传几个都行
8
max(3.1, 4.5, 2.0);

编译器把它当数组处理——double... values 就是 double[] values，方法体里按数组用（上面那个 for-each 就是）。两者唯一的差别在调用端：写成 double... 才能 max(3.1, 4.5) 散着传；写成 double[] 就只能 max(new double[]{3.1, 4.5})。

一个方法最多一个可变参数，而且必须放在参数列表最后。

别和 main 搞混：main(String[] args) 声明的是数组，命令行上 java MyApp foo bar 看着像散着传，其实是 JVM 替你打包的，跟 ... 无关。

5.6 抽象类#

抽象方法只写声明、不写方法体：

1
public abstract class Person {
2
    private String name;
3
    public Person(String name) { this.name = name; }
4
    public String getName() { return name; }
5

6
    public abstract double getSalary();   // 只有声明，没有实现
7
}

类里只要有抽象方法，这个类就必须声明成 abstract
抽象类不能 new
除此之外它和普通类一样：可以有字段、构造器、普通方法

它的关键不在「分开」，而在强制：抽象方法等于父类声明「这件事必须有，但我不规定怎么做」，编译器替你盯着——任何具体子类都必须实现它，否则编译不过。普通继承靠子类自觉（忘了覆盖也能编过），抽象方法把这种「忘了」变成编译错误——还是 4.3.6 那个 fail fast。

vs C：C 没有抽象类，想表达「这个函数必须由使用者自己实现」只能靠文档约定，编译器帮不上忙。

5.7 枚举类#

它解决的是一组「固定取值」没有类型约束的问题。 比如尺寸只有小/中/大，若用 public static final int 常量来表示，size = 999 编译器一声不吭——谁都能造出非法值。enum 把范围锁死：

1
public enum Size { SMALL, MEDIUM, LARGE }

取值只能是列出来的这几个，别的编译不过：

1
Size s = Size.MEDIUM;      // ✅
2
Size t = "MEDIUM";         // ❌ 编译错误，它不是字符串
3
Size u = 999;              // ❌ 编译错误

它是真正的类（编译后就是一个 class），所以能有字段、方法、构造器——不只是「一组带名字的常量」。给枚举加成员怎么写，属于进阶用法，这里不展开。

vs C 的 enum：C 的枚举本质就是 int 常量，随便拿个整数赋值都能过编译；Java 的枚举值不能乱造，类型检查在编译期就兜住了。

5.8 密封类#

sealed 限定哪些类可以继承我，名单外的编译不过：

1
public sealed class Shape permits Circle, Square { }

硬规矩：sealed 类的直接子类必须三选一表态，少一个就编译不过：

子类怎么写	含义
`final`	到此为止，谁都不能再继承我
`sealed`	我也限制，名单写在我的 `permits` 里
`non-sealed`	解封——从我往后恢复成普通类，随便继承
什么都不写	❌ 编译错误

1
public final class Circle extends Shape { }        // 到此为止
2
public non-sealed class Square extends Shape { }   // 想继承随你

为什么要表态：sealed 是「继承被我用名单管住」，可管到哪一层为止，得由每一环自己交代——不然编译器不知道你是想继续封着，还是放开。

Java 17 引入。它和 5.1 的 final 是两个极端：final 谁都不许继承，sealed 只许名单内的继承。

5.9 反射#

反射 = 让程序在运行时「看自己」：拿到一个类，能查出它有哪些字段、方法、构造器，还能当场调用。

先说定位：自己动手写反射，日常极少。它是框架的地基——Spring 的依赖注入、Jackson 转 JSON、JUnit 找 @Test，背后全靠它。所以你通常是使用者而不是作者。但不懂它就读不懂框架报错（NoSuchMethodException 这类），也解释不了「为什么很多框架要求无参构造器」这种日常坑。这一节的目标是认得它、读得懂报错，不是会手写。

Class 类#

每个类都有一个 Class 对象，它是反射的入口：

1
Class<?> c1 = e.getClass();                        // 从对象拿
2
Class<?> c2 = Manager.class;                       // 直接写
3
Class<?> c3 = Class.forName("com.example.Manager"); // 从类名拿

尖括号里的 ? 是个通配符，读作「任意类型」——Class<?> 的意思就是「某个类的 Class 对象，具体是哪个我不点名」。

它严格说不是必须的：写成光秃秃的 Class 也能编译，只是那叫「原始类型」，编译器 / IDE 会提示不规范：

1
Class<?> c1 = e.getClass();   // ✅ 规范
2
Class    c2 = e.getClass();   // 能编译，但「原始类型」，不推荐

之所以用 ? 而不填一个具体类型（比如 Class<Manager>）：e.getClass() 返回的到底是哪个类，写代码的时候不知道，只有运行时才知道——「是某个类、但说不定是哪个」，正是 ? 的用场。

声明受查异常 / 资源#

⚠️ 这节其实是异常的内容（Ch7 讲），书里放在这里只是因为反射 API 会抛受查异常。这里只记一句：受查异常必须在方法上声明，或用 try 包住。

利用反射分析类的能力#

拿到 Class 对象后，能查出这个类的成员：

1
Class<?> c = Manager.class;   // 有了 Class 对象就能开始查
2

3
c.getName();                  // 类名
4
c.getDeclaredFields();        // 所有字段
5
c.getDeclaredMethods();       // 所有方法
6
c.getDeclaredConstructors();  // 所有构造器

使用反射在运行时分析对象#

拿到字段之后，能读出某个对象当前的值——包括 private 的：

1
Employee e = new Employee("张三", 50000, 2000, 1, 1);
2

3
Class<?> c = e.getClass();               // ① 拿到 Employee 的 Class
4
Field f = c.getDeclaredField("salary");  // ② 找到名为 salary 的字段
5
f.setAccessible(true);                   // ③ salary 是 private，先开门
6
double s = f.getDouble(e);               // ④ 读出这个对象的该字段值

setAccessible(true) 是关键一步——它把 private 那道门打开了，所以反射能读到普通代码碰不到的字段。5.1.1 说连子类都碰不到父类的 private，反射却可以——这正是它危险的地方。

使用反射编写泛型数组代码#

Array.newInstance(...) 这类，实用性低，扫一眼即可。

调用任意方法和构造器#

1
Manager boss = new Manager("张三", 50000, 2000, 1, 1);
2

3
Class<?> c = boss.getClass();// ① 拿到 Class
4
Method setBonus = c.getDeclaredMethod("setBonus", double.class);
5
// ② 找方法：名字 + 参数类型
6
setBonus.invoke(boss, 1000.0);
7
// ③ 在 boss 上调用，实参 1000.0

调用构造器是同一套，只是把「找方法」换成 getDeclaredConstructor(...)、「调用」换成 newInstance(...)。

代价：绕过了编译期检查，写错要到运行期才炸，而且慢。日常业务代码很少直接用，用得最多的是框架。

vs C：C 编译后类型信息基本被抹掉，运行时拿不到「这个结构体有哪些成员」；Java 的 class 文件里保留了完整类型信息，所以能反射。

5.10 继承的设计技巧#

公共的字段和方法往父类提，子类只留差异。
不要用继承表达「has-a」。Order 有 Customer，那是聚合（4.1 讲过），写成 Order extends Customer 就错了。判断法：B 是不是「一种」A，是才用继承。
覆盖方法时不要改变约定的行为。父类的 getSalary 是「返回薪水」，子类不能把它改成「发邮件」。
多用多态、少用类型判断。instanceof 和强制转换堆多了，通常说明设计出了问题——该把差异做成方法，让子类自己去实现。
优先组合。能靠「装一个对象当字段」解决的，就不要用继承。

10进阶:推送与自动化构建

Tue, 13 Oct 2026 00:00:00 GMT

第 10 关推送与自动化构建#

本关的产出：把镜像推到一个别人也能拉的地方，给它定一套经得起用的标签，再让机器替你构建和推送。

10.1 镜像怎么出门：仓库#

前面九关，镜像都只躺在这台机器上（docker images 里那些）。要让它「出门」——给别人用、给服务器用、给 CI 用——就得放进一个仓库（registry）里：你往里推，别人从里拉。

最常用的仓库是 Docker Hub；此外还有 GitHub 的 ghcr.io、GitLab 的、云厂商的，也能自己搭一个。

第 3 关说 FROM nginx 时「本地没有它会先去拉」——它去的就是 Docker Hub。那些镜像，正是别人推上去的。

推之前先登录：

1
docker login

不带参数就是登 Docker Hub，会让你输用户名和密码。正经场景该用 access token，不是账号密码（10.5 会用上）。

10.2 推送的三步#

先看要推的东西叫什么：

1
docker images

REPOSITORY 那一列就是镜像的名字。而一个完整的名字有四段：

1
[仓库地址/] 命名空间/ 名字 : 标签

第 3 关打的 mysite:1.0，前两段都省了——省掉时默认是 Docker Hub、和你的账号。

第一步，给镜像打上「仓库认的那个名字」：

1
docker tag mysite:1.0 <你的用户名>/mysite:1.0

docker tag 不复制镜像，只是给同一个镜像再挂一个名字——原来的 mysite:1.0 还在。

第二步，推：

1
docker push <你的用户名>/mysite:1.0

第三步，换台机器拉：

1
docker pull <你的用户名>/mysite:1.0

易踩的坑：docker push 时，名字必须带上仓库里的那段路径。直接 docker push mysite:1.0 会报错——mysite:1.0 在 Docker Hub 上没有归属，它不知道该往谁那儿推。

10.3 `latest` 不是「最新」#

第 3 关留的那个坑，在这儿收：latest 不是「最新版本」，它只是「没写标签时的默认标签」。

docker build -t mysite . → 实际名字是 mysite:latest；
docker run nginx → 实际是 nginx:latest；
docker pull nginx → 拿的也是 latest。

麻烦在于：它不保证是最新的，而且随时会变。CI 每推一次都覆盖 latest，于是——

今天 docker pull app:latest 和明天拉的，可能是两个完全不同的程序；
服务器上跑的那份，你没法从「它写的是 latest」反推是哪个版本；
想回滚时，latest 指向哪儿，你说了不算。

所以生产上别用 latest，用明确的版本：mysite:1.0，或者干脆用提交号 mysite:sha-a1b2c3d。

配一条约定：同一个名字下，一个版本标签推上去就不再动它（发了 1.0 就别再覆盖 1.0），要改就发新号。这样 1.0 永远指同一份东西，能复现、能回滚。

10.4 digest：指向「这一份内容」#

版本标签是你起的名字，靠上面的约定保证它不变。还有一种编号是内容自己算出来的，叫 digest：

1
nginx@sha256:...

它由镜像内容哈希得来，内容变一个字节，digest 就变——所以它天生不可变，没有「指着同一份、其实变了」这回事。

看一个镜像的 digest：

1
docker inspect --format '{{index .RepoDigests 0}}' nginx

要「绝对确保跑的就是这一份」，就用 digest 引用。日志、事故报告、锁死的生产版本，都该记 digest 而不是标签。（日常还是用版本标签，好念；digest 是较真时的最后一道保险。）

10.5 让机器来推：CI 与多架构#

手动 build 再 push 迟早会忘。交给 CI——推一个 tag 或合并到主分支，机器自动构建、自动推。

以 GitHub Actions 为例，仓库里放一个 .github/workflows/build.yml：

1
name: build-and-push
2
on:
3
  push:
4
    tags: ["v*"]                    # 只在推 v 开头的 tag 时触发
5
jobs:
6
  build:
7
    runs-on: ubuntu-latest
8
    steps:
9
      - uses: actions/checkout@v7
10
      - uses: docker/login-action@v4
11
        with:
12
          username: ${{ secrets.DOCKERHUB_USERNAME }}
13
          password: ${{ secrets.DOCKERHUB_TOKEN }}
14
      - uses: docker/build-push-action@v7
15
        with:
16
          push: true
17
          tags: ${{ secrets.DOCKERHUB_USERNAME }}/mysite:${{ github.ref_name }}

展开收起

三点：

凭据不写进文件，放 GitHub 仓库的 secrets 里，用 ${{ secrets.xxx }} 取；CI 里用的是 access token（就是 10.1 提的那个）。
tags: 用 github.ref_name——即触发的那个 tag 名（如 v1.0）。这正是 10.3 说的「用明确版本」。
整件事不在你的电脑上发生——全在 CI 的一台临时机器上。镜像从源码直接进仓库，不经过你。

多架构：同一份镜像要让 Intel 服务器和 ARM 服务器（Apple 芯片、新云主机）都能跑，得分别构建、再合成一个「多架构镜像」。这一步交给 buildx，加两行：

1
      - uses: docker/setup-buildx-action@v4
2
      - uses: docker/build-push-action@v7
3
        with:
4
          push: true
5
          platforms: linux/amd64,linux/arm64
6
          tags: ${{ secrets.DOCKERHUB_USERNAME }}/mysite:${{ github.ref_name }}

推上去仍是一个名字。docker pull 的时候，Docker 自动挑跟当前机器匹配的那个架构——拉的人不用管。

这一关的产出：镜像能推到仓库、标签定得起经得起用、构建交给 CI。下一关换个方向——容器跑起来之后，它的日志和磁盘会悄悄长大，那是另一类日常麻烦。

本关命令速查#

镜像的推送与标签，见命令速查表 · 镜像。

09进阶:构建进阶与镜像瘦身

Mon, 12 Oct 2026 00:00:00 GMT

第 9 关构建进阶与镜像瘦身#

本关的产出：让重复构建稳定命中缓存、明显变快，并把构建工具从最终镜像里清出去。

9.1 第 3 关留下的下半场：构建也能复用#

第 3 关讲分层时说过一句没展开的话：层能被复用，构建的时候也一样。

docker build 会逐条读 Dockerfile，给每条指令算一个「指纹」：RUN 的指纹是那条命令本身，COPY 的指纹是复制进去的文件内容，FROM 的指纹是基础镜像。

指纹和上次一样 → 这一层直接拿上次的，不重跑，输出里打 CACHED。不一样 → 重做，并且从这里往下，每一步都不再复用（后面都建在它上面）。

（逐条看结果：docker build 的输出就是一行一条。）

9.2 顺序决定命中：把不常变的放前面#

拿一个 Node 应用举例：

1
FROM node:20
2
WORKDIR /app
3
COPY . .
4
RUN npm install
5
CMD ["node", "server.js"]

能跑，但改一行源码就触发 COPY . . 失效 → 它后面每一步全部重来，包括最慢的 npm install。源码天天改，依赖几周才动一次，这个顺序把最贵的活儿排在了最容易失效的地方。

换个顺序：

1
FROM node:20
2
WORKDIR /app
3
COPY package*.json ./
4
RUN npm install
5
COPY . .
6
CMD ["node", "server.js"]

现在依赖清单单独先复制。改源码 → COPY package*.json 没变、npm install 那层命中 CACHED，只有最后的 COPY . . 重做，秒级完成。改依赖 → 从 COPY package*.json 起重做，该跑的照跑。

规矩一句话：不会变的放前面，会变的放后面。

易踩的坑：某一层的指纹一变，它后面所有层都不再复用——不是只有那一条重做。所以最贵的指令（装依赖、编译）要尽量排在前面、排在很少变的输入后面。

9.3 多阶段构建：把构建工具挡在门外#

9.2 那份 Dockerfile 还藏着更大的浪费：它把整个 node 装进了最终镜像。可跑起来的应用只要那几份产物，编译它的那套工具根本不该上生产。

多阶段构建就是干这个的：

1
# 第一段：编译
2
FROM node:20 AS build
3
WORKDIR /app
4
COPY package*.json ./
5
RUN npm ci
6
COPY . .
7
RUN npm run build
8

9
# 第二段：成品
10
FROM nginx:alpine
11
COPY --from=build /app/dist /usr/share/nginx/html

一份 Dockerfile，两个 FROM，就是两个阶段：

build 阶段（AS build 给它起名）装依赖、编译，产出一堆构建垃圾。
成品阶段从 nginx:alpine 重新开始——干干净净，上一阶段的 node 不带过来，只把 dist 里那点成果拷进来。

关键在 COPY --from=build /app/dist /usr/share/nginx/html 这一行。它的第一个参数从哪儿算，看有没有 --from：

没有 --from（普通 COPY）：从 docker build 末尾那个 . 交出去的目录里找；
有 --from=build：改从 build 阶段的文件系统里取。

上一阶段用完就扔，不进最终镜像。

结果：最终镜像 = nginx:alpine 加一份静态文件，node 那一大坨（几百 MB）留在门外。这就是「1GB → 100MB」的来源。

易踩的坑：--from= 后面既可以写阶段名（build），也可以写镜像名（--from=nginx:latest），用来从任意现成镜像里捞文件。

9.4 VOLUME：第 4 关那条没点名的指令#

第 4 关讲匿名卷时说「有些镜像在构建的时候就声明了某个目录是卷」，当时没给指令名（那是写 Dockerfile 的活）。它叫 VOLUME：

1
FROM mysql
2
VOLUME /var/lib/mysql

一行，两个后果。

后果一：docker history 里它是一条 0B。 回扣第 3 关那句——只改配置、不碰文件系统的指令不占层。VOLUME 就是这一类：它登记了一个「这个位置归卷管」的声明，没往文件系统里写任何东西。

后果二：docker run 时自动生成一个匿名卷。 这正是第 4 关那些「看不出用途、也不敢删」的僵尸卷的来源之一——你一个 -v 都没写，卷照样冒出来。

VOLUME 是镜像作者的东西。写自己的镜像时，除非真有这个需要（数据必须外置），别随手加——每起一个容器就多一个匿名卷。

9.5 还能再瘦的地方#

几条通用的：

换个更小的底：同一个 nginx，nginx 建在 Debian 上，nginx:alpine 建在 Alpine 上——Alpine 是个精简得多的 Linux，所以后者小一大截。选底的时候挑刚好够用的那个。
装完就清，而且要清在同一条 RUN 里：

1
RUN apt-get update && apt-get install -y curl \
2
 && rm -rf /var/lib/apt/lists/*

这条要讲清：一条 RUN 就是一层，按写的先后从上往下排——所以装的那条落在第 1 层，它留下的索引实物就搁在第 1 层里。拆成两条时，删的那条落在第 2 层，只能在新一层盖一个「已删」的标记，盖不住实物，镜像一点没小。清在同一条 RUN 里，则是这层定稿前就把索引擦掉，快照里压根没有它。

（层为什么擦不掉下层的实物，是 overlayfs 的事——层是「差异」、删除只是个「标记」，机制归第 15 关 · 底层原理。） 3. .dockerignore（第 3 关讲过）挡掉 .git、node_modules 这类根本不该进去的东西。

这一关的产出：会让构建命中缓存、知道怎么把镜像瘦下来，也认识了 VOLUME 这条会悄悄造卷的指令。下一关把造好的镜像推出去——以及那个 latest 标签的坑。

本关命令速查#

构建与镜像，见命令速查表 · 构建镜像。

08入门:容器里的进程

Sun, 11 Oct 2026 00:00:00 GMT

第 8 关容器里的进程#

本关的产出：看清容器里那个「1 号进程」是谁、由什么决定，以及它为什么会决定容器能不能优雅地停下来。

8.1 停一个容器，走的是什么流程#

docker stop <容器> 不是直接把容器掐掉，它先发一个信号：

给容器里的 1 号进程发 SIGTERM——「请你退下」。
等它自己退，默认最多等 10 秒。
还不退，再发 SIGKILL——直接打死，不给商量的余地。

这解释了那个常见现象：同一个命令 docker stop，有的容器秒停，有的一卡就十秒。差别就在 1 号进程收到 SIGTERM 之后做了什么。

关键在「1 号进程」四个字。 信号只发给它一个，不会挨个通知容器里的所有进程。谁坐在这把椅子上，谁才有机会优雅退出。

8.2 谁坐在 1 号那把椅子上#

第 3 关摆过那两行启动配置——ENTRYPOINT 和 CMD。容器起来时，Docker 把它们拼起来跑，跑起来的第一个进程就是容器里的 1 号。

问题来了。第 3 关说过 nginx 镜像的 ENTRYPOINT 是一段准备脚本（第 2 关留的那个口子）。那么脚本跑起来，1 号就是它——nginx 跑在哪？

看脚本的末尾：

1
docker run --rm --entrypoint tail nginx:latest -3 /docker-entrypoint.sh

要观察：最后一行是 exec "$@"。那串 "$@" 就是上面那条 CMD。所以这一行干的事是——把脚本自己换成 nginx，接着跑。

exec 是 shell 的一个动作：用新程序替换掉自己。进程号不变，跑的东西换了。于是 nginx 接管了那个进程号，成了 1 号；发信号就直接打在它身上。

起一个真 nginx 容器，docker top ngx 一看便知：1 号是 nginx: master process，底下那一排 worker 都是它 fork 出来的子进程。

8.3 一个字的差别：exec#

假如那一行写的不是 exec "$@"，而是普通的 "$@"，会怎样？表面上看不出任何区别——nginx 照样起来、照样服务，你盯着终端、浏览器都察觉不到。差别藏在进程结构里。

做个对照，拿 sleep 当个占位的长跑程序（换成谁都一样）：

1
docker run -d --name with-exec --entrypoint sh nginx:latest -c 'exec sleep 1000'
2
docker run -d --name no-exec  --entrypoint sh nginx:latest -c 'sleep 1000'

两条只差一个 exec。看各自的进程：

1
docker top with-exec     # 一行：sleep 1000
2
docker top no-exec       # 两行：sh -c ...，以及它的子进程 sleep 1000

有 exec：sleep 直接顶上 1 号，容器里就它一个进程。
没有 exec：sh 占着 1 号，sleep 是它的子进程。

这直接决定了停止时的待遇——因为 SIGTERM 只发给 1 号：

有 exec：信号打在 sleep 上，它能收尾（把手上正在处理的请求做完、关掉连接）再退。
没有 exec：信号打在 sh 上，永远到不了 sleep。sleep 没有半点收尾机会，sh 一退，它就跟着被内核带走（收到的是 SIGKILL，不是 SIGTERM）。

易踩的坑：别拿 docker stop 快不快当判据。 上面这两种写法，容器都是一秒就停——壳自己被打发走了，容器照样秒停，但里面那个程序是被硬拽走的、没做任何收尾。信号到底有没有传到真程序，看进程结构（docker top），不是看停得快慢。

这就是「表面对、代价在别处」：差一个 exec，肉眼看不出来，却决定了容器是优雅退出还是被硬拽走。

8.4 `CMD` 的两种写法，差的就是这个#

第 3 关把 CMD 的两种写法摆出来时说过，差别归本关讲：

1
CMD ["nginx", "-g", "daemon off;"]     # 逐项写开
2
CMD nginx -g "daemon off;"             # 整句话交给 shell

第二种写法，Docker 实际跑的是 /bin/sh -c "nginx -g \"daemon off;\""——它替你套了一层 shell。那层 sh 就是 1 号，nginx 又成了子进程，和 8.3 里「没写 exec」是同一回事。

所以两种写法的真正差别不在好不好看，在于：第二种多套了一层壳，信号到不了真正的程序。

易踩的坑：规矩倒过来也成立——想让哪个程序优雅退出，就得让它当 1 号。要么用 exec 形式（CMD 数组写法、或 ENTRYPOINT 脚本结尾 exec），要么它自己就是 1 号。中间夹一层壳，信号就断了。

8.5 1 号进程还多一份差事#

1 号进程在 Linux 里有特殊地位，除了上面那条，还有一条：它要负责回收自己那些跑完的子进程。

普通进程跑完退出，得有人替它「收尸」它才算真正消失；没人收，它就变成僵尸挂在那儿（ps 里显示成 defunct）。平时这活儿有系统那个 1 号 init 兜底。

容器里没有那一层 init——你的 1 号进程就是容器里的 init，收尸的活儿落到了它头上。它要是只管干活、不理会这件事，跑完的子进程就会攒成一片僵尸。这不是每关都要操心的事，但它是「容器不适合随随便便跑多进程」的原因之一。

（这套「1 号为什么特殊」的机制，跟第 15 关的 namespace 是近邻——但那关讲的是内核怎么把进程隔开，本关讲的是进程自己的规矩。）

8.6 回头改第 2 关那句话#

第 2 关 2.4 的坑里写过一句：

换掉启动命令之后，容器的主进程就成了你写的这个，它一退出，容器就停。

这句要收窄：容器停不停，取决于 1 号进程；你写的命令是不是 1 号，取决于那个 exec。

结尾 exec 了 → 你的命令就是 1 号，那句话成立。
没有 exec → 1 号还是那层壳，你的命令只是它的子进程，它退出容器未必停。

菜鸟阶段先给结论没错，现在把这一层补上。

这一关的产出：看懂「信号只发给 1 号进程」，以及 exec 为什么值钱——它决定你的程序是不是 1 号、能不能优雅退出。下一关回到镜像本身：怎么让它更小、构建得更快。

本关命令速查#

进程与信号，见命令速查表 · 进程与信号。

18附录:命令速查

Sun, 04 Oct 2026 00:00:00 GMT

命令速查#

按主题汇总全系列出现过的命令。同一条命令往往在好几关里反复出现，所以这里只收一处，正文在用到时链到对应小节。

上下文#

命令	作用
`docker context ls`	列出所有上下文，带 `*` 的是当前在用的那个
`docker context use <名字>`	切换当前上下文
`docker --context <名字> <子命令>`	只对这一条命令指定上下文，不动全局设置

容器生命周期#

命令	作用
`docker run hello-world`	最简的一次运行：拉镜像、建容器、跑一次、退出
`docker run -d -p 8080:80 nginx`	后台运行一个容器，把宿主机 8080 转发到容器的 80
`docker ps`	列出运行中的容器
`docker ps -a`	连已停止的容器一起列出
`docker start <容器>`	启动一个已停止的容器
`docker stop <容器>`	停止一个运行中的容器
`docker restart <容器>`	重启容器
`docker rm <容器>`	删除容器
`docker rm -f <容器>`	强制删除，运行中的也能删
`docker rename <容器> <新名字>`	改容器名，运行中或已停止都能改，不用重启

运行时的参数#

命令	作用
`docker run -d --name <名字> <镜像>`	给容器指定名字；不指定则随机生成一个，用名字或 ID 指代容器都可以
`docker run --hostname <名字> <镜像>`	指定主机名；不写就是容器 ID。容器名（`--name`）和主机名是两回事，内建 DNS 两个都登记
`docker run --rm <镜像>`	容器退出后自动删除
`docker run -e 名字=值 <镜像>`	用环境变量改掉镜像的默认行为，要传几个就写几遍
`docker run -v 宿主路径:容器路径 <镜像>`	把宿主机的目录或文件接到容器里，顺序是「宿主<容器>」
`docker run -v 宿主路径:容器路径:ro <镜像>`	同上，但容器里只能读不能改
`docker run <镜像> <命令>`	覆盖镜像默认启动的那个程序（顶掉的是 `CMD`）
`docker run --entrypoint <程序> <镜像>`	连 `ENTRYPOINT` 一起换掉，而不只是换 `CMD`

日志与进入容器#

命令	作用
`docker logs <容器>`	查看容器主进程的输出
`docker logs -f <容器>`	持续跟随输出
`docker inspect --format '{{.LogPath}}' <容器>`	看这个容器的日志文件落在哪（在虚拟机里）
`docker run --log-opt max-size=10m --log-opt max-file=3 <镜像>`	给日志设上限：单文件最大 10m，最多留 3 个
`docker exec -it <容器> bash`	在运行中的容器里另起一个进程，通常是开一个交互式终端

进程与信号#

命令	作用
`docker top <容器>`	列出容器里跑着的进程
`docker stop -t <秒> <容器>`	改那个宽限期；默认 10 秒，`-t 0` 直接发 SIGKILL
`docker kill <容器>`	直接发 SIGKILL，不给商量的余地
`docker kill -s <信号> <容器>`	发指定信号，发完就走，不等

镜像#

命令	作用
`docker login [仓库]`	登录仓库，不写就是 Docker Hub；正经场景用 access token 而不是账号密码
`docker logout [仓库]`	退出登录
`docker pull <镜像>`	把镜像从仓库拉到本地
`docker tag <镜像> <新名字>`	给同一个镜像再挂一个名字，不复制镜像
`docker push <名字:标签>`	把镜像推到仓库；名字要带上仓库里的路径，否则不知道往谁那儿推
`docker images`	列出本地已有的镜像
`docker rmi <镜像>`	删除镜像，前提是没有容器还引用着它
`docker inspect <镜像或容器>`	打出完整的配置，包含镜像的默认值与这次运行实际用的值
`docker inspect --format '{{.State.ExitCode}}' <容器>`	只取一个字段，不用在整段 JSON 里翻；`{{json .Config.Env}}`、`{{json .Mounts}}` 同理

构建镜像#

命令	作用
`docker build -t 名字:标签 .`	用当前目录的 Dockerfile 构建；末尾的 `.` 指的就是当前目录，材料都从这儿取
`docker build --no-cache -t 名字:标签 .`	不用缓存，每次都从零重来
`docker build --target <阶段> .`	多阶段构建里，只建到指定阶段为止
`docker builder prune`	清掉构建缓存
`docker history <镜像>`	列出这个镜像是一层层怎么来的
`docker commit <容器> <新镜像>`	把容器当前的改动冻成一个新镜像（不推荐当常规手段）

卷与数据#

命令	作用
`docker volume create <名字>`	建一个卷
`docker volume ls`	列出所有卷；看起来像一长串随机字符的是匿名卷
`docker volume inspect <名字>`	看这个卷在磁盘上的位置
`docker volume rm <名字>`	删卷，前提是没有容器在用它
`docker volume prune`	清掉所有没被使用的卷（不问就删）
`docker run -v 卷名:容器路径 <镜像>`	把卷挂进容器
`docker run -v 容器路径 <镜像>`	只写一边 → Docker 自动建一个匿名卷
`docker run --tmpfs 容器路径 <镜像>`	挂一块内存盘，不落磁盘，容器一停就没

网络#

命令	作用
`docker network ls`	列出所有网络；`bridge`、`host`、`none` 是自带的三张
`docker network create <名字>`	建一张自定义网络
`docker network inspect <名字>`	看这张网里有谁、各自的 IP
`docker network connect <网络> <容器>`	把容器接上网络，运行中的也能接
`docker network disconnect <网络> <容器>`	摘下来
`docker network rm <名字>`	删网络，前提是没有容器还挂在上面
`docker network prune`	清掉没有容器在用的网络（不问就删）
`docker run --network <名字> <镜像>`	起容器时直接接上某张网络
`docker run --network host <镜像>`	容器不单独隔离网络——但 macOS 上那个「host」是虚拟机，见第 5 关

Compose#

命令	作用
`docker compose up -d`	按当前目录的 compose.yaml 后台拉起整个项目，缺的镜像先拉
`docker compose down`	停并删掉项目的容器和它自动建的网；卷不删
`docker compose down -v`	连文件里声明的卷一起删，数据就没了
`docker compose ps`	只看这个项目的容器，`STATUS` 一列带 `(healthy)` 这类健康状态
`docker compose logs -f <服务>`	跟踪输出，不写服务名就是整个项目
`docker compose exec <服务> <命令>`	在某个服务里另起一个进程，服务名就是文件里的键
`docker compose config`	校验并打印合并后的完整配置（叠了多份文件时，用它看最后长什么样）
`docker compose -f a.yaml -f b.yaml up -d`	按顺序叠多份文件，后面的覆盖前面的
`docker compose --profile <名> up -d`	连同这个 profile 的服务一起起；可写多遍，或用 `"*"` 全开
`docker compose up -d <服务>`	只起点名的那个服务；就算它的 profile 没激活也会起

Compose 常用字段#

正文用到的字段（image、ports、environment、volumes、depends_on、healthcheck、profiles）在各关讲过。下面这些同样常用，只是还没轮到，写到对应关再展开：

字段	作用
`build: .`	不用现成镜像，就地按 Dockerfile 构建
`command:` / `entrypoint:`	覆盖镜像的启动命令，相当于 `docker run` 的 `<命令>` 和 `--entrypoint`
`restart: unless-stopped`	重启策略：`no`（默认）/ `on-failure` / `always` / `unless-stopped`
`env_file: .env`	从文件读环境变量，一行一个 `名字=值`
`container_name: <名字>`	固定容器名（默认是 `<项目>-<服务>-<序号>`）；名一固定，这个服务就不能起多个副本
`networks:`	显式定义、接入网络；不写就用项目自建的那张
`secrets:`	敏感数据，以文件形式挂在 `/run/secrets/<名字>`；只支持 Linux 容器
`deploy:`	资源上限、副本数等；哪些键本地 `docker compose` 认、哪些只给 Swarm，看官方参考
`logging:`	日志驱动与上限，如 `max-size`、`max-file`（为什么要限制，第 11 关讲）

完整字段清单见官方 Compose file reference。

系统与清理#

命令	作用
`docker version`	分别列出客户端与服务端的版本
`docker info`	列出服务端的详细信息（存储、内核、内存等）
`docker system df`	查看镜像、容器、卷、构建缓存各占多少空间
`docker system df -v`	同上，再列出每一项具体是谁
`docker container prune`	清掉已停止的容器
`docker image prune`	清掉悬空镜像；加 `-a` 连没被任何容器引用的镜像也清
`docker system prune`	清理未使用的容器、网络与悬空镜像
`docker system prune -a`	连未被引用的镜像与构建缓存一起清理
`docker system prune -a --volumes`	再加一样：连没在用的卷也清

用法备忘#

这些不是命令，是命令里那些容易记反、记漏的地方。

带冒号的参数，两边都是「宿主机在前，容器在后」——-p 宿主:容器（端口同理）和 -v 宿主:容器 一个规矩。

-v 的第一段决定它是路径还是卷名：

/ 开头是绝对路径，./、../ 开头是相对当前目录的路径；
不是这两种开头的（如 mysql-data:/var/lib/mysql），会被当成卷的名字（见前面「卷与数据」）；
~ 由 shell 展开，所以不能写进引号——-v "~/x:/y" 会把字面量 ~ 传给 Docker，开头不是 /，于是被当成卷名而报错。

:ro 是 Linux 挂载的 read-only 选项（mount -o ro 的那两个字母），写在末尾让容器里只能读。对称的 :rw 是默认值，一般不用写。这套挂载只对那一个容器可见，宿主机的目录树不变。

docker build 末尾的那个 . 指的就是当前目录，不是 Dockerfile 的位置。COPY 只能从当前目录里拿东西，而这里面的东西随时可能被复制进镜像——不想要的用 .dockerignore 挡掉（写法同 .gitignore）。目录里东西多时这一步也可能变慢；守护进程跑在本机时不一定全传，但「可能被复制进镜像」永远成立。

-t 名字:标签：冒号前是名字、后是标签；不写标签就是 latest（那个陷阱见第 10 关）。一个镜像可以挂多个「名字<标签>」。

latest 不是「最新」，只是「没写标签时的默认值」——它随时会变，指向哪由最后一次推送决定。生产用明确版本（1.0、提交号），别用它。想看「绝对跑的是这一份」，用 digest：nginx@sha256:...，由内容算出来、变一个字节就变，天生不可变。

镜像名的完整结构：[仓库地址/]命名空间/名字:标签。省掉前两段时默认是 Docker Hub 加你自己的账号；官方镜像的命名空间是 library（所以 nginx 就是 docker.io/library/nginx）。

构建会复用上次的层——每条指令算一个指纹（RUN 是命令本身，COPY 是文件内容），没变就打 CACHED；一变，它后面所有层一起重做，不是只有那一条。所以 Dockerfile 里不会变的放前面、会变的放后面。

COPY --from=<阶段> 源目标 从另一个阶段（或另一个镜像）的文件系统里拷文件——多阶段构建靠它把编译产物挑出来、把编译工具留在门外。

VOLUME 声明过的目录，docker run 时会自动生成匿名卷，哪怕一个 -v 都没写——这是僵尸卷的一大来源。

三种挂载怎么选：要长期留住、要交付给别人 → 卷；开发时改文件、要能用编辑器直接看到 → 绑定挂载；不该落盘的临时东西 → --tmpfs。卷住在虚拟机里（docker volume inspect 能看到位置），绑定挂载就是你磁盘上的一个目录——所以 macOS 上绑定挂载慢一截。

备份一个卷：开一个临时容器，同时挂上「要备份的卷（:ro）」和「宿主机上一个落地的目录」，在里头 tar。两个 -v 少一个都不行；打包时加 -C 卷里的路径，否则包里会带上绝对路径。

-it 两个参数缺一不可：-i 保持输入，-t 分配终端，少一个就没有交互。

docker stop 和 docker kill 不是一回事——stop 先发 SIGTERM 再等（默认 10 秒），等不到才 SIGKILL；kill 默认直接 SIGKILL，-s 可换信号但同样不等待。

信号只发给容器里的 1 号进程，不会挨个通知。真正干活的程序想收到信号、想优雅退出，它自己就得是 1 号——ENTRYPOINT 脚本结尾的 exec、以及 CMD 用数组写法而不是整句话交给 shell，都是为了让它顶上 1 号。

想无条件钻进任何镜像，用 --entrypoint sh——它在 Docker 这一层直接换掉 ENTRYPOINT，不看镜像自己怎么写。直接用 docker run -it <镜像> sh 不保证有效：镜像名后面那个位置的含义由镜像决定，有的镜像把它当「要跑的程序」启动，有的只当「参数」。

docker network ls 里三张自带网的差别，在 DRIVER 那一列：bridge（驱动 bridge）搭一台虚拟交换机，是容器默认接的那张；host（驱动 host）不给容器单独建网络、直接用宿主机的；none（驱动叫 null）什么都不搭。自己建的网络驱动也是 bridge——所以「默认 / 自定义」的差别不在驱动，在有没有内建 DNS（下一条）。

容器名能被解析，靠的是内建 DNS，不是默认网络——默认网络（bridge）不做名字解析：它的 /etc/resolv.conf 指向宿主机 DNS，里面没有容器名；自定义网络里 /etc/resolv.conf 是 nameserver 127.0.0.11，那是 Docker 内建的 DNS，容器名就登记在它那儿。所以容器之间要用名字互相访问，得先接上同一张自定义网络。

判断名字解析对不对，看 getent hosts <名字>，别看 curl 通不通——两者不是一回事。

host.docker.internal 是容器里指回宿主机的名字（Docker Desktop 提供），容器要访问宿主机上的服务就用它。

-p 在 macOS 上等于 Docker Desktop 在宿主机上占住了那个端口——lsof -nP -iTCP:<端口> -sTCP:LISTEN 看到的是 com.docker.backend（Windows 用 netstat -ano | findstr :<端口>）。不写 -p，这个端口在宿主机上就不存在。

compose 的服务名就是容器之间互相叫的名字，网络也不用自己建——compose 自动建一张 <项目名>_default 网，项目名默认是 compose.yaml 所在目录的名字。挂载写命名卷，卷要在文件末尾的顶层 volumes: 里声明。

depends_on 只管顺序，不管就绪——它只等对面跑起来，不等它能应答。要等真的就绪，得给对面写 healthcheck，再用 condition: service_healthy（还有 service_started、service_completed_successfully）。start_period 是开头宽限期，这期间的失败不计数，专治启动慢的服务。

叠多份文件，后一份覆盖前一份，但按条目类型分：单值项（image、command）直接换；键值项（environment、labels）按键名合并；挂载（volumes）按容器路径合并；而 ports、expose 是累加，不是替换——以为第二份文件写了新端口就顶掉了旧的，是错的。拿不准就先 docker compose config 看合并结果。文件名叫 compose.override.yaml 时会被自动叠上，不用写 -f。

profile 只控制「起不起」：没写 profiles 的服务永远起，写了的一律默认不起，得 --profile <名> 激活。点名 docker compose up -d <服务> 可以绕过 profile 直接起。down 默认不碰带 profile 的服务。

容器主进程写进 stdout/stderr 的东西，Docker 全接住存成文件——路径用 docker inspect --format '{{.LogPath}}' <容器> 看（在跑引擎的那台机器上），docker logs 读的就是它。默认没有上限，话多的容器能把磁盘写满。设上限：单次用 --log-opt，或全局改守护进程配置 daemon.json 的 log-opts（Linux 是 /etc/docker/daemon.json，Docker Desktop 走 Settings → Docker Engine。改完重启，只对新容器生效）。轮转的代价是旧日志会被丢。

prune 不碰正在跑的容器的日志，也不治根——缓存会再攒、匿名卷会再造。它是扫帚不是堵源头：真办法是日志设上限、.dockerignore、RUN 里装完就清。

macOS 上 prune 释放的空间不一定立刻还给硬盘——Docker Desktop 的磁盘镜像是只长不缩的。

退出码直接说明「怎么死的」：0 正常结束；1 程序报错；125 docker run 自己参数错；126 命令不可执行；127 命令找不到；137 被 SIGKILL（128+9，常见于内存超限或 stop 超时）；143 被 SIGTERM（128+15）。

Connection refused 和 Connection timed out 是两回事：前者说明到了那台机器、只是端口上没人在听（服务没起 / 没就绪 / 端口写错）；后者说明包根本没到（网络不通）。

docker inspect 不用整段读：Config.Cmd、Config.Entrypoint 看启动配置；Config.Env 看最终环境变量（镜像默认值和你 -e 的合并）；Config.ExposedPorts 看端口；Mounts 看挂载；State.ExitCode、State.Error、State.OOMKilled 看死因。

07入门:Compose进阶

Wed, 23 Sep 2026 00:00:00 GMT

第 7 关 Compose 进阶#

本关的产出：把第 6 关那份文件补上「顺序」和「就绪」两层，再用多文件与 profiles 管住本地、生产两套环境。

7.1 起得来，不等于能连#

第 6 关那份文件，up -d 之后有个问题：web 里的程序连 db 会失败一阵。第 2 关那条坑——mysql 第一次启动要先初始化数据目录，得等十几秒——到了 compose 里原样复现。

compose 起容器有顺序，但顺序来自 depends_on，得自己写：

1
services:
2
  web:
3
    image: nginx
4
    depends_on:
5
      - db

写了它，db 会先于 web 创建；down 的时候反过来，web 先拆。（不写 depends_on 也起得来，只是顺序不保证。）

但要注意它管的是什么：depends_on 只等 db 跑起来，不等 db 能应答。mysql 的容器起来了、进程在跑，那十几秒的初始化里 3306 上仍然没人应答——web 该连还是连不上。

所以「起来了」和「就绪了」是两回事。 要表达后者，得先定义什么叫就绪。

7.2 定义一个「就绪」的判据#

在 db 上加一段 healthcheck：

1
  db:
2
    image: mysql
3
    environment:
4
      - MYSQL_ROOT_PASSWORD=hecloud
5
    healthcheck:
6
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uroot", "-phecloud"]
7
      interval: 5s
8
      timeout: 5s
9
      retries: 10
10
      start_period: 30s

逐项：

test：判据本身。它是一条命令，退出码为 0 就算这一轮健康。这里用 mysqladmin ping——数据库能应答，它才返回 0。
interval：隔多久查一轮。
timeout：单轮超时就当这轮失败。
retries：连续失败几次，才把状态判成「不健康」。
start_period：开头的宽限期。这期间内的失败不计数——mysql 初始化慢，就是靠它不至于一上来被误判成挂了。

看状态：

1
docker compose ps

STATUS 那一列会从 (health: starting) 变成 (healthy)。健康检查是容器身上的一层属性，docker inspect 里也看得到。

7.3 等到就绪再起下一个#

有了判据，depends_on 就能等它：

1
  web:
2
    image: nginx
3
    depends_on:
4
      db:
5
        condition: service_healthy

condition 有三种：

service_started：只等跑起来——就是 7.1 那个默认行为。
service_healthy：等健康检查判成 healthy 才算过了。
service_completed_successfully：等它跑完退出，且退出码为 0。给那种「一次性做完就走」的初始化服务用。

改成 service_healthy，web 会一直等到 db 报 healthy 才被创建——第 2 关那个坑，到这儿才算收口。

易踩的坑：condition 写在依赖方（web）上，healthcheck 得写在被依赖方（db）上——两处别写反。对面没有 healthcheck 时，service_healthy 就没有依据可等。

7.4 一套文件，拆成多份#

本地开发和生产跑的不一样：本地要挂源码、开调试端口，生产不要。把这些都塞进一个文件，靠 if 之类的思路去开关，很快就乱了。compose 的办法是按层叠文件。

两个文件，后一个叠在前一个上面：

1
docker compose -f compose.yaml -f compose.prod.yaml up -d

按命令行顺序合并，后面的覆盖前面的。 怎么覆盖，看是哪一类条目，记不住就先跑 docker compose config 看合并后的结果：

单值项（image、command）：后面的直接盖掉前面的。
键值项（environment、labels）：按键名合并，同名的以后一个为准，新键加上去。
挂载（volumes）：按容器里的路径合并，同一个路径以后一个为准。
端口列表（ports、expose）：累加——两边都留，加了新的旧的也不消失。

易踩的坑：文件名是 compose.override.yaml 时会被自动叠上，不用写 -f——这是给本地开发留的口子。哪天发现「为什么本地多了一份配置」，通常就是它。

7.5 按需起：profiles#

生产不要的东西，除了用 7.4 的文件覆盖关掉，还可以一开始就不让它起。给服务挂一个 profile 名：

1
services:
2
  db:
3
    image: mysql
4

5
  phpmyadmin:
6
    image: phpmyadmin
7
    profiles:
8
      - debug

规矩很简单：

没写 profiles 的服务永远起——db 就是。
写了 profiles 的只在它那个 profile 激活时才起——phpmyadmin 平时不出现。

激活：

1
docker compose --profile debug up -d

要开多个就写多遍 --profile，或者逗号隔开；--profile "*" 全开。也可以直接点名：

1
docker compose up -d phpmyadmin

被点名的服务就算 profile 没激活也会起——临时跑个调试工具时会用到。

易踩的坑：docker compose down 只停没 profile 的服务，phpmyadmin 这种得用 docker compose down phpmyadmin 或带 --profile 才停得掉。

这一关的产出：服务之间能表达「等它真的就绪」，以及一套文件管住多套环境的两种手法。下一关回到单个容器，钻进一个第 2 关就绕开的问题——容器里那个进程，是怎么被启动、被停掉的。

本关命令速查#

Compose 的命令与用法，见命令速查表 · Compose。

06入门:Compose起全栈

Tue, 22 Sep 2026 00:00:00 GMT

第 6 关 Compose 起全栈#

本关的产出：一份 compose 文件，把第 5 关那三个各带参数的容器收进去，一条命令整体拉起、整体拆掉。

6.1 命令写不下的那天#

第 5 关收尾时，三个容器终于能互相叫到名字。代价是命令行里多出一串东西：一条 docker network create、每个容器各一次 --network、外加「记住谁叫什么」。往后想改个端口、加个变量、换台机器重跑，都得把这串命令原样再敲一遍。

第 2 关说过：容器可以随手删掉重造，值钱的是那条命令本身。这句话现在要再进一步——那条值钱的命令，也该从命令行里搬进一个文件：能复制、能备份、能改版、能交给别人。Docker Compose 干的就是这件事。

命令是 docker compose，随 Docker Desktop 一起装好。网上老教程里带连字符的 docker-compose 是旧的独立脚本，已经停止维护，别照着敲。

6.2 把三条命令翻译成一份文件#

起点是第 5 关 5.6 那段命令：

1
docker network create app-net
2

3
docker run -d --name web --network app-net -p 8080:80 nginx
4

5
docker run -d --name db --network app-net \
6
  -e MYSQL_ROOT_PASSWORD=hecloud \
7
  -v ~/docker/mysql-data:/var/lib/mysql \
8
  mysql
9

10
docker run -d --name cache --network app-net \
11
  -v ~/docker/redis-data:/data \
12
  redis

建一个空目录（比如叫 demo），在里面放一个文件，叫 compose.yaml：

1
services:
2
  web:
3
    image: nginx
4
    ports:
5
      - "8080:80"
6

7
  db:
8
    image: mysql
9
    environment:
10
      - MYSQL_ROOT_PASSWORD=hecloud
11
    volumes:
12
      - mysql-data:/var/lib/mysql
13

14
  cache:
15
    image: redis
16
    volumes:
17
      - redis-data:/data
18

19
volumes:
20
  mysql-data:
21
  redis-data:

展开收起

和上面那段命令逐段对照：

services: 下面是三个服务，键名 web、db、cache 就是第 5 关那三个容器名。
image: 是镜像名，对应 docker run 结尾那个参数。
ports: 对应 -p，"8080:80" 还是「宿主在前，容器在后」。
environment: 对应 -e。
服务里的 volumes: 对应 -v。挂的东西从第 5 关的宿主机目录 ~/docker/mysql-data 换成了命名卷 mysql-data——第 4 关说过，要交付、换台机器还能跑出一样结果，用卷。compose 是「交出去」的东西，所以写卷。
文件末尾那个孤立的 volumes: 是顶层声明：两个卷要在这儿登记一次，服务里才能用名字指它们。

要观察：文件里没有 docker network create、也没有 --network。网络整块不见了——6.4 说为什么。

6.3 一条命令顶掉那一整串#

在 compose.yaml 所在目录里：

1
docker compose up -d

-d 是后台跑，跟 docker run -d 一个意思。第一次会先拉缺失的镜像，然后三个容器一起起来。看一眼：

1
docker compose ps

三行，NAME 那列是 demo-web-1、demo-db-1、demo-cache-1（demo 就是目录名，6.4 细说）。

要观察：docker ps 也看得到它们，但 docker compose ps 只看这个项目。往后凡是「对整体」的操作都走 docker compose 开头——logs、exec、stop、down，作用域是整个项目，不用逐个写容器名。

6.4 网络和名字：第 5 关的活它替你干了#

第 5 关为了让容器互相叫到名字，手动做了两件事：建一张网、把每个容器接上去。Compose 一上来就把这两件都办了：

1
docker network ls

多出一张 demo_default。compose 给每个项目自动建一张 bridge 网络，所有服务自动接上去——这就是 6.2 里为什么没有 --network。

更关键的是名字：

1
docker compose exec web getent hosts db

打出来是 db 的 172.x 地址。服务名直接就是容器之间互相叫的名字——在 web 里写 db、cache 就能访问它们，这正是第 5 关那张自定义网络 + 内建 DNS 的效果，只是不用手敲了。

第 5 关 5.6 结尾那句「下一关的 Compose 会自己建网、也会把每个服务名注册成互相叫得到的名字」，到这里兑现。

易踩的坑：

缩进。YAML 靠缩进分层，同一层要对齐，而且只能用空格、不能混用 Tab；冒号后要留一个空格。错一格，docker compose up 报语法错，报错的行号常常指不准——先盯缩进，拿不准就先 docker compose config 校验一遍。
端口映射要加引号：写 "8080:80"。不加引号，中间那个冒号会让 YAML 把它当成一个数（六十进制），不再是字符串。
项目名 = 目录名。换目录、给目录改名，项目就成了另一个，网络名、容器名前缀全跟着变。down 的时候要认准自己在哪个目录。

6.5 整体拆掉#

第 2 关那句「容器是消耗品」，到 compose 变成「整个项目都是消耗品」：

1
docker compose down

一条命令：停掉三个容器、删掉它们、删掉那张自动建的网。

要观察：down 不删卷。第 4 关那句「容器是消耗品，卷不是」在这里照样成立——db 里的数据还躺在卷里，下次 up -d 原样回来。想连数据一起清掉，加 -v：

1
docker compose down -v

会删掉文件里声明的那两个卷，数据就真没了，用之前想清楚。

这一关的产出：一份 compose 文件、一条拉起和拆掉整个项目的命令，以及「网络和名字都不用自己管了」的确定性。但名字叫得到，不等于服务已经就绪——mysql 第一次启动要先初始化十几秒（第 2 关那个坑），这期间 db 是通的、3306 上却还没人应答。怎么表达「等它真的就绪」，是第 7 关的事。

本关命令速查#

Compose 的命令与用法，见命令速查表 · Compose。

05入门:容器网络

Mon, 21 Sep 2026 00:00:00 GMT

第 5 关容器网络#

本关的产出：让第 2 关那三个各跑各的容器能互相叫到名字，并补齐宿主机与容器之间两个方向的访问。

5.1 默认网络：IP 通，名字不通#

第 2 关「三连」收尾时说过：三个容器各跑各的，互相看不见。这一关把这句话拆开。

前面认识过镜像、容器、卷，网络是第四个对象，它管的是谁跟谁能说话：

1
docker network ls

装好 Docker 自带三张网，由 DRIVER 那一列决定各自怎么搭：

bridge（驱动 bridge）：搭一台虚拟交换机，容器接上去就彼此可通。这是默认网络——docker run 不写 --network 就接在它上面。
host（驱动 host）：不给容器单独建网络，直接用宿主机的。Linux 上名副其实，macOS 上不是（5.5 讲）。
none（驱动叫 null）：什么都不搭，容器没有对外网卡。

第 2 关那三个容器都在 bridge 上，却互相找不到。起两个默认容器做对照（第 2 关的 web 还在就先 docker rm -f web）：

1
docker run -d --name web nginx:latest
2
docker run -d --name app nginx:latest

web 里跑着 nginx，监听 80。用 IP 连——先取它的地址：

1
docker exec web hostname -i
2
docker exec app curl -m 3 http://<上一步打出来的地址>

要观察：欢迎页出来了。它们本来就能通。

换成名字：

1
docker exec app curl -m 3 http://web

打不开。原因在「名字该问谁」这份名单里：

1
docker exec app cat /etc/resolv.conf

那行 nameserver 指向宿主机上的 DNS，它不认识 web。

所以默认网络的短板是：不解析容器名。 容器之间只能靠 IP 找人，而 IP 是创建时按顺序分的，docker rm 重起一次就可能换——别写死在配置里。

5.2 自定义网络：名字能互相叫到#

解法是不用默认网络，自己建一张：

1
docker network create demo-net
2
docker network ls

demo-net 列出来了。注意它的 DRIVER 也是 bridge——和默认网络一模一样，所以差别不在这一列。

把两个容器删掉重起，接在自己建的网上：

1
docker rm -f web app
2
docker run -d --name web --network demo-net nginx:latest
3
docker run -d --name app --network demo-net nginx:latest

这次用名字连：

1
docker exec app curl -m 3 http://web

要观察：一个 IP 都没写，欢迎页出来了。用 getent hosts 看 web 这个名字解析到了谁：

1
docker exec app getent hosts web

打出来就是 web 的那个 172.x 地址。（getent hosts 是查「名字解析成什么地址」的命令，后面都用它确认。）

原因还是 resolv.conf：

1
docker exec app cat /etc/resolv.conf

nameserver 变成了 127.0.0.11——Docker 内建的 DNS，容器名就登记在它那儿。

这里说的「名字」是容器名（--name 给的），它跟主机名是两回事：主机名不写就是容器 ID，要自己定就用 --hostname <名字>。内建 DNS 把容器名、主机名、容器 ID 一起登记，所以哪个都叫得到。

所以差别不在容器，在有没有内建的 DNS。 顺带兑现第 2 关那句：名字的第二份工作，就是「别的容器能叫到它」。

易踩的坑：确认名字解析，用 getent hosts，别拿 curl 通不通当判据——两者不是一回事。

5.3 接上、摘下、多张网#

刚才删掉重起，是因为要用 --network。其实运行中的容器也能后接上、或摘下：

1
docker network connect demo-net <容器>
2
docker network disconnect demo-net <容器>

一个容器可以同时接好几张网。看它挂在哪儿：

1
docker inspect <容器>

翻到 NetworkSettings 下面的 Networks 段，每张网都列着。这很有用：让数据库只待一张内部网，让 web 同时接内外两张——该露的露，不该露的留在里面。

易踩的坑：

有运行中的容器挂着时删不掉网：docker network rm 报 has active endpoints。
但停着不算在用——stop 之后再删会成功，那个容器下次 start 就起不来了（网没了）。
docker network prune 清掉所有没被容器用的网，不问就删；跑之前先 docker network ls 看一眼。

5.4 宿主机与容器之间的两个方向#

容器之间通了，剩下宿主机怎么访问容器、容器怎么访问宿主机。

方向一：宿主机 → 容器，靠 -p。

1
docker run -d --name pub-demo -p 18080:80 nginx:latest
2
lsof -nP -iTCP:18080 -sTCP:LISTEN

打出来的是 Docker Desktop 自己的进程。这就是 -p 在 macOS 上的真相：Docker Desktop 在宿主机上占住那个端口，再把流量送进虚拟机里的容器。第 1 关那句「不写 -p，端口就不会出现在 Mac 上」就是这回事。

在 Linux 上，占端口这件事由内核的网络规则做——那归第 15 关。

方向二：容器 → 宿主机，靠 host.docker.internal。

容器里写 localhost 是它自己。要访问宿主机上的服务（比如本机一个 dev server），用固定名字 host.docker.internal：

1
python3 -m http.server 8765          # 宿主机上起个服务（另开一个终端，用完 Ctrl+C 停）
2
docker exec app curl -m 3 http://host.docker.internal:8765

拿到目录列表，说明容器访问到了宿主机。

5.5 `--network host` 在 macOS 上名不副实#

Linux 上，--network host 是「不给容器单独建网络，直接用宿主机的」——容器开个端口，外面直接能访问，很省事。

macOS 上不是：

1
docker run -d --name host-demo --network host nginx:latest
2
docker exec host-demo hostname

打出来是 docker-desktop——那台 Linux 虚拟机。第 1 关说过，Docker Desktop 的守护进程跑在虚拟机里，所以这里的「host」指虚拟机，不是 Mac 本身。容器里的 127.0.0.1:80 是通的，Mac 上 curl localhost:80 打不开。

所以 macOS 上 --network host 基本没用，想要的效果还是得靠 -p。（用完 docker rm -f host-demo。）

5.6 把三连接回去#

回到第 2 关那三个容器，加一张网、每个容器加一次 --network（第 2 关的 db、cache 还在就先 docker rm -f db cache）：

1
docker network create app-net
2

3
docker run -d --name web --network app-net -p 8080:80 nginx
4

5
docker run -d --name db --network app-net \
6
  -e MYSQL_ROOT_PASSWORD=hecloud \
7
  -v ~/docker/mysql-data:/var/lib/mysql \
8
  mysql
9

10
docker run -d --name cache --network app-net \
11
  -v ~/docker/redis-data:/data \
12
  redis

web 里的程序现在可以用 db 这样的名字找数据库了。

但名字能叫到，不等于服务已经就绪——mysql 第一次启动要初始化十几秒（第 2 关说过），这期间 db 是通的、3306 上却还没人应答。怎么等它真的就绪，是第 7 关的事。

这一关的产出：三个容器互相叫得到名字，以及宿主机与容器之间两个方向的路。而命令也越写越长——建网、--network、记名字。下一关的 Compose 把它们收进一个文件：它会自己建网，也会把每个服务名注册成互相叫得到的名字。

本关命令速查#

网络对象的增删与连接，见命令速查表 · 网络。

04入门:数据持久化

Sun, 20 Sep 2026 00:00:00 GMT

第 4 关数据持久化#

本关的产出：三种「把数据放在容器外面」的方式，一套选择它们的判据，以及把一份数据搬走再搬回来的能力。

4.1 数据为什么会丢，以及三种不丢的思路#

第 1 关埋过一句话：容器删掉之后，写进它自己文件系统里的改动一并消失。第 2 关把原因讲清楚了——容器没有自己的磁盘，它看到的那个根目录是拼出来的，只有自己改过的那一点点是独占的，一删就没。

对「跑一次就完」的东西来说这没问题。但对持有数据的东西——数据库、上传的文件、日志——这是致命的。

所以这一关只解决一件事：让数据住在容器外面。

「外面」有三种，这就是本关的骨架：

卷：数据放在容器外面一块 Docker 自己管的地方。位置不用你操心，用名字指它。
绑定挂载：数据放在容器外面一个你自己指定的目录里。位置你说了算。
tmpfs：数据存在内存里，不落磁盘。容器一停就没了——它是专门用来「让东西不要留下来」的。

第 2 关用的一直是第二种（-v ~/docker/mysql-data:/var/lib/mysql）。当时刻意只讲「把外面的东西接进来」这一个动作，现在把三种一次讲清。

4.2 卷：Docker 自己管的那块地方#

先建一个：

1
docker volume create demo-vol
2
docker volume ls

docker volume ls 会把所有卷列出来。看到一长串随机十六进制字符的名字不要慌，那是匿名卷，4.4 讲。

想知道它到底在哪儿：

1
docker volume inspect demo-vol

输出很短，里面有一项是：

1
"Mountpoint": "/var/lib/docker/volumes/demo-vol/_data"

这里要回扣第 2 关。 /var/lib/docker 是那台 Linux 虚拟机的文件系统里 Docker 的地盘。所以卷的位置在虚拟机内部——它不是宿主机上的一个目录。这正是它和绑定挂载（4.3）的根本差别。这一点往下会反复用到。

然后用它：

1
docker run --rm -v demo-vol:/data nginx:latest sh -c 'echo 你好，我住在卷里 > /data/hello.txt'

注意 -v 的第一段：demo-vol。 它不以 / 开头、也不以 ./ 开头，按第 2 关那条规则，它会被当成卷的名字。第 2 关的一条报错里写着「那是另一套东西，第 4 关讲」——就是现在这个。

换个容器读一遍（上一个容器已经 --rm 掉了）：

1
docker run --rm -v demo-vol:/data nginx:latest cat /data/hello.txt

要观察：第二个容器和第一个没有任何关系，可它读到了第一个写进去的东西。数据的寿命跟容器解绑了。

再走一步——把容器全删光，卷还在：

1
docker volume ls | grep demo-vol

这就是这一关要的东西：容器是消耗品，卷不是。

三条延伸事实，都有用：

一个卷可以同时挂给多个容器。 数据是共享的，不是每个容器各一份。
卷在用的时候删不掉。 docker volume rm demo-vol 会报 volume is in use，报错里还带着用它的那个容器 ID。
删容器不会碰到卷。 docker rm 不碰它，docker system prune 默认也不碰（那个命令只管容器、网络和悬空镜像）。

4.3 绑定挂载：你自己指定的那个目录#

就是第 2 关一直在用的那个：

1
docker run --rm -v ~/docker/mysite:/data nginx:latest sh -c 'echo 我在你自己的目录里 > /data/note.txt'

~/docker/mysite 是个普通目录，以 / 或 ~ 开头，所以被当成宿主机上的路径。

和卷的差别，一张表说清：

	卷	绑定挂载
位置谁定	Docker	你
住在哪	虚拟机的磁盘上、Docker 的地盘里	你指定的那个路径
长什么样	一个名字（`demo-vol`）	一个路径（`~/docker/mysite`）
能直接用编辑器改吗	不能，它在虚拟机里面	能，它就是个普通目录
备份	得开一个临时容器去打包（4.6）	直接拷目录就行
换台机器还认得吗	认得，名字是逻辑的	不认得，那是个本机路径

怎么选：

开发的时候用绑定挂载：改宿主机上的文件，容器里立刻能看到；嫌它会乱改，加 :ro 只读（第 2 关讲过）。
要交付、要让别人跑出一样的结果，用卷：名字不绑死在某台机器的某个路径上。
数据库这类由程序自己管文件布局的东西，用卷更省心——那些文件长什么样你根本不用操心。

易踩的坑：

绑定挂载的路径必须是绝对路径，或者 ./、../ 开头。写 mysite:/data 会被当成卷名，东西悄悄跑进一个卷里，你以为在改本地文件却什么也没发生。
macOS 上绑定挂载比卷慢一截：宿主机和容器之间隔着一层，读写都要穿过去。卷在虚拟机内部，不跨那一层。对慢这件事敏感的东西，优先用卷。

4.4 匿名卷：只写一个路径的时候#

-v 只写一边会怎样：

1
docker run -d --name anon-demo -v /data nginx:latest

没写宿主那半边。Docker 的动作是：替你新建一个卷，名字是一长串随机的十六进制，然后挂上去。

1
docker volume ls

demo-vol 旁边多出来一个看不出是什么的名字，就是它。这种卷叫匿名卷——它有名字，只是名字没有含义。

它最容易留下的后果：容器删了，它不走。我实测的时候起了一个用匿名卷的容器，docker rm -f 之后，docker volume ls 里就多出那么一个——一次疏忽就攒一个。攒多了就是一堆看不出用途、也不敢删的东西。

匿名卷还有一个来源：有些镜像在构建的时候就声明了某个目录是卷。那样即使你在 docker run 里一个 -v 都不写，也会自动生成一个匿名卷。

清理：

1
docker volume prune

它只删没被任何容器用的卷。

易踩的坑：

docker volume prune 不问你，直接把没在用的卷全删掉。跑之前先 docker volume ls 看一眼，确认里面没有你还要的东西。
docker system prune 默认不碰卷，要连卷一起清得显式加 --volumes。这两个命令的默认行为不一样，容易记混。

4.5 tmpfs：只要内存，不要磁盘#

第三种跟前两种用途完全不同：东西不要落到磁盘上。

1
docker run -d --name tmp-demo --tmpfs /scratch nginx:latest

--tmpfs /scratch 把一块内存挂到容器里的 /scratch。往里写的东西待在内存里，容器一停就没了。

什么时候要它：

临时文件：程序跑的时候需要一个地方写中间结果，跑完就该消失，落盘反而还要清理。
不该留在磁盘上的东西：口令、令牌、解密后的私钥。落到磁盘上就可能被人从磁盘上捞走；只在内存里，容器一停就散。

要观察：docker inspect tmp-demo 里翻 Mounts，你会发现 /scratch 不在里面。它在另一处：

1
"Tmpfs": {
2
    "/scratch": ""
3
},

翻了一遍 Mounts 没找到、就以为没挂上——这是个很容易踩空的地方。

三种摆在一起：

	数据住哪	容器删了	主要用途
卷	虚拟机的磁盘，Docker 管	还在	要长期留住的数据
绑定挂载	你指定的目录	还在	开发时改文件、要能直接看到
tmpfs	内存	没了	临时文件、不该落盘的东西

4.6 备份与迁移#

先把卷的代价说清楚：它在虚拟机里，你没法用文件管理器打开它。 这是它换来「位置不用你操心」的代价。

所以备份得开一个临时容器去做——让一个容器同时看到「要备份的卷」和「宿主机上的一个目录」，在里面打包：

1
docker run --rm \
2
  -v demo-vol:/data:ro \
3
  -v /tmp/backup:/backup \
4
  nginx:latest tar czf /backup/data.tar.gz -C /data .

拆开看：

-v demo-vol:/data:ro：把要备份的卷挂进来，:ro 只读——备份不该改原数据。
-v /tmp/backup:/backup：把宿主机上一个目录挂进来，备份文件要落到这里。少了这半边，包会跟着临时容器一起消失。
tar czf ... -C /data .：进到 /data 再打包。用 -C 是为了让包里的路径是相对的，恢复时不会带上一串绝对路径。最后那个 . 就是「当前目录」。

要观察：这条命令里没有在跑任何服务——它就是拿容器当了一个一次性的命令行环境。手头没有某个工具时，用一个装了它的镜像跑一次就完了，不用在自己机器上装。

恢复是反过来，解到一个新卷里：

1
docker volume create restore-vol
2

3
docker run --rm \
4
  -v restore-vol:/data \
5
  -v /tmp/backup:/backup \
6
  nginx:latest tar xzf /backup/data.tar.gz -C /data

要观察：恢复出来的是一份完全独立的副本。实测里把原卷里的文件删掉之后，新卷里那份还在。

迁移就是「备份 + 在新机器上恢复」：把 data.tar.gz 拷到新机器，在新机器上建卷、解包。这也是为什么卷比绑定挂载更适合交付——绑定挂载换台机器就不认了（4.3 那张表）。

易踩的坑：

备份那条命令里两个 -v 少一个都不行：少了卷那半边没东西可备，少了宿主机那半边包会跟着容器一起消失。
忘了 -C /data，打进去的就是容器里的路径结构，恢复出来位置全不对。
绑定挂载不需要这一套：它本来就在你的磁盘上，直接拷目录。

这一关的产出：三种挂载的取舍判断、一个自己的卷、以及把数据搬走再搬回来的能力。下一关换个方向——这些容器现在各跑各的、互相看不见（第 2 关「三连」留的钩子），要让它们互相说话。

本关命令速查#

卷与各类挂载，见命令速查表 · 卷与数据。

02菜鸟:玩转现成镜像

Sat, 19 Sep 2026 00:00:00 GMT

第 2 关玩转现成镜像#

本关的产出：三个同时跑着的容器（nginx、mysql、redis），每一个都被改过默认行为；以及一套「拿到任意一个陌生镜像，自己找出它有哪些旋钮」的方法。

2.1 镜像不是黑盒，它身上有一排默认值#

第 1 关把 nginx 当靶子练了一遍命令，那会儿它只是「随便一个能在浏览器打开的镜像」，命令练完、容器删掉，没人关心它自己是怎么配的。这一关换个问法：同一个镜像，能不能不重新构建，就让它表现出不同的行为？

能。因为一个镜像打包的不只是程序本身，还有一整套默认值：默认监听哪个端口、默认读哪个路径下的配置、默认把数据写在哪儿、默认以哪个身份运行、默认启动时跑哪个程序。这些是镜像的作者在构建时就写下的——但写下的是默认值，不是不可改的值。

docker run 时给出的参数，就是这一次运行的实际值。参数盖住默认值，而镜像本身一个字节都不动。

能盖的四类旋钮，其中两类第 1 关已经用过了：

端口：-p 宿主:容器（第 1 关用过）。
启动命令：写在镜像名后面的那串东西。
环境变量：-e 名字=值。
挂载：-v 宿主:容器，用宿主机的目录或文件顶掉容器里的。

这一关把这四类全用一遍，最后回头解决一个问题：这些旋钮的名字，是怎么知道的。

2.2 环境变量：官方镜像最常留的那排旋钮#

先把这个词说清楚。环境变量就是一组「名字 = 值」，跟着进程一起启动。程序在启动的那一刻读它们一遍：读到了就照上面写的做，没读到就用自己的默认值。这不是 Docker 发明的东西，是 Linux 上早就有的机制；Docker 只是把它变成了一个命令行参数。

「官方镜像」指的是 Docker 官方维护并发布的那批常见软件镜像，nginx、mysql、redis 都是。mysql 官方镜像就是一个典型：它启动时必须知道 root 密码是什么，而它又没有合理的默认值可给，于是干脆不给，逼你显式写出来。

1
docker run -d --name mysql-demo -e MYSQL_ROOT_PASSWORD=hecloud mysql

拆开看：

--name mysql-demo：给这个容器起个名字。
-e MYSQL_ROOT_PASSWORD=hecloud：把这个名字和值送进容器的环境变量。镜像里的启动脚本读到它，就知道 root 密码该设成什么。
结尾的 mysql：镜像名。本地没有它会先去拉。

「起个名字」是什么意思：容器一被创建就有一个名字，不写 --name 时 Docker 会随手拼两个单词给它（dreamy_einstein 之类），docker ps 的 NAMES 一列就是它。所以 --name 不是重命名，而是指定。

名字就是容器身上的一个字段，这两个动作是同一个字段的两个时机：docker run --name 在容器创建时把它写定，docker rename <容器> <新名字> 在创建之后改写它——后者才是重命名。左边填 ID 或旧名字都行，运行中、已停止都能改，改完不用重启。

名字和容器 ID 是一回事——都是这个容器的标识，凡是命令里要写 <容器> 的地方两样都能填。区别只在：ID 是 Docker 生成的、唯一但记不住；名字是人给的、短、好念，也唯一。第 1 关一直用 ID，是为了先看清「容器真有 ID 这回事」；要同时跑好几个容器时，名字就明显更好使。

名字还有第二份工作：等第 5 关给容器接上自定义网络，它就是别的容器能叫到它的那个名字。到那时「起个有意义的名字」就不只是好念的问题了。

不给 MYSQL_ROOT_PASSWORD 会怎样？容器起来后立刻退出，docker logs 里写得明明白白：它拒绝启动，理由是没有告诉它 root 密码。这是官方镜像一个很常见的约定：没有合理默认值、又必须知道的东西，就用这种方式逼你说出来，而不是悄悄用一套「root + 空密码」把问题埋进深处。等到线上才发现，代价就大了。

怎么知道密码真的生效了：等它起来之后进去问一句——docker exec -it mysql-demo mysql -uroot -phecloud -e "show databases;"。能列出数据库，就说明 -e 送进去的那个密码确实被程序读到了。

注意：要给的变量不止一个时，-e 名字=值 写几遍就是几个。

要观察：docker ps 里这个容器的 PORTS 一列是空的。mysql 默认在容器里监听 3306，但没写 -p，所以那个端口只存在于容器自己的网络里，宿主机上碰不到。

易踩的坑：

密码写在命令里，会留在终端的历史记录里，也会明文记在容器的配置里。这一关先接受这个做法，正经的密码管理留到第 13 关。
环境变量只在容器第一次创建时读一次，之后就成了容器配置的一部分。Docker 没有提供「改一个已存在容器的环境变量」这个操作——名字有 docker rename，CPU、内存这类运行参数另外有命令，唯独环境变量没有。想变只能删掉重建，docker start 读的也是当初那一份。（删掉重建为什么不吃亏，2.3 会说。）
名字在所有容器里唯一，包括已经停掉的。一个停着不动的 mysql-demo 也照样占着这个名字，再起一个同名的会直接报 Conflict. The container name "/mysql-demo" is already in use，得先 docker rm mysql-demo。
-e 和名字常被放在一起记，但两者的可变性正好相反：-e 定了就改不了，名字随时能改（docker rename）。唯一的共同点是都长在容器身上——容器一删，两者一起消失。
mysql 第一次启动要先初始化数据目录，得等十几秒才真正能连。这期间上面那条查询会报连接失败，但那不是密码错了。docker logs mysql-demo 能看到它在做什么，最后打印出 ready for connections 才算好了。

2.3 挂载：把宿主机的目录或文件接到容器里#

第 1 关留过一句话：容器删掉之后，写进它自己文件系统里的改动一并消失。这句话得先把「文件系统」拆开才站得住——它在这里指的是两个不同层级的东西：

跑 Docker 的那台 Linux 虚拟机，有一份自己的文件系统。它就是一块普通的磁盘，镜像和容器都住在这块磁盘上，是它的住户。
容器里的进程看到的那个 /，不是一个磁盘，是拼出来的：下面那层来自镜像，只读；上面那层是容器自己写的。

所以容器里的 /etc/nginx/nginx.conf 并不像普通机器上那样「是磁盘上的一个文件」，它是一次查询的结果——去镜像那层找到了，就给你。改它，改动落到容器自己那层；容器一删，那层没了，读到的又变回镜像里原来那份。

容器没有自己的磁盘。 它不是一台小机器，它看到的那个根目录由镜像撑着，只有它自己改过的那一点点是独占的。数据就是这样丢的。第 3 关讲镜像怎么分层时，会把这套拼装讲全。

mysql 把整个数据库都存在容器自己的文件系统里。按上面那段，删掉容器就等于删库——这显然不行。要让数据活在容器之外，就得让容器别把数据写在自己身上，而是让宿主机上的一个目录，出现在它写数据的那个位置上。挂载做的事，就是让那个位置不再来自镜像、也不再来自容器自己那层，而是直接指向宿主机上一个真实存在的目录。

1
docker run -d --name mysql-demo \
2
  -e MYSQL_ROOT_PASSWORD=hecloud \
3
  -v ~/docker/mysql-data:/var/lib/mysql \
4
  mysql

-v 宿主路径:容器路径：顺序和 -p 一样，是「宿主在前，容器在后」，同样是容易记反的地方。
/var/lib/mysql 是 mysql 官方镜像约定好的数据目录。
~/docker/mysql-data 是宿主机上的路径。~ 指家目录，所以这条命令的意思是：让家目录下 docker/mysql-data 这个目录，成为容器里的 /var/lib/mysql。写进后者的东西，实际落到前者身上。

这个能力不只对数据目录有用。镜像里的任何一个文件，都能被宿主机上的文件顶掉——包括它的配置文件。比如把 nginx 的主配置换成自己写的：

1
docker run -d --name nginx-demo -p 8080:80 \
2
  -v ~/docker/nginx.conf:/etc/nginx/nginx.conf:ro \
3
  nginx

挂的可以是一个目录，也可以是一个文件。
末尾的 :ro 表示容器里只能读、不能改。挂配置文件时习惯加上，免得容器里的程序把宿主机上这份文件顺手改了。

验证一下真的留住了：docker rm -f mysql-demo 把容器删掉，再用上面那条命令重新起一个，挂的是同一个目录——之前建过的库还在。这就是「数据活在容器之外」的意思。
这一步顺手印证了一件更大的事：容器是可以随手删掉重造的，只要它身上有状态的东西都挂到了外面。改环境变量、改端口、改启动命令，走的都是同一个套路——把容器删掉，把 docker run 那条命令改一改，重来一遍。所以那条命令本身是值得留着的，容器反倒不值钱。
换句话说：有状态的东西挂出去，没状态的东西写在创建命令里。这是这一关真正想让人带走的一句话，也是为什么第 6 关的 Compose 干的事，就是把这条命令从命令行里搬进一个文件。

易踩的坑：

-v 的第一段，必须以 / 或 ./ 开头，才会被当成宿主机的路径；不然它会被当成一个卷的名字（那是另一套东西，第 4 关讲），不是目录。这条规则能解释一个高频错误：~ 只在 shell 里展开，所以一旦写成 -v "~/docker/mysql-data:/var/lib/mysql"——引号把 ~ 挡住了，它原样传给 Docker，开头不是 /，于是被当成卷名，报 includes invalid characters for a local volume name ... If you intended to pass a host directory, use absolute path。报错里那句提示就是答案。
宿主路径不存在时，Docker 不会报错，而是替你造一个空目录。如果本该挂的是一个文件，那个位置就变成了一个空目录，容器里的程序找不到文件直接报错，报错内容还跟「挂载」两个字没关系。
挂载会整个盖住目标位置。宿主目录是空的，容器里那个目录就变成空的——哪怕镜像里原本装了东西。所以挂数据目录之前，先确认镜像在那个位置是安全的.
macOS 上宿主机和容器之间隔着一层，读写挂载目录比在 Linux 上慢一截。开发够用，跑数据库压测就不合适了。

为什么需要 -v 这件事、它和「卷」有什么区别、数据怎么备份迁移，是第 4 关的全部内容。这一关只把它当成「把外面的东西接进来」这个动作用。

2.4 覆盖启动命令：镜像说它默认这么启动，你可以改启动模式#

镜像里除了默认值，还写死了一件事：容器一启动就跑哪个程序。nginx 镜像跑 nginx，mysql 镜像跑 mysqld，redis 镜像跑 redis-server。想换掉它，就在镜像名后面接着写：

1
docker run --rm redis redis-server --appendonly yes

镜像名后面的东西（redis-server）就是启动命令，它会把镜像里写死的那个整个换掉。
--rm 表示容器一退出就自动删掉。跑「看一眼就走」的临时容器时常用，省得回头再 docker rm。
这条命令换掉的就是 redis-server，变动只不过是给它加了个参数—appendonly yes。

要换成一个完全不同的程序也行。这招真正的用处是：钻进一个陌生镜像里，看看它到底装了什么。手头有个没用过的镜像，不确定里面是什么样子，就开一个容器给它一个终端，而不是先费劲跑起来、再想办法钻进去：

1
docker run -it --rm nginx sh

进去之后 ls、cat、which 都跟普通 Linux 一样，看完 exit 出来，容器自己就没了。

要观察：容器生下来就开始跑这条命令，命令一结束容器就退出。所以像上面那样开一个 shell 的容器，退出那一刻它就从 docker ps 里消失了；docker ps -a 也看不到——--rm 已经把它删了。

易踩的坑：

有些镜像在启动真正的主程序之前，还会先跑一段自己的准备工作（初始化数据目录、生成配置文件）。那段准备工作不会被替换掉，被换掉的只有最后那个程序。所以「镜像名后面写什么，就跑什么」这句话是简写版，第 3 关讲镜像的启动配置时会补全。
换掉启动命令之后，容器的主进程就成了你写的这个。它一退出，容器就停——这正是上面那个 shell 容器的行为。

2.5 这些旋钮的名字，从哪儿知道#

四类旋钮都会用了，但还剩最关键的一步：拿到一个从没用过的官方镜像，怎么知道它认哪些环境变量、数据该往哪个目录挂？ 总不能靠猜。

第一手资料是官方镜像的文档页。 Docker Hub 上每个官方镜像都有一页说明，里面列着它支持的环境变量、约定好的数据目录和配置目录、默认暴露的端口、默认以哪个身份运行。优先看它。

docker inspect <镜像> 是另一条路：它把镜像的完整配置整个打出来，比文档页更全，但输出很长、里面没有任何解释——它是留给排查问题用的。这里先知道有这么个东西就够，怎么读它放到第 12 关。

再回头看，官方镜像的默认约定其实相当一致，一般摸清三条就够用了：

没有合理默认值、又必须知道的，就拒绝启动，用这种方式逼你显式给（mysql 的 root 密码就是）。
数据目录固定在某个路径，文档里会写。这个路径是「运行期才写」的，所以可以挂载，也应该挂载。
端口默认只在容器内监听，想在宿主机上访问，必须自己写 -p。

2.6 三连：把三个一起跑起来#

前面每样都单练过一遍，现在把 nginx、mysql、redis 三个同时跑起来，各改各的行为。

1
docker run -d --name web -p 8080:80 nginx
2

3
docker run -d --name db -p 3306:3306 \
4
  -e MYSQL_ROOT_PASSWORD=hecloud \
5
  -v ~/docker/mysql-data:/var/lib/mysql \
6
  mysql
7

8
docker run -d --name cache -p 6379:6379 \
9
  -v ~/docker/redis-data:/data \
10
  redis

三个镜像改的地方各不相同：web 只做了端口映射；db 既给了必填的环境变量，又把数据目录挂了出来；cache 只挂了数据目录，因为它没有必填变量，默认就是不带密码启动的。

跑起来之后有一点会立刻感觉到：三个容器各跑各的，互相看不见。web 里的 nginx 没有任何办法找到 db，db 也找不到 cache——它们各自是一个独立的小世界。怎么让它们互相说话，是第 5 关的事。

本关命令速查#

运行容器时的各类参数，见命令速查表 · 运行时的参数。

03菜鸟:写Dockerfile

Sat, 19 Sep 2026 00:00:00 GMT

第 3 关写 Dockerfile#

本关的产出：一份能交付的 Dockerfile、一个自己造出来的镜像，以及一套读懂别人镜像的本事。

3.1 容器里改好的东西，怎么留下来#

第 2 关最后留下一句话：有状态的东西挂出去，没状态的东西写在创建命令里。按那句话，容器可以随手删掉重造，真正值钱的是那条 docker run。

但那句话有个前提：你要的东西必须已经躺在某个镜像里。你能改的只是「怎么跑它」，改不了镜像本身。

现在把问题往前推一步：如果我想改的，是镜像里的内容呢？

举个具体的。第 1 关和第 2 关都用过 nginx，它启动后给你看一个欢迎页。假如想把这个页面换成自己的——进容器里把那个文件改掉，浏览器里立刻就能看到。可容器一删，改动跟着没了，跟第 1 关那句「写进容器自己文件系统里的改动一并消失」一模一样。

有一条路是现成的：把容器当前的样子冻成一个新镜像。

1
docker commit <容器> mysite:1.0

它真的能用，而且看起来很省事——改完就冻上，不用写任何文件。

但它不该当常规手段用。 理由有四条：

它记的是结果，不是过程。 你拿到一个新镜像，但它为什么长这样、中间做过什么，只有一叠没有说明的层。三个月后的自己，和任何接手的人，都只能猜。
不可复现。 同一步操作换个基础镜像、换个时间做，结果可能不一样。而「再跑一遍得到同一个东西」，本来就是镜像存在的意义。
没法被检查。 Dockerfile 是文本，能进版本库、能对比改动、能让人在上面提意见。commit 的产物是二进制，谁也不知道里面夹带了什么。
改不动。 想调整一行？只能回到容器里重来一遍。第 2 关那句「环境变量改不了得重建」，在镜像这一层会放大好几倍。

所以这一关的立场是一句话：

镜像应该由一份文件描述出来，而不是由一次操作冻结出来。

那份文件就是 Dockerfile。

3.2 第一份 Dockerfile 与 docker build#

要打包的东西先准备好——一个自己的网页：

1
<!doctype html>
2
<html>
3
<head><meta charset="utf-8"><title>我的第一个镜像</title></head>
4
<body><h1>它跑起来了</h1><p>这个页面是我自己打进镜像里的。</p></body>
5
</html>

存成 index.html，放在一个空目录里。然后在同一个目录下建一个文件，就叫 Dockerfile，没有后缀名：

1
FROM nginx
2
WORKDIR /usr/share/nginx/html
3
COPY index.html .

三行，逐条看：

FROM nginx：选一个底。不从零开始，而是从已经做好的 nginx 镜像出发，在它之上做改动。「一台装好了 nginx 的 Linux」这件事已经有人做完了，重造一遍是浪费。
WORKDIR /usr/share/nginx/html：把接下来的指令的工作目录切到这里，相当于 cd。注意它管的是后面所有指令，不是一次性的。
COPY index.html .：把 index.html 复制进镜像。第二个参数 . 就是上面 WORKDIR 定下的那个目录。而 /usr/share/nginx/html 正是 nginx 官方镜像约定好的网站根目录——这个路径是从文档页查来的（第 2 关的 2.5）。

接着构建：

1
docker build -t mysite:1.0 .

-t 后面那串是给镜像起的名字，由两部分组成，中间用冒号隔开：冒号前面是名字（mysite），冒号后面是标签（1.0）。

标签就是给人看的锚点，用来区分同一个名字下的不同版本。不写冒号和标签时会自动用 latest——这个默认值有个很有名的陷阱，第 10 关专门讲。

可以反复构建，没有次数限制。 改一次 Dockerfile 就重建一次，是开发的正常节奏。每构建一次产出一个新镜像；如果用的是同一个名字，新镜像会接管这个名字，旧的那份仍然留在磁盘上、只是没名字了——第 1 关的 docker system prune 收的就是这一类。

构建完起容器：

1
docker run -d --name site -p 8080:80 mysite:1.0

浏览器打开 http://localhost:8080，看到自己那个页面。

要观察：这个新镜像的行为跟 nginx 一模一样——照样监听 80、照样把页面发出来。因为你只是在它上面盖了一层。

易踩的坑：8080 被占用时换宿主机那一边的端口号会变（-p 8081:80），容器的 80 不用动。

3.3 那条 `.` 到底是什么#

docker build -t mysite:1.0 . 末尾那个孤零零的 .，是用来指定一个目录的：这次构建允许用到的全部材料，都从这个目录里取。. 是「当前目录」的写法——所以整句话的意思是「材料就从我站的这儿取」。

为什么非得交一份材料过去？回到第 1 关那两个角色：真正干活的是服务端，它可能在另一台机器上，看不见你本地的文件。你要用的东西，得先交到它手上。

后果有两条：

COPY 只能从当前目录里拿东西。 写成 COPY ../other/x . 会直接报错，那个路径根本不在交出去的材料里。
当前目录里的东西，可能被复制进镜像。 这一条比看上去严重。

第二条能亲眼看见。把 COPY 那一行改成 COPY . /src（把整个当前目录都复制进去），再往目录里放两样东西：一个 .git，一个 node_modules。重建之后进去看：

1
docker run --rm mysite:1.0 ls -a /src

.git、node_modules、Dockerfile 全在里头。.git 里可能躺着提交历史和密钥，node_modules 可能几百兆——它们本来都不该出现在镜像里。

挡住它的东西叫 .dockerignore：一个文件，列一堆「不要交出去」的路径，写法跟 .gitignore 一样。

1
node_modules
2
.git
3
*.log

加上它，重建，再 ls 一次，那两样就没了。

易踩的坑：

.dockerignore 不会自动排除 Dockerfile 自己。需要的话得把它也写进去。
换个目录敲 docker build，交出去的材料就换了一份——跟第 2 关那条挂载的坑是同一类事。
这个目录里搁着大东西（数据库文件、模型、日志）时，这一步可能明显变慢。守护进程跑在本机时不一定全传，但「它可能被 COPY 进镜像」这一条永远成立，别指望不传就等于没事。

3.4 你刚造出来的东西，其实是一叠层#

第 2 关为了让「容器删了数据就没了」站得住，给过一个简化版的说法：

容器里的进程看到的那个 /，不是一个磁盘，是拼出来的：下面那层来自镜像，只读；上面那层是容器自己写的。

「下面那层」——它不是铁板一块，是一叠压在一起的文件层。而 Dockerfile 里的每一条指令产生其中的一层（FROM 除外：它只是选底，不落层）。

看实物：

1
docker history mysite:1.0

输出里最上面两条是刚写的，往下全是基础镜像的：

1
24.6kB  COPY index.html . # buildkit
2
4.1kB   WORKDIR /usr/share/nginx/html
3
0B      CMD ["nginx" "-g" "daemon off;"]
4
0B      STOPSIGNAL SIGQUIT
5
0B      EXPOSE map[80/tcp:{}]
6
0B      ENTRYPOINT ["/docker-entrypoint.sh"]
7
16.4kB  COPY 30-tune-worker-processes.sh …
8
12.3kB  COPY 20-envsubst-on-templates.sh …

看两个地方。

第一，最左侧一列。 最上面两条不是 0——因为它们真动了文件系统（WORKDIR 建了目录，COPY 放进一个文件）。而基础镜像那一段里，CMD、EXPOSE、ENTRYPOINT、STOPSIGNAL 全是 0B：它们只改配置，不产生文件。所以「一条指令一层」是个简写——准确地说，一条指令一条记录，只有碰了文件系统的那种才真的占一层。

这一列也不等于「你的文件多大」，它有额外开销，别拿它当尺子量文件。

第二，从第三条往下，全是 nginx 官方镜像的东西。 你这份镜像底下那一大截，和官方镜像根本是同一份文件——磁盘上只存一份，两边共用。这次构建真正新增的，只有最上面那两条。

这就是为什么「基于现成镜像造自己的镜像」这么便宜：层是可以被复用的。

回到第 2 关那句简化版，它现在完整了：

容器 = 基础镜像的所有层（共用、只读）＋ Dockerfile指令新建的层（共用）＋容器运行时的可写层（独有，一删就没）

「层能被复用」还有下半场：构建的时候也能复用——两条指令产生的层如果一模一样，第二次就不用重做。怎么让这件事发生，是第 9 关的全部主题。

3.5 镜像怎么启动#

回头看那份 Dockerfile：三行里没有一条管「启动」，可容器起来之后 nginx 确实跑了。谁让它跑的？

docker history 里已经写着答案——就是那两行：

1
CMD ["nginx" "-g" "daemon off;"]
2
ENTRYPOINT ["/docker-entrypoint.sh"]

基础镜像替你写了。 这是镜像里两个专门管启动的字段，名字本身就把分工说清楚了：

ENTRYPOINT（入口）—— 「从哪儿进去」。它相对固定，是这个镜像的身份。nginx 镜像让它先跑一段准备脚本，就是第 2 关那条坑里说的「准备工作」。
CMD（command 的缩写，「命令」）—— 「默认跑什么」。它是默认值，可以被覆盖。

第 2 关留的那个口子，现在能补全了：

docker run <镜像> <命令> 里写在镜像名后面的东西，顶掉的是 CMD；
ENTRYPOINT 不动；
想连它一起换掉，得显式说：docker run --entrypoint <程序> <镜像>。

顺带一句：镜像名后面那个位置的含义由镜像决定——有的镜像（如中间件 / 应用镜像nginx 、mysql、redis的entrypoint是shell脚本）把它当「要跑的程序」启动，有的只当「参数」。所以第 2 关那招是个经验、不是保证。想无条件进去，用 docker run -it --entrypoint sh <镜像>：它在 Docker 这一层直接换掉 ENTRYPOINT，不看镜像自己怎么写。

把这两条写进自己的 Dockerfile 看看。 在 COPY 那行下面加两条：

1
FROM nginx
2
WORKDIR /usr/share/nginx/html
3
COPY index.html .
4
EXPOSE 80
5
CMD ["nginx", "-g", "daemon off;"]

重建之后再 docker history mysite:1.0：

1
0B      CMD ["nginx" "-g" "daemon off;"]      ← 你写的
2
0B      EXPOSE [80/tcp]                       ← 你写的
3
24.6kB  COPY index.html . # buildkit
4
4.1kB   WORKDIR /usr/share/nginx/html
5
0B      CMD ["nginx" "-g" "daemon off;"]      ← 基础镜像的

两行一模一样。（history 的排版是它自己的事，跟你 Dockerfile 里的写法不必逐字相同。）

这正说明你抄了一份基础镜像已经做过的事——实际项目里这两行当然可以不写。写出来是为了让你亲手看见「基础镜像替你做了什么」。而当一个镜像要跑的是你自己的程序时，CMD 就必须自己写了，那才是它真正出场的地方。

CMD 有两种写法，上面用的是第一种：

1
CMD ["nginx", "-g", "daemon off;"]     # 逐项写开：程序，以及它的参数
2
CMD nginx -g "daemon off;"             # 整句话交给 shell 去解释

第二种看着更眼熟，但两者不是一回事。这里先记住有这两种写法、别写混就够了——为什么要在意它们的区别，第 8 关会讲。

EXPOSE 80 是声明「这个镜像会在容器里监听 80」。它只是声明：真正让宿主机能访问到，还是得靠 -p（第 2 关的 2.5 讲过，EXPOSE 就是那份声明的出处）。

3.6 反过来：用这一关的本事读别人的镜像#

现在把方向倒过来。手上有个陌生镜像，你不写它、只想看懂它——docker history 就是入口。

其实刚才已经读过一次了：mysite:1.0 输出里从第三条往下那一整段，就是 nginx 官方镜像的层。从上往下读，它做过什么基本能还原出来——装了哪些包、加了什么用户、把自己的脚本复制到了哪、最后用什么启动。

nginx 的 Dockerfile 公开在 Docker Hub 的官方镜像页上，文档页里就链着它。两样对着看，一个镜像就没有秘密了。

这一关的产出：一份能交付的 Dockerfile、一个自己造的镜像，和一套读镜像的本事。下一关镜头转向容器要承载的东西，先解决第 1 关就埋下的那个问题——数据怎么活过容器。

本关命令速查#

构建与查看镜像，见命令速查表 · 构建镜像。

01菜鸟:装好跑起来

Fri, 18 Sep 2026 00:00:00 GMT

第 1 关装好跑起来#

本关的产出：一个装好的运行时，一条从拉镜像、起容器到在浏览器里打开的完整链路，以及查看、进入、停止、删除这一套日常操作。

1.1 先搞清这条命令发给了谁#

问题的来源：Docker 分成两半。敲下的 docker 命令是「客户端」，真正拉镜像、起容器的是常驻在后台的「服务端」（也就是守护进程）。客户端每执行一条命令，都得先知道自己该把它发给谁。

两个角色，这里说清楚一次，后面一直用。
服务端是那个常驻后台的守护进程。它掌握全部状态：有哪些镜像、有哪些容器、每个容器在跑什么、网络怎么连、数据存在哪。活都是它干的。
客户端就是敲下的 docker 命令。它自己什么都不做（无状态），只干三件事：把命令翻译成一个请求，发给服务端，再把返回的结果打出来。
最能说明问题的一点：客户端不掌握任何运行状态。敲 docker ps 的那一瞬间，它并不知道这台机器上有几个容器，它只是问服务端「现在有哪些容器」，然后照着答案印出来。
所以客户端不止一个。命令行是一个，图形界面是一个，编辑器里的插件也是一个——它们问的是同一个服务端。这正是上下文必须存在的原因：客户端可以有好几个，但「问谁」只能有一个答案。
想亲眼看到这两个角色，敲一次 docker version：它会打印两段，第一段标题是 Client，第二段是 Server。

在「上下文」出现之前，这个「发给谁」只能靠终端里的一个设置来指定（环境变量 DOCKER_HOST）。它有三个麻烦：

它是终端窗口的状态，不是系统里的一件东西：只对当前这个终端窗口有效，另开一个窗口就没了；想让它一直有效就得写进终端的配置文件，然后过几个月连自己都忘了配过。
没有清单：「这台机器上到底有几个 Docker 可以连」这个问题无解，目标只存在于记忆里。
最要命的是会连错：忘了当前指向哪，对着生产环境的守护进程敲下一句 docker rm。在上下文这个概念出现之前，这是很常见的事故。

在 macOS 上，这个问题一定会撞上：Docker Desktop 的守护进程并不直接跑在 Mac 上，而是跑在 Docker 自己管的一台小 Linux 虚拟机里，Colima 也是同样的路数。两者的守护进程各自守在不同的位置，客户端要连的地址并不相同。两个都装的时候，「这条命令到底发给谁」必须有个明确答案。

上下文就是为这件事设计的：它把「连哪个守护进程」以及连上它所需要的全部设置，打包成一个有名字、会被记住的东西，存在 ~/.docker/ 下。于是：

可枚举：docker context ls 把「目标」从记忆里的东西变成系统里列得出来的东西。
可切换：docker context use <名字> 显式切换，切完一直有效。
可按单条命令覆盖：docker --context <名字> ps 只影响这一条命令，不动全局设置。
不只终端能用：编辑器插件、图形界面工具都读它；而那个终端设置只有终端有。

它真正给人的东西：从此 docker 命令不关心守护进程在哪儿。跑在本机的虚拟机里，或者跑在另一台服务器上，对它来说都只是「一个上下文」。在同一台 Mac 上敲 docker ps，列出来的可以是远端那台机器上的容器。

一个关键性质：上下文是纯客户端的概念。守护进程完全不知道它存在，它只是客户端本地的一份连接配置。

常见的三个选择：

Docker Desktop：官方方案，带图形界面，自带那台小 Linux 虚拟机，资源占用偏大。
Colima：开源命令行方案，同样是虚拟机，但没有图形界面，内存占用小。
OrbStack：Mac 上性能最好，商业软件，个人免费。

动手：

docker context ls —— 看有哪些上下文，带 * 的是当前在用的那个。
docker context use <名字> 切到另一个，再跑一次 docker ps 对比。
切回来。

要观察：

docker context ls 里 default 那条的描述写着 Current DOCKER_HOST based configuration —— 它就是把上面说的「老办法」原样保留成了一个上下文，从这能看出这个机制是怎么长出来的。
切到 Colima 那边的上下文而它又没启动时，docker ps 报的是连不上，而不是「没有容器」。这两句话的区别，就是「客户端连不上服务端」和「服务端上没东西」的区别。

易踩的坑：

带 * 的是「当前在用」，不是「默认」。名字叫 default 的那个，很可能恰恰不是当前在用的。
切换上下文之后，之前 docker ps 能看到的容器会「消失」——它们还在，只是在另一台虚拟机上。

1.2 验证安装，跑出 hello-world#

目标：确认这套装好了，并看清一次 run 到底做了几件事。

验证：docker version 看客户端与服务端两段版本号，docker info 看服务端信息（存储驱动、内核版本、总内存）。
跑一次：docker run hello-world。
拆开这一步：去找镜像 → 没有就从仓库拉 → 用它创建一个容器 → 启动容器里的进程 → 进程输出那几行字 → 进程退出、容器停止。

要观察：

docker ps 看不到刚跑完的容器，docker ps -a 才看得到 —— 因为它已经退出了。
退出码是 0，表示正常结束，不是失败。

易踩的坑：第一次拉镜像会卡在 Unable to find image ... locally 一会儿，那是真的在下东西，不是卡死。

1.3 拉下镜像、跑起来、访问它#

目标：跑一个不止转瞬即逝的容器，从浏览器里访问到它。

先把镜像拉下来：docker pull nginx。拉完再敲一次同样的命令，会立刻返回——镜像已经在本地了，不用再下一次。
起容器：docker run -d -p 8080:80 nginx。
-d：后台运行，命令立刻返回，终端不被占住。
-p 8080:80：把宿主机的 8080 端口转发到容器的 80 端口。顺序是「宿主<容器>」，这里最容易记反。
访问：浏览器打开 http://localhost:8080，看到 nginx 的欢迎页。

要观察：docker ps 的 STATUS 与 PORTS 两列分别写了什么。

易踩的坑：

第 1 步其实可以省：本地没有这个镜像时，docker run 会自己去拉。单独拉一次的用处是把「拉」和「跑」分成两步——出问题时一眼看得出是压根没拉下来，还是拉下来了但跑不起来。
8080 已被占用时会报 bind: address already in use，换个宿主端口即可（容器的 80 不用动）。
macOS 上必须显式做端口映射。Docker Desktop 的「宿主机」其实是那台 Linux 虚拟机，不写 -p，端口就不会出现在 Mac 上，浏览器里自然打不开。

1.4 看日志与进容器#

目标：容器是黑盒，学会从外面看它、钻进它里面。

看输出：docker logs <容器ID>，加 -f 持续跟随。
钻进去：docker exec -it <容器ID> bash，进去之后 ls、cat、改文件都跟普通 Linux 一样。
exec 与 attach 的区别：attach 接的是容器主进程的标准输入输出，在里面按 Ctrl+C 会把主进程一起送走、容器跟着停；exec 是另开一个进程，退出它不影响容器。

易踩的坑：

docker logs 给的是容器里主进程的输出，不是 Docker 自己的日志。主进程不往标准输出写东西时它就是空的——哪怕程序正往自己的文件里勤勤恳恳地写日志。守护进程自己的日志是另外一套。
exec 只对运行中的容器有效，停了的容器要先 start。
-it 两个参数缺一不可：-i 保持输入，-t 分配终端，少一个就没有交互。
精简镜像（后面会遇到的 alpine、distroless）里没有 bash，得换成 sh 或者根本没有 shell。

1.5 停掉、删掉、找回#

目标：把「容器」和「镜像」这两样东西的关系理顺。

停与启：docker stop <ID>、docker start <ID>、docker restart <ID>。停掉的容器还在，能再启。
删容器：docker rm <ID>，加 -f 可以强删运行中的容器。
删镜像：docker rmi <镜像>。
顺序：容器是镜像的实例，所以先删容器，再删镜像。

易踩的坑：

docker rm 直接删运行中的容器会报错，要么先 stop，要么加 -f。
docker rmi 报 image is being used by ... 时，不是权限问题，是有容器（哪怕是已停止的）还指着它。
容器删掉之后，写进它自己文件系统里的改动一并消失——这是第 4 关要解决的问题。

1.6 看看这些东西占了多大地方#

目标：知道怎么查、怎么收，别让镜像和缓存把磁盘悄悄吃满。

查：docker system df，分别看镜像、容器、卷、构建缓存各占多少。
收：docker system prune 清掉已停止的容器和没在用的网络；-a 连没被任何容器引用的镜像一起清。

要观察：docker system df 里 RECLAIMABLE 那一列，就是「现在能收回多少」。

易踩的坑：prune -a 会把构建缓存一起清掉，下次构建会明显变慢。清之前先看清楚。

本关命令速查#

容器生命周期与日常操作，见命令速查表 · 容器生命周期。

00概述Docker

Thu, 17 Sep 2026 00:00:00 GMT

概述#

本系列是 Docker 的学习笔记，路线是「小白变怪兽」：从装好 Docker、跑出第一个容器开始，一路做到能手写一个迷你容器。

Docker 和 Java SE 那类语言笔记不太一样。语言的知识点可以先理解再动手；Docker 是一个完整的应用程序，知识几乎都长在手上——把 docker run 的每个参数敲明白，比背下「容器是什么」的定义有用得多。所以本系列不按概念分章，按关卡推进：每一关都是一条能跑通的操作链，命令随用随讲，成体系的收进命令速查表。

本系列的运行环境是 macOS，涉及 Linux 与 Windows 差异的地方会单独点出。内容会作为知识节点，串连进后端路线中「部署与运维基础」一段。创作过程使用 AI 辅助以尽量减少错误，如有纰漏欢迎指出。

这套教程适合谁#

面向运维工程师与后端开发人员，也适合任何想把「在我机器上是好的」这个问题彻底解决掉的人。

阅读前需要掌握 Linux 的常用命令（cd、ls、ps、文件权限、标准输入输出）。没有基础的话可以先补一下 Linux 教程，本系列涉及 Linux 的地方只讲与容器有关的部分。

怎么用这套教程#

边读边敲：每关的正文就是操作步骤，只看不练等于没看。
关卡独立：每关自包含，跳读不会断档；需要用到上一关的成果时，会在开头交代。
命令去速查表：正文只在用到时给出命令，系统的整理收进命令速查表；速查表上的反向链接会显示哪些关卡引用过它。
保留踩坑：报错与排查过程会留在正文里，它们比顺利跑通的命令更有信息量。

全系列地图#

关	阶段	内容	实操产出
1	菜鸟	装好跑起来	选定运行时并跑出 nginx，在浏览器打开
2	菜鸟	玩转现成镜像	nginx + mysql + redis 三连
3	菜鸟	写 Dockerfile	写出第一个可交付的镜像
4	入门	数据持久化	容器删了，数据还在
5	入门	容器网络	容器之间、容器与宿主机互相说话
6	入门	Compose 起全栈	一条命令起整套服务
7	入门	Compose 进阶	服务按依赖顺序就绪，多环境一套配置
8	入门	容器里的进程	让容器优雅停止，不再硬等满 10 秒
9	进阶	构建进阶与镜像瘦身	镜像从 1GB 压到 100MB，构建也变快
10	进阶	推送与自动化构建	多架构镜像自动构建并推送
11	进阶	日志与磁盘治理	磁盘爆了，能查出是谁吃掉的
12	进阶	出事了怎么查	十分钟内定位到出错的那一层
13	进阶	容器安全	把容器关进笼子
14	进阶	资源限制与性能	一个容器压不垮机器
15	怪兽	底层原理	看懂 veth、iptables 与 overlayfs
16	怪兽	手写迷你容器	自己造一个「Docker」
17	怪兽	综合实战	把真项目部署上线（附 K8s 衔接）
18	附录	命令速查	全系列命令手册

四个阶段#

菜鸟：跨过陌生感。三个动作对应 Docker 的三个基本对象——跑别人的、用别人的、造自己的。
入门：让容器真的能承载应用。四件事缺一不可——状态、通信、编排、生命周期。
进阶：从「能跑」到「能交付」。小、快、自动、查得动、关得住。
怪兽：解释前面每一步的「玄学」，最后收网到一个真项目。

Docker 是什么#

Docker 是一个开源的应用容器引擎，用 Go 语言编写，遵循 Apache 2.0 协议开源。

它让开发者可以把应用和依赖一起打包进一个轻量、可移植的容器，然后发布到任何流行的 Linux 机器上运行。容器之间相互隔离，性能开销极低。

这里要先纠正一个流行的直觉：容器不是安全沙箱。它靠 Linux 内核的 namespace 与 cgroups 做隔离，共享宿主机内核，隔离强度远不及虚拟机。把容器当成「轻量虚拟机」来理解，会在涉及权限与逃逸时踩大坑——这一点在第 13 关展开。

核心概念#

镜像（Image）：只读模板，定义了容器的运行环境（操作系统、软件、配置）。它采用分层存储，镜像之间可以共享层，空间与构建速度都因此受益。
容器（Container）：镜像的运行实例，包含应用代码、运行时与依赖，彼此隔离，共享宿主机内核。
Dockerfile：一个文本文件，描述如何自动构建镜像——从哪个基础镜像开始、装什么软件、复制哪些文件。
仓库（Registry）：存放和分发镜像的地方。Docker Hub 是官方公共仓库，Harbor 一类属于私有仓库。

四者的关系是一条链：Dockerfile —构建→ 镜像 —运行→ 容器，而镜像存放在仓库里。

核心优势#

跨平台一致性：解决「在我机器上能跑」的问题，让开发、测试、生产三套环境保持一致。
资源高效：直接共享宿主机内核，不必虚拟化整个操作系统，内存与 CPU 开销远小于虚拟机。
快速部署：容器秒级启动，扩缩容易于自动化。
隔离性：每个容器拥有独立的文件系统、网络与进程空间。

应用场景#

微服务架构：每个服务独立容器化，便于管理与扩展。
CI/CD 流水线：与 Jenkins、GitLab CI 等集成，实现自动化构建与测试。
开发环境标准化：新成员一键启动全套依赖服务（数据库、消息队列等）。
云原生基础：Kubernetes 等编排工具建立在容器之上。

附录#

关于版本#

Docker 从 17.03 版本起分为 CE（社区版）与 EE（企业版），本系列统一使用社区版 CE。

茶叶品类大全

Mon, 14 Sep 2026 00:00:00 GMT

笔者对茶叶品鉴能力不强，目前感受最强的是信阳毛尖，有一种绿茶夹杂的豆香味，更多的茶叶待我评鉴之后更新于此

Linux文件系统目录扫盲

Sun, 13 Sep 2026 00:00:00 GMT

02对象与类

Wed, 09 Sep 2026 00:00:00 GMT

第 4 章对象与类#

4.1 面向对象程序设计概述#

这一节只讲一个核心：C 把数据放在 struct、把函数写在外面，Java 则把二者合并进类中。

先看 C 的写法：

1
struct Employee {
2
    char name[32];
3
    double salary;
4
};
5

6
void raise_salary(struct Employee *e, double pct) {
7
    e->salary *= (1 + pct / 100);
8
}

数据在 struct 里，操作数据的函数在外面，两边唯一的联系是这个函数碰巧收了个 Employee 指针。Java 把这两半塞进同一个 class：

1
class Employee {
2
    private String name;
3
    private double salary;
4

5
    public void raiseSalary(double pct) {
6
        salary *= 1 + pct / 100;
7
    }
8
    public String getName() { return name; }
9
}

类是构造对象的模板，对象是类的实例；字段保存状态，方法描述行为；封装则通过访问权限隐藏实现细节。

对象：类是定义，对象是具体实例。每个对象拥有独立的实例字段。a == b 比较的是身份（是不是同一个对象），不是内容（字段值是否相同）——两个字段完全相同的对象，a == b 仍然为 false。变量只是保存引用，new 才创建对象。
要能识别类：可以先把需求中的名词作为候选类或字段，把动词作为候选方法。例如“雇员有姓名和薪水，可以加薪”，可得到 Employee、name、salary 和 raiseSalary()。
类之间的关系：类与类之间只有三种关系。
- 依赖（uses-a）：一个类的方法里用到了另一个类。最弱也最常见，例如 Order 的某个方法里调用了 Employee 的方法。书上建议尽量少依赖，去耦合。
- 聚合（has-a）：一个对象里装着另一个对象当字段，即「整体-部分」，例如 Order 里有个 Customer 字段。
- 继承（is-a）：一个类是另一个类的特殊化，例如 Manager is-a Employee。这条 Ch5 会整章展开，这里只要认得。
UML 类图的画法：依赖用虚线箭头，聚合在线尾画空心菱形，继承在线尾画空心三角。

概括来说，C 主要靠约定连接数据和函数，Java 则用类与访问控制把它们组织在一起。

4.2 使用预定义类#

对象与对象变量#

Java 的对象变量保存的是引用，不是对象本身：

1
Date deadline = new Date();

它可以粗略类比为 C 中的指针和动态分配：Date d 对应指针，new Date() 对应分配并初始化对象，null 对应空指针。Java 引用不能做指针运算，赋值也只复制引用，不复制对象：

1
Date a = new Date();
2
Date b = a;
3
b.setTime(0);
4
System.out.println(a.getTime()); // 0，指向同一对象

若引用为 null，调用方法会抛出 NullPointerException；局部变量未赋值则会在编译期报错。单独写 new Date() 虽然合法，但对象无人引用，最终会被回收。

new Date() 中的 Date() 是构造器，不是普通方法。构造器名称必须与类名相同，不能写返回类型，负责初始化新对象。

LocalDate#

旧的 Date 可变且接口混乱。Java 8 的 java.time 提供了更清晰的日期类型：

1
import java.time.LocalDate;
2

3
LocalDate today = LocalDate.now();
4
LocalDate d = LocalDate.of(2007, 12, 3);
5
System.out.println(d.getMonthValue()); // 1~12

LocalDate 只表示年月日，不包含时刻和时区。LocalDate.of(...) 是静态工厂方法：类库在内部创建对象并返回引用，因此不需要公开构造器。类类型方法返回的是引用，但不保证一定是新对象。

访问器、更改器与不可变对象#

更改对象状态的方法叫更改器（如 Date.setTime），只读的方法叫访问器（如 getTime）。LocalDate 是不可变类，plusDays 不修改原对象，而是返回新对象：

1
LocalDate d = LocalDate.of(2000, 1, 1);
2
LocalDate e = d.plusDays(100);

必须接住返回值；单独写 d.plusDays(100); 是合法但无效果的代码。不可变对象可以安全共享，避免通过同一引用互相修改状态。

4.3 自定义类#

4.1 里那个只有骨架的 Employee，这一节补完整——也是第一次自己写类。

Employee类：完整版长这样：

1
import java.time.LocalDate;
2

3
public class Employee {
4
    private String name;
5
    private double salary;
6
    private LocalDate hireDay;
7

8
    public Employee(String name, double salary, int year, int month, int day) {
9
        this.name = name;
10
        this.salary = salary;
11
        this.hireDay = LocalDate.of(year, month, day);
12
    }
13

14
    public String getName() { return name; }
15
    public double getSalary() { return salary; }
16
    public LocalDate getHireDay() { return hireDay; }
17

18
    public void raiseSalary(double byPercent) {
19
        double raise = salary * byPercent / 100;
20
        salary += raise;
21
    }
22
}

展开收起

对照 4.1 里那版 C：

C	Java
`struct Employee` 里放字段	`class Employee` 里放字段
`raise_salary(&e, 5)` 外面的函数	`e.raiseSalary(5)` 类里的方法
字段谁都能改	字段 `private`，只能走方法

用起来：

1
Employee e = new Employee("张三", 50000, 2000, 1, 1);
2
e.raiseSalary(5);                    // 加薪 5%
3
System.out.println(e.getSalary());   // 52500.0

使用多个源文件：Java 的硬规矩是一个 .java 文件里最多只能有一个 public 类，而且文件名必须和这个类名一模一样。所以 Employee 存成 Employee.java，测试程序（带 main 的那个）另存 EmployeeTest.java：

Terminal window

1
javac EmployeeTest.java
2
java EmployeeTest

书里强调的一点：编译 EmployeeTest.java 时，javac 发现它用到了 Employee，会自动去同目录找 Employee.java 一起编译，不用手动把两个文件都列上。（它靠比对时间戳判断：Employee.java 比 Employee.class 新就重新编。）

vs C：C 靠「#include "employee.h" 抄声明 + 链接器找实现」两套机制拼装；Java 没有头文件，编译器顺着源码和类路径自己找。
同一个目录（默认包）下的类互相引用不需要 import，直接写类名就行。

剖析Employee类：一个类就三样东西：
- 实例字段（name / salary / hireDay）—— 数据，每个对象各存一份
- 构造器（Employee(...)）—— 造对象时初始化字段
- 方法（raiseSalary 等）—— 行为
字段全 private、方法全 public，这就是 4.1 说的「封装」落到实处。

字段带 static 就是「类字段」（所有对象共享一份，4.4 讲），不带就是「实例字段」（每个对象独一份）。这里三个都是实例字段。
从构造器开始：4.2 前向引用过它，现在正式交代。四条规矩：
- 名字必须和类名一模一样
- 没有返回类型——连 void 都不写
- 只能跟着 new 用，不能写成 e.Employee(...)
- 可以重载（同名、不同参数），new 时按实参挑

两个容易踩的点：

① 不写构造器 ≠ 没有构造器。 一个构造器都没写时，编译器自动送你一个无参构造器；但只要你自己写了任意一个（哪怕是有参的），这个免费的就立刻消失——new Employee() 直接编译报错。这条 4.6.3 会再细说。

② this.name = name; 参数名和字段同名时，右边是参数、左边是字段，靠 this 区分。this 就是「正在构造的这个对象」（4.3.7 展开）：

1
public Employee(String name, double salary, ...) {
2
    this.name = name;      // 左边 this.name 是字段，右边 name 是参数
3
    this.salary = salary;
4
    ...
5
}

参数名起成 aName 这类不重名的，this. 就能省——但 this.x = x 是 Java 惯用写法，认得它。

顺带把「实参填进哪个门」理清。 构造器只在造对象那一刻被调用一次，之后你反复调的是方法——填实参这件事发生两次，进的是两个不同的门：

1
① 造对象：new Employee("张三", 50000, 2000, 1, 1)   ← 实参填给【构造器】
2
                  ↓  对象造好了，存在变量 e 里
3
② 用对象：e.raiseSalary(5)                          ← 实参填给【方法】

术语上，声明里列出的变量叫形参（public Employee(String name, ...) 里的 String name），调用时传进去的值叫实参（"张三"）。

方法返回什么，由返回类型决定。并不一定返回对象，拿上面那四个方法验一遍：

方法	返回类型	实际返回什么	对象变了吗
`getName()`	`String`	一个已有对象的引用（字段里那个）	没变
`getSalary()`	`double`	一个数值，压根不是对象	没变
`getHireDay()`	`LocalDate`	一个已有对象的引用	没变
`raiseSalary(5)`	`void`	什么都不返回	变了（`salary` 被改）

注意 raiseSalary 恰恰是唯一让对象发生变化的那个，而它返回 void。可见「方法改了对象」和「方法返回了新对象」是两条不同的路：

1
e.raiseSalary(5);                  // 更改器：返回 void，改自己
2
LocalDate f = d.plusDays(100);     // 访问器 + 不可变：返回新对象，自己不动

前者是 4.2.3 讲的更改器，后者是访问器+不可变类。两种风格在 Java 里同时存在，别指望统一成一种。

用var声明局部变量：Java 10 之后，局部变量可以不写类型：

1
var e = new Employee("张三", 50000, 2000, 1, 1);
2
//   ↑ 编译器从右边推断出 e 的类型是 Employee

动机就是省掉重复——老写法里类型出现了两次：Employee e = new Employee(...);。四条限制：

只能用在局部变量（方法体里的变量），不能用于字段、方法参数、方法返回类型
必须带初始值，var x; 直接编译错误——没有右边就无从推断
不是动态类型，类型在编译期就定死了，只是你没写出来
右边类型必须明确，var x = null; 也是错的

1
var e = new Employee(...);
2
e = "字符串";     // ❌ 编译错误，e 已经是 Employee 了

1
var n = 3;                            // int
2
var s = "hello";                      // String
3
var list = new ArrayList<String>();   // ArrayList<String>

vs C++11 的 auto：同一个思路，都是编译期推断。差别是 C++ 的 auto 用得更野（函数返回类型、结构化绑定、lambda 参数都能用），Java 的 var 只管局部变量，保守得多；反过来 C++ 的 auto 会丢掉顶层 const 和引用，是个老坑，Java 这边没有对应问题（对象本来就都是引用语义）。

实用建议：类型一目了然时才用 var。var e = new Employee(...) 挺好；var x = compute(); 就不好了——读者根本不知道 x 是什么，不如老实写 Employee x = compute();。

使用null引用：4.2.1 讲过「变量可能不指向任何对象」，这里讲怎么应对：

1
String n = null;
2
n.length();     // 运行时抛 NullPointerException

三种做法：

1
// ① 显式判空：能用，但只保护了这一处
2
if (n != null) {
3
    System.out.println(n.length());
4
}
5

6
// ② 入口处立即失败
7
public Employee(String name, ...) {
8
    this.name = Objects.requireNonNull(name, "name 不能为 null");
9
}
10

11
// ③ 给个兜底值（Java 9+）
12
Objects.requireNonNullElse(n, "无名")

Objects 是 java.util.Objects，一个纯工具类，方法全是静态的。

②这种做法叫 fail fast：与其让这个 null 飘到很远的地方才炸、报错现场和出事现场隔了十万八千里，不如在入口就拦下来，让报错直接指向真正的源头。书里推荐的就是这种。

vs C：

1
char *p = NULL;
2
strlen(p);     /* 段错误，或者更糟——未定义行为，静默破坏别处内存 */

同样是空指针解引用，C 不给你任何交代：运气好当场崩，运气不好带病跑完、在别的地方炸。Java 必定抛 NullPointerException，还带完整堆栈，直接告诉你哪一行。

null 是 Java 被诟病最多的一处设计（Tony Hoare 自己称之为「十亿美元错误」）。现代 Java 在补这个漏：Optional（卷二讲）、Objects 这套工具、以及「不要返回 null 数组/集合，返回空集合」的约定。现阶段记住两条就够——别随便返回 null、参数该查就查。

隐式参数与显式参数：看这一句：

1
e.raiseSalary(5);
2
// │            └─ 显式参数：括号里的 5
3
// └─ 隐式参数：点号前面的 e，也就是方法体里的 this

显式参数（explicit parameter） 就是括号里列出来的那个 5，也就是方法声明里写明的参数；隐式参数（implicit parameter） 是点号前面的 e——方法所属的那个对象，在方法体里它就是 this。所以在 raiseSalary 的方法体里：

1
public void raiseSalary(double byPercent) {
2
    double raise = salary * byPercent / 100;
3
    salary += raise;
4
    // 这两个 salary 其实都是 this.salary 的简写
5
}

这里要分两种情况说清楚，否则很容易以为 this 是多余的一遍：

① 没有同名变量时，salary 和 this.salary 完全等价，写不写随你。上面 raiseSalary 里参数叫 byPercent、不叫 salary，所以裸写的 salary 就是字段。

② 一旦出现同名的参数或局部变量，情况就反过来了——它们会遮蔽（shadow） 字段，裸写的那个名字优先指离得近的那个：

1
public class Employee {
2
    private String name;          // ← 实例字段：写在类的头上，每个对象一份
3
    private double salary;
4

5
    public Employee(String name, double salary) {   // ← name / salary 是参数
6
        System.out.println(name);        // 打印的是【参数】
7
        System.out.println(this.name);   // 打印的是【实例字段】（此刻还是 null）
8

9
        name = name;                     // ❌ 参数赋给自己，实例字段纹丝不动
10
        this.name = name;                // ✅ 右边是参数，左边 this.name 才是实例字段
11
        this.salary = salary;            // 同理，带 this. 的那个才是字段
12
    }
13
}

关键在于头两行 private String name; 和下面参数表里的 String name 是两个不同的东西——它们只是名字撞了。这就是遮蔽会发生的前提。

所以 this 不是”把字段名多写一遍”，而是字段被同名变量挡住时，唯一能指到它的路径。这也正是 this.name = name; 左边必须带 this 的原因——不带的话，左边那个 name 同样指参数，整句等于什么都没干。

注意区分「类变量」。private String name; 这种没有 static 的，叫实例字段（instance field）——每个对象各有一份。Java 里的「类变量」是专有词，只指带 static 的字段：它属于类本身，所有对象共享一份。区分方法只有一条——看有没有 static，跟”写没写在类里面”完全无关。类变量 4.4 讲。

vs C 才是关键——同样的逻辑，C 里两个参数都写在括号里：

1
raise_salary(&e, 5);     /* struct Employee *e 和 double pct 都是显式参数 */

1
e.raiseSalary(5);        /* e 被挪到了点号前面，变成隐式参数 */

Java 做的事就是：把第一个参数从括号里提到了点号左边，让它「隐」起来。反过来说，e.raiseSalary(5) 用 C 的写法展开就是 raiseSalary(e, 5)，只是 e 被放到了前面。

这就是「面向对象」在调用语法上的体现：数据（e）和方法（raiseSalary）绑在一起，不必每次手动把对象当第一个参数传进去。书里专门用这两个术语，是为了让你看清「对象方法其实多带了一个隐藏参数」。

this 还有个用法是 this(...)——在构造器第一行调用本类另一个构造器，4.6.6 讲。

封装的优点：字段私有 + 给方法访问，换来四样好处。
- 内部实现想怎么改就怎么改：把 name 拆成 firstName / lastName，只要 getName() 还返回拼好的全名，外面几十处调用一行都不用动。换成 C 那种公有 struct 成员，字段一改，所有使用方全得改。
- setter 里能加校验：公有字段拦不住 e.salary = -99999;但方法可以。
- 只给 getter、不给 setter，就是只读字段
- 可以惰性计算：getter 里现算，不用提前存

1
public void raiseSalary(double byPercent) {
2
    if (byPercent < 0) throw new IllegalArgumentException("加薪比例不能为负");
3
    ...
4
}

但这里有个必须知道的坑：访问器不要返回可变对象。

1
class Employee {
2
    private Date hireDay;
3

4
    public Date getHireDay() {
5
        return hireDay;        // ❌ 把内部状态的控制权交出去了
6
    }
7
}

1
Employee e = ...;
2
Date d = e.getHireDay();
3
d.setTime(0);          // 直接从外面改掉了 e 的内部状态，e 一点没察觉

getHireDay 返回的是引用（引用共享，4.2.1 讲过），对方拿到就能改你的内部数据。两种修法：

1
// 修法一：字段直接用不可变类型
2
private LocalDate hireDay;
3
public LocalDate getHireDay() { return hireDay; }   // LocalDate 改不了，安全
4

5
// 修法二：返回一份副本
6
public Date getHireDay() {
7
    return (Date) hireDay.clone();     // 每次给的是拷贝，随便改
8
}

这就是 4.2.3 讲「不可变」的实战回报——不可变对象可以放心交出去。

基于类的访问权限：Java 的 private 是类级别，不是对象级别——同一个类里的代码，可以访问该类任何对象的私有成员：

1
public class Employee {
2
    private String name;
3

4
    public boolean hasSameName(Employee other) {
5
        return name.equals(other.name);    // 直接摸 other 的私有字段，合法
6
    }
7
}

other 到底是哪个对象？取决于调用时传进去的是谁：

1
Employee a = new Employee("张三");
2
Employee b = new Employee("张三");
3
Employee c = new Employee("李四");
4

5
a.hasSameName(b);   // this = a，other = b  → true
6
a.hasSameName(c);   // this = a，other = c  → false

这正好是 4.3.7 的那对术语：this 是隐式参数（点号左边那个），other 是显式参数（括号里那个）。两者都是参数，只是填进去的时机不同。

所以「类级权限」的意思是：同一个类的代码，能摸到任何一个 Employee 对象（不只是 this）的私有字段；换成别的类，即便拿到同一个对象，也不许碰。

vs C：C 没有「类」这层封装单位，最接近的是 static——文件作用域，同一个 .c 文件里的函数能访问文件里的 static 变量。所以 C 的封装单位是「文件」，Java 的封装单位是「类」。C++ 除了 class 级别还有 friend，Java 没有 friend：需要跨类互访时，要么把类放进同一个包（4.8 讲包访问），要么干脆合成一个类。

私有方法：只给类内部用的辅助方法设成 private：

1
public class Employee {
2
    private double salary;
3

4
    public void raiseSalary(double byPercent) {
5
        salary += computeRaise(byPercent);
6
    }
7

8
    private double computeRaise(double byPercent) {   // 外部调不到
9
        return salary * byPercent / 100;
10
    }
11
}

好处很实在：既然外面调不到，你就可以放心删它、改它、改它的参数列表，不用担心动了谁的代码。这也是把大方法拆成小步骤的常用手段——拆出来的步骤是实现细节，不该进入公开接口。

对照 C：C 里做同样的事就是把函数声明成 static（文件内可见，链接器看不到）。思路一样，只是可见范围从「文件」变成了「类」。

final实例字段：

1
class Employee {
2
    private final String name;      // 构造之后就不能再改
3
    private final int id;
4

5
    public Employee(String name, int id) {
6
        this.name = name;           // 必须在构造器里赋值
7
        this.id = id;
8
    }
9
}

三条要点：

① 必须在声明处或每个构造器里赋值，一次且仅一次，之后再赋值就是编译错误。所以这种字段必须有构造器来喂——正好呼应 4.3.4 说的「你写了构造器，默认那个就没了」。

② 每个对象可以有不同的 final 值。final 不是「全局唯一」，只是「这个对象一旦定下就不变」：

1
private final int id;                    // 每个 Employee 各有各的 id，各自定死
2
public static final double PI = 3.14159; // static + final 才是全局唯一的常量

前者跟着对象走，后者跟着类走（就是类变量 + 不可变）。

③ final 锁的是引用，不是对象内容。

1
private final StringBuilder sb = new StringBuilder();
2

3
sb.append("x");                 // ✅ 合法：改的是对象内容，不是引用
4
sb = new StringBuilder();       // ❌ 编译错误：不能让它改指向别的对象

字段是引用类型时，final 只保证「永远指向同一个对象」，不保证那个对象本身不变。

vs C 的 const：C 的 const 能靠强制类型转换、或者 memcpy 之类绕过；Java 的 final 字段是真的改不了（除非上反射，那属于非常规手段）。

4.4 静态字段与静态方法#

static 表示成员属于类，而不是某个对象。下面是静态方法：

1
class Employee {
2
    private static int nextId = 1;
3
    private int id;
4

5
    Employee() { id = nextId++; }
6
}

所有对象共享一份 nextId，但每个对象拥有自己的 id。静态字段可以通过类名访问，虽然也能通过对象访问，但后者容易误导读者。public / private 控制访问范围，static 控制归属，final 控制能否再次赋值；public static final 常用于定义常量。

final 字段必须在声明处或每个构造器中初始化。对于引用类型，final 只保证引用不能换指向，不能保证对象内容不变；真正的不可变性还需要对象本身不提供修改状态的操作。

静态方法没有 this，不能直接访问实例字段或调用实例方法。方法不依赖对象状态时，可以设计为静态方法：

1
Math.sqrt(x);
2
LocalDate.of(2007, 12, 3);

静态工厂方法还可以用不同名称表达不同创建意图，并隐藏具体实现。Java 程序通常从以下入口开始：

1
public static void main(String[] args)

它必须是静态方法，因为启动时还没有现成对象；每个类都可以有自己的 main 用于小测试。

4.5 方法参数#

Java 永远按值传递：实参的值会被复制一份交给形参。区别只在「这个值是什么」——基本类型的值就是那个数，对象的值是引用。由此得到两类结果：

基本类型：形参拿到的是数值副本，怎么改都影响不到外部变量。
对象：形参拿到的是引用副本，和实参指向同一个对象。所以改对象的内容，外部看得见：

1
static void tripleSalary(Employee x) {
2
    x.raiseSalary(200);
3
}

但改形参自己的指向，动的只是副本，外部不受影响：

1
static void swap(Employee a, Employee b) {
2
    Employee temp = a;
3
    a = b;
4
    b = temp;
5
}

所以准确说法不是“对象按引用传递”，而是“对象引用按值传递”。这与 C 的指针参数规则完全一致：指针按值传递，可以通过它改指向的对象；要改调用方的指针本身，C 也得升到二级指针。

4.6 对象构造#

对象初始化顺序固定：字段先得到默认值（数字为 0、boolean 为 false、引用为 null），再按声明顺序执行字段初始化和初始化块，最后执行构造器体。局部变量没有默认值，未初始化就使用会编译失败。

重载：同一个名字、不同的参数列表——个数、类型、顺序任一不同即可，编译器按实参挑最合适的那个：

1
Math.abs(-3);      // 匹配 Math.abs(int)
2
Math.abs(-3.5);    // 匹配 Math.abs(double)

决定「是不是同一个方法」的是签名 = 方法名 + 参数列表，返回类型不在签名里。所以 void f() 和 int f() 不算重载，而是编译错误；实参挑不出唯一匹配时也会报错。构造器同样可以重载。

C 没有这个机制，只能为类似功能起不同名字：abs / labs / fabs。

类完全没有声明构造器时，才会自动获得一个无参构造器。字段可以直接初始化：

1
private String name = "";
2
private LocalDate hireDay = LocalDate.now();

构造器可以用 this(...) 委托给同类的另一个构造器——括号里的实参决定调哪一个，跟重载挑方法同一套规则。它必须位于第一行，以集中公共初始化逻辑：

1
public Employee(double salary) {
2
    this("Employee", salary);   // 实参是 (String, double)，就匹配接收这两个参数的构造器
3
}

一个构造器里只能有一个 this(...)，也不能互相绕圈（A → B → A 是编译错误），所以委托链永远是一条不循环的直线，最终停在一个不调用 this(...) 的构造器上——真正完成字段初始化的就是它。

初始化块是类体里直接写的一对 { }，不属于任何方法：

1
class Employee {
2
    private static int nextId;
3
    private int id;
4

5
    { id = nextId++; }        // 实例初始化块：每 new 一个对象执行一次
6
    static { nextId = 1; }    // 静态初始化块：类第一次初始化时执行一次
7
}

实例块和字段初始化一起，在构造器体之前、按声明顺序执行（意思就是构造器不管写在哪都最后执行），可以访问实例字段。静态块和静态字段只跑一次，用来初始化静态字段——它在类加载时执行一次，此后任何static控制的字段或块都不再执行。

两者实际都很少用：能用字段初始化直接表达的，就写在字段处。

Java 没有 C 式析构函数。对象不再被引用后由 GC 回收内存，但不能依赖回收时机清理资源；finalize 已废弃。文件句柄、数据库连接等外部资源仍须显式关闭，通常使用 close() 或 try-with-resources。

4.7 记录#

record 是 Java 16+ 的类型声明关键字——和 class 同一层（不是 private 那种修饰符），站的就是 class 的位置，专门用来定义「一组字段 + 原样读出」的不可变类型。一行就够：

1
record Point(int x, int y) { }

相当于：

1
class Point {
2
    // ① 自动生成 private final 字段（不可修改！final）
3
    private final int x;
4
    private final int y;
5

6
    // ② 全参构造器，接收所有参数
7
    public Point(int x, int y) {
8
        this.x = x;
9
        this.y = y;
10
    }
11

12
    // ③ 访问器方法：名字就是字段名，没有get，没有setter！
13
    public int x() {
14
        return x;
15
    }
16
    public int y() {
17
        return y;
18
    }
19

20
    // ④ 自动重写 equals()、hashCode()、toString()
21
    @Override
22
    public boolean equals(Object o) { ... }
23
    @Override
24
    public int hashCode() { ... }
25
    @Override
26
    public String toString() { ... }
27
}

展开收起

编译器据此生成：私有的 final 字段、一个接收全部字段的构造器、同名访问器 x() / y()（不带 get 前缀），以及 equals / hashCode / toString（Ch5 讲）。

1
Point p = new Point(3, 4);
2
p.x();     // 3

构造器有三种形态：

标准构造器：编译器自动生成，逐个字段赋值。
自定义构造器：自己写，但每个字段仍必须被赋值一次。
简洁构造器：连参数列表都不写，只写构造体，用来做校验或修正——赋值由编译器补上：

1
record Range(int lo, int hi) {
2
    Range {                                    // 简洁构造器
3
        if (lo > hi) throw new IllegalArgumentException();
4
    }
5
}

vs C：struct 只是数据容器，比较、打印、复制全得自己写；record 自带这一整套，而且不可变。

4.8 包#

包是命名空间，用来避免类名冲突。它在磁盘上就是一个目录：一个包可以装很多类，一个类只能属于一个包；不写 package 语句的类属于默认包（前面那些 Employee.java / EmployeeTest.java 就是）。

包名的惯例是用自己拥有的域名倒过来写——域名是全球唯一的，倒写出来就是一个全球唯一的前缀，跟别人撞不了名（站点 hecloud.top → 包名前缀 top.hecloud）。包名还要与目录一一对应：

1
com.example.myapp   ←→   com/example/myapp/

源文件开头写 package com.example.myapp;文件就必须放在对应目录下。同一个包里的类互相引用不需要 import。

import 不是 C 的 #include——它不复制任何代码，只是让你少写全名：import java.util.ArrayList; 之后写 ArrayList，等价于写全名 java.util.ArrayList。

有两处不用 import：同一个包里的类，以及 java.lang——编译器默认替你执行了 import java.lang.*;，所以 String、System、Math、Integer 这些从来不用导入。注意它是通配符形式，按下面那条规则不覆盖 java.lang.reflect 这样的子包。

通配符 import java.util.*; 只覆盖这一个包，不递归子包——父包和子包本来就是互不包含的两个包，只是名字看起来有层级。
两个包有同名类时通配符失效，必须写全限定名（如java.lang.System.out.println()）。
静态导入 import static java.lang.Math.*; 让你直接写 sqrt(x) 和 PI，省掉类名前缀——它只导入静态成员。

包访问：修饰符什么都不写时（既非 public 也非 private），成员只对同一个包里的类可见，包外看不见。

类路径（classpath）：告诉 javac / java 去哪里找 .class 文件，默认是当前目录，可以用 -cp 指定：

Terminal window

1
javac -cp build/classes MyApp.java
2
java  -cp build/classes MyApp

可以有多个路径，用 : 分隔（Windows 上用 ;）。

vs C：C 没有命名空间，全局符号一律裸奔，只能靠命名约定防撞名；Java 用包做命名空间，用 import 声明依赖。

4.9 JAR 文件#

JAR 本质是一个 zip 包，把一棵目录树打成一个文件。打包默认递归，子目录一并装进去；目录结构必须原样保留——类是按「包名 → 路径」找的，路径乱了就找不到了。

Terminal window

1
jar cf app.jar com/example/     # c = create，f = file；装的是 com/example/ 整棵子树

因此 classpath 上 jar 和目录是等价的：-cp app.jar 和 -cp build/classes 对 javac / java 来说是一回事。jar 里也不只装 .class，资源文件（配置、图片）同样可以放进去——它就是个通用容器。

包内的 META-INF/ 是存放元数据的约定目录，其中的 MANIFEST.MF 就是清单文件——JAR 里唯一必需的文件，内容是一行行 键: 值。在清单里写上入口类，这个 jar 就能直接运行：

1
Main-Class: com.example.MyApp

Terminal window

1
java -jar app.jar

多版本 JAR：META-INF/versions/N/ 下放的是另一套 class 文件（照抄包结构），N 是 JDK 主版本号。老 JDK 用根目录里的类，新 JDK 优先用自己版本目录里的类——一个 jar 同时兼容多代 JDK。前提是清单里写了 Multi-Release: true，否则 JVM 会忽略 versions/。

vs C：JAR 类似把多个 .o 打包成 .a / .so 再发布；但 JAR 跨平台、自带元数据，还能直接运行。

4.10 文档注释#

/** ... */ 是文档注释。它与普通注释的区别是可以被 javadoc 工具提取，生成 HTML 格式的 API 文档——JDK 官方那些在线文档就是这么来的。

1
/**
2
 * 给雇员加薪。
3
 * @param byPercent 加薪百分比
4
 * @return 加薪后的薪水
5
 */
6
public double raiseSalary(double byPercent) { ... }

常用标签：@param、@return、@throws 分别描述参数、返回值和异常；类上还可以用 @author、@since、@see。字段也能写文档注释，包级文档则写在 package-info.java 里。

Terminal window

1
javadoc com/example/myapp

vs C：C 的注释只给人看；Java 的文档注释是可提取的文档，能一键生成在线 API 手册。

4.11 类设计技巧#

这一节的清单可以直接当自查表用：

字段一律私有，需要访问就提供方法。
每个字段都要初始化，别把默认值当成「正常状态」。
方法不访问对象状态，就把它做成静态的。
几个基本类型字段总是一起出现（street / city / zip），把它们包成一个类。
不是所有字段都要配访问器和更改器，只暴露真正需要的。
职责过多的类要拆开，这是最常见的坏味道。
类名用名词、方法名用动词，名字要能体现职责。
优先使用不可变类——LocalDate 的取舍就是这个道理。

两句话贯穿全章：数据私有、边界收窄。对照 C 的 struct 就明白代价在哪——成员全部公开，任何一处改动都波及所有使用方。

公告与固定页面文案维护

Mon, 07 Sep 2026 00:00:00 GMT

📖 本文管什么#

站点上除了「文章 / 碎碎念」这两种会持续新增的内容，还有一批固定的站点文案——侧边栏公告、关于页、留言板、隐私政策等。它们不常改，但真要改的时候得知道去哪。

一、侧边栏公告#

改公告文字 → `src/config/announcementConfig.ts`#

1
export const announcementConfig = {
2
    title: "",          // 公告栏标题，留空显示默认「公告」
3
    content: "……公告正文……",  // ← 要改的就是这
4
    closable: false,    // true = 访客可点 × 关闭
5
    link: {
6
        enable: true,   // 底部是否放链接
7
        text: "了解更多",
8
        url: "/about/",
9
        external: false, // true = 新窗口外链
10
    },
11
};

可用可选字段：type: "info" | "warning" | "success" | "error"（左侧装饰色），icon（图标名）。

⚠️ 公告是纯文本#

content 里写 Markdown 不会渲染，**加粗**、[链接]() 会原样显示符号。想要链接就走下面那个 link 字段。

显示 / 隐藏公告 → 不在公告配置里！#

公告是「侧边栏组件」，开关注册在 src/config/sidebarConfig.ts。桌面端在 leftComponents、移动端在 mobileBottomComponents 里都有一组 type: "announcement"：

1
{
2
    type: "announcement",
3
    enable: true,      // ← 改成 false 就隐藏
4
    position: "top",
5
    showOnPostPage: true,
6
},

想调公告在侧栏的上/下顺序，也在这里挪位置。

二、固定页面（spec）文案#

「关于我 / 留言板 / 隐私政策 / 用户协议 / 友链信息」这类页面的正文，存在 src/content/spec/ 里，像改普通 Markdown 一样改它们：

页面	文件
关于	`src/content/spec/about.md`
留言板	`src/content/spec/guestbook.md`
隐私政策	`src/content/spec/privacy-policy.md`
用户协议	`src/content/spec/user-agreement.md`
友链页的「本站信息」	`src/content/spec/friends.mdx`

改完的发布#

这几篇是页面正文，改完同样走 git 三连即上线，没有独立的「后台」。

⚠️ 内容同步提醒#

隐私政策 / 用户协议要和站点实际能力保持一致（接入了哪些分析、评论数据存哪）。每次给站点新增会收集数据的服务（统计、弹幕、评论等）后，回来核对一遍这两篇是否还成立。
关于页里通常写着「本站架构说明」，改了架构（换图床、增减部署）要同步更新。

三、站内入口文案（顶部菜单 / 页脚）#

这类不是「正文」，但也属于站点文案，出问题要知道去哪个配置：

想改什么	文件
顶部导航菜单项	`src/config/navBarConfig.ts`
页脚自定义内容（如备案号）	`src/config/footerConfig.ts`
侧栏简介 / 头像 / 社交链接	`src/config/profileConfig.ts`

细讲见系列里「友链与站点入口维护」一篇。

✅ 速记#

公告文字 → announcementConfig.ts；公告显隐/位置 → sidebarConfig.ts
固定页面正文 → src/content/spec/ 对应文件，改完 git 三连
公告是纯文本；隐私/协议文案要跟着站点新功能走
页面文案和正文一样：改文件 → git add/commit/push → 上线

碎碎念（动态）维护指南

Mon, 07 Sep 2026 00:00:00 GMT

📖 什么是碎碎念#

和文章相对的轻量内容：几句话、随手拍、临时想法。它和文章共用一套发布流程（写文件 → git push），只是文件放不同目录、frontmatter 更简单。

	文章（posts）	碎碎念（dynamic）
目录	`src/content/posts/`	`src/content/dynamic/`
形态	长篇、可分类打标签	短句、随手记
frontmatter	十几个字段	就 3 个字段
是否进系列	可	不进系列

一、文件放在哪、怎么命名#

1
src/content/dynamic/2026-09-07-123000.md

目录固定：src/content/dynamic/
文件名 = 发布时间 YYYY-MM-DD-HHMMSS.md（命名规则即排序规则，别乱起名）
每一条碎碎念 = 一个文件

仓库里留了一条参考文件，忘了怎么写就打开看：src/content/dynamic/ 下最早那条。

二、frontmatter（只有 3 个字段）#

1
---
2
published: 2026-09-07 12:30:00    # 必填，发布时间
3
pinned: true                        # 可选，true 则置顶
4
location: 中国                      # 可选，显示地点
5
---
6

7
正文内容随便写……支持普通 Markdown。

字段	必填	作用
`published`	✅	时间。格式 `YYYY-MM-DD HH:MM:SS`
`pinned`	❌	置顶到列表顶部
`location`	❌	在卡片上显示的地点文字

三、发布：脚手架一行命令（最快）#

Terminal window

1
pnpm new-dynamic 今天的第一条碎碎念！

它自动做三件事：

用当前时间生成合法文件名
写进 src/content/dynamic/
自动填好 published 字段

一句话就一条，不需要手动想文件名和日期。

想加地点/置顶时#

脚手架只填 published，要 location/pinned 就手动补两行，或用下面的方式 B：

Terminal window

1
pnpm new-dynamic 带地点的碎碎念
2
# 然后打开生成的文件，在 --- 之间补上
3
# location: 中国

四、图片怎么放#

用标准 Markdown，多张图片会自动拼成图集：

1
正文……
2

3
![第一张](https://cdn.xxx.top/dynamic/2026-09-07-a.webp)
4
![第二张](https://cdn.xxx.top/dynamic/2026-09-07-b.webp)

图片本体先传图床（见 R2 图床运营规范），再贴链接
图片放正文任意位置即可，位置决定显示顺序

五、修改与删除#

改：直接编辑那个 .md 文件（改正文、补 location…）→ git 三步 → 覆盖更新
置顶/取消置顶：加/删 pinned: true
删除：删文件 → git 三步 → 线上消失。删除不可恢复，删前确认

发布/修改/删除都是那三连：

Terminal window

1
git add .
2
git commit -m "新增一条碎碎念"   # 或 修改 / 删除
3
git push

✅ 碎碎念速记#

随手短记录 → src/content/dynamic/
最快发布：pnpm new-dynamic 内容
frontmatter 就 published（+ 可选 pinned/location）
图片：传图床 → ![](链接)，多张自动成图集
上线方式与文章完全一样：git 三连

相册与照片墙维护指南

Mon, 07 Sep 2026 00:00:00 GMT

📖 相册的组成（记牢这个模型）#

每个相册 = 两处配置 + 一处照片来源，任何相册的增删改都逃不出这个框架：

1
① galleryConfig.ts 里加一个「相册对象」  ← 定义名字/密码/封面
2
        ↕ 靠 id 对应
3
② public/gallery/<相册id>/ 目录          ← 照片来源所在
4
        │
5
        ├─ 直接放目录里的图片文件
6
        └─ urls.txt（每行一个远程图片链接）★ 本站主力

本站照片都放对象存储，所以 public/gallery/<id>/ 目录里通常只有一个 urls.txt，图片本体不在仓库里。

一、相册对象的字段（配置在 `src/config/galleryConfig.ts`）#

1
{
2
    id: "trip-2026",            // 唯一标识 = 目录名 = 网址路径，三者必须一致
3
    name: "2026 旅行",          // 相册显示名（必填）
4
    description: "走过的地方",   // 描述
5
    date: "2026-09-07",        // 日期 YYYY-MM-DD
6
    location: "云南",           // 拍摄地
7
    tags: ["旅行", "风景"],      // 标签数组
8
    cover: "https://…",        // 手动指定封面（可选，规则见下）
9
    password: "你的密码",        // 填了就加密（存的是明文字符串，见下方安全提醒）
10
    passwordHint: "给访客的提示",// 密码提示（可选）
11
}

封面三选一规则#

你怎么写	封面是谁
不填 `cover`，目录里有 `cover.*` 图片文件	自动用 `cover.*`
不填 `cover`，也没 `cover.*`	自动用目录里第一张照片
填了 `cover: "https://…"`	用你指定的这张

⚠️ 加密相册的安全提醒#

password 字段的密码会明文写在 galleryConfig.ts 里，而 src/ 源码会打进线上包。加密相册适合「防路人、防误点」级别，别拿来存真正机密。文档示例一律写占位符，别在文章里贴真实相册密码。

二、新增一个相册（两步）#

① 建目录 + 放照片清单

1
public/gallery/trip-2026/urls.txt

urls.txt 每行一个图片链接，# 开头是注释：

1
# 2026 云南旅行
2
https://cdn.xxx.top/gallery/yunnan-1.webp
3
https://cdn.xxx.top/gallery/yunnan-2.webp

（也可以直接把图片文件丢进目录，系统会全部自动扫描收录，jpg/png/webp/avif/gif 都认。）

② 在 galleryConfig.ts 的 albums 数组里加相册对象（见上），保存 → git 三连 → 上线。

三、照片墙 / 相册页怎么显示（两个机制）#

站点有两处用到相册：

主页照片墙 —— 只显示 homeAlbumId 指定的那个相册的前 6 张：

1
homeAlbumId: "photo-wall",   // 想换主页照片墙的内容，就改这里指向别的相册 id

相册页 /gallery/ —— 列出 albums 数组里的全部相册（加密的点击要输密码），点进 /gallery/<相册id>/ 看全部照片。

想让一个相册既出现在相册页、又出现在主页照片墙：把它 id 填给 homeAlbumId 即可。主页照片墙是「绑定某个相册的前 6 张」，不是自动挑最新的——这是刻意的设计，避免加密相册被无密码展示。

四、日常维护操作速查#

想干什么	操作
往现有相册加照片	图片传图床 → `urls.txt` 加一行 → 想放最前面就插到首行
换相册封面	填 `cover: "https://…"`，或目录里放 `cover.*`
改相册名/描述	改 `galleryConfig.ts` 里对应对象
加密/解除加密	加/删 `password` 字段
主页换一批照片	改 `homeAlbumId` 指向别的相册
删除相册	两处一起删：`albums` 数组去掉对象 + 删掉 `public/gallery/<id>/` 目录

⚠️ 三个坑#

id 与目录名必须一字不差，否则照片扫出来是空的
主页照片墙只认 homeAlbumId，其它相册的照片不会出现在主页
删相册要同时删目录，否则删了配置、图片还被构建进站点

✅ 速记#

一个相册 = galleryConfig.ts 对象 + public/gallery/<id>/ 目录
加照片 → 传图床 → 往 urls.txt 加一行链接
封面不填则取 cover.* 或第一张；主页照片墙是绑 homeAlbumId 前 6 张
照片本体永远走对象存储，别往仓库塞大图

友链·导航书签·站点入口维护

Mon, 07 Sep 2026 00:00:00 GMT

📖 本文管什么#

把站点里所有「链接集合」和「身份入口」收在一起讲——友链、导航书签、顶部菜单、简介与社交链接。它们都是配置文件里的一组数组，维护方式高度相似：改数组 → git 三连。

一、友链（`src/config/friendsConfig.ts`）#

友链是一个对象数组，每项大概长这样：

1
{
2
    name: "示例站点",                    // 站点名
3
    url: "https://example.com",
4
    avatar: "https://cdn.xxx.top/page/01-example.webp",  // 头像
5
    description: "一句话介绍",
6
}

加 / 改 / 删友链#

操作	做法
加	数组末尾加一个对象
改	改对应对象字段
删	去掉对应对象
排序	一般按数组顺序，想置顶就挪到前面

⚠️ 头像一定要本地化（重要）#

不要把外链头像直接填进去。别人的头像热链到你的页面，一是依赖对方服务器、随时裂图，二是每次访问都打对方站、不礼貌也慢。

正确姿势：

把对方头像下载 → 转成 webp
传图床上传到 page/ 目录
把 avatar 填成你图床的本地链接（命名规范见 R2 图床运营规范）

已上传的本地头像也叫不回来了——所以对没配头像的友链、或头像失效的，都用「下载 → 转 webp → 传 page/」流程修。

本站自己在别人站里的信息#

友链是双向的：别人挂你，你也得在自己页面放「本站信息」给别人抄——在 src/content/spec/friends.mdx 里维护 site 对象（站点名、网址、头像、邮箱、一句话介绍）。

二、导航书签页（`src/config/booknavConfig.ts`）#

/booknav/ 页面是个收藏夹，两级结构：分组 → 组内书签。

1
export const booknavConfig = [
2
    {
3
        id: "dev",            // 分组锚点 id
4
        name: "开发",          // 分组名
5
        items: [              // 组内的书签
6
            { title: "GitHub", url: "https://github.com" },
7
            { title: "某文档", url: "https://example.com",
8
              icon: "fa7-brands:github",   // 可选，留空自动取目标 favicon
9
              desc: "说明", weight: 1, enabled: true },
10
        ],
11
    },
12
];

书签 icon 留空会自动抓目标站 favicon
weight 越大排越前（默认 0）；enabled: false 可暂时隐藏一条
增删书签 = 增删 items 里的对象

三、顶部导航菜单（`src/config/navBarConfig.ts`）#

页面顶部菜单项也在这里：

1
export const navBarConfig = {
2
    links: [
3
        { name: "全览", url: "/posts/", icon: "…" },
4
        { name: "外部链接", url: "https://example.com", external: true },  // 外部
5
        { name: "带子菜单", url: "#", children: [ /* 子菜单项 */ ] },
6
    ],
7
};

菜单项 = links 数组里的对象；children 支持二级子菜单
external: true 的项会在新窗口打开
首页那几个「板块入口」若有独立配置在页面文件里，改动入口时会单独说明，不在这个文件

四、简介与社交链接（`src/config/profileConfig.ts`）#

侧栏的「个人资料卡」内容在这：

1
export const profileConfig = {
2
    avatar: "/assets/xxx.webp",   // 头像（本地放 public/assets/ 或图床链接）
3
    name: "站点主人",
4
    bio: "主页一句话简介",
5
    sidebarBio: "侧栏简介，留空则复用 bio",   // 想主页和侧栏文案不同就填它
6
    links: [
7
        { name: "GitHub", url: "https://github.com/…", icon: "fa7-brands:github" },
8
        { name: "Email",  url: "mailto:…",            icon: "…" },
9
    ],
10
};

sidebarBio：主页 bio 和侧栏简介想显示不同文字时用（留空回退到 bio）
links：侧栏资料卡的图标链接。注意主页首屏的社交图标可能是另一处（主页背景配置里的 homeText 链接）——两处入口位置不同，都认 name/url 结构

改邮箱 / 社交号等个人资料后，记得 profileConfig.links、主页 hero 社交图标、以及 friends.mdx 里的本站信息是三处独立的，别只改一处。

五、页脚与音乐歌单#

想改什么	文件	说明
页脚底部自定义（备案号等）	`src/config/footerConfig.ts`	`customHtml` 直接写 HTML
换网易云歌单	`src/config/musicConfig.ts`	改歌单 id 即可（播放走第三方接口，主题负责拉取渲染）

换歌单：在网易云把歌单设成公开 → 复制歌单 id → 填进 musicConfig 对应字段 → 本地预览确认能加载 → git 三连。

✅ 速记#

友链、导航书签、顶部菜单、社交链接 = 四个配置文件里的数组，增删都是「加/减一个对象」
友链头像必须本地化：下载 → 转 webp → 传图床 page/
个人资料有多处副本（侧栏 profile / 主页 hero / friends.mdx），改一处记得核对其它
全部改完统一 git 三连上线

内容发布全流程（写文章 + 推送上线）

Mon, 07 Sep 2026 00:00:00 GMT

📖 一句话理解本站内容#

本站是静态站：文字（Markdown）存在 Git 仓库里，图片存在对象存储里，两者分开。你只要做一件事——改好文字 → git push，剩下的构建、上线全部自动完成。

1
你在 Obsidian / 编辑器里写 .md
2
        │
3
   图片先传图床 → 得到 https://cdn.xxx.top/xxx.webp
4
        │
5
   正文里用 ![](图片链接) 引用
6
        │
7
   git add → commit → push（GitHub）
8
        │
9
   云端自动构建 → 站点更新

仓库的位置、图床的上传工具、每次构建后去哪个平台确认，见本系列「R2 图床运营规范」。本文只讲「内容怎么发布」。

一、内容文件都放在哪#

1
src/content/
2
├── posts/      ← 博客文章（长篇，本文的主角）
3
│   ├── xxx.md
4
│   └── 子目录/  ← 也可以建子目录归类，不影响发布
5
├── dynamic/    ← 碎碎念（短记录，单独一篇讲）
6
└── spec/       ← 固定页面（关于/留言板/协议）

判断标准：想认真写的长篇 → posts；随手一句话/一张图 → dynamic；站点固定文案 → spec。

二、新建一篇文章#

方式 A：脚手架命令（推荐）#

Terminal window

1
pnpm new-post my-first-post

会在 src/content/posts/my-first-post.md 生成带完整 frontmatter 模板的文件，你只需填内容。

方式 B：手动新建#

在 src/content/posts/ 里新建 .md 文件，最少只需 3 个字段：

1
---
2
title: 我的第一篇文章      # 网页显示的大标题
3
published: 2026-09-07      # 发布日期，决定出现在哪一天
4
category: 闲谈杂录           # 分类（留空也可以）
5
---
6
正文……支持完整 Markdown。

常用可选字段#

字段	作用	什么时候用
`description`	摘要，显示在列表卡片上	想让首页简介好看点就填
`tags`	标签数组 `[A, B]`	按主题聚合同类文章
`image`	封面图	网络链接或相对路径
`pinned`	`true` = 置顶到列表顶部	公告类、长期有效文章
`draft`	`true` = 草稿，不上线	没写完不想发布
`updated`	修订日期	大改后补一笔
`password` / `passwordHint`	加密整篇正文	私密文章（见系列「文章加密」篇）
`series` / `seriesOrder`	归入系列	见下文

⚠️ cover 图片规范：封面、正文图片一律传图床后填 https://… 完整链接，不要往仓库里塞图片文件（会让仓库变大、构建变慢）。传图细节见 R2 图床运营规范。

三、系列字段（series / seriesOrder）#

「系列」就是把几篇文章串成一个合集，在 /series/ 页面统一展示、自动生成上一篇/下一篇导航。

1
---
2
title: 某一篇
3
series: "Firefly 教程"     # 填同一个系列名 → 自动归到一起
4
seriesOrder: 5             # 该系列内的排序，数字小的在前
5
---

归到哪个系列，取决于 series 填的名字，跟文件在哪个目录无关
不填 series = 独立文章，不进任何系列
seriesOrder 只影响系列内顺序，不影响主页按日期的排序

本站约定：以后所有本站维护教程都放进 Firefly 教程 系列，新文章记得 seriesOrder 接续现有最大号。

四、发布：git 三步#

写完、本地预览没问题后，在仓库根目录执行：

Terminal window

1
git add .
2
git commit -m "新增：xxx 文章"
3
git push

三步各管一件事：

命令	作用
`git add .`	把改动「登记」进暂存区
`git commit`	打一个本地存档点
`git push`	把存档传到 GitHub —— 只有这一步才会触发线上构建

commit 消息建议用 新增：… / 修改：… / 删除：… 开头，方便以后翻历史。

push 成功后，GitHub 会自动触发构建，多个部署平台陆续更新。构建需要一两分钟，别急着刷新。

本地预览（发布前检查）#

Terminal window

1
pnpm dev        # 打开 http://localhost:4321 预览
2
pnpm build      # 生产构建，发布前跑一遍确保没报错

pnpm 全部指令、构建流水线原理、常见坑，见本系列「pnpm 常用指令速查」。

五、修改与删除文章#

改文字：直接改 .md → git 三步 → 覆盖更新
改网址：文章网址 = 文件相对路径去掉扩展名（my-first-post.md → /posts/my-first-post/）。改名 = 改网址，会让旧链接 404、影响已分享出去的地址——发布过的文章尽量别改名
下线文章：最稳妥是 draft: true（保留草稿可再启用）；真要删就删文件，但注意删了无法找回

六、Obsidian 写作小贴士（个人习惯）#

Markdown 语法与系列里的《Markdown 教程》一致，Obsidian 所见即所得
传图用图床工具，自动返回 ![](链接) 格式直接粘贴
写「本站维护教程」时，正文开头能配一张封面/示意图观感更好

✅ 发布清单（自检）#

图片已传图床、正文里是 https://… 链接（不是本地路径）
frontmatter 完整，published 是 YYYY-MM-DD
pnpm dev 本地能正常渲染
git add → commit → push 三连，push 输出无报错
一分钟后线上刷新能看到

pnpm 常用指令速查（本地开发与构建）

Mon, 07 Sep 2026 00:00:00 GMT

📖 前置须知#

本站强制使用 pnpm（项目里配了 preinstall: only-allow pnpm，用 npm/yarn 会被拦下）
环境要求：Node ≥ 22.23，pnpm 11 系（package.json 里锁了 packageManager）
换机器/新克隆仓库后，先 pnpm install 装依赖，再跑下面命令

一、指令速查表#

指令	作用	什么时候用
`pnpm install`	安装依赖	新克隆仓库 / 首次使用 / 报缺依赖
`pnpm dev`	起本地开发服务器（localhost<4321>，改代码热更新）	日常写文章/改配置预览
`pnpm build`	生产构建，产物输出到 `dist/`	发布前必跑，确保能构建成功
`pnpm preview`	本地预览 `dist/` 构建产物	想模拟线上效果时
`pnpm new-post 文件名`	脚手架：建一篇新文章	写新文章（见下）
`pnpm new-dynamic 内容`	脚手架：建一条碎碎念	发碎碎念
`pnpm check`	`astro check` 类型与内容集合检查	改代码后查错误
`pnpm type-check`	TypeScript 类型检查（tsc）	同上，更严格
`pnpm lint` / `pnpm format`	代码规范检查/自动格式化	改过 `.ts/.astro` 源码后
`pnpm astro <子命令>`	直接调 Astro CLI	一些高级操作

需要联网才能完成的#

pnpm install（装依赖）、pnpm new-post 里的中文转拼音（内置依赖）、build 时可能的封面数据拉取（按配置，网络不好会慢/跳过）。

二、内容脚手架#

建文章 `pnpm new-post <文件名>`#

Terminal window

1
pnpm new-post my-first-post        # 或中文名也行
2
pnpm new-post guide/xxx            # 支持子目录，自动建目录

它会在 src/content/posts/ 建好文件，自动补 .md 扩展名、填好今天的日期和一套 frontmatter 模板：

1
---
2
title: my-first-post      # 记得改成真正标题
3
published: 2026-09-07     # 自动填今天
4
description: ''
5
tags: []
6
category: ''
7
draft: false
8
---

生成的 slug/title 只是模板，真正控制显示的是 frontmatter 里的 title；网址由文件名决定（见内容发布全流程）。

发碎碎念 `pnpm new-dynamic 内容`#

Terminal window

1
pnpm new-dynamic 今天的第一条碎碎念！
2
pnpm new-d            # new-dynamic 的别名

自动按当前时间命名文件、写进 src/content/dynamic/、填好 published。细节见碎碎念维护指南。

三、构建流水线（build 到底做了什么）#

pnpm build 不是单纯打包，是一整串流水线（按顺序执行）：

1
① 生成 GitHub 仓库卡片数据   → generate-github-card-data
2
② 生成图片占位 LQIP          → generate-lqips
3
③ 拉取封面数据（按配置）      → generate-vndb-covers
4
④ Astro 主构建               → astro build（产出 dist/）
5
⑤ 清理无用看板娘资源         → prune-pio-assets
6
⑥ 字体子集化                 → subset-fonts
7
⑦ 压缩内联脚本               → minify-inline-scripts
8
⑧ 生成站内搜索索引           → run-pagefind（Pagefind）

所以要理解两件事：

build 比较慢是正常的（要跑 8 步），别以为卡住了
有几步（LQIP、字体、搜索索引）的产物是要提交进仓库的——本地跑过 build 后若提示这些文件有改动，记得一并 git add，否则线上构建用的数据可能旧

四、本地发布自检流程（每次发布前）#

Terminal window

1
pnpm dev        # ① 起本地，浏览器看效果（新文章在 posts 列表/系列里）
2
# —— 满意了 ——
3
pnpm build      # ② 生产构建，确保零报错通过（可选，改动纯内容时可用 dev 代替）
4
git add . && git commit -m "新增：xxx" && git push   # ③ 上线

只加/改 Markdown 内容时，dev 预览够了；动了配置/源码（.ts、.astro、组件）建议 pnpm check + pnpm build 都过一遍再推。

⚠️ 常见坑#

现象	原因	解决
`Only pnpm is allowed`	用了 npm/yarn	换 `pnpm`
build 报 Node 版本错	Node 太老	升到 ≥ 22.23
页面图不显示，本地是好的	图片没走图床	见 R2 图床运营规范
build 后一堆文件「变了」	流水线重新生成了数据	正常，一起 commit

✅ 速记#

日常两条：pnpm dev 看效果，git 三连上线
写文章 pnpm new-post、发碎碎念 pnpm new-dynamic，让脚手架帮你填日期和模板
发布前：纯内容用 dev 预览；动了源码就 check + build 都过
build 是 8 步流水线，慢是正常的；生成的数据要记得 commit

R2 图床运营规范

Mon, 07 Sep 2026 00:00:00 GMT

📖 为什么图片要放图床#

本站文字和图片分离：

文字（Markdown）进 git 仓库 —— 仓库永远很小，克隆、构建都很快
图片进对象存储图床 —— 独立于站点，走 CDN 加速，图片挂了也不拖垮页面

所以规则是：凡是 >几十 KB 的图片，一律传图床，用 https://… 链接引用，绝不把图片文件塞进仓库。

一、上传工具（PicList）#

日常传图用 PicList（桌面图床管理工具），配好一次就不用再动。关键配置点（不含凭证）：

协议：S3 兼容
区域：auto
Endpoint：R2 专属地址（不带桶名前缀）
Path Style：开启
关闭桶名自动前缀：避免路径被重复拼成 桶/桶/文件
自定义域名：填好图床 CDN 域名，上传后它直接返回可用的 https://… Markdown 链接
拖图自动转 webp + 自动生成 ![](链接)，复制即用

凭证（Access Key / Secret）只在工具里配一次，别写进任何文档、别进 git。

二、目录与命名规范#

图床里按用途分目录，别乱堆：

目录	放什么	命名
`gallery/`	相册/照片墙、碎碎念配图	`YYYY-MM-DD-含义.webp`
`page/`	友链头像（本地化用）	`序号-域名.webp`
`firefly-tutorial/`	教程系列封面/示意图	语义化英文

命名规则：日期-含义，扩展名统一 .webp。好处是看图名就知道什么时候传的、什么内容，而且日期天然避免重名冲突。

⚠️ 别用中文文件名（链接里会带 URL 编码，复制粘贴易错），文件名里也别带空格。

三、缓存规则（配一次，但要知道）#

图床域名已配 CDN 缓存规则：Edge/Browser TTL 设为约 1 年。这样访客的图片请求打到 CDN 缓存，不会每次都回源对象存储，省流量也快。

怎么确认缓存生效：浏览器开发者工具看图片请求的响应头，cf-cache-status: HIT（缓存命中）说明走缓存；如果显示 DYNAMIC，说明还没配缓存规则、每次都在回源。

四、⚠️ 最容易踩的坑：换图必须换文件名#

因为缓存 TTL 长达 1 年，同名文件被覆盖后，访客可能几个月都看到旧图（CDN 缓存没失效）。

所以铁律：

改图 = 重新上传一个新文件名，改引用链接。永远不要覆盖同名文件。

正例：

1
原来：2026-09-07-girl.webp  → 引用了它
2
改图：上传 2026-09-07-girl-v2.webp → 把正文链接改成 v2

错误示范：直接覆盖 2026-09-07-girl.webp —— 你本地看是新图，线上访客大概率还是旧图。

五、传完图后回正文#

图床工具会返回 ![](https://cdn.xxx.top/gallery/2026-09-07-xxx.webp)，直接粘进 Markdown 即可。别手动改链接里的域名拼写，复制出来的最稳。

文章 / 碎碎念 / 相册 urls.txt 引用图片的完整流程串起来见对应各篇：

文章怎么引用 → 内容发布全流程
碎碎念配图 → 碎碎念维护指南
相册照片清单 → 相册与照片墙维护指南

✅ 速记#

大图一律图床，仓库只存文字
上传工具配好别乱动，凭证不进文档
目录 gallery/、page/… 分类放；命名 日期-含义.webp
已配 1 年缓存；看到 DYNAMIC 说明缓存没生效
改图 = 新文件名，绝不同名覆盖

00概述

Fri, 28 Aug 2026 00:00:00 GMT

本分类是Java SE的学习笔记，是我个人的根据《Java核心技术卷》的一些知识总结，如有纰漏，欢迎指出。本分类会被作为知识节点串连进入后端路线或者其它用到Java SE的技术路线中。本教程的运行环境是MacOS，不过鼓励读者在任意平台探索，体会Unix家族和Windows的差异。本系列创作过程使用AI辅助创作尽可能避免错误。

上一学年遗憾博客停更，C语言程序设计入门和数据结构部分没有被整理发布，未来如果有时间一定会把C语言部分按照严长生的《C语言小白变怪兽》教程补上，当然我也并非闲的蛋疼，C语言是学习Java SE的前置知识，本笔记也仅面向已掌握C语言的群体。

算法竞赛实际上是高级数据结构+算法，可以说包含了通俗的数据结构课程知识，我会按照罗勇军的《算法竞赛》分类将数据结构部分作为知识节点发布，内容扩充了传统的数据结构课程知识。

我的博客体系就是如此，因为需要用到Java SE的方向一定不仅有后端开发，所以每一个具体知识点我都节点化，在多个路线中共享。

卷一#

章	内容	去向	系数
Ch1	Java 概述	✅ ①	1
Ch2	编程环境	✅ ①	1
Ch3	基本结构（类型/字符串/数组/控制台IO/大数值/日期）	✅ ①	2
Ch4	对象与类（封装/构造/包/文档注释/Object方法）	✅ ②	3
Ch5	继承（多态/抽象/枚举/反射）	✅ ③	3
Ch6	接口/lambda/内部类（服务加载/clone/序列化）	✅ ④	3
Ch7	异常/断言/日志	✅ ⑤	2
Ch8	泛型（通配符/擦除）	✅ ⑥	2
Ch9	集合（含遗留集合/Properties）	✅ ⑦	2
Ch10	GUI 程序设计	❌ 跳	—
Ch11	Swing 组件	❌ 跳	—
Ch12	并发（线程/锁/原子/线程池/CompletableFuture/进程）	✅ ⑧	4

卷二#

章	内容	去向	系数
Ch1	流（Stream API：filter/map/collect/Optional/并行流）	✅ ⑨	2
Ch2	输入输出（IO 流/文件/序列化/正则/NIO）	✅ ⑩	3
Ch3	XML（DOM/SAX/StAX/XPath）	🔀 按需（JSON 为主）	1
Ch4	网络编程（Socket/HttpClient/HTTP Server）	✅ ⑪	2
Ch5	数据库编程（JDBC/事务/连接管理）	✅ ⑬	3
Ch6	日期时间（java.time 进阶，卷I Ch3 已有基础）	✅ 并入①，进阶按需	1
Ch7	国际化	❌ 跳	—
Ch8	编译与脚本（编译 API / 脚本引擎）	❌ 跳	—
Ch9	安全（类加载器/认证/签名/加密）	🔀 按需（平台安全 API，≠后端 Web 安全）	1
Ch10	GUI 程序设计	❌ 跳	—
Ch11	Swing 组件	❌ 跳	—
Ch12	高级 Swing 与图形	❌ 跳	—
Ch13	外部函数与本地方法（FFM/JNI）	❌ 跳	—

01Java背景和基本结构

Fri, 28 Aug 2026 00:00:00 GMT

1.1 Java 程序设计平台#

Java是一个完整的平台，有庞大的库，有大量可以直接抄的代码，有可以保证安全性、跨操作系统、内存垃圾回收的环境，集多种优势于一身。

1.2 Java 白皮书的关键术语#

简单性：几乎所有编程语言的推出的目的都是优化上一代编程语言的不足，Java就是在C++的特性上剔除了许多难以理解的功能。而且刚刚推出时完整占用仅在Kb级别面向对象：（一种程序设计技术）将重点放在数据上而非工具上。分布式：网络功能强大，可以打开和访问云端对象。健壮性：其指针模型可以消除重写内存和损坏数据的可能，编译器可以在运行前检测出问题。安全性：具备沙箱功能，不可信代码隔离运行。体系结构中立：编译后生成的字节码可以在任何有JRE的环境运行，和计算机体系无关。可移植性：基本数据类型和运算行为是明确的，比如int类型的大小在任何机器上都是固定的。解释性：不是纯编译型语言，先编译出字节码之后解释器翻译成机器码高性能：靠JIT即时编译，把运行次数最多的代码片段直接编译成机器码。现代的优化直逼C/C++ 多线程：第一个在语言层面内置多线程，无需附加库。动态性：按需动态加载新代码。

以上特性需要在后续学习中体会，纯看理解不了

1.3 Java applet 与 Internet#

运行在网页上的java代码是applet，开发者在网页上设计java程序发布字节码，用户端直接用本地解释器运行，当时很牛，但马上被flash碾压。

1.4 Java 发展简史#

Java 诞生于 1991 年 Sun 公司的 “Green 项目”。James Gosling 等人最初的设想是给嵌入式消费电子产品（电视机顶盒、遥控器之类）写一门语言，当时取名 Oak（橡树）。可惜产品没有找到市场，项目一度濒临放弃。

转机出现在 1995 年。互联网爆发式增长，Sun 发现网络上的设备五花八门、平台极不统一，而 Oak 的跨平台特性（编译成字节码、由各平台 JVM 解释执行）正好命中了 Web 时代的需求。于是 Oak 改名 Java 正式发布，并借助浏览器运行小程序（applet）一战成名。“一次编写，到处运行”（Write Once, Run Anywhere）成为 Java 最深入人心的口号。

此后 Java 一路快速迭代，几个关键节点：

1996 JDK 1.0 正式版
1997 JDK 1.1：内部类、反射、JDBC、RMI
1998 Java 2（1.2）：Swing、集合框架、JIT 编译器
2004 Java 5：泛型、注解、枚举、自动装箱、并发包 —— 现代 Java 的基石
2006 Java 6：脚本引擎、JDBC 4.0
2009 Oracle 收购 Sun 公司
2011 Java 7：try-with-resources、switch 支持字符串、NIO.2
2014 Java 8：lambda、Stream、java.time、接口默认方法 —— 另一个里程碑
2017 Java 9：模块系统、JShell；此后改为每半年发一版
2018/2021/2023 Java 11 / 17 / 21：长期支持版本（LTS）

只要抓住两个关键版本就够了：Java 5 定下了泛型、注解、并发这些基础语法；Java 8 是写法的分水岭，lambda 与 Stream 让 Java 从”啰嗦的 C++ 改良版”进化成了现代化的语言。之后的版本大多是在这个地基上做增量。本书正是基于这一生态展开的。

1.5 关于 Java 的常见误解#

“Java 很容易学” 语法确实比 C++ 温和，但”学语法”和”会写程序”是两码事。Java 真正的难度在生态：JVM、集合、并发、框架。入门容易，精通极难——就像 C 语法也不难，指针和内存才是坎。

“Java 能取代所有语言” 没有万能语言。C/C++ 统治系统编程与游戏引擎，Python 主导 AI，JavaScript 垄断浏览器，Go/Rust 在云原生崛起。Java 的天下是企业级后端，它再强也取代不了所有场景。

“Java 不过是换了个写法的 C/C++” 这是最值得掰扯的一条。两者的差异不在语法在运行模型：C++ 编译成机器码直接跑，Java 编译成字节码交给 JVM；C++ 手动管内存，Java 自动回收；C++ 指针能算数，Java 引用不行。同样的逻辑任何语言都能表达，但各自解决不同层面的问题——这正是本系列要慢慢体会的。

“Java 是闭源的” 反了。OpenJDK 是开源实现（GPL 许可），语言演进走公开的 JSR 流程。Oracle JDK 也只是基于 OpenJDK 的发行版。把「有大厂主导」说成「闭源」是个误会。

“JavaScript 是 Java 的简易版” 俩名字都带 “Java” 而已。Java 是 Sun 的静态类型面向对象语言，跑在 JVM；JavaScript 是 Netscape 为浏览器发明的脚本语言，跑在浏览器引擎。语法、类型系统、运行环境全都不一样，纯属当年蹭热度起的名字。

“Java 性能低下” 20 年前的刻板印象。早期纯解释执行确实慢，但 JIT 会把热点代码编成机器码，现代 JVM 峰值性能逼近 C++（大厂的高并发服务很多就是 Java）。真正的代价是启动慢、吃内存——它是「用启动速度和内存换运行性能」。

“Java 写程序容易有安全风险” 恰恰相反，Java 的安全设计是核心卖点：没有指针算术杜绝内存破坏、字节码校验、数组越界检查、沙箱机制。C/C++ 里缓冲区溢出、野指针这类经典漏洞，在 Java 里从机制上就没了。Java 的安全问题更多在应用层（框架配置、依赖漏洞），那是所有语言都躲不掉的。

第 2 章 Java 编程环境#

Hello.java（源代码） │ ① javac Hello.java ▼ Hello.class（字节码 bytecode，磁盘文件） │ ② java Hello（启动 JVM） ▼ JVM：类加载 → 字节码校验 → 执行引擎 │ ③ 解释执行 + JIT 即时编译（热点代码） ▼ 机器码（二进制，内存中，CPU 真正执行）

2.1 安装 Java 开发工具包#

https://www.java.com/zh-CN/

Java 的开源本体只有 OpenJDK 一份，Azul Zulu、Amazon Corretto、Eclipse Temurin、Oracle JDK 等全部是基于这同一份源码编译出的发行版——内核相同，差异只在打包方式、支持周期和性能优化。类比 Linux 内核 vs Ubuntu/Fedora。

运行安装程序一路下一步即可完成安装，除非你非要编译安装。记得勾选添加系统环境变量、Add to PATH一类的标识。

运行以下命令，即可查看java版本。（一般装cli软件这一步是必须做的）

Terminal window

1
javac --version

如果报错未找到command not find，多半是你忘了勾选添加环境变量，win用户去设置内找编辑系统环境变量的对话框，手动把你安装java的根目录添加于此。unix-like用户（Linux、MacOS）去~/.zshrc或~/.bashrc文件加一行export PATH=jdk/bin:$PATH(jdk/bin是linux默认安装位置，如果你装在别处请改写)

2.2 使用命令行工具#

学习Java需要具备一定的命令行基础，Java SE相关笔记中会体现一些基本用法。命令行主流教学基本都是 Unix‑like，相关深入用法在 Linux 基础与命令行 节点深入详解。

新建hw.java文件，输入

1
public class Hello {
2
    public static void main() {
3
        System.out.println("Hello World!");
4
    }
5
}

在同级目录下，使用命令

Terminal window

1
javac Hello.java
2
#先用编译器生成class字节码
3
java Hello
4
#再用JVM翻译成机器码，输出第一个hello world

以上过程初学者可能会发现一些必须要遵守的写java程序必须要遵守的原则，简称语法。遵守这些规则怪谈才能不出bug。

2.3 使用集成开发环境#

集成开发环境（IDE，Integrated Development Environment）把编辑、编译、运行、调试、代码补全等工具整合到一个图形界面里，省去手动敲命令的麻烦。

本系列使用 IntelliJ IDEA（JetBrains 出品），业界主流的 Java IDE。它分两个版本：

Community（社区版）：免费开源，本阶段够用
Ultimate（旗舰版）：付费，内置 Spring、数据库等企业开发支持——后面走后端路线时用得上

用 IDEA 跑 Hello World，本质就是把 2.2 的命令行两步（javac 编译、java 运行）搬进图形界面：新建项目 → 指定 JDK → 写代码 → 点运行。

2.4 JShell#

JShell 是 Java 9 起自带的交互式命令行工具（REPL，Read-Eval-Print Loop），类似 Python 的交互式 shell：敲一行、立刻看到结果，不用建文件、编译、运行。

终端敲 jshell 进入，试几条：

1
jshell> System.out.println("Hello World!")
2
Hello World!
3

4
jshell> 1 + 1
5
$1 ==> 2
6

7
jshell> "abc".repeat(3)
8
$2 ==> "abcabcabc"

与 Python shell 的手感差异源于语言本身：Java 声明变量要写类型（int x = 5;），语句结尾要分号。而且 JShell 只是「试用台」——验证语法、算表达式、试 API 很方便，而且还能使用tab键补全查函数名，但正经程序还是走 2.2 的编译运行或 2.3 的 IDEA。对比 C：C 没有官方 REPL，想试个语法得写文件编译，Java 这一点更顺手。

第 3 章 Java 的基本程序设计结构#

3.1 一个简单的 Java 程序#

从 Hello World 起手，对照 C 最容易看清 Java 的程序骨架，很多新概念、新名词在这里先露个脸、留个印象，具体的深入剖析需要到之后的章节。

1
public class Hello {
2
    public static void main(String[] args) {
3
        System.out.println("Hello World!");
4
    }
5
}

类名与文件名：public class Hello 声明一个公共类，类名 Hello。类名习惯以大写字母开头；源文件名必须与公共类同名（Hello.java）。Java 里所有内容都必须放进类的容器中——C 可以在文件顶层写自由函数，Java 不行，这就是「万物皆类」的起点。

访问修饰符：public 表示「公开」，谁都能访问。Java 的类、方法、字段前面几乎都有修饰符（public / private 等）控制可见性，C 没有对应概念，只能靠文件作用域和头文件的约定来模拟。

main 方法——程序入口：public static void main(String[] args)，逐词拆解：

public：JVM 要从外部调用它，必须公开
static：静态方法，不需要创建对象就能调用
void：不返回值
String[] args：命令行参数数组，对应 C 的 int argc, char *argv[]（Java 只保留了参数那半，argc 用 args.length 代替）

执行 java Hello 时，JVM 从 Hello 类的 main 方法开始运行。Java 里函数叫方法（method），等价于 C++ 的成员函数。

调用方法：通用语法是 对象.方法(参数)。System.out.println("Hello World!") 中，System 是一个类，out 是它内部代表标准输出的对象，println 是对象的方法——对应 C 的 printf。区别在于 C 调用的是库函数，Java 调用的是对象的方法，这是面向对象和面向过程的第一处体感差异。

大小写敏感：Java 严格区分大小写，Hello 和 hello 是两回事，main 必须小写。C 同样区分大小写，但 Java 的驼峰命名惯例（类名大写开头、方法变量小写开头）从一开始就要适应。

3.2 注释#

几乎所有编程语言的注释都不会出现在可执行程序中——它们只是写给编译器和人看的说明，编译时被直接丢弃。

三种注释方式，一段代码全演示：

1
public class CommentDemo {
2
    /**
3
     * 文档注释：/** */ 之间的内容，
4
     * 可用 javadoc 工具生成 HTML 文档
5
     */
6
    public static void main(String[] args) {
7
        // 单行注释：// 到行尾都被忽略
8
        System.out.println("Hello");  // 也可以跟在代码后面
9

10
        /*
11
         * 多行注释：/* */ 之间的内容
12
         * 跨越多行全部忽略
13
         */
14
        System.out.println("World!");
15
    }
16
}

展开收起

不能嵌套：三种注释都不能互相嵌套，尤其多行注释——/* 外层 /* 内层 */ 外层 */ 是错的：编译器遇到第一个 */ 就认为注释结束，后面剩的 外层 */ 会被当成代码，直接编译报错。

对比 C：// 和 /* */ 与 C 一致；/** */ 是 Java 新增的文档注释（C 没有），配合 javadoc 工具生成 API 文档。

小提示：示例中多行注释和文档注释每行开头的 * 并非语法要求，只是排版风格——Java 只认开头的 /* 或 /** 和结尾的 */，中间怎么写都行，IDEA 会自动帮你补 *。

3.3 数据类型#

Java 有 8 种基本数据类型，每种的大小在所有平台上都固定不变——这是和 C 最根本的差异之一：C 的 int 在 16/32/64 位机器上是 2/4/4 字节，Java 的 int 永远是 4 字节，跨平台行为完全一致。

类型	存储	取值范围	字面量后缀
`byte`	1 字节	-128 ~ 127	无
`short`	2 字节	-32,768 ~ 32,767	无
`int`	4 字节	-21.4 亿 ~ 21.4 亿	无（整数默认）
`long`	8 字节	-922 亿亿 ~ 922 亿亿	`L` / `l`
`float`	4 字节	约 ±3.4E38（6~7 位有效数字）	`F` / `f`（必须写）
`double`	8 字节	约 ±1.8E308（15 位有效数字）	`D` / `d`（可省，浮点默认）
`char`	2 字节	0 ~ 65,535（无符号）	单引号 `'A'`
`boolean`	不规定	`true` / `false`	无

（E 是科学计数法，3.4E38 = 3.4 × 10³⁸）

整型：整数默认是 int，超过范围加 L（后缀建议大写，小写 l 和数字 1 长得太像）。支持多种进制前缀：

1
int dec = 10;      // 十进制（默认）
2
int oct = 010;     // 八进制：0 开头，值 = 8
3
int hex = 0x10;    // 十六进制：0x 开头，值 = 16
4
int bin = 0b10;    // 二进制：0b 开头（Java 7+），值 = 2

长数字可以用 _ 分组（Java 7+，编译时忽略）：1_000_000 就是 100 万。_ 不能放在开头/结尾、小数点两侧、以及 L/F 后缀前，比如 _100、100_.0 都非法。

vs C：Java 没有无符号数。C 有 unsigned int，Java 所有整数类型都是带符号的，唯一的”无符号”是 char——但它是字符类型，不做算术。

浮点型：带小数默认是 double，存 float 必须写 F 后缀。遵循 IEEE 754 标准，浮点运算有 3 种特殊结果：

Double.POSITIVE_INFINITY 正无穷，如 1.0 / 0
Double.NEGATIVE_INFINITY 负无穷，如 -1.0 / 0
Double.NaN 非数字，如 0.0 / 0

判断 NaN 必须用 Double.isNaN(x)——因为 NaN 不等于任何值，包括它自己，x == Double.NaN 永远为 false。

字符型：char 是 2 字节无符号(C/C++是1字节)，直接表示 Unicode 字符。有个著名大坑：Java 在解析代码之前就先处理 Unicode 转义（\uXXXX），所以写 Windows 路径 "c:\users" 会编译报错——\u 被当成 Unicode 转义开头，而 \users 不是合法的十六进制序列。改成 "c:\\users" 或 "c:/users" 就好。

顺带解释码点（code point）：Unicode 给每个字符分配的唯一编号就是码点，范围 0 ~ 0x10FFFF（约 110 万）。char 只有 16 位，只能直接装 0~65535 的码点（基本多语言平面）；更大的码点（如 emoji）要两个 char 拼成「代理对」表示。意思就是码点可能是一个char也可能是两个char拼起来的代理对。这就是 3.6 字符串「码点与代码单元」要展开的话题。

布尔型：boolean 只有 true / false，和 C/C++ 最大的区别是不能用数字代替——if (1) 在 Java 里是编译错误，必须写布尔表达式。这也顺带杜绝了 C 里”赋值写进条件”那类经典 bug。

3.4 变量与常量#

声明变量：先声明后使用，命名规则：

以字母开头，后面可接字母、数字、_、$，大小写敏感，注意不能用关键字当变量名（class、int、if…）
Java 的”字母”包含 Unicode 字符，支持中文变量名
惯例：驼峰命名、下划线命名，如 int totalCount; int total_count;

1
double salary;       // 声明
2
int i, j;            // 一行声明多个

不区分声明和定义：C/C++ 里声明（告诉编译器类型）和定义（分配存储）是两回事，于是有 extern、头文件、前置声明。Java 没有这套——每个声明天然就是定义，变量一旦声明就真实存在、占存储，因此也不需要头文件。
初始化：Java 编译期强制要求局部变量使用前必须赋值，否则直接编译报错：

1
int x;
2
System.out.println(x);   // 编译错误：变量 x 可能尚未初始化

C/C++ 里这属于未定义行为（可能读到垃圾值），Java 把这种错误直接拦在编译期。

作用域（块作用域）：变量在声明它的块 { } 内有效，块结束即失效，这点和 C 一致。但有个关键差异——Java 禁止遮蔽（shadowing）：

1
int x = 0;
2
{
3
    int x = 1;   // C/C++ 合法（内层遮蔽外层），Java 编译错误！
4
}

C/C++ 允许内层块重新声明同名变量（内层隐藏外层），Java 直接拒绝同名局部变量同时存在于同一作用域链。另外，Java 没有全局变量：C 有文件作用域的全局变量，Java 一切都在类内，最接近的等价物是类里的 static 字段（详见后文对象与类）。

常量：用 final 声明，只能赋值一次：

1
final double CM_PER_INCH = 2.54;

对比 C：C 用 #define（预处理器文本替换，无类型检查）或 const（编译器只读）。Java 的 final 语义更强——基本类型 final 变量的值不可变。类级常量用 static final 声明。

枚举类型：Java 5+ 引入，定义一组有限的值：

1
enum Size { SMALL, MEDIUM, LARGE }

C 也有 enum，但 Java 的枚举是完整的类，能力远超 C（能带字段和方法），细节放到继承那篇展开。

3.5 运算符#

算术运算符：+ - * / % 与 C 一致：

1
int a = 10, b = 3;
2
a / b   // 3：整数除法直接截断（向 0 取整）
3
a % b   // 1：取余

一个 vs C 的差异：Java 里整数除零直接抛异常（ArithmeticException），浮点除零则是无穷或 NaN；C 的整数除零是未定义行为，程序可能悄悄崩掉。

Math 类：Java 的数学函数都收在 Math 类里，静态调用即可，不需要 #include <math.h> 也不用链接 -lm：

1
Math.sin(x)      // 正弦
2
Math.cos(x)      // 余弦
3
Math.tan(x)      // 正切
4
Math.atan(x)     // 反正切（弧度）
5
Math.atan2(y, x) // 直角坐标 → 极坐标的角度
6
Math.exp(x)      // e^x
7
Math.log(x)      // 自然对数 ln(x)
8
Math.log10(x)    // 以 10 为底的对数
9
Math.pow(a, b)   // a 的 b 次方
10
Math.PI          // 圆周率 π
11
Math.E           // 自然常数 e

注意：三角函数参数是弧度，不是角度。

隐式类型转换：小范围类型自动转大范围类型（隐式「拓宽」转换），合法转换如图：

1
byte → short → int → long → float → double
2
               ↑
3
               char

实线箭头无损、可隐式转换。另有几条虚线转换（int→float、long→float、long→double）虽合法但可能损失精度，因为 float/double 的尾数位有限。

隐式转换：

赋值：double d = 3;（右侧自动拓宽成左侧类型）

算术运算：3 + 3.14（窄操作数自动提升成宽操作数）

二元运算时数值会自动提升：操作数里有 double 结果就是 double，其次 float、long，否则一律提升到 int——所以 byte + byte 的结果也是 int。原因是 JVM 的字节码指令没有 byte/short 级别的算术运算，一律按 int（或更大）宽度计算，这和 C 的整型提升（integer promotion）如出一辙。后果就是：

1
byte a = 10, b = 20;
2
byte c = a + b;          // 编译错误：a + b 是 int，不能直接赋给 byte
3
byte d = (byte) (a + b); // 正确：强转回来

强制类型转换：大范围转小范围（「缩小」转换）必须显式强转，语法 (目标类型) 表达式：

1
double x = 9.997;
2
int n = (int) x;   // 9：直接截断小数，不是四舍五入

想要四舍五入用 Math.round(x)，不是强转
大转小可能溢出或截掉高位（如 int → byte），结果可能出乎意料
boolean 不能转数值，数值也不能转 boolean

赋值运算符：= 之外还有复合赋值 += -= *= /= %= &= |= ^= <<= >>= >>>=：

1
x += 4;   // 等价于 x = x + 4;

一个小坑：复合赋值自带一次隐式强转——byte b = 1; b += 1; 合法（等价于 b = (byte)(b + 1)），而 b = b + 1; 编译报错。

自增自减：++ -- 与 C 完全一致，注意前后缀的区别：

1
int x = 5;
2
int y = x++;   // y = 5，先用后加
3
int z = ++x;   // z = 7，先加后用

关系与逻辑运算符（返回 boolean）：全部列出来，按优先级从高到低：

优先级	运算符	说明
1	!	逻辑非
2	< > <= >=	关系比较
3	== !=	相等判断
4	&	与（不短路）
5	^	异或
6	\|	或（不短路）
7	&&	与（短路）
8	\|\|	或（短路）

vs C 的核心差异：&& 和 || 只能操作 boolean，没有 C 里「非 0 即真」那一套，if (1) 直接编译错误。短路：&& || 左边能决定结果时右边不会执行；& | 不短路，两边都会算。

三目运算符：条件 ? 值1 : 值2，与 C 一致：

1
int max = (a > b) ? a : b;

switch：传统写法和 C/C++ 差不多（会 fall-through，记得 break），Java 支持 4 种用法，逐一来看：

1
// ① 整数 / 字符：传统写法，会贯穿，记得 break
2
int day = 2;
3
switch (day) {
4
    case 1:
5
    case 2: System.out.println("工作日"); break;
6
    case 6:
7
    case 7: System.out.println("周末"); break;
8
    default: System.out.println("非法");
9
}
10

11
// ② 字符串（Java 7+）
12
String fruit = "apple";
13
switch (fruit) {
14
    case "apple":  System.out.println("苹果"); break;
15
    case "banana": System.out.println("香蕉"); break;
16
    default:       System.out.println("未知");
17
}
18

19
// ③ 枚举
20
enum Color { RED, GREEN, BLUE }
21
Color c = Color.GREEN;
22
switch (c) {
23
    case RED:   System.out.println("红"); break;
24
    case GREEN: System.out.println("绿"); break;
25
    case BLUE:  System.out.println("蓝"); break;
26
}
27

28
// ④ switch 表达式（Java 14+）：箭头写法，不贯穿，整体可作为表达式
29
int month = 4;
30
int days = switch (month) {
31
    case 2 -> 28;
32
    case 4, 6, 9, 11 -> 30;
33
    default -> 31;
34
};

展开收起

要点：①②③是语句（执行完就完事），④是表达式（能整体返回一个值赋给变量）；前三者会贯穿，④的箭头写法天然不贯穿。箭头分支只有一句表达式时，直接写在 -> 后面就是返回值；要写多句话就用 { } 块，块内必须用 yield 给出值：

1
int days = switch (month) {
2
    case 2 -> 28;
3
    default -> {
4
        System.out.println("走默认分支");
5
        yield 31;   // 块内用 yield 返回值
6
    }
7
};

位运算：& | ^ ~ << >> >>>。操作数是整数时是位运算；操作数是 boolean 时，& | ^ 退化为逻辑运算（不短路）。

右移有 C/C++ 没有的明确行为：

>> 算术右移，高位补符号位
>>> 无符号右移，高位补 0

C/C++ 对有符号数的右移是实现定义（不同编译器可能补符号位或补 0），Java 用 >> / >>> 明确区分，消除了这种不确定性。

括号与优先级：Java 的运算符优先级和 C 基本一致（() 最优先，* / % 高于 + -，然后是移位、关系、逻辑、赋值）。拿不准就加括号，可读性永远第一，记优先级可维护性差。

3.6 字符串#

子串：substring(a, b) 提取子串（左闭右开）；C 没有直接等价物（只能指针 + 长度模拟）
拼接：+ 直接拼字符串，任何类型和字符串 + 都会自动转成字符串：

1
String s = "Hello " + 123;   // "Hello 123"

按分隔符拼一组字符串用 String.join：

1
String csv = String.join(", ", "a", "b", "c");   // "a, b, c"

"str".repeat(n)（Java 11+）重复字符串 n 次，方便方法，知道即可。

字符串不可变：String 一旦创建就不可改变，所有”修改”（拼接、replace、substring）都是创建新字符串对象，旧对象留给垃圾回收。好处是安全、可共享、天然线程安全；代价是每次修改都有开销——这就是第 9 条要用 StringBuilder 的原因。

手感：C++ 的 std::string 可变，且有操作符重载（== 比内容、[ ] 访问），Java 没有操作符重载，一律走方法（.equals()、.charAt()），所以初看不如 C++ 直观。这是设计取舍：Java 用统一的方法调用换来了简单一致的模型。

检测字符串是否相等：内容相等用 equals，忽略大小写用 equalsIgnoreCase。不能用 ==——== 对引用比较的是”是不是同一个对象”，不是内容：

1
String a = "hello";
2
String b = new String("hello");
3
a.equals(b)      // true，内容相等
4
a == b           // false，两个不同的对象
5

6
String c = "hello";
7
a == c           // true：字面量被"驻留"到常量池，指向同一对象

最后这个例子是个陷阱：字符串 字面量（常量） 会被驻留（intern）到常量池，所以两个字面量 == 碰巧相等。但驻留只对字面量和编译期常量生效，运行时生成的新字符串不会自动共享：

1
String d = "he" + "llo";   // 编译期常量折叠 → 仍是字面量，和 a 同一个对象
2
String x = "he";
3
String y = x + "llo";      // 运行时拼接 → 新对象，和 a 不同
4
a == d                     // true
5
a == y                     // false

所以任何依赖 == 判断内容的做法都是侥幸，内容判断一律用 equals，养成习惯。对比 C：C 用 strcmp 才比内容，Java 把”比内容”（equals）和”比身份”（==）拆成两个操作，反而更明确。

空串与 null 串：""（空串，有对象、长度 0）和 null（没有对象）是两回事：

1
String empty = "";
2
String nothing = null;
3

4
empty.length() == 0    // true
5
nothing.length()       // 抛 NullPointerException！

判空用 str.isEmpty() 或 str.length() == 0；判 null 用 str == null。两个都要防时，先判 null 再判空（&& 短路保证安全）：

1
if (str != null && !str.isEmpty()) {
2
    // 既不是 null 也不是空串
3
}

null 可以类比 C++ 的 nullptr：表示引用没指向任何对象；它不是对象，所以对 null 调方法会抛 NullPointerException。 6. 码点与代码单元：length() 数的是 UTF-16 代码单元（char）个数，charAt(i) 取第 i 个 char；codePointCount(a, b) 数的是码点（真实字符）个数，codePointAt(i) 取第 i 个位置的码点：

1
String s = "A😀B";
2
s.length()                       // 4：A + 代理对(占 2 个 char) + B
3
s.codePointCount(0, s.length())  // 3：A、😀、B 三个真实字符

普通文本遍历用 for + charAt 遍历就够；要正确处理 emoji 这类增补字符才需要码点方法。codePoints() 会返回码点流，在 Stream API 的范畴再展开讲。

String API：不用背。Java 标准库方法成千上万，没人全记得住。要做的是：

记住高频的几个：length charAt substring indexOf equals equalsIgnoreCase isEmpty toUpperCase replace
其余靠 IDEA 补全（敲 str. 自动弹）+ 查文档，用多了自然熟

阅读联机 API 文档：Java 标准库的官方文档就是 Oracle 维护的 javadoc，后端开发也查它（docs.oracle.com 搜 java 17 api）。IDEA 里把鼠标悬停在类/方法上，或按 Ctrl+Q（Mac 是 Ctrl+J）直接看说明，不用每次开浏览器。
构建字符串：大量拼接别用 +（每次都会 new 一个新 String），改用 StringBuilder：

1
StringBuilder builder = new StringBuilder();
2
builder.append("Hello");
3
builder.append(" ");
4
builder.append("World");
5
String result = builder.toString();   // "Hello World"

顺带回答一个基础问题——类到底是什么？ 类不是”容器”，是图纸（模板）：它规定了对象长什么样（字段）和能干什么（方法）。StringBuilder 是一个类，new StringBuilder() 是按图纸造出一个对象，builder.append(...) 是调用这个对象的方法。一张图纸可以造出无数个对象，每个对象是独立的一份”实物”。这会在对象与类下一章细说。

文本块（Java 15+）：用 """ 包起来的多行字符串，写 HTML / JSON / SQL 不用再拼一堆 \n：

1
String html = """
2
    <html>
3
        <body>你好</body>
4
    </html>
5
    """;

两个注意点：

内容里的单个 " 不用转义，只有会影响到结束定界符 """ 时才需要 \"
行尾放一个 \ 表示忽略这个换行（\ 不进入字符串）

3.7 输入与输出#

读取输入：从标准输入读数据，用 java.util.Scanner。注意 System.in 不是包，它是 System 类里的一个静态字段，代表标准输入流（对应 C 的 stdin）；Scanner 负责把流里的字节解析成你要的类型：

1
import java.util.Scanner;
2
//`java` 顶级包 → `util` 子包 → `Scanner` 类
3
Scanner in = new Scanner(System.in);
4
String name = in.nextLine();    // 读一整行
5
int age = in.nextInt();         // 读一个整数
6
double score = in.nextDouble(); // 读一个双精度浮点数

对比 C：scanf 靠格式串 + 取地址符，类型不匹配很容易出问题；Scanner 的方法是类型化的（nextInt() 保证返回 int），更安全但略啰嗦。还有 next()（读一个单词）、hasNextInt()（先判断下一个是不是整数）等。

另外还有 java.io.Console（System.console() 获取），适合交互式控制台场景（如读密码不回显）；但它在 IDE/重定向环境下可能拿不到，普通场景用 Scanner 就够。

格式化输出：和 C 的 printf 几乎一模一样——Java 直接把格式串机制搬了过来：

1
System.out.printf("%d %f %s%n", age, score, name);

对应 C 的 printf("%d %f %s\n", age, score, name);，占位符 %d %f %s 完全一致。完整格式串语法是：

1
%[参数索引$][标志][宽度][.精度]转换符

部分	含义
`%`	格式串起始符
`参数索引$`	指定用第几个参数（如 `%1$d` 用第 1 个参数）
`标志`	对齐、符号、补零等控制
`宽度`	最小输出宽度，不足补空格或 0
`.精度`	浮点 = 小数位数；字符串 = 最大长度
`转换符`	决定输出格式与接受类型

全部标志：

标志	作用	示例	输出
`-`	左对齐（默认右对齐）	`printf("%-5d", 12)`	`12`
`+`	正数带 `+` 号	`printf("%+d", 12)`	`+12`
`0`	数字前补 0	`printf("%05d", 12)`	`00012`
`空格`	正数前留一个空格	`printf("% d", 12)`	`12`
`(`	负数用括号包起来	`printf("%(d", -12)`	`(12)`
`,`	千位分隔符	`printf("%,d", 1234567)`	`1,234,567`
`#`	备选形式（如 `0x` 前缀）	`printf("%#x", 255)`	`0xff`
`$`	参数索引结束符：`%2$d` 用第 2 个参数，可重排/复用	`printf("%2$s %1$s", "a", "b")`	`b a`
`<`	复用上一个格式符的参数	`printf("%d %<x", 255)`	`255 ff`

全部转换符：

转换符	含义	适用类型	示例（对 42）
`%d`	十进制整数	byte / short / int / long / BigInteger	`42`
`%o`	八进制整数	同上	`52`
`%x` `%X`	十六进制整数	同上	`2a`
`%f` `%F`	十进制浮点	float / double / BigDecimal	`3.140000`
`%e` `%E`	科学计数法	同上	`3.140000e+00`
`%g` `%G`	通用浮点（自动选 f 或 e）	同上	`3.14000`
`%a` `%A`	十六进制浮点数	float / double / BigDecimal	`0x1.0p-1`（对 0.5）
`%s` `%S`	字符串	String / 任意对象	`hello`
`%c` `%C`	字符	char / byte / short / int	`A`
`%b` `%B`	布尔（`%B` 输出大写）	boolean	`true` / `TRUE`
`%h` `%H`	散列码	任意对象	`5e9a2c`
`%n`	平台换行	—	换行
`%%`	字面量百分号	—	`%`
`%tx` `%Tx`	日期时间（必须跟后缀，如 `%tY` 年份）	long / Long / Date / Calendar	`2026`

%t 单独写不合法，它是日期时间的”前缀”，后面必须跟一个字母指定取哪部分：%tY 年、%tm 月、%td 日、%tH 时（24 小时制）、%tM 分、%tS 秒、%tF 完整日期 yyyy-MM-dd、%tT 完整时间 HH:mm:ss。

几个注意点：

%n 输出平台原生行分隔符。C 的 printf("\n") 在 Windows 文本模式下会自动转成 \r\n，但 Java 的 \n 永远是 LF、不做转换，想要平台分隔符就用 %n
String.format(...) 是 Java 版的 sprintf：格式化后返回字符串而不打印
类型必须匹配：%d 配 String 直接抛异常——C 是未定义行为，Java 把错误拦在运行时
System.out.printf 与 System.out.format 完全等价

文件输入与输出：套路和标准输入输出一模一样，只是把 System.in 换成文件路径。

读文件用 Scanner，传一个 Path：

1
Scanner in = new Scanner(Path.of("data.txt"), StandardCharsets.UTF_8);
2
while (in.hasNextLine()) {
3
    System.out.println(in.nextLine());
4
}

写文件用 PrintWriter：

1
PrintWriter out = new PrintWriter("output.txt", StandardCharsets.UTF_8);
2
out.println("Hello 文件");
3
out.close();   // 写完必须关，否则可能没落盘

对比 C 的 FILE*：C 是 fopen("file.txt", "r") + fscanf / fprintf，Java 是把文件包进 Scanner / PrintWriter 对象再读写——同样是面向对象的”构造对象、调方法”套路。

相对路径：相对的是 JVM 的工作目录（启动 java 命令时所在的目录），不是 .java / .class 文件所在的目录。在 IDEA 里默认是项目模块目录，容易和直觉不符——报 FileNotFoundException 时，先想想”当前工作目录到底在哪”。

两个注意点：

编码：建议显式传 StandardCharsets.UTF_8，否则用平台默认编码，跨机器容易乱码
关闭：用完要 close()，否则数据可能没写入磁盘、句柄泄漏（后面 ⑩ 文件 IO 会讲 try-with-resources 自动关闭）

3.8 控制流程#

块作用域：和 C 一样，变量在声明它的 { } 块内有效。唯一区别在 3.4 提过：Java 不允许内层块遮蔽外层同名变量。

条件语句：if / else if / else 与 C 完全一致，唯一区别是条件必须是 boolean（if (1) 编译错误）。

循环：while、do-while、for 和 C 一模一样：

1
while (条件) { ... }
2
do { ... } while (条件);
3
for (int i = 0; i < n; i++) { ... }

for 里声明的 int i 只在循环内有效，这点和 C99 之后一致。switch 已在 3.5 讲过，不重复。

中断控制流程：break 跳出当前循环/switch；continue 跳过本次循环剩余部分、进入下一轮。Java 还有 C 没有的带标签的 break/continue，专治多层嵌套循环：

1
outer:
2
for (int i = 0; i < 3; i++) {
3
    for (int j = 0; j < 3; j++) {
4
        if (j == 1) break outer;   // 跳出整个外层循环，执行它后面的语句
5
    }
6
}

带标签的 continue 则跳到外层循环的下一次迭代：

1
outer:
2
for (int i = 0; i < 3; i++) {
3
    for (int j = 0; j < 3; j++) {
4
        if (j == 1) continue outer;   // 直接开始外层下一轮 i
5
        System.out.println(i + "," + j);
6
    }
7
}
8
// 输出：0,0 / 1,0 / 2,0

	`break outer`	`continue outer`
行为	退出整个外层循环（不再执行）	跳到外层循环下一次迭代
类比	循环直接结束	外层跳过这一轮，继续

对比 C：C 想跳出多层循环只能靠 flag 标志位或 goto。Java 把 goto 留作保留字但禁用（怕 goto 把结构搅成”意大利面条式代码”），用带标签的 break/continue 作为结构化替代——能跳出/跳过多层循环，但跳转方向被限制在循环的进出，不会乱跳。

带标签的 break 还能用在普通块上（不限于循环）——这是很实用的”提前退出嵌套逻辑”手法：

1
outer:
2
{
3
    if (条件A) {
4
        if (条件B) {
5
            break outer;   // 满足条件，块里剩余代码全部跳过
6
        }
7
        //这里是代码
8
    }
9
    System.out.println("条件不满足时才执行到这里");
10
}

等价于 C 里用 goto 提前跳出，但只允许”从块内退出”，方向被限定，不会乱跳。

最后一条硬性规则：break / continue 只能跳到”包着它”的标签——标签标记的语句必须在词法上包含当前语句。站在块里面才能”跳出去”，站在外面就不能”跳出”这个块，编译器直接报错：

1
outer:
2
{
3
    break outer;   // ✅ 合法：break 在块内部
4
}
5
break outer;       // ❌ 编译错误：已经在块外面了

这一节最容易踩的坑（都是相对 C 的新东西）：

continue 会跳过循环体里的更新语句——for 安全（i++ 在循环头部，continue 跳回时自动执行）；while 危险（更新写在循环体里，continue 直接跳回条件判断，把更新跳过了 → 可能死循环）
带标签的 continue 不保存状态——跳到外层循环的下一轮，内层循环整体作废、从零开始，不会”接着上次”
标签类型有限制——continue 的标签必须标在循环上；break 的标签可以是循环/块/switch。标错当场编译报错
break outer 跳到标签块之后，不是跳到标签那一行

3.9 大数#

C 没有原生大数：long 上限也就 ±9.2×10¹⁸。Java 提供两个类处理超出范围的数：

BigInteger：任意精度整数
BigDecimal：任意精度小数（适合金额，避免浮点误差）

不能直接用 + - * / 运算符，要调方法：

1
BigInteger a = BigInteger.valueOf(1234567890);
2
BigInteger b = BigInteger.valueOf(9876543210L);
3
BigInteger sum = a.add(b);          // 加
4
BigInteger diff = a.subtract(b);    // 减
5
BigInteger prod = a.multiply(b);    // 乘
6
BigInteger quo = a.divide(b);       // 除

构造要点：

小数值用 BigInteger.valueOf(long) 转换
超大数用字符串构造：new BigInteger("123456789012345678901234567890")——直接写数字字面量会因超出 long 范围编译报错

BigDecimal 常见于金额计算。0.1 + 0.2 用 double 算出来是 0.30000000000000004，用 BigDecimal 精确：

1
BigDecimal d = BigDecimal.valueOf(0.1).add(BigDecimal.valueOf(0.2));
2
// 结果是精确的 0.3

坑：用 BigDecimal.valueOf(0.1) 才是精确的 0.1；new BigDecimal(0.1) 会把 double 的二进制近似值原样带进去，反而”不精确”。

3.10 数组#

声明与初始化：数组是对象，声明只是引用，必须 new 才有实体：

1
int[] a = new int[10];           // 10 个元素，默认 0
2
int[] b = { 1, 2, 3, 4, 5 };     // 花括号直接初始化，不用 new
3
int[] c = { 1, 2, 3, 4, 5, };    // 允许最后位置有逗号

vs C：int a[10] 声明即分配，Java 必须 new。

匿名数组与空数组：new int[] { 1, 2, 3 } 是匿名数组，不赋给变量，直接传给方法用：

1
int sum = sum(new int[] { 1, 2, 3 });   // 匿名数组做参数

new int[0]（或 new int[] {}）是长度为 0 的数组——合法且有用：方法没结果时返回空数组而不是 null，调用方就不用判空了。

数组长度固定，但引用可以换：数组对象一旦创建长度就定死，但变量只是个引用，可以随时指向新数组——这就是”声明和构造分离”的灵活性：

1
int[] a;          // 声明：只是引用，没分配内存
2
a = new int[10];  // 构造
3
a = new int[20];  // 换个更大的（旧数组交给垃圾回收）

要”换大小还保留内容”用 Arrays.copyOf(a, 新长度)（自动拷贝并补零/截断）。对比 C：C 里 int a[10] 声明即定死，想换只能手动 malloc + memcpy + free，还得自己管内存——Java 的”引用可换 + GC 回收”灵活得多。

访问与长度：下标从 0 开始；a.length 是属性（不是函数，C 得 sizeof(a)/sizeof(a[0]) 自己算）。越界抛 ArrayIndexOutOfBoundsException——C 越界是未定义行为，Java 直接拦下来。

for each 循环：遍历数组的简写：

1
for (int x : b) {
2
    System.out.println(x);
3
}

等价于 C 的下标遍历。注意拿到的是元素副本，改 x 不影响原数组；想改元素就用传统 for 加下标。

数组拷贝：= 赋值只是复制引用（两个变量指向同一个数组，改一个另一个也变）；要独立副本用 Arrays.copyOf：

1
int[] same = b;                           // 只是多一个引用，同一数组
2
int[] copy = Arrays.copyOf(b, b.length);  // 深拷贝，新数组
3
int[] first3 = Arrays.copyOf(b, 3);       // 只拷前 3 个

数组排序：Arrays.sort(a) 一行升序排序——C 要么手写排序要么 qsort。

命令行参数：main(String[] args) 对应 C 的 argc/argv。Java 不传 argc（用 args.length），且 args[0] 是第一个用户参数（C 的 argv[0] 是程序名）：

1
public static void main(String[] args) {
2
    System.out.println(args.length);  // 参数个数
3
    System.out.println(args[0]);      // 第一个参数
4
}

多维数组：本质是”数组的数组”。声明 int[][] grid = new int[3][4];，访问 grid[i][j]。

不规则数组（Java 的优势）：每一行长度可以不同，C 的多维数组必须是矩形，Java 可以”锯齿”：

1
int[][] triangle = new int[5][];
2
for (int i = 0; i < 5; i++) {
3
    triangle[i] = new int[i + 1];   // 第 i 行 i+1 个元素
4
}

C 想实现不规则数组得用”指针数组 + 手动管理”，Java 天然支持。

附录#

日期#

java.time 的 LocalDate（不可变日期类）：

1
import java.time.LocalDate;
2

3
LocalDate today = LocalDate.now();          // 今天
4
LocalDate bday = LocalDate.of(2000, 1, 1);  // 指定日期
5

6
bday.plusDays(100);       // 100 天后（返回新对象，原对象不变）
7
bday.getDayOfWeek();      // 星期几
8
bday.until(today);        // 距离今天多少天

和 String 一样，LocalDate 是不可变的：plusDays 返回新对象，不会改原来的。

对比 C：C 标准库没有好用的日期类型（time_t 是秒数，得自己转格式），Java 的 java.time 开箱即用。

小结：Java vs C 对照表#

维度	C	Java
程序结构	自由函数 + main	万物皆类，main 在类内
编译运行	`gcc` → 可执行文件 → CPU 直接跑	`javac` → 字节码 → JVM（解释 + JIT）
内存	手动管理（malloc/free）	自动垃圾回收
整型大小	随平台（int 可能是 2/4 字节）	固定（int 永远 4 字节）
无符号数	有 unsigned	没有（唯一”无符号”的 char 不做算术）
字符串	`char*` / `char[]`	`String` 对象，不可变，`equals` 比内容
数组	下标遍历，`sizeof` 求长	对象，`length` 属性，for-each，越界抛异常
输入输出	`scanf` / `printf` / `FILE*`	`Scanner` / `System.out.printf` / `PrintWriter`
大数	无原生支持	`BigInteger` / `BigDecimal`
布尔	0 / 非 0 当真假	只有 `true`/`false`，`if (1)` 报错
内存安全	野指针、越界家常便饭	引用不能算数，越界即异常
等等

本章收获：C 给你完全控制权（和一堆踩坑机会），Java 帮你管好内存与边界，换来跨平台与安全。 学完这一章，可以用 Java 写出任何 C 能写的基础程序了。

蜂窝版 MacBook：80 块钱让 Mac 直插 4G 卡上网 + 保号接码

Tue, 25 Aug 2026 00:00:00 GMT

一颗大疆无人机拆机的 4G 模块，一条 AT 指令，让你的 MacBook 变成「蜂窝版」——既能独立 4G 上网，还能跑 VoHive 平台控制sim卡接码等功能。全程软件成本 0 元。

写在前面：这不是「破解」，是「切换」#

很多人看到「大疆模块改 EC25」以为是什么高深破解。其实一句话就能讲完：

大疆 4G 模块（一代）本质是移远 Quectel EG25-G，但出厂被大疆写成了私有 USB 身份（VID/PID 2ca3:4006），通用驱动不认。我们要做的，只是发一条厂商本来就支持的 AT 配置指令，把它的 USB 身份从大疆改回标准的移远 EC25（2c7c:0125）：

1
AT+QCFG="usbcfg",0x2C7C,0x0125,1,1,1,1,1,0,0

没有刷固件、没有破解加密、没有改 Mac 任何系统文件——芯片本来就会变多种身份，我们只是让它换回标准的那套。改一次，写进模块 NVRAM，终身有效。

为什么是这颗模块#

便宜：大疆无人机拆机件。最早 3040 元，火了之后被炒到 80 元左右，但依然比一颗全新的移远 EC25（100200 元）便宜。
本质是移远 EG25-G：高通平台，LTE Cat 4，标准 AT 指令集齐全。
被大疆「封印」了身份：所以便宜，也所以要改。

代价是它默认的 USB 身份和模式都不是「标准」的，得手动改一次。

我要实现的两个目标#

Mac 独立 4G 上网（学校WIFI你懂得，不想天天开手机热点）
海外卡保号 / 接码（用 VoHive 平台收发短信、看 SIM 状态，甚至以后做 VoWiFi ）

这两个目标对应模块的两种工作模式，不可兼得：

模式	模块在哪	用途
ECM（`usbnet=1`）	Mac	4G 上网（macOS 原生认）
QMI（`usbnet=0`）	虚拟机	VoHive 接码/保号

这就是后面所有折腾的根源：一颗模块、一根 USB，一次只能干一件事、待在一个地方。

材料清单#

项	成本
大疆 4G 模块（一代）	~80 元
一张有流量的 SIM 卡	自备
UTM（虚拟机）	免费
Ubuntu Server 24.04 arm64	免费

第一步：让 Mac 能上网（改 ID + 切 ECM）#

这一步是一次性的，做完以后模块插上 Mac 就是网卡。

核心就是在 Linux 环境（UTM 虚拟机）里，用 socat 往串口发两条指令：

Terminal window

1
# 改身份：大疆 2ca3:4006 → 移远 2c7c:0125
2
AT+QCFG="usbcfg",0x2C7C,0x0125,1,1,1,1,1,0,0
3
# 切模式：QMI(0) → ECM(1)，macOS 才能认
4
AT+QCFG="usbnet",1
5
# 软重启生效
6
AT+CFUN=1,1

模组重启后弹回 Mac，macOS 原生驱动 AppleUSBECM 直接把它认成一张 USB 网卡，自动拨号（APN cmnet）后就能上网了。

第二步：部署 VoHive（保号/接码）#

VoHive 是面向高通 4G 模组的管理平台，网页端收发短信、看信号、管 eSIM。

这里有个重要的坑：VoHive 上游项目已经无限期停维护了，官方 release 的二进制全被清空（最后的 v9.9.9 是 12 字节的告别占位符）。arm64 的二进制只能去 fork 里挖——我花了点功夫，从三个字节完全一致的 fork 里找回了一份，并交叉验证了 sha256。

踩坑记录（这才是真干货）#

这套东西的教程网上很多，但实测和教程对不上的地方不少，逐个锤下来：

usbnet 映射教程写错了：有篇笔记说 usbnet=2 是 ECM，实测这颗模块 2 是 MBIM、1 才是 ECM。照抄 2 会导致 Mac 死活拿不到网卡。
UTM 的命令行直通是坏的：utmctl usb connect 报 -2700「找不到设备」。翻源码发现是 UTM 对「复合设备」（一个 VID/PID 下面挂多个接口）的匹配 bug，GUI 直通走的是另一条路径所以能通——直通只能手动点。
模组会休眠：AT 口闲置一段时间就睡着，前 1~2 次发 AT 唤不醒，要发到第 3 次才回 OK。所以脚本里找 AT 口必须带重试。
stale 文件坑：往串口写指令时如果设备节点刚好不存在，tee 会在 /dev 下误建一个普通文件，挡住真正的设备节点。得先清掉再 mknod 重建。

最终成果#

三个 shell 脚本 + 一个菜单命令，全在 PATH 里：

Terminal window

1
vohive    # 进入菜单，选 1 保号 / 2 上网 / 3 状态

命令	作用
`vohive` → 1	切保号（QMI / VoHive）
`vohive` → 2	切上网（ECM / Mac 蜂窝）
`vohive` → 3	查状态

结语#

从「一颗插上什么都不认的大疆私有模块」到「Mac 的 4G 网卡 + 保号平台」，总成本不到 100 元。核心认知就一句：这不是破解，是让芯片换回它本来的标准身份。 教程不可靠的地方，实测永远能锤出真相。

通信技术基础：先把这些名词搞懂#

这篇文章的重点其实是借这颗 80 块的模块，把移动通信的底层概念讲清楚。下面按「网络 → 频段 → 身份 → 接口 → 实用功能」的顺序，把文中涉及的所有名词一次补齐。看不懂的实操细节，都能在这里找到答案。

一、什么是 LTE#

LTE（Long Term Evolution，「长期演进」）就是俗称的 4G。 名字本身没有「第四代」的意思，只是 3GPP 给这套标准起的代号——因为它是从 3G（UMTS/WCDMA）一路「长期演进」过来的。

手机通信的「代」是这样排的：

代	技术	能干什么
1G	模拟（AMPS 等）	只能打电话
2G	数字 GSM	打电话 + 短信 + 极慢速上网
3G	UMTS / WCDMA / CDMA2000	能真正上网了
4G	LTE	纯 IP 网络，快
5G	NR	更快、更低时延

LTE 的核心变化是彻底 IP 化：把 2G/3G 那套「电路交换」（打电话专用线路）拆掉，语音、数据全部变成 IP 包。正因如此，4G 时代「打电话」要靠 VoLTE（Voice over LTE，走 IMS 的语音），而不是老线路。

LTE 内部又按能力分 Cat（Category，类别）：Cat 1、Cat 4、Cat 6……数字越大越快。这颗 EG25-G 是 Cat 4：下行最高 150 Mbps、上行 50 Mbps，日常上网、刷视频完全够用。

一句话：LTE = 4G 的标准名；Cat 4 = 这颗模块的「档位」。

二、频段（Band）和频率的关系#

这是新手最容易混的一对概念。

频率：无线电波的物理频率，单位 Hz。比如 1800 MHz、2100 MHz——这是真实存在的物理量。
频段（Band）：3GPP 给每段可用频率统一编了号，比如 Band 3 = 1800 MHz、Band 1 = 2100 MHz、Band 8 = 900 MHz、Band 40 = 2300 MHz。这个编号就是「Band」。
关系：Band 是频率的标准化标签。 说「支持 Band 3」，意思就是「支持 1800 MHz 附近那一段」。

为什么要搞 Band 编号？因为同一个频率范围，各国运营商拿到手的「切片」不一样（上下行差多少、带宽多宽），用编号能精确指代「这一整段」，而不只是「中心频率」一句话。

另外，移动网络大多是 FDD 双工（见下一节）：上行和下行用不同的频率，所以一个 Band 里同时定义了上行段和下行段。比如 Band 3：

上行（手机 → 基站）：1710–1785 MHz
下行（基站 → 手机）：1805–1880 MHz

模块支持的 Band 越多，跨国漫游越稳。EG25-G 标称支持包括国内 B1/B3/B5/B8/B39/B40/B41 在内的多种 FDD + TDD 频段。

三、信道（Channel）#

如果说 Band 是「一整段马路」，信道就是这条马路上划出的一条具体车道。

在 Band 内部，运营商会把频率再切成一个个更窄的「信道」，每个信道一个中心频率、一个编号。
GSM 时代的信道编号叫 ARFCN，LTE 时代叫 EARFCN。手机/模块「搜网」时，就是在逐个扫描信道，看哪个上面有基站的广播信号。
日常使用你几乎不用直接跟信道打交道——模块会自动扫信道、选信道。但当你用工具看「当前驻留的频点」时，看到的那串数字（EARFCN）就是信道编号。

四、FDD 与 TDD：中国和外国的「通信模式」#

这里要澄清一个常见误解：「FDD / TDD」不是「中国模式 vs 外国模式」，而是移动网络最底层的「双工（Duplex）方式」——即「上下行怎么错开，避免自己发出的信号撞上自己收到的信号」。

FDD（频分双工）：上行、下行用两条不同频率，同时进行。像一条双向八车道——去的车走左边、来的车走右边，互不干扰。全球绝大多数 4G 网络、欧美日韩的主流，都是 FDD。
TDD（时分双工）：上行、下行用同一条频率，靠时间轮流切换。像单行道按红绿灯交替放行——这一瞬只发、下一瞬只收。省频谱，但需要精确的时钟同步。

那「中国」特殊在哪？——中国三大运营商是 FDD 和 TDD 混着用的：

运营商	4G 主力制式
中国移动	TDD（Band 38/39/40/41）为主
中国联通	FDD（Band 1/3）为主
中国电信	FDD（Band 1/3/5）为主

（后来三家也都拿到了对方制式的牌照，但历史主力如上。）

所以「中国 FDD」这个说法要拆开看：电信、联通走 FDD，移动走 TDD。 而这颗 EG25-G 频段覆盖够全，FDD / TDD 都支持，插哪家卡都能用——这就是「多频多模」的意思。

顺带一提，「外国」并不构成一个统一模式：欧美主流是 FDD，日本部分运营商也用 TDD。真正该记的维度是 FDD vs TDD，而不是「中国 vs 外国」。

五、三张身份证：IMEI / ICCID / IMSI#

移动网络里最容易搞混的三个 ID，恰好分别对应「设备 / 卡 / 用户」三个东西：

	全称	位数	标识谁	读取方式
IMEI	国际移动设备识别码	15 位	设备（这台模块）	`AT+CGSN`
ICCID	集成电路卡识别码	19~20 位	SIM 卡（那张塑料卡）	卡面印着 / `AT+QCCID`
IMSI	国际移动用户识别码	15 位	用户/账户（运营商开的户）	存 SIM 里 / `AT+CIMI`

拆开讲：

IMEI：设备的身份证。厂家出厂烧进去，标识这台硬件唯一。丢手机可以去运营商报失，按 IMEI 把设备拉黑变砖。这颗模块的 IMEI 也能改（AT+EGMR），那是另一个话题。
ICCID：SIM 卡的身份证。每张卡出厂就印了唯一编号，直接印在卡面上那串长数字就是。换卡 = 换 ICCID。
IMSI：账户的身份证。格式 = MCC（国家码，3 位，中国 460）+ MNC（运营商码，2~3 位，移动 00 / 联通 01 / 电信 03，各自还有备用码）+ MSIN（用户号）。网络靠它判断「你是谁、该用谁的套餐」。

一句话记法：IMEI 认设备，ICCID 认卡，IMSI 认人。 换卡不换机，IMSI/ICCID 变、IMEI 不变；换机不换卡，IMEI 变、IMSI/ICCID 不变。

六、模块的四种「工作模式」#

模块和电脑靠 USB 相连，但「USB 上跑什么协议、数据以什么形态出来」有几种可选。这就是 AT+QCFG="usbnet",x 里那个 x 的含义。这颗 EG25-G 支持这四种（usbnet 的取值）：

usbnet	模式	全称	出来的是	谁在用
0	QMI	Qualcomm MSM Interface	高通私有二进制接口	Linux / ModemManager
1	ECM	Ethernet Control Model	一张标准「USB 网卡」	macOS 原生认（本文上网用）
2	MBIM	Mobile Broadband Interface Model	现代 USB 宽带标准接口	Windows 10+ / 新版 Linux
3	RNDIS	Remote NDIS	微软风格的「USB 网卡」	老 Windows / Android

关键区别：

ECM / RNDIS / MBIM 这三类，模块会把蜂窝网络「伪装成一张以太网卡」交给电脑。电脑不用懂 4G，只要会认网卡、会 DHCP 拿 IP 就能上网。区别只在「伪装手法」：ECM 是通用标准（macOS 认），RNDIS 是微软家的，MBIM 是最新最规范的通用标准。
QMI 不是网卡，而是高通芯片的原生控制接口（二进制协议）。它比「网卡」暴露得更多、控制力更强，所以 VoHive 这类要深度管理模块的平台走 QMI。

这就是「一颗模块一次只能选一种身份」的原因：选了 ECM 就是「网卡」，选了 QMI 就是「管理接口」，两者不能同时是。（另外还有一堆 ttyUSB 串口是 AT 命令口，见下——它们与这四种「数据模式」并存，不冲突。）

七、两种「管理模式」：AT 和 QMI——你怎么指挥这颗芯片#

上一节讲「数据怎么出来」，这一节讲「你怎么命令它」。有两套截然不同的「遥控器」：

	AT 命令	QMI
形态	文本指令，人可读	二进制协议，机器读
通道	串口（某个 `ttyUSB`）	USB 的 `cdc-wdm` 设备
例子	`AT+CSQ` 查信号、`AT+QCFG` 改配置	libqmi 库 / ModemManager 调用
优点	简单、通用、能手敲	强大、结构化、能做的事多
谁用	我们（脚本里 `socat` 发的那几条）	VoHive、ModemManager

AT 命令：脱胎于老式调制解调器的「Hayes 指令集」，一行行 AT+... 文本。开头那两条 AT+QCFG 就是 AT 命令。它几乎成了所有蜂窝模组的「通用普通话」——别看形式简单，能做的事其实极多：ATD10086; 拨号打电话、ATA 接电话、ATH 挂电话、AT+CMGS 发短信、AT+CNMI/AT+CMGR 收/读短信、AT+CSQ 查信号、AT+CUSD 拨 USSD、AT+VTS 发 DTMF……整颗模组从打电话到收发短信，几乎每个动作都能用一行文本命令搞定。它唯一的「限制」是形式：一次一条、逐条来。
QMI：高通芯片的私有二进制接口，功能远强于 AT——能并发、结构化地读网络状态、注册事件监听、管理数据通路。代价是复杂，得靠 libqmi 这类库调用，人没法手敲。

本文「改身份、切模式」用 AT（一次性配置），「日常接码管理」用 QMI（VoHive 内部），正好体现分工：AT 做一次性配置，QMI 做持续管理。

八、APN 是什么#

APN（Access Point Name，接入点名称）= 你接入互联网时经过的那个「运营商网关」的名字。

手机网络的出口不直接通公网，而是先经过运营商的一个网关。这样的网关有很多个，各干各的活：

上网流量 → 走「互联网 APN」（移动 cmnet、联通 3gnet、电信 ctnet）
彩信 MMS → 走「彩信 APN」（cmwap 之类，现在基本淘汰）
VoLTE/IMS 语音 → 走「IMS APN」（ims）

APN 就是告诉模块：「我要上网，请把我接到叫 cmnet 的那个网关去。」配置里一般还附带用户名/密码（很多国内 APN 是空的）和鉴权方式。

文章里「自动拨号（APN cmnet）」指的就是：模块建立数据连接时，自动用移动的 cmnet 这个 APN 接入互联网。

九、USSD 是什么#

USSD（Unstructured Supplementary Service Data，非结构化补充业务数据）= 你在拨号键盘按 *100# 之后弹出的那种实时代码菜单。

它是一组短代码，走的是网络的信令信道（不是普通数据/语音信道），所以：不联网也能用、几乎零延迟、实时会话式。
典型用途：查话费余额、查流量、充值、开业务。国外运营商（尤其非洲、印度）的 USSD 菜单尤其丰富，甚至用来做移动支付。
和短信 SMS 的区别：SMS 是「存储转发」的异步消息（发出去对方可能晚收到）；USSD 是「实时会话」（你一按，服务器立刻回，像打电话一样一问一答）。

在模块上，USSD 通过 AT+CUSD 发送和接收。VoHive 这类平台就是靠它触发「查余额」这类即时查询的。（具体代码各家运营商不同，*100# 只是示例。）

十、DTMF 通信是什么#

DTMF（Dual-Tone Multi-Frequency，双音多频）= 你打电话按数字键时发出的「嘟—嘟」声的正式名字。

原理：电话键盘每个键按下时，同时发出两个不同频率的正弦波（一个来自「低频组」、一个来自「高频组」），接收端根据「哪两个频率同时出现」判断按了哪个键。两个音叠加，抗干扰、可靠，所以叫「双音多频」。
一共 16 个键：0-9、*、#，外加 4 个备用键 A/B/C/D（普通人用不到）。
用途：拨号；以及打 IVR 自助语音后「请按 1 转人工」——你按的那个「1」，就是通过 DTMF 传过去的。输银行卡密码、身份证号也是 DTMF。这个过程完全由你的拨号APP完成

在模块上，DTMF 用 AT+VTS 发送（主动按一个键）、AT+DDET 接收/检测（识别对方 IVR 传来的按键）。

十一、VoWiFi 是什么#

VoWiFi（Voice over WiFi，WiFi 通话）= 不靠蜂窝信号，用 WiFi 网络打电话、发短信的技术。

传统打电话走蜂窝网络（2G/3G 电路交换，或 4G 的 VoLTE）。VoWiFi 则把语音/短信打包，通过 WiFi → 互联网 → 运营商 IMS 核心网这条隧道来传。
关键：VoWiFi 走的是运营商自家的 IMS 平台，所以用的是你的手机号、按你的套餐计费（甚至免费），对方来电看到的还是你的号码。它不是微信语音那种「App 到 App」的网络电话。
好处：蜂窝信号差（地下室、海外漫游）但 WiFi 好的地方，照样接打电话。
技术上靠 ePDG（演进分组数据网关）：手机先和运营商的 ePDG 建立一条加密的 IPSec 隧道，再在隧道里跑 IMS 语音。

文章里「以后做 VoWiFi」的意思：VoHive 这类高通模组管理平台，理论上能驱动模块走 ePDG 隧道，让这颗 4G 模块/这张卡在 WiFi 环境下也能「打电话」。这是接码保号之外的一个进阶玩法。

Markdown 入门教程：一篇就够了

Mon, 24 Aug 2026 00:00:00 GMT

Markdown 是一种轻量级标记语言，让你专注于写作内容，不能用于排版。下面是最常用的语法速查。

1. 标题语法#

使用 # 号表示标题，几个 # 就是几级标题。

一级标题#

二级标题#

三级标题#

2. 文字强调#

加粗：使用 **文字** 包裹（快捷键 Ctrl+B）
斜体：使用 *文字* 包裹（快捷键 Ctrl+I）
加粗斜体：使用 ***文字*** 包裹
删除线：使用 ~~文字~~ 包裹（表示废弃或修改）

3. 列表结构#

无序列表（使用 - 或 *）#

苹果
- 红富士（子项缩进 2 或 4 个空格）
香蕉

有序列表（使用数字加点）#

第一步
第二步
1. 子步骤

4. 链接与图片#

点击访问百度 https://www.baidu.com

这是一张示例图片

5. 代码块#

三个反引号，指定语言可以实现语法高亮。

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

TARS — 个人 AI 管家

Fri, 21 Aug 2026 00:00:00 GMT

TARS doesn’t remember you. It learns how to work with you.
不保存用户，而是持续学习用户。

这个项目暂时废了，后期准备包装成obsidina插件发布，文档方式交互。#

一、为什么做 TARS#

TARS 的名字来自《星际穿越》中的战术机器人——可靠、直接、偶尔黑色幽默，绝对忠诚。

作为一个 J 人，我一直希望有一个能辅助规划一切、提供最清晰路径的 AI。但使用现有 AI 的过程中发现一个根本问题：缺少人情味。

这种”活人感”的缺失来自哪里？经过深度思考，我认为核心是：AI 没有确定的立场。 它总是站在最普世的角度思考问题。二选一的问题，它给你”最真诚、最不绕弯子的废话”——所有人都知道收益最大化是什么，但你要的不是这个。

TARS 解决两件事：立场不对称（AI 没有你的立场）和被动性（AI 不会主动找你）。

二、什么是立场#

“屁股决定脑袋”。

你的阅历和所处环境决定了你的想法和行动。没有经历过底层互害，就不会认可社会达尔文主义。笑是你最安全的表情，可能是你对不确定性的排斥导致的。不擅长侃侃而谈，可能是因为过去这么做收益不高。所有外界刺激的总和，构成了你的性格、潜意识、表达风格、决策倾向、价值观。

这个世界上没有绝对的傻子——每个人都在自己立场的最大限度内，被多巴胺刺激做出当下最优的选择。立场是人的根本属性。

如何为 AI 赋予立场？ 提示词切换（“你是英语专家”→“你是风水大师”）恰恰说明 AI 没有确定的立场。TARS 的解决方案是：从记忆系统入手。

立场是记忆的产物。我们每天醒来还记得自己叫什么、经历过什么——立场就是从记忆中解释和抽象出来的。推理能力由大模型提供，但立场存续靠的是记忆架构。在大模型推理模式被下一代技术变革之前，记忆系统是我们实现立场模拟的核心路径。

三、记忆系统#

三种存储，各司其职#

存储	存什么	为什么
SQLite	体重/心情/睡眠（时序）、项目状态、事件日志、每日日记、任务、情绪、承诺、偏好、关系、想法、财务 — 共 30 张表	精确查询——“本周体重中位数”、“哪些项目卡住了”、“3 天没更新的指标”
Chroma 向量库	人生档案分段 + 事件摘要的语义索引	模糊回忆——“我之前提过类似的想法吗”、“大学时我是什么状态”
Markdown 文件	人生档案原文（profile/goals/timeline/worldview）	人类可读、随手能改、git 版本跟踪

三者不可互换——SQL 做不了语义检索，向量做不了精确数值查询，文件做不了结构化统计。

每次 tick 的装填过程#

TARS 不是常驻进程。每次被 macOS 快捷指令或 tars 命令”踹”一脚，Docker 容器启动，从三种存储里拼出一张 ~3500 字的上下文快照喂给 LLM：

1
tars 命令触发容器
2
  │
3
  ├─ 1. 读 Markdown 文件
4
  │     profile.md → "我是谁"
5
  │     goals.md → "我要去哪"
6
  │     worldview.md → "我戴什么眼镜看世界"
7
  │
8
  ├─ 2. 查 SQLite
9
  │     metrics → 体重/心情/睡眠最新值
10
  │     entities → stuck 项目
11
  │     events WHERE pending → 悬而未决的事
12
  │     diaries LIMIT 7 → 近一周摘要
13
  │
14
  ├─ 3. 语义检索 Chroma（基于当前任务）
15
  │
16
  ├─ 4. 拟合 Self Model（行为 vs 声明 gap）
17
  │     条件化规则（IF deadline<3天 THEN 执行力91%）
18
  │
19
  └─ 5. 拼成 system prompt → LLM

展开收起

记忆生命周期#

events 表的 lifecycle 字段控制四态流转：

1
你说"在考虑换工作"
2
  → TARS 写入: event(kind=decision, lifecycle=pending)
3

4
下次 check-in，TARS 查: SELECT * FROM events WHERE lifecycle='pending'
5
  → 主动问："换工作的事有结论了吗？"
6

7
你说"决定再待一年"
8
  → TARS 更新: UPDATE events SET lifecycle='resolved'
9
  → resolved 不再出现在"待追踪"列表
10

11
三个月后你思考职业规划
12
  → RAG 语义召回 → "三个月前你决定再待一年，现在需要重新评估吗？"

pending 留在眼前催你决断，resolved 沉入向量库等待语义召回，fact 和 preference 永远留档。 每天 200 字日记摘要提供”最近发生了什么”的最小上下文。30 天前的日记合并为月摘要——旧的没丢，只是压缩了。

会话间的记忆传递#

TARS 每次醒来不是同一个进程，而是一个全新的 LLM 会话。它之所以感觉有记忆，是因为上一次的 TARS 在退出前调了 save_session——写了日记摘要、更新了实体状态、标记了已解决的 pending。下一次的 TARS 读到这些，就像读到了自己上一次留下的笔记。

四、六层能力栈#

1
Evidence Capture   → 不可变记录。用户说了什么、做了什么、情绪如何
2
Behavior Understanding → 条件化 IF-THEN 规则。不是人格标签，是行为规律
3
Prediction & Learning    → 预测→现实打脸→校准→Meta Learning（曾被推翻的假设未来自动降权）
4
Self Model Evolution     → 月度快照 + 变化速率 + Plasticity（可塑性）
5
Interaction Policy       → Agent 根据对用户的理解调整自己的行为——deadline驱动的人自动拆小目标
6
Adaptive Response        → 不只是理解用户，是学会怎么跟用户协作

五、Intent Parser — 意图分类#

每条消息进入 TARS 时，LLM 先判断它属于什么行为类型，然后走对应通道。

核心边界：问题是关于外部世界的，还是关于用户自己的。

行为类型	例子	lifecycle	后续
emotional_release	“操他妈的""好焦虑”	fact	记情绪。check-in 时泛问恢复，不追问单条
commitment	“我要考雅思""明天学英语”	pending	创建承诺 + 预测成功率。check-in 追问
decision	“要不要读研”	pending	记决策点。季度回顾
self_reflection	“为什么我总拖延”	pending	记自我认知。触发 Self Model 更新
curiosity	“地球为什么是圆的”	fact	回答。不主动追问
meta_cognition	“为什么我总犹豫”	pending	提假设。check-in 跟进
idea_capture	“我突然想到一个产品”	fact	存 Idea 库。90天不提自动归档
data_log	“52kg""背了200单词”	fact	记时序数据。不追问
memory_recall	“我之前是不是说过”	fact	检索旧记忆
identity_question	“你觉得我是怎样的人”	fact	即时回答 Self Model
casual	“哈哈哈""好累""吃饭去了”	fact	只存。默认兜底通道

默认规则：拿不准 → casual → fact → 只存不追问。不丢数据。

六、运行时模型#

TARS 不常驻后台。macOS 快捷指令定时踹，Docker 容器按需启动。

1
你的 MacBook
2
  ├─ 7:00  快捷指令踹 → 生成内参 PDF → 发邮件
3
  ├─ 21:00 快捷指令踹 → 晚间 check-in → Telegram 追问
4
  └─ 随手踹 → 拉 Telegram 消息 → 有新消息进入即时通信 → 30分钟空闲退出

Telegram 场景：你在外面用手机发消息给 TARS bot → 消息在 Telegram 服务器排队 → 回家 MacBook 被踹 → TARS 拉回来处理。

8 个 CLI 命令，tars 封装所有 Docker 参数：

1
tars         日常踹一脚
2
tars setup   安装引导
3
tars talk    对话模式（rich 渲染 Markdown，方向键正常）
4
tars check   系统自检
5
tars pack    打包备份
6
tars migrate 生成完整迁移包（镜像+数据+配置一把带走）

七、技术架构#

组件	选型
LLM	Anthropic SDK + DeepSeek 兼容端点
数据库	SQLite + SQLAlchemy — 30 张表
向量	Chroma + BAAI/bge-small-zh-v1.5
Telegram	python-telegram-bot getUpdates
PDF 报告	Markdown + Jinja2 + WeasyPrint + Noto CJK
终端渲染	rich（Markdown 渲染）+ readline（方向键）
容器	Docker
调度	macOS 快捷指令 + task_dispatcher
版本控制	GitPython + git

代码规模：~6400 行 Python，83 个 MCP 工具，12 条定时任务。

八、定时任务 — Memory 自己生长#

1
凌晨 2:00  nightly  推理验证 + 假设审查 + 归档 + 衰减 + 冲突检测
2
凌晨 3:00  weekly   周模式 + 情绪趋势 + 压缩
3
凌晨 4:00  monthly  月特质 + 行为指标 + 交互策略更新 + Self Model 快照
4
凌晨 5:00  quarterly 季度行为统计 + worldview gap + Plasticity
5
早上 7:00  内参报告 PDF → 邮箱
6
晚上 21:00 check-in  注意力预算 + drift 追问 + 冲突提醒

补跑机制：MacBook 睡眠错过了凌晨任务 → 开机后第一次 tick 自动检测并补跑。不会静默跳过。

九、自我进化#

TARS 可以修改自己的代码。write_file、edit_file、register_task、run_command、git_revert 都在 MCP 工具里。

1
用户说"帮我每天十点提醒喝水"
2
  → TARS 写新工具文件到 layer1/tools/
3
  → 注册定时任务到 tasks.yaml
4
  → git commit
5
  → 下次 tick 自动加载生效
6
  → 改坏了就 git_revert 回滚

内核（layer0）也可修改——安全网是 git，不是权限墙。

十、安装#

Terminal window

1
cd ~/life-agent
2
bash scripts/bootstrap.sh
3
docker build -t life-agent .
4
bash scripts/install.sh
5
tars setup
6
tars talk

前置条件：Docker Desktop、Telegram + API、Telegram bot token。

【小白向】Mac设备音响排查记（扬声器不定时吱吱响破音

Fri, 21 Aug 2026 00:00:00 GMT

最近我的Macbook（M1 pro）不知道为什么，六扬声器在播放声音的时候会莫名有吱吱、噗噗的声音，关键的是响一下就没事了，还不能被手动复现，尤其在突然关闭正在播放声音的标签页、或者播放音量很高时，这种声音很恶心。起初我以为是我玩城市天际线，其内置的unity引擎音频流不兼容，玩的时候吱吱响把音响振膜搞坏了，但在进入安全模式后扬声器又正常了，气爆了，把驱动、Edge、后台进程都检查了个遍，最后发现是Todesk在安装时，也会装一个音频驱动运行在后台，与 macOS 的原生音频核心（Core Audio）存在兼容性问题，尤其是在音频流启动/停止的瞬间。以下是排查修复Mac设备扬声器的一个大概的流程，供各位参考思路，毕竟去线下店或者重装系统代价都不小：

1.重启，（若还有则直接下一步）
2.重启Mac按住 Shift 键直到登录界面，进入安全模式，如果安全模式下完全正常，即可 100% 确定是软件/驱动冲突，而非硬件损坏。（硬件损坏直接做好掏钱的准备吧）

3.终端执行sudo lsof | grep -i "coreaudio"查看音频驱动占用，寻找任何非苹果的驱动文件（.driver）。（在我的案例中，输出显示了 /Library/Audio/Plug-Ins/HAL/ToDeskOutputDriver.driver，这就是元凶）
4.检查系统扩展列表systemextensionsctl list,检查有无audio、virtual、loopback等第三方扩展。
5.在音频MIDI设置中，任何其他多余的虚拟设备都可能是冲突源

6.卸载相关软件，（比如我的Todesk）
7.在/Library/Audio/Plug-Ins/HAL/目录下，删除陌生的.driver文件
8.终端执行sudo killall coreaudiod
rm -rf ~/Library/Preferences/com.apple.audio.*
rm -rf ~/Library/Caches/com.apple.audio.*然后重启

Mac毕竟用户基数少，一般的软件bug修复周期就很缓慢，(比如城市天际线的音频兼容问题至今未修复)。如果还有问题，还是得跑线下啦

博客园同名 https://www.cnblogs.com/snyxz/

这大概是我干过最逆天的事

Thu, 02 Jul 2026 00:00:00 GMT

如题，这条内容曾经拿到了上千浏览和几百点赞，今天重新写一遍，用现在的眼光回看23年。

原文发布于 QQ 空间，点击查看原文）

背景#

大概是高二，学校统一使用科大讯飞的所谓“AI辅助课堂教学“——每人发一台平板，深度定制 ROM。叫定制其实不算，说是阉割更准确：没浏览器，没原生系统设置，没文件管理器。相册只能看照片，视频播放器直接被砍了。本质上就是一台只能做题和交作业的电子砖头。

突破口#

我没事就翻预装软件，主页一个叫 GeoGebra 的东西很受学生追捧，官方说法是“数学动态画图工具”，数学好的考完试拿它研究最后一道大题，数学差的干脆直接用它当计算器，但我点进去就看出来了—这玩意儿是网页套壳的，很多时候这种非原生软件一眼就能看出来，同时用起来手感顿顿的大概率就是Electron、Tauri此类封装方案，但GeoGebra直接演都不演——纯WebView 套壳。

1
window.open("https://www.bing.com")

跳不出去。系统把 http/https 协议全封了CONNECTION_REFUSED，底层WebView 被魔改。而且输入框有过滤，输入直接吞字或者干扰。

柳暗花明#

第一处：键盘输入会被拦截，可以使用剪切板粘贴，从别处复制粘贴进来不走那条拦截逻辑，最后多输一个回车正好被吞掉，只剩下正确逻辑。

第二处：http不通，那就弃帅保车，使用file协议访问本地文件，好在我大概摸索出 Linux/Android 的目录结构了。

1
window.open("file:///storage/emulated/0/")

原生文件目录直接打开了，我欣喜若狂。能看到文件名、层级导航、文件大小。视频点进去，调用WebView就放了。

今日回首#

ifly的工程师大概是这么想的：把浏览器干掉、把 http/https 封掉、把输入拦截做好，学生就没办法了。

但他们漏了两件事：

WebView 本质上是浏览器。你可以不让它上网，但它读本地文件的权限是 Android 沙箱赋予的，不是 ROM 说了算的。
file 协议不需要网络权限，只读本地存储，你在 WebView 层面拦不住。

说穿了就是攻击面分析的问题：只封了网络层，没考虑本地文件系统层。

引爆#

我把方法整理成教程发到博客，顺手投稿到了表白墙，直接引爆——几百点赞，上千浏览，评论区全是”配享太庙”、“哥你是电教之神”之类，一时之间，风光无量。

开学第一周，级部广播直接点名diss：“我们级部还有个技术高手，掌握了比较高的计算机技术，破解出平板看视频的功能”。

随后发生的事，果不其然超出了我的控制范围，一开始可能只是传着看视频消遣，但后面有人用这个方法在家翻录电影、在宿舍熬夜追剧——一个数学画图工具被用成了娱乐终端。即便我在原博客郑重声明滥用的后果，失控的范围依旧远大于控制的成本，下架就成了唯一的选择。

没制裁我。但说实话，这件事我一直有点愧疚在心。

GeoGebra 是个好软件。数学课上用它画函数图像、做几何演示，确实比课本上的静态图直观太多。我用了快两年，很熟悉它的每一个角落——也正因如此，才看出它是网页套壳。讽刺的是，正因为我太了解它，才让它从全校平板上消失了，后面几届的学弟学妹连用都用不上了。技术上是我的一个高光时刻，但结果上，我带走的远比带来的多。

如果重来一次，我大概还是会发现那个漏洞——一个 WebView 套壳的应用放在一个对计算机充满好奇的高中生手里，这是迟早的事。但我可能不会把教程发到论坛上。

不过换个角度想，这件事之后我开始系统地研究前沿相关的技术，也学会了从”攻击面”的角度去审视一个系统的设计。某种意义上，它比我任何一门课给我的东西都多。

CC操作手册

Tue, 30 Jun 2026 00:00:00 GMT

一、Claude Code是如何工作的？#

Claude Code CLI可以直接api通信，如果是background任务则借助Daemon程序完成会话管理、agents池管理，定时任务等，Daemon开机自启后台活跃，终端内看到的是cli界面，bg任务控制权完全交给Daemon完成。

二、会话的管理#

claude code cli启动agent，默认kind是interactive branch后从当前节点复制出一份，分叉出独立会话 clear源对话归档，就地开启新对话 ba ckground后kind被标记为bg，控制权完全交由daemon exit正常结束，归档进project claude rm删的渣都不剩

三、存储结构#

一共四种记忆方式

history.jsonl 保存全局命令和用户prompt
projects/dir/id.jsonl 按项目隔离完整对话
projects/dir/memory/ 按项目隔离，自动注入新会话
安装目录CLAUDE.md 全局指令注入，项目级CLAUDE.md优先级更高

项目目录~/.claude/projects/ 内 -Users-wjh/ ← 你的项目之一 {id}.jsonl ← 每个会话的完整转录 memory/ ← 跨会话项目记忆（MEMORY.md + 各记忆文件）

根目录~/.claude/内 sessions/ ←当前活跃会话的元数据（pid、状态） session-env/ ← 每会话环境变量（残留，可清） shell-snapshots/ ← Shell 状态备份 file-history/ ← 文件修改前快照（用于 undo） backups/ ← settings.json 写前备份 plugins/ ← 已安装插件 settings.json ← 全局设置（主题、模型、权限） settings.local.json ← 本地覆盖（不参与同步） CLAUDE.md ← 全局指令（每次会话注入） history.jsonl ← 命令历史（↑ 键回溯） stats-cache.json ← 使用统计

四，Agent系统#

主对话（main agent）可派出子代理（sub-agent）最多派分出5层，子代理之间互不认识，只能通过接任务→交结果沟通一共有三级权限： Allow → 直接执行 Ask → 弹窗等你批准 Deny → 绝对不执行

五、对话内命令#

/init 扫描一遍项目目录，生成CLAUDE.md文件 /help General / Command / Custom Command三个界面显示不同的命令和快捷键的用法 /context 显示可视化不同上下文tokens占比，包括系统提示词、工具调用等 /config 总控面板，主题、权限、hook都在里面 /usage 显示token总用量和花费 /status 显示claude code版本、模型、目录和等基本信息 /recap 生成当前会话一句话摘要，走神回来快速回忆 /export 导出对话为纯文本，加文件名直接保存：/export 开发记录.txt /clear 归档原上下文，新开一个本项目空对话 /resume 恢复本项目已经归档的上下文文件 /compact 压缩上下文，在原来基础上压缩，context满时也会自动触发 /btw 单独开一个小对话，复制当前上下文到新session，之后完全独立，除非fork，无法调用工具 /copy 复制agent上一条输出 /diff 交互式 diff 查看器，检查未提交的代码改动，跟git协作使用 /insights 生成个人全局使用分析报告（HTML），含习惯分析、建议、未来工作流 /review 跟github协作，审查pr的效率质量，告诉你哪有毛病 /ultrareview 跟github协作，更狠地告诉你哪有毛病，更贵 /simplify 跟github协作，不废话，直接动手改 /plan 进入plan模式，只能看代码、搜索，不能改文件、不能运行非只读命令 /goal 进入goal模式，不再问要不要继续，不达目标誓不停止。中途/goal查看进度，/goal clear停止 /loop 举例：/loop 5m 检查一下部署状态，每5分钟daemon自动来一句发到对话里，/loop检查进度，/loop clear停止 /rewind 回退上文，注意只能在同一个对话文件内，包括三种 1. Restore conversation：对话和文件改动一起回到所选节点，节点之后的内容全部丢弃 2. Summarize from here：不改动文件，把所选节点之后的对话压缩成摘要，后面聊岔了但还想继续聊 3. Summarize up to here：不改动文件，把所选节点之前的对话压缩成摘要，前面太长，只想留最近清晰上下文 /branch 新建分支对话文件，注意不能用rewind，完全等于/fork /model 选择模型和思考力度（5档） /effort 只能调整思考力度 /fast 要求服务器加急处理推理，更贵 /mcp 管理mcp连接，接入外部服务 /plugin 插件市场，插件就是可以包含多个skill+主题+hooks的套件（hook是触发器，可以在agent工具调用前，会话启停时，停下来等等时设置跑命令，比如设置改文件前，先自动跑语法检查） /skills 管理接入的skill /rename 重命名当前对话 /background 把当前回话扔到后台，注意这是不可逆的，当前对话kind被标记为background，在claude agents中管理 /agents 显示当前会话内派出的子代理，涉及到复杂情景如并行搜索、独立出去干脏活累活时派出或者明确要用子代理去工作 /tasks 显示当前对话里正在跑的后台任务 /exit 关闭当前对话以及子代理

六、终端命令#

claude —bg “任务” 一步启动后台会话 claude —resume 直接恢复上次会话 claude —safe-mode 安全模式，禁用所有自定义项 claude agents 列出/管理所有后台会话 claude rm │ 删除指定会话 claude —print “任务” │ 非交互模式，输出结果到 stdout

[第2章 2.2e1] Palindromes

Sat, 27 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
bool solve(){
6
    string str;
7
    cin>>str;
8
    ll len=str.size();
9
    for(ll i=0;i<len;i++){
10
        if(str[i]!=str[len-i-1])return false;
11
    }
12
    return true;
13
}
14
int main(){
15
    ll t;
16
    cin>>t;
17
    while(t--){
18
        if(solve())cout<<"yes"<<endl;
19
        else cout<<"no"<<endl;
20
    }
21
    return 0;
22
}

展开收起

[第2章 2.2t1] Subsequence

Sat, 27 Jun 2026 00:00:00 GMT

1
2

[第1章 1.1e1] 约瑟夫问题

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意使用erase操作后赋值一定要判断迭代器合法性
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
void solve(){
6
    ll n,m;
7
    cin>>n>>m;
8
    list<ll> nd;
9
    ll nn;
10
    for(ll i=1;i<=n;i++)nd.push_back(i);
11
    ll st=nd.size();
12
    auto it=nd.begin();
13
    while(nd.size()>0){
14
        for(ll i=0;i<m-1;i++){
15
            it++;
16
            nn=*it;
17
            if(it==nd.end())it=nd.begin();
18
        }
19
        if(nd.size()!=st)cout<<" ";
20
        cout<<*it;
21
        it=nd.erase(it);
22
        if(it==nd.end())it=nd.begin();
23
    }
24
    cout<<endl;
25
}
26
int main(){
27
    solve();
28
    return 0;
29
}

展开收起

[第1章 1.1t1] 队列安排

Fri, 26 Jun 2026 00:00:00 GMT

1
//使用结构体数组模拟链表，节省查找时间，实在是高
2
//注意初始化中需要一个虚拟0位置作为全链条最左侧或最右侧
3
#include <bits/stdc++.h>
4
using namespace std;
5
typedef long long ll;
6
const ll MAXN=1e5+5;
7
struct node{
8
    ll l,r;
9
    ll d;
10
}m[MAXN];
11
void solve(){
12
    ll n;
13
    cin>>n;
14
    m[1].d=1;
15
    m[1].l=0,m[1].r=0;
16
    m[0].d=0;
17
    m[0].l=0,m[0].r=1;
18
    for(ll i=2;i<=n;i++){
19
        ll k,p;
20
        cin>>k>>p;
21
        if(p==0){
22
            m[i].r=k;
23
            m[i].l=m[k].l;
24
            m[m[k].l].r=i;
25
            m[k].l=i;
26
        }else{
27
            m[i].l=k;
28
            m[i].r=m[k].r;
29
            m[m[k].r].l=i;
30
            m[k].r=i;
31
        }
32
        m[i].d=1;
33
    }
34
    ll nn;
35
    cin>>nn;
36
    for(ll i=0;i<nn;i++){
37
        ll x;
38
        cin>>x;
39
        m[x].d=0;
40
    }
41
    ll now=m[0].r;
42
    while(now!=0){
43
        if(m[now].d){
44
            if(now!=m[0].r)cout<<" ";
45
            cout<<now;
46
        }
47
        now=m[now].r;
48
    }
49
    cout<<endl;
50
}
51
int main(){
52
    solve();
53
    return 0;
54
}

展开收起

[第1章 1.2e1] 机器翻译

Fri, 26 Jun 2026 00:00:00 GMT

1
//666小数据直接哈希加速，避免了遍历
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
queue<ll> qq;
6
vector<ll> hh(1010,0);
7
int main(){
8
    ll m,n;
9
    cin>>m>>n;
10
    ll cnt=0;
11
    for(ll i=0;i<n;i++){
12
        ll t;
13
        cin>>t;
14
        if(!hh[t]){
15
            hh[t]=1;
16
            qq.push(t);
17
            cnt++;
18
            while(qq.size()>m){
19
                hh[qq.front()]=0;
20
                qq.pop();
21
            }
22
        }
23
    }
24
    cout<<cnt<<endl;
25
    return 0;
26
}

展开收起

[第1章 1.2e2] 单调队列-滑动窗口

Fri, 26 Jun 2026 00:00:00 GMT

1
//666模拟了个优先队列，让这个队列头存当前最值
2
//但队列内存的是位置，便于比较和输出
3
//超出窗口后自动删掉前面多余部分
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
vector<ll> a;
8
int main(){
9
    ll n,k;
10
    cin>>n>>k;
11
    vector<ll> a(n);
12
    for(ll i=0;i<n;i++)cin>>a[i];
13
    deque<ll> lo;
14
    bool fla=false;
15
    for(ll i=0;i<n;i++){
16
        while(!lo.empty()&&a[lo.back()]>a[i])lo.pop_back();
17
        lo.push_back(i);
18
        if(i>=k-1){
19
            while(!lo.empty()&&i-lo.front()>=k)lo.pop_front();
20
            if(fla)cout<<" ";
21
            cout<<a[lo.front()];
22
            fla=true;
23
        }
24
    }
25
    cout<<endl;
26
    lo.clear();
27
    fla=false;
28
    for(ll i=0;i<n;i++){
29
        while(!lo.empty()&&a[lo.back()]<a[i])lo.pop_back();
30
        lo.push_back(i);
31
        if(i>=k-1){
32
            while(!lo.empty()&&i-lo.front()>=k)lo.pop_front();
33
            if(fla)cout<<" ";
34
            cout<<a[lo.front()];
35
            fla=true;
36
        }
37
    }
38
    cout<<endl;
39
    return 0;
40
}

展开收起

[第1章 1.2e3] Max Sum

Fri, 26 Jun 2026 00:00:00 GMT

1
//hdu1003最大字段和问题，以下为贪心解法，注意累计值大于历史最大值时更新左右边界
2
//也可以使用dp，先赋值为初始值，计算包括当前位置与之前的和，大于当前值则要前面的，否则左边界右移
3
//若大于历史最大值，更新边界，一定要注意区间不要带上产生最小值位置
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
void solve(ll ca){
8
    ll n;
9
    cin>>n;
10
    vector<ll>a(n+2);
11
    for(ll i=1;i<=n;i++)cin>>a[i];
12
    ll sum=0;
13
    ll l=1;
14
    ll a1=1,a2=1;
15
    ll ma=a[1];
16
    ll mi=0;
17
    for(ll r=1;r<=n;r++){
18
        sum+=a[r];
19
        ll cal=sum-mi;
20
        if(cal>ma){
21
            ma=cal;
22
            a1=l;
23
            a2=r;
24
        }
25
        if(sum<mi){
26
            mi=sum;
27
            l=r+1;
28
        }
29
    }
30
    cout<<"Case "<<ca<<":"<<endl;
31
    cout<<ma<<" "<<a1<<" "<<a2<<endl;
32
}
33
int main(){
34
    ll t;
35
    cin>>t;
36
    for(ll i=1;i<=t;i++){
37
        if(i!=1)cout<<endl;
38
        solve(i);
39
    }
40
    return 0;
41
}

展开收起

[第1章 1.2t1] 求m区间内的最小值

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意密集使用到endl，就需要像以下这样加速
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,m;
8
    cin>>n>>m;
9
    vector<ll> a(n+1);
10
    deque<ll> dq;
11
    cout<<0<<'\n';
12
    for(ll i=1;i<=n;i++)cin>>a[i];
13
    for(ll i=1;i<n;i++){
14
        while(!dq.empty()&&a[dq.back()]>a[i])dq.pop_back();
15
        dq.push_back(i);
16
        while(!dq.empty()&&i-dq.front()>=m)dq.pop_front();
17
        cout<<a[dq.front()]<<'\n';
18
    }
19
    return 0;
20
}

展开收起

[第1章 1.2t2] 扫描

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意不要越界和while循环
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,k;
8
    cin>>n>>k;
9
    vector<ll> num(n+5);
10
    for(ll i=1;i<=n;i++)cin>>num[i];
11
    deque<ll> dq;
12
    for(ll i=1;i<=n;i++){
13
        while(!dq.empty()&&num[dq.back()]<num[i])dq.pop_back();
14
        dq.push_back(i);
15
        if(i>=k){
16
            while(!dq.empty()&&i-dq.front()>=k)dq.pop_front();
17
            cout<<num[dq.front()]<<'\n';
18
        }
19
    }
20
    return 0;
21
}

展开收起

[第1章 1.2t3] 切蛋糕

Fri, 26 Jun 2026 00:00:00 GMT

1
//没想到使用队列，建立一个sum累计数组，注意不要i==dq.front否则出现0污染结果
2
//每增加一个位置，要先检查大小，在运用窗口极小值算出最大值，同ans更新
3
//同时检测用当前值将dq更新成小于它的队列，保证单增，开始位置最小
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    ll n,m;
9
    cin>>n>>m;
10
    ll a;
11
    vector<ll> sum(n+3,0);
12
    for(ll i=1;i<=n;i++){
13
        cin>>a;
14
        sum[i]=sum[i-1]+a;
15
    }
16
    deque<ll> dq;
17
    ll ans=-1e18;
18
    dq.push_back(0);
19
    for(ll i=1;i<=n;i++){
20
        while(!dq.empty()&&i-dq.front()>m)dq.pop_front();
21
        ans=max(ans,sum[i]-sum[dq.front()]);
22
        while(!dq.empty()&&sum[dq.back()]>=sum[i])dq.pop_back();
23
        dq.push_back(i);
24
    }
25
    cout<<ans<<endl;
26
    return 0;
27
}

展开收起

[第1章 1.2t4] 好消息坏消息

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题深入理解了两项
2
//1.针对每个窗口要先清整，再推入，最后判断窗口大小
3
//2.使用sum数组可以解决此类涉及到求和的问题
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    ll n;
9
    cin>>n;
10
    vector<ll> a(2*n+2);
11
    for(ll i=1;i<=n;i++){
12
        cin>>a[i];
13
        a[n+i]=a[i];
14
    }
15
    vector<ll> sum(2*n+2);
16
    sum[0]=0;
17
    for(ll i=1;i<=2*n;i++){
18
        sum[i]=sum[i-1]+a[i];
19
    }
20
    deque<ll> dq;
21
    ll ans=0;
22
    for(ll i=1;i<2*n;i++){
23
        while(!dq.empty()&&sum[dq.back()]>=sum[i])dq.pop_back();
24
        dq.push_back(i);
25
        if(i>=n){
26
            while(!dq.empty()&&i-dq.front()>n)dq.pop_front();
27
            if(sum[dq.front()]-sum[i-n]>=0)ans++;
28
        }
29
    }
30
    cout<<ans<<endl;
31
    return 0;
32
}

展开收起

[第1章 1.2t5] 良好的感觉

Fri, 26 Jun 2026 00:00:00 GMT

1
//单调栈问题注意2个stack与a[n]哨兵
2
//前一个确保top可访问，并且初始位置可被计算
3
//第二个确保最后全部位置都被清算，这里设计的很棒
4
//注意要在本轮res计算完成后push
5
#include <bits/stdc++.h>
6
using namespace std;
7
typedef long long ll;
8
int main(){
9
    ll n;
10
    cin>>n;
11
    vector<ll> a(n+2,0),sum(n+2,0),res(n+2,0);
12
    for(ll i=1;i<=n;i++)cin>>a[i];
13
    n++;
14
    stack<ll> st;
15
    st.push(0);
16
    ll ans=0;
17
    for(ll i=1;i<=n;i++){
18
        sum[i]=sum[i-1]+a[i];
19
        while(!st.empty()&&a[st.top()]>a[i]){
20
            ll tp=st.top();
21
            st.pop();
22
            res[tp]+=(sum[i-1]-sum[tp]);
23
        }
24
        res[i]=(sum[i]-sum[st.top()]);
25
        st.push(i);
26
    }
27
    for(ll i=1;i<=n;i++){
28
        ans=max(ans,res[i]*a[i]);
29
    }
30
    cout<<ans<<endl;
31
    return 0;
32
}

展开收起

[第1章 1.2t6] 机器翻译-NOIP

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
queue<ll> qq;
5
vector<ll> hh(1010,0);
6
int main(){
7
    ll m,n;
8
    cin>>m>>n;
9
    ll cnt=0;
10
    for(ll i=0;i<n;i++){
11
        ll t;
12
        cin>>t;
13
        if(!hh[t]){
14
            hh[t]=1;
15
            qq.push(t);
16
            cnt++;
17
            while(qq.size()>m){
18
                hh[qq.front()]=0;
19
                qq.pop();
20
            }
21
        }
22
    }
23
    cout<<cnt<<endl;
24
    return 0;
25
}

展开收起

[第1章 1.2t7] 跳房子

Fri, 26 Jun 2026 00:00:00 GMT

1
//滑动窗口队列+二分+DP
2
//此处二分当模版记住得了
3
//此处j只有在等到满足left后才++，此处把一个区间掰成2步处理很不错，值得借鉴，同时这也是运用队列的原因
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
const ll INF=1e18;
8
ll n,d,k;
9
vector<ll> x,s;
10
bool check(ll t){
11
    vector<ll> gain(n+1,-INF);
12
    deque<ll> dq;
13
    gain[0]=0;
14
    ll j=0;
15
    ll left=max(1LL,d-t),right=d+t;
16
    for(ll i=1;i<=n;i++){
17
        while(j<i&&x[i]-x[j]>=left){
18
            if(gain[j]!=-INF){
19
                while(!dq.empty()&&gain[dq.back()]<gain[j])dq.pop_back();
20
                dq.push_back(j);
21
            }
22
            j++;
23
        }
24
        while(!dq.empty()&&x[i]-x[dq.front()]>right)dq.pop_front();
25
        if(!dq.empty())gain[i]=gain[dq.front()]+s[i];
26
        else gain[i]=-INF;
27
        if(gain[i]>=k)return true;
28
    }
29
    return false;
30
}
31
int main(){
32
    cin>>n>>d>>k;
33
    x.resize(n+1),s.resize(n+1);
34
    for(ll i=1;i<=n;i++)cin>>x[i]>>s[i];
35
    ll r=1e9,l=0;
36
    ll ans=-1;
37
    while(l<=r){
38
        ll mid=(r+l)/2;
39
        if(check(mid)){
40
            ans=mid;
41
            r=mid-1;
42
        }else{
43
            l=mid+1;
44
        }
45
    }
46
    cout<<ans<<endl;
47
    return 0;
48
}

展开收起

[第1章 1.2t8] 琪露诺

Fri, 26 Jun 2026 00:00:00 GMT

1
//跟上一题有异曲同工之妙，把区间掰成两段，先把满足l的入队并排序
2
//接着消除不满足r的元素，使用dp不断计算每个位置的最大收益
3
//最后注意并非每个位置都可退出游戏，需要在合法i位置取最大值
4
//注意窗口主要维护的是j，i只是比较对象
5
#include <bits/stdc++.h>
6
using namespace std;
7
typedef long long ll;
8
const ll INF=-1e18;
9
int main(){
10
    ll n,l,r;
11
    cin>>n>>l>>r;
12
    vector<ll> a(n+1);
13
    vector<ll> gain(n+1,INF);
14
    gain[0]=0;
15
    deque<ll> qq;
16
    for(ll i=0;i<=n;i++)cin>>a[i];
17
    ll j=0;
18
    ll ans=INF;
19
    for(ll i=1;i<=n;i++){
20
        while(i>=j+l){
21
            if(gain[j]!=INF){
22
                while(!qq.empty()&&gain[qq.back()]<gain[j])qq.pop_back();
23
                qq.push_back(j);
24
            }
25
            j++;
26
        }
27
        while(!qq.empty()&&i-qq.front()>r)qq.pop_front();
28
        if(!qq.empty()){
29
            gain[i]=gain[qq.front()]+a[i];
30
            if(i+r>n)ans=max(ans,gain[i]);
31
        }
32
    }
33
    cout<<ans<<endl;
34
    return 0;
35
}

展开收起

[第1章 1.2t9] 小组队列

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,m;
8
    cin>>n>>m;
9
    vector<pair<ll,ll>> a(n);
10
    deque<ll> se;
11
    vector<deque<pair<ll,ll>>> num(300);
12
    for(ll i=0;i<n;i++){
13
        cin>>a[i].first;
14
        a[i].second=i;
15
    }
16
    ll t;
17
    cin>>t;
18
    for(ll i=0;i<t;i++){
19
        string str;
20
        cin>>str;
21
        if(str=="push"){
22
            ll nn;
23
            cin>>nn;
24
            ll na=a[nn].first;
25
      ll nb=a[nn].second;
26
            if(num[na].empty()){
27
                se.push_back(na);
28
            }
29
            num[na].push_back({na,nb});
30
        }else{
31
            ll fr=se.front();
32
            cout<<num[fr].front().second<<endl;
33
            if(num[fr].size()==1){
34
                se.pop_front();
35
            }
36
            num[fr].pop_front();
37
        }
38
    }
39
    return 0;
40
}

展开收起

[第1章 1.3e1] Text Reverse

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll t;
7
    cin>>t;
8
    cin.ignore();
9
    while(t--){
10
        string str;
11
        getline(cin,str);
12
        stack<char> st;
13
        string oo;
14
        for(ll i=0;i<=str.size();i++){
15
            if(str[i]==' '||i==str.size()){
16
                while(!st.empty()){
17
                    oo.push_back(st.top());
18
                    st.pop();
19
                }
20
                if(i==str.size())oo.push_back(' ');
21
            }else st.push(str[i]);
22
        }
23
        cout<<oo<<endl;
24
    }
25
    return 0;
26
}

展开收起

[第1章 1.3e2] Look Up S

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll t;
7
    cin>>t;
8
    vector<ll> h(t+2),ans(t+2);
9
    deque<ll> dq;
10
    dq.push_back(t+1);
11
    for(ll i=1;i<=t;i++)cin>>h[i];
12
    h[t+1]=1e18;
13
    for(ll i=t;i>=1;i--){
14
        while(h[i]>=h[dq.back()])dq.pop_back();
15
        if(dq.back()==t+1)ans[i]=0;
16
        else ans[i]=dq.back();
17
        dq.push_back(i);
18
    }
19
    for(ll i=1;i<=t;i++)cout<<ans[i]<<endl;
20
    return 0;
21
}

展开收起

[第1章 1.3t1] 单调栈-模板

Fri, 26 Jun 2026 00:00:00 GMT

1
//单调栈
2
#include <bits/stdc++.h>
3
#define endl '\n'
4
using namespace std;
5
typedef long long ll;
6
int main(){
7
    ll n;
8
    cin>>n;
9
    vector<ll> ans(n+2),a(n+2);
10
    deque<ll> dq;
11
    a[n+1]=1e18;
12
    dq.push_back(n+1);
13
    for(ll i=1;i<=n;i++)cin>>a[i];
14
    for(ll i=n;i>=1;i--){
15
        while(a[dq.back()]<=a[i])dq.pop_back();
16
        if(dq.back()==n+1)ans[i]=0;
17
        else ans[i]=dq.back();
18
        dq.push_back(i);
19
    }
20
    for(ll i=1;i<=n;i++){
21
        if(i!=1)cout<<" ";
22
        cout<<ans[i];
23
    }
24
    cout<<endl;
25
    return 0;
26
}

展开收起

[第1章 1.3t2] 后缀表达式

Fri, 26 Jun 2026 00:00:00 GMT

1
//直接用ac、bc作为临时数据，出现.完成一次计算
2
#include <bits/stdc++.h>
3
#define endl '\n'
4
using namespace std;
5
typedef long long ll;
6
int main(){
7
    string str;
8
    cin>>str;
9
    deque<ll> dq;
10
    ll ac=0,bc=0;
11
    ll a,b;
12
    for(ll i=0;i<str.size();i++){
13
        auto it=str[i];
14
            switch (it){
15
            case '@':
16
                break;
17
            case '.':
18
                dq.push_back(ac);
19
                ac=bc=0;
20
                break;
21
            case '+':
22
                a=dq.back();
23
                dq.pop_back();
24
                b=dq.back();
25
                dq.pop_back();
26
                dq.push_back(a+b);
27
                break;
28
            case '-':
29
                a=dq.back();
30
                dq.pop_back();
31
                b=dq.back();
32
                dq.pop_back();
33
                dq.push_back(b-a);
34
                break;
35
            case '*':
36
                a=dq.back();
37
                dq.pop_back();
38
                b=dq.back();
39
                dq.pop_back();
40
                dq.push_back(a*b);
41
                break;
42
            case '/':
43
                a=dq.back();
44
                dq.pop_back();
45
                b=dq.back();
46
                dq.pop_back();
47
                dq.push_back(b/a);
48
                break;
49
            default:
50
                ac=bc*10+it-'0';
51
                bc=ac;
52
                break;
53
        }
54
    }
55
    cout<<dq.back()<<endl;
56
    return 0;
57
}

展开收起

[第1章 1.3t3] 表达式括号匹配

Fri, 26 Jun 2026 00:00:00 GMT

1
//小心))((
2
//一定要确保操作数据结构时，是非空状态，否则RE
3
#include <bits/stdc++.h>
4
#define endl '\n'
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    string str;
9
    cin>>str;
10
    stack<char> st;
11
    for(ll i=0;i<str.size();i++){
12
        if(str[i]=='(')st.push('(');
13
        else if(str[i]==')'){
14
            if(st.empty()){
15
                cout<<"NO"<<endl;
16
                return 0;
17
            }
18
            st.pop();
19
        }
20
    }
21
    if(!st.empty())cout<<"NO"<<endl;
22
    else cout<<"YES"<<endl;
23
    return 0;
24
}

展开收起

[第1章 1.3t4] 表达式求值

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    string str;
7
    cin>>str;
8
    ll a=0,b=0;
9
    str.push_back(1);
10
    stack<ll> st;
11
    ll acc=1;
12
    ll ans=0;
13
    for(ll i=0;i<=str.size();i++){
14
        auto it=str[i];
15
        ans%=10000;
16
        acc%=10000;
17
        a%=10000;
18
        b%=10000;
19
        if(it=='+'||i==str.size()-1){
20
            ans+=(acc*a);
21
            acc=1;
22
            a=b=0;
23
            if(i==str.size())break;
24
        }else if(it=='*'){
25
            acc*=a;
26
            a=b=0;
27
        }else{
28
            a=b*10+it-'0';
29
            b=a;
30
        }
31
    }
32
    cout<<ans<<endl;
33
    return 0;
34
}

展开收起

[第1章 1.3t5] 表达式的转换

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
ll power(char a){
6
    if(a=='+'||a=='-')return 1;
7
    if(a=='*'||a=='/')return 2;
8
    if(a=='^')return 3;
9
    return 0;
10
}
11
bool isop(string it){
12
    if(it.size()==1&&string{"+-*/^"}.find(it[0])!=string::npos)return true;
13
    return false;
14
}
15
ll kua(ll a,ll b){
16
    ll ans=1;
17
    while(b){
18
        if(b%2)ans*=a;
19
        b/=2;
20
        a*=a;
21
    }
22
    return ans;
23
}
24
ll ca(ll a,ll b,char c){
25
    if(c=='+')return b+a;
26
    if(c=='-')return b-a;
27
    if(c=='*')return b*a;
28
    if(c=='/')return b/a;
29
    if(c=='^')return kua(b,a);
30
}
31
int main(){
32
    string str;
33
    cin>>str;
34
    vector<string> dq;
35
    deque<char> cal;
36
    for(ll i=0;i<str.size();){
37
        char cnt=str[i];
38
        if('0'<=cnt&&cnt<='9'){
39
            string num;
40
            while(i<str.size()&&('0'<=str[i]&&str[i]<='9'))
41
                num+=str[i++];
42
            dq.push_back(num);
43
            continue;
44
        }else if(cnt=='('){
45
            cal.push_back('(');
46
        }else if(cnt==')'){
47
            while(!cal.empty()&&cal.back()!='('){
48
                string tran=string(1,cal.back());
49
                dq.push_back(tran);
50
                cal.pop_back();
51
            }
52
            if(!cal.empty())cal.pop_back();
53
        }else{
54
            while(!cal.empty()&&cal.back()!='('){
55
                if(power(cnt)<=power(cal.back())&&cnt!='^'){
56
                    dq.push_back(string(1,cal.back()));
57
                    cal.pop_back();
58
                }else break;
59
            }
60
            cal.push_back(cnt);
61
        }
62
        i++;
63
    }
64
    while(!cal.empty()){
65
        dq.push_back(string(1,cal.back()));
66
        cal.pop_back();
67
    }
68
    for(ll i=0;i<dq.size();i++){
69
        if(i!=0)cout<<' ';
70
        cout<<dq[i];
71
    }
72
    cout<<endl;
73
    while(dq.size()>1){
74
        for(ll j=0;j<dq.size();j++){
75
            if(isop(dq[j])){
76
                ll a=stoll(dq[j-1]);
77
                ll b=stoll(dq[j-2]);
78
                ll op=dq[j][0];
79
                dq.erase(dq.begin()+j-2,dq.begin()+j+1);
80
                dq.insert(dq.begin()+j-2,to_string(ca(a,b,op)));
81
                break;
82
            }
83
        }
84
        for(ll j=0;j<dq.size();j++){
85
            if(j!=0)cout<<' ';
86
            cout<<dq[j];
87
        }
88
        cout<<endl;
89
    }
90
    return 0;
91
}

展开收起

[第1章 1.4e1] Entropy-熵

Fri, 26 Jun 2026 00:00:00 GMT

1
//能按照树构建的顺序计算出ans的确没想到
2
//string类不存在访问到边界以外的位置导致内存错误
3
#include <bits/stdc++.h>
4
#define endl '\n'
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    string str;
9
    while(getline(cin,str)&&str!="END"){
10
        sort(str.begin(),str.end());
11
        priority_queue<ll,vector<ll>,greater<ll>> pq;
12
        ll num=1;
13
        for(ll i=1;i<=str.size();i++){
14
            if(str[i]!=str[i-1]){
15
                pq.push(num);
16
                num=1;
17
            }else num++;
18
        }
19
        ll ans=0;
20
        if(pq.size()==1)ans=str.size();
21
        while(pq.size()>1){
22
            ll a=pq.top();
23
            pq.pop();
24
            ll b=pq.top();
25
            pq.pop();
26
            ans+=a+b;
27
            pq.push(a+b);
28
        }
29
        printf("%lld %lld %.1lf\n",str.size()*8,ans,double(str.size())*8/ans);
30
    }
31
    return 0;
32
}

展开收起

[第1章 1.4t1] Safe Or Unsafe

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
bool solve(){
6
    ll n;
7
    cin>>n;
8
    string str;
9
    cin>>str;
10
    sort(str.begin(),str.end());
11
    priority_queue<ll,vector<ll>,greater<>> pq;
12
    ll num=1;
13
    for(ll i=1;i<=str.size();i++){
14
        if(str[i-1]!=str[i]){
15
            pq.push(num);
16
            num=1;
17
        }else num++;
18
    }
19
    ll ans=1;
20
    if(pq.size()==1)ans=str.size();
21
    while(pq.size()>1){
22
        ll a=pq.top();pq.pop();
23
        ll b=pq.top();pq.pop();
24
        ans+=a+b;
25
        pq.push(a+b);
26
    }
27
    if(ans<=n)return true;
28
    else return false;
29
}
30
int main(){
31
    ll t;
32
    cin>>t;
33
    while(t--){
34
        if(solve())cout<<"yes"<<endl;
35
        else cout<<"no"<<endl;
36
    }
37
    return 0;
38
}

展开收起

[第1章 1.4t2] FBI树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
ll len;
6
string ans;
7
vector<ll> num;
8
ll kuai(ll a,ll b){
9
    ll ans=1;
10
    while(b){
11
        if(b%2)ans*=a;
12
        b/=2;
13
        a*=a;
14
    }
15
    return ans;
16
}
17
char cal(ll l,ll r){
18
    if(r==l){
19
        if(num[l])return 'I';
20
        else return 'B';
21
    }
22
    ll mid=(l+r)/2;
23
    char lres=cal(l,mid);
24
    ans.push_back(lres);
25
    char rres=cal(mid+1,r);
26
    ans.push_back(rres);
27
    if(lres==rres&&lres=='I')return 'I';
28
    else if(lres==rres&&lres=='B')return 'B';
29
    else return 'F';
30
}
31
int main(){
32
    ll n;
33
    cin>>n;
34
    len=kuai(2,n);
35
    num.resize(len+1);
36
    for(ll i=1;i<=len;i++){
37
        char c;
38
        cin>>c;
39
        num[i]=c-'0';
40
    }
41
    ans.push_back(cal(1,len));
42
    cout<<ans<<endl;
43
    return 0;
44
}

展开收起

[第1章 1.4t3] 求先序排列

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
void fid(string fr,string be){
6
    if(fr.size()>0){
7
        char root=be.back();
8
        cout<<root;
9
        ll gap=fr.find(root),siz=fr.size();
10
        fid(fr.substr(0,gap),be.substr(0,gap));
11
        fid(fr.substr(gap+1,siz-gap),be.substr(gap,siz-gap-1));
12
    }
13
}
14
int main(){
15
    string fr,be;
16
    cin>>fr>>be;
17
    fid(fr,be);
18
    cout<<endl;
19
    return 0;
20
}

展开收起

[第1章 1.4t4] 新二叉树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<char,char> pll;
6
unordered_map<char,pll> mp;
7
void fid(char pos){
8
    char l=mp[pos].first,r=mp[pos].second;
9
    cout<<pos;
10
    if(l!='*')fid(l);
11
    if(r!='*')fid(r);
12
}
13
int main(){
14
    ios::sync_with_stdio(false);cin.tie(0);
15
    ll n;
16
    cin>>n;
17
    char root;
18
    for(ll i=0;i<n;i++){
19
        char a,b,c;
20
        cin>>a>>b>>c;
21
        if(i==0)root=a;
22
        mp[a]={b,c};
23
    }
24
    fid(root);
25
    cout<<endl;
26
    return 0;
27
}

展开收起

[第1章 1.4t5] 遍历问题

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题可以辅助理解前中后序遍历，前后遍历强调了根的位置，中序遍历强调了子树位置
2
//仅有前后遍历，无法构造确定的树，比如前序AB，后序BA，根都是A但B无法确定在哪个树上
3
//故如果要找树可能的形态就要找形如以上形式的个数，这是造成差异的原因
4
#include <bits/stdc++.h>
5
#define endl '\n'
6
using namespace std;
7
typedef long long ll;
8
int main(){
9
    string s1,s2;
10
    cin>>s1>>s2;
11
    ll ans=0;
12
    for(ll i=0;i<s1.size();i++){
13
        for(ll j=0;j<s2.size();j++){
14
            if(s1[i]==s2[j+1]&&s1[i+1]==s2[j])ans++;
15
        }
16
    }
17
    cout<<(ll)pow(2,ans)<<endl;
18
    return 0;
19
}

展开收起

[第1章 1.4t6] 对称二叉树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include<bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<ll,ll> pll;
6
vector<ll> v;
7
vector<ll> tree;
8
unordered_map<ll,pll> mp;
9
ll count(ll x){
10
    if(x==-1)return 0;
11
    ll l=mp[x].first;
12
    ll r=mp[x].second;
13
    tree[x]=count(l)+count(r)+1;
14
    return tree[x];
15
}
16
bool mirror(ll x,ll y){
17
    if(x==-1&&y==-1)return true;
18
    if(x==-1||y==-1)return false;
19
    if(v[x]!=v[y])return false;
20
    return mirror(mp[x].first,mp[y].second)&&mirror(mp[x].second,mp[y].first);
21
}
22
int main(){
23
    ios::sync_with_stdio(false);cin.tie(0);
24
    ll n;
25
    cin>>n;
26
    tree.resize(n+1);
27
    v.resize(n+1);
28
    for(ll i=1;i<=n;i++)cin>>v[i];
29
    for(ll i=1;i<=n;i++){
30
        cin>>mp[i].first>>mp[i].second;
31
    }
32
    ll ans=0;
33
    count(1);
34
    for(ll i=1;i<=n;i++){
35
        if(mirror(i,i))ans=max(ans,tree[i]);
36
    }
37
    cout<<ans<<endl;
38
    return 0;
39
}

展开收起

[第1章 1.4t8] 荷马史诗

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<ll,ll> pll;
6
int main(){
7
    ll n,k;
8
    cin>>n>>k;
9
    priority_queue<pll,vector<pll>,greater<>> pq;
10
    for(ll i=1;i<=n;i++){
11
        ll w;
12
        cin>>w;
13
        pq.push({w,0});
14
    }
15
    ll ans=0;
16
    ll ma=0;
17
    while((pq.size()-1)%(k-1)!=0)pq.push({0,0});
18
    while(pq.size()>1){
19
        ll tmp=0;
20
        ll h=0;
21
        for(ll i=0;i<k;i++){
22
            tmp+=pq.top().first;
23
            h=max(h,pq.top().second);
24
            pq.pop();
25
        }
26
        ans+=tmp;
27
        pq.push({tmp,h+1});
28
    }
29
    cout<<ans<<endl<<pq.top().second<<endl;
30
    return 0;
31
}

展开收起

[第1章 1.5e1] 堆-模板

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n;
7
    cin>>n;
8
    priority_queue<ll,vector<ll>,greater<>>pq;
9
    while(n--){
10
        ll op;
11
        cin>>op;
12
        if(op==1){
13
            ll x;
14
            cin>>x;
15
            pq.push(x);
16
        }else if(op==2)cout<<pq.top()<<endl;
17
        else pq.pop();
18
    }
19
    return 0;
20
}

展开收起

[第1章 1.5t1] 合并果子

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n;
8
    cin>>n;
9
    priority_queue<ll,vector<ll>,greater<>> a;
10
    for(ll i=0;i<n;i++){
11
        ll tmp;
12
        cin>>tmp;
13
        a.push(tmp);
14
    }
15
    ll ans=0;
16
    while(a.size()>1){
17
        ll aa=a.top();a.pop();
18
        ll bb=a.top();a.pop();
19
        ans+=aa+bb;
20
        a.push(aa+bb);
21
    }
22
    cout<<ans<<endl;
23
    return 0;
24
}

展开收起

[第1章 1.5t2] 中位数

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n;
7
    cin>>n;
8
    priority_queue<ll> r;
9
    priority_queue<ll,vector<ll>,greater<>> l;
10
    ll tmp;
11
    cin>>tmp;
12
    cout<<tmp<<endl;
13
    r.push(tmp);
14
    for(ll i=1;i<n;i++){
15
        cin>>tmp;
16
        if(tmp>r.top())l.push(tmp);
17
        else r.push(tmp);
18
        while(r.size()>l.size()+1){
19
            l.push(r.top());r.pop();
20
        }
21
        while(l.size()>r.size()+1){
22
            r.push(l.top());l.pop();
23
        }
24
        if(i%2==0)cout<<(l.size()>r.size()?l.top():r.top())<<endl;
25
    }
26
    return 0;
27
}

展开收起

[第1章 1.5t3] 最小函数值

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5

6
struct node {
7
    ll w;
8
    ll a, b, c;
9
    ll cntx = 1;
10
};
11

12
struct cmp {
13
    bool operator()(const node &a, const node &b) const {
14
        return a.w > b.w;
15
    }
16
};
17

18
int main() {
19
    ll n, m;
20
    cin >> n >> m;
21
    priority_queue<node, vector<node>, cmp> pq;
22
    for (ll i = 0; i < n; i++) {
23
        ll a, b, c;
24
        cin >> a >> b >> c;
25
        node po;
26
        po.a = a, po.b = b, po.c = c;
27
        po.cntx = 1;
28
        po.w = a + b + c;
29
        pq.push(po);
30
    }
31
    while (m--) {
32
        auto f = pq.top();
33
        pq.pop();
34
        cout << f.w << " ";
35
        f.cntx++;
36
        f.w = f.a * f.cntx * f.cntx + f.b * f.cntx + f.c;
37
        pq.push(f);
38
    }
39
    cout<<endl;
40
    return 0;
41
}

展开收起

[第1章 1.5t4] 蚯蚓

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n,m,q,u,v,t;
7
    cin>>n>>m>>q>>u>>v>>t;
8
    deque<ll> q1,q2,q3;
9
    for(ll i=0;i<n;i++){
10
        ll tmp;
11
        cin>>tmp;
12
        q1.push_back(tmp);
13
    }
14
    bool bk=false;
15
    sort(q1.begin(),q1.end(),greater<ll>());
16
    for(ll i=0;i<m;i++){
17
        ll ma=LLONG_MIN,lo=0;
18
        if(!q1.empty()&&q1.front()>ma)ma=q1.front(),lo=1;
19
        if(!q2.empty()&&q2.front()>ma)ma=q2.front(),lo=2;
20
        if(!q3.empty()&&q3.front()>ma)ma=q3.front(),lo=3;
21
        if(lo==1)q1.pop_front();
22
        else if(lo==2)q2.pop_front();
23
        else q3.pop_front();
24
        ma+=i*q;
25
        ll res1=ma*u/v,res2=ma-res1;
26
        q2.push_back(res1-q-i*q);
27
        q3.push_back(res2-q-i*q);
28
        if((i+1)%t==0){
29
            if(bk)cout<<' ';
30
            cout<<ma;
31
            bk=false;
32
        }
33
    }
34
    bk=true;
35
    cout<<endl;
36
    for(ll i=0;i<n+m;i++){
37
        ll ma=LLONG_MIN,lo=0;
38
        if(!q1.empty()&&q1.front()>ma)ma=q1.front(),lo=1;
39
        if(!q2.empty()&&q2.front()>ma)ma=q2.front(),lo=2;
40
        if(!q3.empty()&&q3.front()>ma)ma=q3.front(),lo=3;
41
        if(lo==1)q1.pop_front();
42
        else if(lo==2)q2.pop_front();
43
        else q3.pop_front();
44
        if((i+1)%t==0){
45
            if(bk)cout<<' ';
46
            cout<<ma;
47
            bk=false;
48
        }
49
    }
50
    cout<<endl;
51
    return 0;
52
}

展开收起

[第1章 1.5t5] Cow Coupons G

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题为反悔贪心，总结一下堆的知识，着重在于考察利用某些性质管理不同堆解决问题
2
//反悔贪心在于每次都比较一下是硬着头皮上还是选择反悔一次代价最小的
3
//如果是后者回报高，那就付出代价，把仅有的减免机会让给c组
4
//注意使用buy数组同步p和c组内已买过的物品，每一轮都要删掉已买的，保证一致性
5
#include <bits/stdc++.h>
6
#define endl '\n'
7
using namespace std;
8
typedef long long ll;
9
typedef struct{
10
    ll pri,pre;
11
    ll ord;
12
}pll;
13
struct cmp1{
14
    bool operator()(const pll &a,const pll &b){
15
        return a.pri>b.pri;
16
    }
17
};
18
struct cmp2{
19
    bool operator()(const pll &a,const pll &b){
20
        return a.pre>b.pre;
21
    }
22
};
23
int main(){
24
    ll n,k,m;
25
    cin>>n>>k>>m;
26
    vector<bool> buy(n,false);
27
    priority_queue<pll,deque<pll>,cmp1>p;
28
    priority_queue<pll,deque<pll>,cmp2>c;
29
    priority_queue<ll,deque<ll>,greater<>>delta;
30
    for(ll i=0;i<k;i++)delta.push(0);
31
    for(ll i=0;i<n;i++){
32
        pll tmp;
33
        cin>>tmp.pri>>tmp.pre;
34
        tmp.ord=i;
35
        p.push(tmp);
36
        c.push(tmp);
37
    }
38
    ll ans=0;
39
    while(!p.empty()){
40
        while(!p.empty()&&buy[p.top().ord])p.pop();
41
        while(!c.empty()&&buy[c.top().ord])c.pop();
42
        if(p.empty())break;
43
        if(p.top().pri<=c.top().pre+delta.top()){
44
            m-=p.top().pri;
45
            if(m<0)break;
46
            buy[p.top().ord]=true;
47
            ans++;
48
        }else{
49
            m-=delta.top()+c.top().pre;
50
            if(m<0)break;
51
            buy[c.top().ord]=true;
52
            delta.pop();
53
            delta.push(c.top().pri-c.top().pre);
54
            ans++;
55
        }
56
    }
57
    cout<<ans<<endl;
58
    return 0;
59
}

展开收起

Firefly 简单使用指南

Fri, 01 May 2026 00:00:00 GMT

这个博客模板是基于 Astro 构建的。对于本指南中未提及的内容，您可以在 Astro 文档中找到答案。

文章的 Front-matter#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
description: 这是我新 Astro 博客的第一篇文章。
5
image: ./cover.jpg
6
tags: [前端, 开发]
7
category: 前端开发
8
draft: false
9
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`updated`	文章更新日期。如果未设置，将默认使用发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。 1. 以 `http://` 或 `https://` 开头：使用网络图片 2. 以 `/` 开头：`public` 目录中的图片 3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`lang`	文章语言代码（如 `zh-CN`）。仅当文章语言与站点默认语言不同时设置。
`licenseName`	文章内容的许可证名称。
`licenseUrl`	文章内容的许可证链接。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`comment`	是否启用此文章的评论功能。默认为 `true`。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。
`password`	文章密码。设置后文章内容将被 AES-256-GCM 加密，访客需输入密码才能查看。
`passwordHint`	密码提示。显示在密码输入框上方，帮助访客回忆密码，也可以不加。

文章文件的放置位置#

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

示例 1：使用文件名作为 URL#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/my-first-blog-post

示例 2：自定义 Slug#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/hello-world

示例 3：其他语言文件名使用Slug#

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

文件：src/content/posts/如何使用Firefly博客主题.md

URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议#

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项#

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

Firefly 代码块示例

Fri, 01 May 2026 00:00:00 GMT

在这里，我们将探索如何使用 Expressive Code 展示代码块。提供的示例基于官方文档，您可以参考以获取更多详细信息。

表达性代码#

语法高亮#

语法高亮

常规语法高亮#

1
console.log('此代码有语法高亮!')

渲染 ANSI 转义序列#

Terminal window展开收起

1
Standard ANSI colors:
2
- Dimmed:      Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
3
- Foreground:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
4
- Background:  Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
5
- Reversed:    Black  Red  Green  Yellow  Blue  Magenta  Cyan  White 
6

7
8-bit colors (showing colors 160-171 as an example):
8
- Dimmed:      160  161  162  163  164  165  166  167  168  169  170  171 
9
- Foreground:  160  161  162  163  164  165  166  167  168  169  170  171 
10
- Background:  160  161  162  163  164  165  166  167  168  169  170  171 
11
- Reversed:    160  161  162  163  164  165  166  167  168  169  170  171 
12

13
24-bit colors (full RGB):
14
- Dimmed:      ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
15
- Foreground:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
16
- Background:  ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
17
- Reversed:    ForestGreen - RGB(34,139,34)  RebeccaPurple - RGB(102,51,153) 
18

19
Font styles:
20
- Default
21
- Bold
22
- Dimmed
23
- Italic
24
- Underline
25
- Reversed
26
- Strikethrough

展开收起

编辑器和终端框架#

编辑器和终端框架

代码编辑器框架#

my-test-file.js

1
console.log('标题属性示例')

src/content/index.html

1
<div>文件名注释示例</div>

终端框架#

Terminal window

1
echo "此终端框架没有标题"

PowerShell 终端示例

1
Write-Output "这个有标题!"

覆盖框架类型#

1
echo "看，没有框架!"

PowerShell Profile.ps1

1
# 如果不覆盖，这将是一个终端框架
2
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
3
New-Alias tail Watch-Tail

文本和行标记#

文本和行标记

标记整行和行范围#

1
// 第1行 - 通过行号定位
2
// 第2行
3
// 第3行
4
// 第4行 - 通过行号定位
5
// 第5行
6
// 第6行
7
// 第7行 - 通过范围 "7-8" 定位
8
// 第8行 - 通过范围 "7-8" 定位

选择行标记类型 (mark, ins, del)#

line-markers.js

1
function demo() {
2
  console.log('此行标记为已删除')
3
  // 此行和下一行标记为已插入
4
  console.log('这是第二个插入行')
5

6
  return '此行使用中性默认标记类型'
7
}

为行标记添加标签#

labeled-line-markers.jsx

1
<button
2
  role="button"
3
  {...props}
4
  value={value}
5
  className={buttonClassName}
6
  disabled={disabled}
7
  active={active}
8
>
9
  {children &&
10
    !active &&
11
    (typeof children === 'string' ? <span>{children}</span> : children)}
12
</button>

在单独行上添加长标签#

labeled-line-markers.jsx展开收起

1
<button
2
  role="button"
3
  {...props}
4

5
  value={value}
6
  className={buttonClassName}
7

8
  disabled={disabled}
9
  active={active}
10
>
11

12
  {children &&
13
    !active &&
14
    (typeof children === 'string' ? <span>{children}</span> : children)}
15
</button>

展开收起

使用类似 diff 的语法#

1
此行将标记为已插入
2
此行将标记为已删除
3
这是常规行

1
--- a/README.md
2
+++ b/README.md
3
@@ -1,3 +1,4 @@
4
+this is an actual diff file
5
-all contents will remain unmodified
6
 no whitespace will be removed either

结合语法高亮和类似 diff 的语法#

1
function thisIsJavaScript() {
2
  // 整个块都会以 JavaScript 高亮显示，
3
  // 并且我们仍然可以为其添加 diff 标记！
4
  console.log('要删除的旧代码')
5
  console.log('新的闪亮代码！')
6
}

标记行内的单独文本#

1
function demo() {
2
  // 标记行内的任何给定文本
3
  return '支持给定文本的多个匹配项';
4
}

正则表达式#

1
console.log('单词 yes 和 yep 将被标记。')

转义正斜杠#

Terminal window

1
echo "Test" > /home/test.txt

选择内联标记类型 (mark, ins, del)#

1
function demo() {
2
  console.log('这些是插入和删除的标记类型');
3
  // return 语句使用默认标记类型
4
  return true;
5
}

自动换行#

自动换行

为每个块配置自动换行#

1
// 启用换行的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// wrap=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

配置换行的缩进#

1
// preserveIndent 示例（默认启用）
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

1
// preserveIndent=false 的示例
2
function getLongString() {
3
  return '这是一个非常长的字符串，除非容器极宽，否则很可能无法适应可用空间'
4
}

可折叠部分#

可折叠部分


5 collapsed lines
1
// 所有这些样板设置代码将被折叠
2
import { someBoilerplateEngine } from '@example/some-boilerplate'
3
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'
4

5
const engine = someBoilerplateEngine(evenMoreBoilerplate())
6

7
// 这部分代码默认可见
8
engine.doSomething(1, 2, 3, calcFn)
9

10
function calcFn() {
11
  // 您可以有多个折叠部分
3 collapsed lines
12
  const a = 1
13
  const b = 2
14
  const c = a + b
15

16
  // 这将保持可见
17
  console.log(`计算结果: ${a} + ${b} = ${c}`)
18
  return c
19
}
20

4 collapsed lines
21
// 直到块末尾的所有代码将再次被折叠
22
engine.closeConnection()
23
engine.freeMemory()
24
engine.shutdown({ reason: '示例样板代码结束' })

展开收起

行号#

行号

为每个块显示行号#

1
// 此代码块将显示行号
2
console.log('来自第2行的问候!')
3
console.log('我在第3行')

// 此块禁用行号
console.log('你好?')
console.log('抱歉，你知道我在第几行吗?')

更改起始行号#

5
console.log('来自第5行的问候!')
6
console.log('我在第6行')

Tab 代码块#

由 rehype-code-group 提供，语法与 VitePress 代码组一致：用 ::: code-group labels=[...] 包裹多个代码块，即可合并成一组标签页。

Note

labels=[...] 中的标签按顺序对应组内的代码块，用英文逗号分隔；::: 与 code-group 之间的空格不能省略。

基本用法#

1
::: code-group labels=[code.js, code.py, code.html]
2

3
```js
4
export function greet(name) {
5
  return `Hello, ${name}!`;
6
}
7
```
8

9
```py
10
def greet(name):
11
    return f"Hello, {name}!"
12
```
13

14
```html
15
<p>Hello, world!</p>
16
```
17

18
:::

展开收起

渲染效果：

code.jscode.pycode.html

1
export function greet(name) {
2
  return `Hello, ${name}!`;
3
}

1
def greet(name):
2
    return f"Hello, {name}!"

1
<p>Hello, world!</p>

标签中使用 Emoji#

标签支持 emoji 短代码，构建时会自动转换成 emoji：

1
::: code-group labels=[:package: npm, :package: pnpm, :yarn: yarn]

📦 npm📦 pnpm🧶 yarn

Terminal window

1
npm create astro@latest

Terminal window

1
pnpm create astro@latest

Terminal window

1
yarn create astro

与其他代码块特性组合#

组内仍是普通的 Expressive Code 代码块，标题、行号、行标记、折叠、终端框架等特性都可以照常使用。

配置文件终端折叠

astro.config.mjs

1
export default {
2
  theme: "firefly",
3
  codeGroup: true,
4
};

部署

1
pnpm build && pnpm preview


3 collapsed lines
1
// 这三行默认折叠
2
import { a } from "a";
3
import { b } from "b";
4

5
console.log(a, b);

不止是代码块#

标签页内可以放任意内容，例如文字、列表或图片：

说明列表

这是一段普通的段落内容。

列表项一
列表项二

Tip

标签栏在构建期生成，默认展开第一项；支持鼠标点击与键盘 ← / → / Home / End 切换。

在提醒框内使用（MDX 组件）#

::: code-group 和 ::: tip 等 Docusaurus 风格提醒框都使用 ::: 容器语法，而 micromark-directive 规定父子容器的冒号数必须不同，因此 ::: code-group 无法嵌套在 ::: tip 等提醒框内（整块会失效）。

这种情况改用 MDX 组件 TabGroup：MDX 组件不经过 ::: 指令解析，在提醒框内外都能正常使用，也方便日后扩展更多 UI 组件。把文章后缀改为 .mdx，从统一入口 @/components/firefly-mdx 引入（可一次引入多个组件）：

1
import { TabGroup } from "@/components/firefly-mdx";
2

3
:::tip
4

5
<TabGroup labels={["test.js", "test.py"]} client:load>
6
  ```js
7
  console.log(1)
8
  ```
9

10
  ```py
11
  print("hello world")
12
  ```
13
</TabGroup>
14

15
:::

展开收起

Tip

labels 数组给每个代码块声明标签，顺序一一对应
组件用 client:load 激活标签切换

Firefly 文章加密

Fri, 01 May 2026 00:00:00 GMT

这是一篇密码保护的示例文章，用于演示文章加密功能。

Firefly 一款清新美观的 Astro 博客主题模板

Fri, 01 May 2026 00:00:00 GMT

🌟 项目概述#

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

🖥️在线预览： Firefly - Demo site

📝Firefly使用文档： https://docs-firefly.cuteleaf.cn

⭐Firefly开源地址：https://github.com/CuteLeaf/Firefly

⭐Fuwari开源地址：https://github.com/saicaca/fuwari

CuteLeaf

Firefly

🍀Firefly, fresh and aesthetic Astro blog theme template.

✨A static blog template built with Astro.

—

MIT

Astro

Firefly

🚀 技术架构#

静态站点生成: 基于 Astro ，提供极快的加载速度和优秀的 SEO 优化
TypeScript 支持: 完整的类型安全，提升开发体验和代码质量
响应式设计: 使用 Tailwind CSS 构建，完美适配桌面端和移动端
组件化开发: 支持 Astro、Svelte 组件，灵活可扩展

📖 配置说明#

📚 详细配置文档: 查看 Firefly 使用文档获取完整的配置指南

Firefly 布局系统详解

Fri, 01 May 2026 00:00:00 GMT

📖 概述#

Firefly 提供了灵活的布局系统，允许您根据内容需求和个人喜好自定义博客的视觉呈现方式。布局系统主要包括侧边栏布局和文章列表布局两个维度，它们相互配合，共同决定了页面的整体结构。

本文将详细介绍 Firefly 的各种布局模式、它们的特点、使用场景，以及不同布局组合的效果。

左侧边栏+列表布局

右侧边栏+网格布局

左侧边栏+三列网格布局

双侧边栏+列表布局

双侧边栏+网格布局

双侧边栏+网格瀑布流布局

一、侧边栏布局系统#

侧边栏是博客页面的重要组成部分，用于展示导航、分类、标签、统计信息等辅助内容。Firefly 支持两种侧边栏布局模式。

1.1 单侧边栏模式#

左侧边栏 (position: “left”)#

左侧边栏布局

右侧边栏 (position: “right”)#

右侧边栏布局

特点#

侧边栏固定在页面其中一侧
文章阅读区域体验更佳，更宽敞
更加简约，没有那么紧凑

适用场景#

传统博客风格
强调导航和分类的博客
需要突出用户资料的个人博客
内容为主，辅助信息次之的场景

Tip

可以通过showBothSidebarsOnPostPage配置是否在文章详情页显示双侧边栏

当position为left或right时开启此项后，文章详情页将显示双侧边栏，主页等其他页面保持单侧边栏

适用在只想用单侧栏，但在文章详情页想用对侧栏的目录等组件的场景

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "left", // 左侧边栏
4
  showBothSidebarsOnPostPage: true, // 是否在文章详情页显示双侧边栏
5
};

1.2 双侧边栏模式 (position: “both”)#

特点#

左右两侧同时存在侧边栏
主内容区域位于中间
最大化利用屏幕空间
可以展示更多辅助信息
适合宽屏显示器

布局结构#

双侧边栏+列表布局

双侧边栏+网格布局

适用场景#

宽屏桌面端浏览
信息密集型博客
需要展示大量辅助内容
专业性强的技术博客

配置示例#

src/config/sidebarConfig.ts

1
export const sidebarLayoutConfig: SidebarLayoutConfig = {
2
  enable: true,
3
  position: "both", // 双侧边栏

二、文章列表布局系统#

文章列表是博客首页和归档页的核心内容，Firefly 提供两种展示方式，并支持多种网格配置。

2.1 列表模式 (defaultMode: “list”)#

特点#

单列纵向排列
显示文章封面图，可配置在左侧或右侧
展示更多文章摘要
适合深度阅读

列表布局结构#

列表模式布局

封面位置#

列表模式的封面图默认在卡片右侧，可以通过 coverPosition 改到左侧。改到左侧后，标题前的主题色竖线会自动隐藏（它是贴着卡片左边缘的设计），腾出的间距留给正文。

网格模式的封面固定在卡片顶部，不受这项配置影响。

优点#

✅ 视觉冲击力强，封面图吸引眼球
✅ 可以展示更多文章信息（摘要、标签等）
✅ 适合图片内容丰富的博客
✅ 移动端友好，单列更易阅读
✅ 兼容所有侧边栏配置（单侧、双侧）

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "list",    // 列表模式
4
    coverPosition: "right", // 封面图位置："right" 右侧，"left" 左侧
5
  },
6
};

2.2 网格模式 (defaultMode: “grid”)#

特点#

自适应列数，根据浏览器宽度自动调整
紧凑布局，信息密度高
适合快速浏览

自适应网格#

网格模式通过 columnWidth 配置卡片的最小宽度（单位 px），浏览器会根据容器可用宽度自动计算能容纳多少列。

网格布局

配置示例#

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  postListLayout: {
3
    defaultMode: "grid",
4
    grid: {
5
      masonry: true,      // 开启瀑布流
6
      columnWidth: 320,   // 卡片最小宽度(px)，浏览器自动计算列数
7
    },
8
  },
9
};

2.3 瀑布流布局 (Masonry)#

Firefly 的网格模式内置了智能瀑布流布局支持，解决了网格布局中因图文混合文章导致的卡片高度不一致导致的空白问题。

瀑布流布局

智能排版：自动将卡片放置到最短的列，最大化利用垂直空间。
消除空白：通过绝对定位精确计算每个卡片的位置，让卡片紧贴上方卡片，消除垂直方向的空白间隙。
自适应列数：瀑布流同样根据 columnWidth 和容器宽度动态计算列数，无需固定配置。
配置灵活：您可以在 siteConfig.ts 中通过 postListLayout.grid.masonry 选项自由开启或关闭此功能。

三、布局组合指南#

Firefly 允许您自由组合侧边栏和文章列表布局。以下是各种组合的效果说明。

侧边栏模式	文章列表模式	推荐度	适用场景
单侧边栏	列表模式	⭐⭐⭐⭐⭐	摄影、设计、生活类博客，强调图片和沉浸感
单侧边栏	网格模式	⭐⭐⭐⭐⭐	技术、笔记类博客，平衡阅读与检索效率
双侧边栏	列表模式	⭐⭐⭐⭐⭐	需要展示大量侧边栏信息的站点
双侧边栏	网格模式	⭐⭐⭐⭐⭐	极客风格，追求最高信息密度

四、响应式布局行为#

Firefly 的布局系统具有智能的响应式设计，会根据屏幕尺寸自动调整。

为了保证最佳阅读体验，系统会在屏幕变窄时自动调整布局：

网格列数自动减少：网格模式的列数由 columnWidth 和容器宽度自动决定，屏幕越窄列数越少。
列表模式 -> 网格模式：当屏幕宽度小于 380px（超小屏设备）时，列表模式会自动切换为网格模式，以保证卡片内容的可读性。
双侧边栏 -> 单侧边栏：当屏幕宽度小于 1280px 时，会根据tabletSidebar配置显示单侧边栏，隐藏其中一个侧边栏，文章目录导航会切换成浮动目录导航。

五、常见问题#

Q1: 如何调整网格列数？#

A: 通过 columnWidth 配置卡片最小宽度即可。值越小，同等宽度下列数越多；值越大，列数越少。浏览器会自动根据可用宽度计算最佳列数。

六、总结#

Firefly 的布局系统给予了您更大的自由度，您都可以通过简单的配置实现。

我们建议您根据自己的内容类型和目标读者的设备偏好，尝试不同的组合，找到最适合您的博客形态。

Firefly Wiki Link 内部链接示例

Fri, 01 May 2026 00:00:00 GMT

Firefly 支持在 Markdown、MDX 文章中使用 Obsidian 风格的 Wiki Link 内部链接。链接目标填写文章的 slug 或文件路径，都不需要包含扩展名，具体匹配规则见下文「链接目标的三种写法」。

文章链接卡片#

[[slug]] 单独成段时，会自动读取目标文章的标题、描述、发布时间、分类、标签和封面，渲染为链接卡片：

1
[[firefly]]
2

3
[[guide/index]]
4

5
[[markdown-extended]]

Firefly 一款清新美观的 Astro 博客主题模板

Firefly 是一款基于 Astro 框架和 Fuwari 模板开发的清新美观且现代化个人博客主题模板，专为技术爱好者和内容创作者设计。该主题融合了现代 Web 技术栈，提供了丰富的功能模块和高度可定制的界面，让您能够轻松打造出专业且美观的个人博客网站。

2026-05-01博客指南#Markdown#Firefly#博客#主题#模板

Firefly 简单使用指南

如何使用 Firefly 博客模板。

2026-05-01博客指南#Firefly#博客#Markdown#指南

Markdown 扩展功能

了解 Firefly 中的 Markdown 功能

2026-05-01博客指南#演示#示例#Markdown#Firefly

行内链接#

[[slug]] 出现在正文中间时，渲染为普通链接，链接文字自动使用目标文章的标题

1
请参阅 [[firefly]] 了解主题特性。

请参阅 Firefly 一款清新美观的 Astro 博客主题模板了解主题特性。

自定义显示标题#

在 | 后填写链接的显示文字。行内链接会用它替换文章标题；单独成段时依然渲染为卡片，卡片标题使用自定义文字，描述、时间、分类、标签和封面仍然读取目标文章：

1
请参阅 [[firefly|主题介绍]] 了解主题特性。
2

3
[[firefly|Firefly 主题介绍]]

请参阅主题介绍了解主题特性。

Firefly 主题介绍

2026-05-01博客指南#Markdown#Firefly#博客#主题#模板

一个例外：如果 | 后的文字只是把链接目标又抄了一遍（[[guide/index|index]]），会被当作无效别名忽略，仍然显示文章标题。Obsidian 在插入的链接时会自动补上这样的别名，避免笔记里显示一长串路径，这个例外就是为它准备的。

链接目标的三种写法#

用 Obsidian 管理文章时，把 src/content/posts 目录本身作为 Obsidian 仓库（vault）打开。下文提到的「仓库根目录」都指这个目录，它正好也是 Firefly 解析链接路径的起点。

链接目标按以下顺序匹配：

写法	示例	在 Obsidian 中
frontmatter 的 `slug`	`[[firefly-wiki-link]]`	✗ 不支持
文件路径（相对仓库根目录）	`[[guide/firefly-layout-system]]`	✓ 需改设置（推荐）
裸文件名（仓库内唯一时）	`[[firefly-layout-system]]`	✓ 默认即是

第一种：slug#

slug 写法在 Obsidian 中不支持，slug 是 Firefly 自己的概念，Obsidian 不读取 frontmatter 里的 slug，所以按 slug 写的链接在 Obsidian 里既不会自动补全，也点不动，只有构建出的站点上能正常跳转。如果你主要在 Obsidian 里写作，用下面两种写法。

第二种：文件路径（推荐）#

文件路径写法需要改 Obsidian 设置，在 设置 → 文件与链接 → 链接 → 内部链接类型 中选择基于仓库根目录的绝对路径，Obsidian 插入的链接才会带上目录：

1
[[guide/firefly-layout-system|firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

2026-05-01博客指南#Firefly#布局#博客#指南

因为仓库根目录就是 src/content/posts，Obsidian 写出的这个路径和 Firefly 需要的路径完全一致，不需要任何额外转换。

上面这行末尾的 |firefly-layout-system 是 Obsidian 自动补的别名，Firefly 会忽略它，卡片标题仍然取文章的 title，除非你把它修改和文件名不一致，才会变成你修改后的别名。

内部链接类型下拉框里的基于当前笔记的相对路径只在同目录内可用：它给同目录文章生成的是裸文件名，能正常匹配；但跨目录时会生成 ../ 前缀，Firefly 无法解析，链接会按原文显示。

第三种：裸文件名#

「内部链接类型」的默认值就是尽可能简短的形式：只要文件名在整个仓库里唯一，Obsidian 插入的链接就只有文件名，不带目录。这种写法不需要改任何设置，效果和写完整路径完全一致：

1
[[firefly-layout-system]]

Firefly 布局系统详解

深入了解 Firefly 的布局系统，包括侧边栏布局（左侧/双侧）和文章列表布局（列表/网格），以及自适应网格列数。

2026-05-01博客指南#Firefly#布局#博客#指南

文件名重名时这种写法会失效，构建日志里会给出提示，改用完整文件路径即可，所以推荐直接修改 Obsidian 内部链接类型设置为基于仓库根目录的绝对路径，使用第二种文件路径写法，一劳永逸

链接到其他文章的标题#

在文章 slug 后添加 #标题。带标题锚点的链接始终渲染为普通链接：

查看代码块语法高亮

Firefly 布局系统详解#相关链接

1
[[code-examples#语法高亮|查看代码块语法高亮]]
2

3
[[guide/firefly-layout-system#相关链接|firefly-layout-system]]

标题锚点使用与页面标题相同的 slug 规则，因此中文、空格和大小写都会按页面实际生成的 ID 处理。

链接到本页标题#

省略文章 slug，只填写标题即可链接到当前文章：

跳转到本页目标

1
[[#本页目标|跳转到本页目标]]

本页目标#

这是本页 Wiki Link 指向的标题。

不支持附件嵌入#

附件嵌入语法目前不会被转换，会按原文显示：

![[image.png]]

行内代码和代码块中的 [[firefly]] 也不会被转换。

KaTeX 数学公式示例

Fri, 01 May 2026 00:00:00 GMT

本文展示了 Firefly 主题对 KaTeX 数学公式的渲染支持。

行内公式 (Inline)#

行内公式使用单个 $ 符号包裹。

例如：欧拉公式 eiπ+1=0e^{i\pi} + 1 = 0eiπ+1=0 是数学中最优美的公式之一。

质能方程 E=mc2E = mc^2E=mc2 也是家喻户晓。

块级公式 (Block)#

块级公式使用两个 $$ 符号包裹，会居中显示。

∫−∞∞e−x2dx=π\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}∫−∞∞e−x2dx=πx=−b±b2−4ac2ax = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}x=2a−b±b2−4ac

复杂示例#

矩阵 (Matrices)#

(abcd)(αβγδ)=(aα+bγaβ+bδcα+dγcβ+dδ)\begin{pmatrix} a & b \\ c & d \end{pmatrix} \begin{pmatrix} \alpha & \beta \\ \gamma & \delta \end{pmatrix} = \begin{pmatrix} a\alpha + b\gamma & a\beta + b\delta \\ c\alpha + d\gamma & c\beta + d\delta \end{pmatrix}(acbd)(αγβδ)=(aα+bγcα+dγaβ+bδcβ+dδ)

极限与求和 (Limits and Sums)#

∑n=1∞1n2=π26\sum_{n=1}^{\infty} \frac{1}{n^2} = \frac{\pi^2}{6}n=1∑∞n21=6π2lim⁡x→0sin⁡xx=1\lim_{x \to 0} \frac{\sin x}{x} = 1x→0limxsinx=1

麦克斯韦方程组 (Maxwell’s Equations)#

∇⋅E=ρε0∇⋅B=0∇×E=−∂B∂t∇×B=μ0J+μ0ε0∂E∂t\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\ \nabla \cdot \mathbf{B} &= 0 \\ \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\ \nabla \times \mathbf{B} &= \mu_0\mathbf{J} + \mu_0\varepsilon_0\frac{\partial \mathbf{E}}{\partial t} \end{aligned}∇⋅E∇⋅B∇×E∇×B=ε0ρ=0=−∂t∂B=μ0J+μ0ε0∂t∂E

化学方程式 (Chemical Equations)#

\ceCH4+2O2−>CO2+2H2O\ce{CH4 + 2O2 -> CO2 + 2H2O}\ceCH4+2O2−>CO2+2H2O

Markdown 扩展功能

Fri, 01 May 2026 00:00:00 GMT

GitHub 仓库卡片#

您可以添加链接到 GitHub 仓库的动态卡片，在页面加载时，仓库信息会从 GitHub API 获取。

CuteLeaf

Firefly

🍀Firefly, fresh and aesthetic Astro blog theme template.

—

MIT

Astro

使用代码 ::github{repo="CuteLeaf/Firefly"} 创建 GitHub 仓库卡片。

1
::github{repo="CuteLeaf/Firefly"}

提醒框(Admonitions)配置#

Firefly 采用了 rehype-callouts 插件，支持了四种风格的提醒框主题：GitHub、Obsidian、VitePress 和 Docusaurus。您可以在 src/config/siteConfig.ts 中进行配置：

src/config/siteConfig.ts

1
export const siteConfig: SiteConfig = {
2
  // ...
3
  rehypeCallouts: {
4
    // 选项: "github" | "obsidian" | "vitepress" | "docusaurus"
5
    theme: "github",
6
  },
7
  // ...
8
};

注意：更改配置后需要重启开发服务器才能生效。

以下是各个主题支持的类型列表，每个主题风格和语法不同，可根据喜好选择。

1. GitHub 主题风格#

这是 GitHub 官方支持的 5 种基本类型。

GitHub

基本语法

1
> [!NOTE] NOTE
2
> 突出显示用户应该考虑的信息。
3

4
> [!TIP] TIP
5
> 可选信息，帮助用户更成功。
6

7
> [!IMPORTANT] IMPORTANT
8
> 用户成功所必需的关键信息。
9

10
> [!WARNING] WARNING
11
> 关键内容，需要立即注意。
12

13
> [!CAUTION] CAUTION
14
> 行动的负面潜在后果。
15

16
> [!NOTE] 自定义标题
17
> 这是一个带有自定义标题的示例。

展开收起

2. Obsidian 主题风格#

Obsidian 风格支持非常丰富的类型和别名。

点击展开 Obsidian 语法列表

1
> [!NOTE] NOTE
2
> 通用的笔记块。
3

4
> [!ABSTRACT] ABSTRACT
5
> 文章的摘要。
6

7
> [!SUMMARY] SUMMARY
8
> 文章的总结（同 Abstract）。
9

10
> [!TLDR] TLDR
11
> 太长不看（同 Abstract）。
12

13
> [!INFO] INFO
14
> 提供额外信息。
15

16
> [!TODO] TODO
17
> 需要完成的事项。
18

19
> [!TIP] TIP
20
> 实用技巧或提示。
21

22
> [!HINT] HINT
23
> 暗示（同 Tip）。
24

25
> [!IMPORTANT] IMPORTANT
26
> 重要信息（Obsidian 风格通常使用类似的图标）。
27

28
> [!SUCCESS] SUCCESS
29
> 操作成功。
30

31
> [!CHECK] CHECK
32
> 检查通过（同 Success）。
33

34
> [!DONE] DONE
35
> 已完成（同 Success）。
36

37
> [!QUESTION] QUESTION
38
> 提出问题。
39

40
> [!HELP] HELP
41
> 寻求帮助（同 Question）。
42

43
> [!FAQ] FAQ
44
> 常见问题（同 Question）。
45

46
> [!WARNING] WARNING
47
> 警告信息。
48

49
> [!CAUTION] CAUTION
50
> 注意事项（同 Warning）。
51

52
> [!ATTENTION] ATTENTION
53
> 引起注意（同 Warning）。
54

55
> [!FAILURE] FAILURE
56
> 操作失败。
57

58
> [!FAIL] FAIL
59
> 失败（同 Failure）。
60

61
> [!MISSING] MISSING
62
> 缺失内容（同 Failure）。
63

64
> [!DANGER] DANGER
65
> 危险操作警告。
66

67
> [!ERROR] ERROR
68
> 错误信息（同 Danger）。
69

70
> [!BUG] BUG
71
> 报告软件缺陷。
72

73
> [!EXAMPLE] EXAMPLE
74
> 展示一个例子。
75

76
> [!QUOTE] QUOTE
77
> 引用一段话。
78

79
> [!CITE] CITE
80
> 引证（同 Quote）。
81

82
> [!NOTE] 自定义标题
83
> 这是一个带有自定义标题的示例。

展开收起

Obsidian

3. VitePress 主题风格#

VitePress 风格提供了一套现代化的、扁平的默认样式。目前仅包含与 GitHub 一致的 5 种 基础类型。

点击展开 VitePress 语法列表

1
> [!NOTE] NOTE
2
> 对应 GitHub 的 Note。
3

4
> [!TIP] TIP
5
> 对应 GitHub 的 Tip。
6

7
> [!IMPORTANT] IMPORTANT
8
> 对应 GitHub 的 Important。
9

10
> [!WARNING] WARNING
11
> 对应 GitHub 的 Warning。
12

13
> [!CAUTION] CAUTION
14
> 对应 GitHub 的 Caution。
15

16
> [!TIP] 自定义标题
17
> VitePress 风格同样支持自定义标题。

展开收起

VitePress

4. Docusaurus 主题风格#

Docusaurus 风格提供了一套现代化的提醒框样式，支持 5 种类型。

点击展开 Docusaurus 语法列表

支持以下类型的提醒框：note tip info warning danger

1
:::note
2
突出显示用户应该考虑的信息，即使在快速浏览时也是如此。
3
:::
4

5
:::tip
6
可选信息，帮助用户更成功。
7
:::
8

9
:::info
10
一般信息。
11
:::
12

13
:::warning
14
由于潜在风险需要用户立即注意的关键内容。
15
:::
16

17
:::danger
18
行动的负面潜在后果。
19
:::
20

21
:::tip[自定义标题]
22
可选信息，帮助用户更成功。
23
:::

展开收起

Docusaurus

剧透#

您可以为文本添加剧透。文本也支持 Markdown 语法。

内容被隐藏了哈哈！

1
内容 :spoiler[被隐藏了 **哈哈**]！

图片画廊网格 (Image Grid)#

您可以使用 [grid] 和 [/grid] 标签将多张图片纵向并排展示。这对于展示照片画廊或对比图非常有用。系统会自动根据包裹在其中的图片数量（最多支持并排展示4张）以响应式网格进行布局。

自动补齐图片高度： 同一排中如果有高度、大小或者比例不一的图片，会像「九宫格画廊相册」一样自动撑满。较短或不协调的图片会自动使用 object-cover 进行完美中心裁剪补充视野。图片边框水平彻底对齐无缝隙，但被裁剪后，只有点击图片通过灯箱才能查看完整图片，所以建议尽量避免使用长宽比例不一致的图片在同一排中。

图注恒定底端对齐： 不论上面的图片长宽如何变化，在同一行的所有图像解释文字（图注）都会对标到一条完美的水平基线上了。

示例图片一

示例图片二

基本语法

1
[grid]
2
![示例图片一](https://src.hecloud.top/firefly-tutorial/firefly1.avif)
3
![示例图片二](https://src.hecloud.top/firefly-tutorial/firefly2.avif)
4
![示例图片二](https://src.hecloud.top/firefly-tutorial/firefly3.avif)
5
[/grid]

Markdown Mermaid 图表

Fri, 01 May 2026 00:00:00 GMT

Markdown 中 Mermaid 图表完整指南#

本文演示如何在 Markdown 文档中使用 Mermaid 创建各种复杂图表，包括流程图、时序图、ER 图、类图、状态图、XY 图、甘特图、思维导图等。

Mermaid 图表由 Merman 实现。Firefly 在 Astro 构建阶段生成亮色和深色两套静态 SVG，无需在浏览器中加载 Mermaid 渲染运行时。可以前往 Merman Playground 实时编辑语法并预览渲染结果。

流程图示例#

流程图非常适合表示流程或算法步骤。

是

否

选项 1

选项 2

选项 3

子过程详情

子步骤 1

子步骤 2

子步骤 3

开始

条件检查

处理步骤 1

处理步骤 2

另一个决策

结果 1

结果 2

结果 3

结束

是

否

选项 1

选项 2

选项 3

子过程详情

子步骤 1

子步骤 2

子步骤 3

开始

条件检查

处理步骤 1

处理步骤 2

另一个决策

结果 1

结果 2

结果 3

结束

时序图示例#

时序图显示对象之间随时间的交互。

数据库服务器网页应用用户数据库服务器网页应用用户alt[认证成功][认证失败]提交登录请求发送认证请求查询用户凭据返回用户数据返回认证结果显示欢迎页面请求用户数据获取用户偏好返回偏好设置返回用户数据加载个性化界面显示错误消息提示重新输入

ER 图示例#

ER 图（实体关系图）非常适合表示数据库结构。

writes

posts

has

belongs to

USER

int

string

username

string

datetime

created_at

ARTICLE

int

string

title

text

content

datetime

published

int

author_id

COMMENT

int

text

content

datetime

created_at

int

user_id

int

article_id

类图示例#

类图显示系统的静态结构，包括类、属性、方法及其关系。

写作

发表

拥有

属于

User

+String username

+String password

+String email

+Boolean active

+login()

+logout()

+updateProfile()

Article

+String title

+String content

+Date publishDate

+Boolean published

+publish()

+edit()

+delete()

Comment

+String content

+Date commentDate

+addComment()

+deleteComment()

状态图示例#

状态图显示对象在其生命周期中经历的状态序列。

提交

拒绝

批准

发布

归档

撤回

草稿

审核中

已批准

已归档

已发布

临时隐藏

恢复

活跃

隐藏

提交

拒绝

批准

发布

归档

撤回

草稿

审核中

已批准

已归档

已发布

临时隐藏

恢复

活跃

隐藏

XY 图示例#

XY 图表非常适合展示趋势和对比数据。

月度访问量趋势1月2月3月4月5月6月5000450040003500300025002000150010005000访问量

饼图示例#

饼图适合直观展示各部分在整体中的占比。

45%30%15%10%内容类型占比技术文章 [45]项目记录 [30]生活随笔 [15]其他 [10]

甘特图示例#

甘特图可以按时间轴展示项目阶段、任务依赖和当前进度。

07/0107/0307/0507/0707/0907/1107/1307/1507/17需求整理视觉设计功能实现内容迁移构建检查正式上线准备开发发布博客版本发布计划

思维导图示例#

思维导图适合梳理主题层级和知识结构。

Firefly

内容

技术文章

生活记录

体验

搜索

深色模式

图表

工程

Astro

Svelte

Merman

Firefly

内容

技术文章

生活记录

体验

搜索

深色模式

图表

工程

Astro

Svelte

Merman

时间线示例#

时间线用于按年份或阶段呈现项目的重要事件。

2024建立博客完成基础主题2025加入搜索与图库完善内容系统2026升级 Astro 7使用 Merman 渲染图表Firefly 演进时间线

用户旅程图示例#

用户旅程图能够描述用户在不同阶段的行为和体验评分。

读者

发现内容

发现内容读者

打开首页

打开首页读者

搜索主题

阅读文章

阅读文章读者

浏览正文

浏览正文读者

查看图表

继续探索

继续探索读者

查看相关文章

查看相关文章读者

分享文章

分享文章读者浏览文章的旅程

读者

发现内容

发现内容读者

打开首页

打开首页读者

搜索主题

阅读文章

阅读文章读者

浏览正文

浏览正文读者

查看图表

继续探索

继续探索读者

查看相关文章

查看相关文章读者

分享文章

分享文章读者浏览文章的旅程

Git 图示例#

Git 图可以清晰展示分支、提交和合并历史。

mainfeatureinitadd-diagramspolish-themesmerge-featurerelease

看板示例#

看板适合展示任务在不同工作阶段之间的分布。

待办

进行中

已完成

整理需求

准备示例

接入 Merman

服务端渲染

亮暗主题

待办

进行中

已完成

整理需求

准备示例

接入 Merman

服务端渲染

亮暗主题

Sankey 图示例#

Sankey 图通过连线宽度展示流量在不同节点之间的流向。

Home 1650Post list 1200Search 450Post detail 1220Related posts 260External shares 180

总结#

Mermaid 是在 Markdown 文档中创建各种类型图表的强大工具。本文演示了流程图、时序图、ER 图、类图、状态图、XY 图、饼图、甘特图、思维导图、时间线、用户旅程图、Git 图、看板和 Sankey 图。这些图表可以帮助您更清晰地表达复杂的概念、流程和数据结构。

要使用 Mermaid，只需在代码块中指定 mermaid 语言，并使用简洁的文本语法描述图表。图表会在构建时自动渲染为 SVG，无需客户端 JavaScript 加载。

可以前往 Merman Playground 尝试更多语法，再将图表代码粘贴到文章中。

Markdown PlantUML 图表

Fri, 01 May 2026 00:00:00 GMT

Markdown 中 PlantUML 图表指南#

PlantUML 是一种使用纯文本描述图表的工具。你只需要写一段结构化语法，就可以生成时序图、类图、用例图、活动图等常见工程图。

它特别适合写在技术博客和项目文档里：

图表和正文一起版本管理，便于协作与审阅
修改图只需要改文本，适合频繁迭代
能和 Markdown 无缝结合，保持文档统一

在 Firefly 中，plantuml 代码块会在构建阶段编码并生成服务器 SVG 地址，页面端再根据亮暗主题自动切换图源，并支持缩放、拖拽和全屏交互。

如果你想快速上手，可以记住这个最小模板：

活动图示例#

状态图示例#

用例图示例#

组件图示例#

部署图示例#

ER 图示例#

时序图示例（登录与刷新令牌）#

C4 风格容器图示例#

Markdown 教程

Fri, 01 May 2026 00:00:00 GMT

这是一个展示如何编写 Markdown 文件的示例。本文档汇总了核心语法与常见扩展（GFM）。

块级元素
- 段落与换行
- 标题
- 引用
- 列表
- 代码块
- 分割线
- 表格
内联元素
- 链接
- 强调
- 行内代码
- 图片
- 删除线
杂项
- 自动链接
- 反斜杠转义
内联 HTML

块级元素#

段落与换行#

段落#

HTML 标签：<p>

使用一个或多个空行分隔段落。（仅包含空格或制表符的行也视为空行。）

代码：

1
This will be
2
inline.
3

4
This is second paragraph.

预览：

This will be inline.

This is second paragraph.

换行#

HTML 标签：<br />

在行末添加两个或更多空格来产生换行。

代码：

1
This will be not
2
inline.

预览：

This will be not
inline.

标题#

Markdown 支持两种标题样式：Setext 与 atx。

Setext#

HTML 标签：<h1>，<h2>

使用等号 (=) 表示 <h1>、使用短横线 (-) 表示 <h2>，数量不限，作为“下划线”。

代码：

1
This is an H1
2
=============
3
This is an H2
4
-------------

预览：

This is an H1#

This is an H2#

atx#

HTML 标签：<h1>，<h2>，<h3>，<h4>，<h5>，<h6>

在行首使用 1-6 个井号 (#)，对应 <h1> 至 <h6>。

代码：

1
# This is an H1
2
## This is an H2
3
###### This is an H6

预览：

This is an H1#

This is an H2#

This is an H6#

可选：你可以在行尾“闭合” atx 标题。末尾的井号数量不必与开头一致。

代码：

1
# This is an H1 #
2
## This is an H2 ##
3
### This is an H3 ######

预览：

This is an H1#

This is an H2#

This is an H3#

引用#

HTML 标签：<blockquote>

Markdown 使用邮件风格的 > 作为引用符号。若手动换行并在每行前加 >，显示效果最佳。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4
>
5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
> id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

Markdown 允许“偷懒”：在一个硬换行段落中，只在第一行前加 > 即可。

代码：

1
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
2
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
3
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
4

5
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
6
id sem consectetuer libero luctus adipiscing.

预览：

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

引用可以嵌套（引用中的引用），通过增加 > 层级实现。

代码：

1
> This is the first level of quoting.
2
>
3
> > This is nested blockquote.
4
>
5
> Back to the first level.

预览：

This is the first level of quoting.
This is nested blockquote.
Back to the first level.

引用内可包含其他 Markdown 元素，包括标题、列表与代码块。

代码：

1
> ## This is a header.
2
>
3
> 1.   This is the first list item.
4
> 2.   This is the second list item.
5
>
6
> Here's some example code:
7
>
8
>     return shell_exec("echo $input | $markdown_script");

预览：

This is a header.#

This is the first list item.

This is the second list item.

Here’s some example code:
1
return shell_exec("echo $input | $markdown_script");

列表#

Markdown 支持有序（数字）与无序（圆点）列表。

无序列表#

HTML 标签：<ul>

无序列表可使用 星号 (*)、加号 (+) 或 短横线 (-)。

代码：

1
*   Red
2
*   Green
3
*   Blue

预览：

Red
Green
Blue

等价于：

代码：

1
+   Red
2
+   Green
3
+   Blue

或者：

代码：

1
-   Red
2
-   Green
3
-   Blue

有序列表#

HTML 标签：<ol>

有序列表使用数字加英文句点：

代码：

1
1.  Bird
2
2.  McHale
3
3.  Parish

预览：

Bird
McHale
Parish

注意：像下面这样可能会“意外触发”有序列表：

代码：

1
1986. What a great season.

预览：

What a great season.

你可以用反斜杠转义 (\) 句点：

代码：

1
1986\. What a great season.

预览：

1986. What a great season.

列表中的缩进内容#

列表项里的引用#

在列表项内放置引用，需要将 > 符号整体缩进：

代码：

1
*   A list item with a blockquote:
2

3
    > This is a blockquote
4
    > inside a list item.

预览：

A list item with a blockquote:

This is a blockquote inside a list item.

列表项里的代码块#

在列表项内放置代码块，需要缩进两层——8 个空格或两个 Tab：

代码：

1
*   A list item with a code block:
2

3
        <code goes here>

预览：

A list item with a code block:
```
1
<code goes here>
```

嵌套列表#

代码：

1
* A
2
  * A1
3
  * A2
4
* B
5
* C

预览：

A
- A1
- A2
B
C

代码块#

HTML 标签：<pre>

将代码块中的每行缩进至少4 个空格或1 个制表符。

代码：

1
This is a normal paragraph:
2

3
    This is a code block.

预览：

This is a normal paragraph:

1
This is a code block.

代码块会一直持续，直到遇到未缩进的行（或文末）。

在代码块内，与号 (&) 和尖括号 (< >) 会自动转为 HTML 实体。

代码：

1
    <div class="footer">
2
        &copy; 2004 Foo Corporation
3
    </div>

预览：

1
<div class="footer">
2
    &copy; 2004 Foo Corporation
3
</div>

下文的“围栏代码块”和“语法高亮”属于扩展语法，你也可以用它们来书写代码块。

围栏代码块#

使用成对的反引号围起来（如下所示），就不需要四空格缩进了。

代码：

1
Here's an example:
2

3
```
4
function test() {
5
  console.log("notice the blank line before this function?");
6
}
7
```

预览：

Here’s an example:

1
function test() {
2
  console.log("notice the blank line before this function?");
3
}

语法高亮#

在围栏代码块后添加可选的语言标识，即可启用语法高亮（参见支持语言列表）。

代码：

1
```ruby
2
require 'redcarpet'
3
markdown = Redcarpet.new("Hello World!")
4
puts markdown.to_html
5
```

预览：

1
require 'redcarpet'
2
markdown = Redcarpet.new("Hello World!")
3
puts markdown.to_html

分割线（水平线）#

HTML 标签：<hr /> 一行中放置三个或以上的短横线 (-)、星号 (*) 或下划线 (_)。符号之间允许有空格。

代码：

1
* * *
2
***
3
*****
4
- - -
5
---------------------------------------
6
___

预览：

表格#

HTML 标签：<table>

这是扩展语法。

用竖线 (|) 分隔列，用短横线 (-) 分隔表头，使用冒号 (:) 指定对齐方式。

两侧的竖线 (|) 与对齐可选。用于表头分隔时，每列至少需要 3 个短横线。

代码：

1
| Left | Center | Right |
2
|:-----|:------:|------:|
3
|aaa   |bbb     |ccc    |
4
|ddd   |eee     |fff    |
5

6
 A | B
7
---|---
8
123|456
9

10

11
A |B
12
--|--
13
12|45

预览：

Left	Center	Right
aaa	bbb	ccc
ddd	eee	fff

A	B
123	456

A	B
12	45

内联元素#

链接#

HTML 标签：<a>

Markdown 支持两种链接样式：行内链接与引用式链接。

行内链接#

行内链接格式：[文本](URL "标题")

标题可选。

代码：

1
This is [an example](http://example.com/ "Title") inline link.
2

3
[This link](http://example.net/) has no title attribute.

预览：

This is an example inline link.

This link has no title attribute.

如果引用同一站点的本地资源，可以使用相对路径：

代码：

1
See my [About](/about/) page for details.

预览：

See my About page for details.

引用式链接#

可以预定义链接引用。定义格式：[id]: URL "标题"

标题同样可选。引用时使用：[文本][id]

代码：

1
[id]: http://example.com/  "Optional Title Here"
2
This is [an example][id] reference-style link.

预览：

This is an example reference-style link.

说明：

方括号中包含链接标识（不区分大小写，可在左侧缩进最多三格空格）；
随后是冒号；
再跟一个或多个空格（或 tab）；
然后是链接 URL；
URL 可选地用尖括号包裹；
可选地跟随标题属性，用引号或圆括号包裹。

以下三种定义等价：

代码：

1
[foo]: http://example.com/  "Optional Title Here"
2
[foo]: http://example.com/  'Optional Title Here'
3
[foo]: http://example.com/  (Optional Title Here)
4
[foo]: <http://example.com/>  "Optional Title Here"

如果使用空的方括号，则链接文本本身会作为名称。

代码：

1
[Google]: http://google.com/
2
[Google][]

预览：

Google

强调#

HTML 标签：<em>，<strong>

Markdown 使用 星号 (*) 或 下划线 (_) 表示强调。一个分隔符对应 <em>；两个分隔符对应 <strong>。

代码：

1
*single asterisks*
2

3
_single underscores_
4

5
**double asterisks**
6

7
__double underscores__

预览：

single asterisks

single underscores

double asterisks

double underscores

但如果两侧有空格，则会被视作普通字符而非强调语法。

你可以使用反斜杠进行转义：

代码：

1
\*this text is surrounded by literal asterisks\*

预览：

*this text is surrounded by literal asterisks*

行内代码#

HTML 标签：<code>

用反引号 (`) 包裹。

代码：

1
Use the `printf()` function.

预览：

Use the printf() function.

若行内代码中需要包含反引号字符，可使用多重反引号作为定界符：

代码：

1
``There is a literal backtick (`) here.``

预览：

There is a literal backtick (`) here.

行内代码两侧的定界符允许包含空格（开头一个、结尾一个），方便在代码起始或结尾放置反引号字符：

代码：

1
A single backtick in a code span: `` ` ``
2

3
A backtick-delimited string in a code span: `` `foo` ``

预览：

A single backtick in a code span: `

A backtick-delimited string in a code span: `foo`

图片#

HTML 标签：<img />

Markdown 的图片语法与链接类似，支持行内与引用两种方式。

行内图片#

行内图片语法：![替代文本](URL "标题")

标题可选。

代码：

1
![Alt text](/path/to/img.jpg)
2

3
![Alt text](/path/to/img.jpg "Optional title")

预览：

Alt text

说明：

一个感叹号 !；
后接方括号，放置图片的替代文本；
再接圆括号，内含图片 URL/路径，及可选的标题（引号包裹）。

引用式图片#

引用式图片语法：![替代文本][id]

代码：

1
[img id]: https://s2.loli.net/2024/08/20/5fszgXeOxmL3Wdv.webp  "Optional title attribute"
2
![Alt text][img id]

预览：

Alt text

删除线#

HTML 标签：<del>

这是扩展语法。

GFM 增加了删除线语法。

代码：

1
~~Mistaken text.~~

预览：

Mistaken text.

杂项#

自动链接#

Markdown 支持一种便捷写法来创建“自动链接”（URL 与邮箱地址）：只需用尖括号将其包住即可。

代码：

1
<http://example.com/>
2

3
<address@example.com>

预览：

http://example.com/

address@example.com

GFM 会自动识别标准 URL 并转换为链接。

代码：

1
https://github.com/emn178/markdown

预览：

https://github.com/emn178/markdown

反斜杠转义#

Markdown 允许使用反斜杠来转义那些本用于 Markdown 语法的特殊字符，使其按字面显示。

代码：

1
\*literal asterisks\*

预览：

*literal asterisks*

以下字符可通过反斜杠转义以按字面量输出：

Code:

1
\   backslash
2
`   backtick
3
*   asterisk
4
_   underscore
5
{}  curly braces
6
[]  square brackets
7
()  parentheses
8
#   hash mark
9
+   plus sign
10
-   minus sign (hyphen)
11
.   dot
12
!   exclamation mark

内联 HTML#

对于 Markdown 语法未覆盖的标记，直接使用原生 HTML 即可。无需特别声明从 Markdown 切换到 HTML，直接写标签就行。

代码：

1
This is a regular paragraph.
2

3
<table>
4
    <tr>
5
        <td>Foo</td>
6
    </tr>
7
</table>
8

9
This is another regular paragraph.

预览：

This is a regular paragraph.

Foo

This is another regular paragraph.

请注意：在块级 HTML 标签内不会处理 Markdown 语法。

与块级标签不同，在行内级标签内会处理 Markdown 语法。

代码：

1
<span>**Work**</span>
2

3
<div>
4
    **No Work**
5
</div>

预览：

Work

**No Work**

***

MDX 格式文章示例

Fri, 01 May 2026 00:00:00 GMT

Tip

Firefly 支持 MDX 和 Markdown 两种类型的文章，你可以在文章中混合使用两种格式，如果没有特别复杂内容和需求，推荐使用 Markdown 格式就够了。

Markdown 和 MDX 的区别#

Markdown (MD) 是一种轻量级标记语言，允许用户使用纯文本格式编写文档，然后将其转换为格式化的HTML。它因其简洁易用的语法而广受欢迎，特别适合编写文档和博客文章。
MDX 是一种扩展了 Markdown 语法的格式，允许在 Markdown 文档中无缝地插入 JSX 代码。通过 MDX，用户可以在文档中嵌入 React 组件，从而实现更丰富的交互性和动态性。

特性	Markdown	MDX
基础语法	支持 (CommonMark)	支持 (CommonMark)
HTML 标签	支持	支持 (作为 JSX)
组件导入	不支持	支持 (import)
动态数据	不支持	支持 (JS 表达式)
样式定制	有限 (class/style)	灵活 (className/CSS-in-JS)

Firefly 内置的专属 MDX UI 组件#

这里列出 Firefly 内置的 MDX UI 组件，方便在 MDX 文章中直接使用。

Tab分组：`TabGroup`#

用于创建可切换的标签页，方便在文章中展示不同语言或不同版本的代码等等。

1
<TabGroup labels={["test.js", "test.py"]} client:load>
2
  ```js
3
  console.log(1)
4
  ```
5

6
  ```py
7
  print("hello world")
8
  ```
9
</TabGroup>

test.jstest.py

1
console.log(1)

1
print("hello world")

时间线：`Timeline` / `TimelineItem`#

属性	必填	说明
`date`	否	时间标签，如 “2024-03-10”
`title`	否	条目标题
`type`	否	节点颜色，default 为主题色，其余对应提示框色板（tip / note / important / warning / caution）
`icon`	否	内置图标名，显示在圆点内：star / rocket / git / flag / book / heart / zap / bug / tag / calendar / code / edit
正文	否	`<TimelineItem>` 标签内的内容，支持 Markdown

1
<Timeline>
2
  <TimelineItem date="2026-08-16" title="新版本发布" icon="rocket">
3
    发布了全新版本，带来以下更新：
4

5
    - 新增时间线组件
6
    - 改进暗色主题
7

8
    正文里支持 **Markdown** 内容。
9
  </TimelineItem>
10
  <TimelineItem date="2025-11-02" title="站点上线" type="tip" icon="flag">
11
    欢迎来到我的博客。
12
  </TimelineItem>
13
  <TimelineItem date="2025-06-15" title="项目立项" type="note">
14
    开始规划 Firefly 主题。
15
  </TimelineItem>
16
</Timeline>

展开收起

2026-08-16
新版本发布
发布了全新版本，带来以下更新：
- 新增时间线组件
- 改进暗色主题
正文里支持 Markdown 内容。
2025-11-02
站点上线
欢迎来到我的博客。
2025-06-15
项目立项
开始规划 Firefly 主题。

步骤条：`Steps` / `StepItem`#

编号步骤条，适合教程、部署流程。编号自动生成，无需手动传序号。

属性	必填	说明
`title`	否	步骤标题
`type`	否	编号圆颜色，default 为主题色，其余对应提示框色板（tip / note / important / warning / caution）
`icon`	否	内置图标名，有图标时显示图标而非数字（star / rocket / git / flag / book / heart / zap / bug / tag / calendar / code / edit）
正文	否	`<StepItem>` 标签内的内容，支持 Markdown

1
<Steps>
2
  <StepItem title="安装依赖">
3
    运行 `pnpm install`。
4
  </StepItem>
5
  <StepItem title="启动开发服务器" type="tip" icon="rocket">
6
    运行 `pnpm dev`，打开 `localhost:4321`。
7
  </StepItem>
8
  <StepItem title="编写文章">
9
    在 `src/content/posts/` 新建 `.mdx` 文章。
10
  </StepItem>
11
</Steps>

安装依赖
运行 pnpm install。
启动开发服务器
运行 pnpm dev，打开 localhost:4321。
编写文章
在 src/content/posts/ 新建 .mdx 文章。

徽章：`Badge`#

内联彩色小徽章，可嵌在段落或标题里。

属性	必填	说明
`type`	否	default 为主题色，其余对应提示框色板（tip / note / important / warning / caution）

1
<Badge type="tip">提示</Badge> <Badge type="warning">注意</Badge>

新功能提示笔记重要注意危险

更多信息，请查看 MDX 文档

在文章中嵌入视频

Fri, 01 May 2026 00:00:00 GMT

只需从 YouTube 或其他平台复制嵌入代码，然后将其粘贴到 markdown 文件中。

1
---
2
title: 在文章中嵌入视频
3
published: 2023-10-19
4
// ...
5
---
6

7
<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

符号	代码	渲染结果
Alpha	`\alpha`	α\alphaα
Beta	`\beta`	β\betaβ
Gamma	`\Gamma`	Γ\GammaΓ
Pi	`\pi`	π\piπ
Infinity	`\infty`	∞\infty∞
Right Arrow	`\rightarrow`	→\rightarrow→
Partial	`\partial`	∂\partial∂

hecloud.top

我和计算机

总有一天我会搞清楚所有的细节

05异常-断言-日志

第 7 章 异常、断言和日志#

7.1 处理错误#

7.1.1 异常分类#

7.1.2 声明检查型异常#

7.1.3 如何抛出异常#

7.1.4 创建异常类#

7.2 捕获异常#

7.2.1 捕获异常概述#

7.2.2 捕获多个异常#

7.2.3 再次抛出异常与异常链#

7.2.4 finally子句#

7.2.5 try-with-resources语句#

7.2.6 分析栈轨迹元素#

7.3 使用异常的技巧#

7.4 使用断言#

7.4.1 断言的概念#

7.4.2 启用和禁用断言#

7.4.3 使用断言完成参数检查#

7.4.4 使用断言提供假设文档#

7.5 日志#

7.5.1 基本日志#

7.5.2 高级日志#

7.5.3 修改日志管理器配置#

7.5.4 本地化#

7.5.5 处理器#

7.5.6 过滤器#

7.5.7 格式化器#

7.5.8 日志技巧#

7.6 调试技巧#

附录#

常见异常速查#

04接口与lambda（案例）

InterfaceLambdaTraining 练习代码#

二十岁，以及下一个十年

你好20岁#

七千三百天#

展望十年#

写在最后#

04接口-lambda-内部类

第 6 章 接口、lambda 表达式与内部类#

6.1 接口#

6.1.1 接口的概念#

6.1.2 接口的属性#

6.1.3 接口与抽象类#

6.1.4 静态和私有方法#

6.1.5 默认方法#

6.1.6 解决默认方法冲突#

6.1.7 接口与回调#

6.1.8 Comparator#

6.1.9 对象克隆#

6.2 lambda 表达式#

6.2.1 为什么引入 lambda 表达式#

6.2.2 lambda 表达式的语法#

6.2.3 函数式接口#

6.2.4 方法引用#

6.2.5 构造器引用#

6.2.6 变量作用域#

6.2.7 处理 lambda 表达式#

6.2.8 再谈 Comparator#

6.3 内部类#

6.3.1 使用内部类访问对象状态#

6.3.2 内部类的特殊语法规则#

6.3.3 内部类是否有用、必要和安全#

6.3.4 局部内部类#

6.3.5 由外部方法访问变量#

6.3.6 匿名内部类#

6.3.7 静态内部类#

6.4 服务加载器#

6.5 代理#

6.5.1 什么时候用#

6.5.2 造一个代理#

6.5.3 代理类的特性#

12进阶:出事了怎么查

第 12 关 出事了怎么查#

12.1 先看它是死是活#

12.2 退了？先看日志#

第 7 章异常、断言和日志#

第 6 章接口、lambda 表达式与内部类#

第 12 关出事了怎么查#

12.3 `docker inspect`：字段怎么读#

第 11 关日志与磁盘治理#

11.4 为什么 `prune` 治不了根#

第 5 章继承#