企业官网建设流程全解析

整理一份Java单词手册这件事，听起来像是学生时代抄单词本的活儿。但真正进入开发或者开始准备面试时你会发现，很多问题卡住你的不是语法不会写，而是连报错信息里的关键词都看不懂。所谓"单词盲"，一旦攻克，很多东西是串联着一起通透的。我会按照学习Java和面试复习的实际顺序来整理这套词汇，既覆盖最基础的关键字，也把JVM、Spring这些工程化概念里必须懂的术语拉进来，每个词都会讲清楚它是干什么的、为什么要这么叫、以及最常见的坑在哪里。

如果你正在学Java基础，或者刷面试题时发现自己对某些术语总是"见过但说不清"，这篇文章就是按我的经验帮你把这些词理成一张网。它不是API文档，也不是教科书，更像是我做了几年Java开发后回头画的一张重点词地图。

1. 为什么Java学习要专门做词汇梳理，这套汇总解决什么问题

1.1 语言本身的"词"决定你的思维方式

Java是一门关键字丰富、体系严格的语言，这跟Python、JavaScript那种"少关键字、多语法糖"的风格很不一样。比如public、protected、private还有默认权限，这四个词解决的是"谁能访问"；static、final、abstract解决的是"这个成员到底怎么存在、能不能被改、要不要被实现"。这些词的意义不是背下来就完事，它们直接决定你写出来的类边界、生命周期和扩展方式。

我给很多刚入门的朋友做过梳理，发现大家最容易卡住的不是"怎么用"，而是"为什么要这样设计"。比如final修饰类时表示"这个类不能被继承"，很多人会问，不让继承不是限制我发挥吗。这样的问题说明你对final这个词的理解只停留在"不能被改"，没有进入设计语义。一套把单词和语义绑在一起的汇总，恰恰能把这种"知其然不知其所以然"的缺口补上。

1.2 Step-17在整个学习路线中的定位

如果你跟着一套循序渐进的Java教程走，前面的step通常在做环境搭建、第一个程序、变量赋值这些基础动作。到了step-17这种阶段，往往是已经接触了类、对象、继承，开始产生混乱感的时候：equals和==到底什么区别，ArrayList和LinkedList用哪个，Exception和RuntimeException为什么有的必须捕获有的不用。

词汇汇总在这个阶段的价值，是把之前碰到的所有"模糊概念"集中清理一遍。它不是在给你讲一个新的API，而是帮你把所有学过的东西整合成一套"可用的话术"。面试时你能把volatile说清楚，不只是因为你记住了"可见性"，而是因为你脑子里同时挂着主内存、工作内存、重排序、synchronized这一串相关词，它们彼此之间是有逻辑关系的。

1.3 这套词汇汇总和普通文档的区别

普通API文档是按字母表或者包结构组织的，比如java.util下面有什么接口、什么类、每个方法的参数是什么。这种文档适合查，不适合建立认知。单词汇总则应该按"人在思考时的顺序"来组织：先有需求，再有对应的术语，最后落到API细节。

举个例子，看完这套汇总你应该能这样去理解一段代码：

List<String> names = new ArrayList<>();

• List是"接口"，它定义的是集合该有哪些行为（增删改查）
• ArrayList是"实现类"，它选择用数组这个底层结构来实现List
• <>里的String是"泛型"参数，它约束这个集合只能放字符串
• 整体赋值给一个List类型的变量，这体现的是"面向接口编程"

如果每个词都能拆成这样一句大白话，你的Java基础就不可能是散的。这也是我在整个step系列里反复强调的事情：语法细节会过时，但词汇背后的语义模型是稳定的。

2. 基础语法类词汇，从标识符到控制流的关键术语

2.1 标识符命名规则，Java里的"起名字规矩"

标识符这个词虽然在报错信息里经常出现（illegal identifier就是其中之一），但很多人对它只停留在"变量名"。其实Java对标示符有一套强制规则：必须用字母、下划线、美元符号开头，不能以数字开头，不能用Java关键字，理论上可以包含Unicode字符（比如中文变量名也能跑），但工程里没人这么干。

命名规则里我踩过最典型的坑是"包名"与"关键字冲突"。比如有个老系统，同事建包时用了com.xxx.domain，没问题；但如果你不小心用com.xxx.com这种倒也无所谓，真正会崩的是导入包路径里出现com.xxx.class，class是关键字，直接编译失败。所以我的建议是，包名用全小写，变量用驼峰，常量用全大写加下划线，类名首字母大写。这些约定不是语言强制，但是工程上必须守的"软规则"。

除了标识符本身，还有一个词跟它紧密相关——keyword（关键字）。Java的关键字是编译器承认的、有固定意义的单词，比如if、else、while、for、return、new、package等等。它们不能被用作变量名或类名。另外还有一组"保留字"，比如true、false、null，严格说它们是字面量而不是关键字，但也同样不能拿来命名。

2.2 数据类型、变量与运算符，先把"盒子模型"想明白

Java的数据类型可以分成两大阵营：基本类型（primitive type）和引用类型（reference type）。基本类型就是那些直接存值的类型：byte、short、int、long、float、double、char、boolean。引用类型则包括类、接口、数组、枚举。

引用类型这个词，关键在于"引用"（reference）。Java没有指针这个词，但引用在很多场景下就是"安全的指针"。比如：

Person p = new Person();

p本身不持有Person对象，它持有的是"能定位到那个对象的方式"，在JVM里通常就是一个指针或对象句柄。这个概念非常重要，因为所有的方法传参问题都源于它：基本类型传值，引用类型传引用副本。很多人搞不懂"Java到底是值传递还是引用传递"，本质上就是没把"reference"这个词想透。正确答案是：Java永远都是值传递，只不过引用类型传的是引用的值。

运算符这块，我特别提醒一个高频误解——==和equals。==比较的是"值"，对基本类型来说直接比较数值，对引用类型来说比较的是"引用指向的地址"。equals方法是定义在Object里的，默认实现就是用==，所以如果你不重写，两个内容相同但对象不同的实例用equals比较也会是false。重写equals时还有一个配套词叫hashCode，这条铁律我在第5章再细说。

2.3 控制流词汇：分支、循环与跳转，用词判断代码走向

控制流相关的关键词大概是if、else、switch、case、default、for、while、do、break、continue、return。这几个单词本身不重要，重要的是它们的"陷阱点"。

switch在老版本的Java里只能匹配整数类型（int及兼容类型）和枚举，后来才支持String。这里有个隐藏的坑：匹配是从上往下的，而且case匹配成功后如果没有break，会一路"穿透"执行下去，这叫fall-through。很多初学者在这上面栽过跟头，看到一个case后面没写break，结果把下面所有分支都执行了。

break和continue的区别也值得用词义来记忆：break是"打破"整个循环结构，直接跳出去；continue是"继续"，但它是跳过当前这轮循环的剩余代码，直接进入下一轮的判断条件。这两个词加上return，构成了你控制方法内部逻辑流向的基本语法。理解它们，比看任何流程图都管用。

3. 面向对象核心词汇，类和对象的语义才是Java的灵魂

3.1 class、object、instance，三个很难分的词

class（类）是模板，object（对象）是真实存在的实体，instance（实例）强调"从某个类创建出来的"这个结果。这三者关系可以用一个生活类比来讲：class是蛋糕模具，object是烤出来的那个蛋糕，instance强调"这个蛋糕是某个模具做出来的"，所以我们会说instance of a class。

在Java代码层面，你写Person这个类时，它只是一个"蓝图"。只有通过new关键字（或者反射、克隆、反序列化等方式）才能创建出实际的object。创建出的每个object都会有自己独立的成员变量存储空间，但共享类里定义的方法代码。new这个单词也很形象，它的意思就是"给我造一个新的实例出来，并且调用它的构造器"。

构造器本身也是一个常考的词汇点，英文是constructor。它跟普通方法的区别有三个：名字必须和类名一致，没有返回值类型，不能用static修饰。我见过不少人把constructor误以为是"返回了一个对象的方法"，其实更准确地说，构造器是完成"对象初始化"的专门过程。在字节码层面，new先分配内存，然后调用<init>方法完成初始化，这两步不是一个东西。

3.2 继承、多态、封装，用词记住设计思路

面向对象三大特性——封装（encapsulation）、继承（inheritance）、多态（polymorphism）——对应的英文单词本身就藏着设计思路。

encapsulation的词根是"capsule"（胶囊），意思是把数据和操作数据的方法包在一个壳里，对外只暴露接口，不暴露内部细节。在Java中体现为权限控制符：private私有的，default包内可见，protected子类可见，public谁都能用。在工程上，我们通常要求成员变量private，通过getter/setter访问，以此保证封装。

inheritance对应Java的extends关键字。它的设计动机是代码复用和层次抽象。但子类继承父类时有一个千万不能搞混的词：super。super不是"父类对象"，它是用来访问父类成员的"引用"或者说是一个特殊语法。构造子类实例时，必须先调用父类构造器（隐式或显式调用super()），否则编译都不通过。

polymorphism可能是这几个词里最微妙的一个。多态在Java里的具体表现是：父类引用指向子类对象，调用方法时动态绑定到子类实现。比如：

Animal a = new Dog(); a.sound(); // 实际执行的是Dog里的sound()

这里涉及两个相关的词：编译期类型（静态类型）和运行期类型（动态类型）。a的编译期类型是Animal，所以你不能用a调用Dog独有的方法；但运行期JVM会识别a实际指向的对象是Dog，所以方法调用会走Dog的实现，这也叫动态绑定（dynamic binding）。如果你需要用子类独有的功能，就得先把a强制转换回Dog，这就是cast。强制转换如果不安全会抛出ClassCastException，所以通常配合instanceof做类型检查。

3.3 重载、重写、隐藏，面试中最经典的一词三坑

overload（重载）和override（重写）是英语里非常接近、中文里也让人头疼的两个词。我的记忆方法是：

• overload是"过载"，同一个类里多个方法用相同名字、不同参数列表，编译期就能决定调用哪个，相当于一个名字承载了多个版本。
• override是"覆盖"，子类方法把父类方法重新实现一遍，方法签名必须相同（或至少参数兼容），调用哪个版本是运行期决定的。

还有一个相对小众但老面试官爱问的是hide（隐藏）。如果子类定义了一个和父类同名的静态方法，或者同名的成员变量，那就叫"隐藏"。静态方法没有动态绑定，所以你让父类引用调用那个静态方法时，执行的是父类的版本；变量也是，引用类型决定你访问到哪个变量。这三个词放在一起，能解释很多"为什么运行结果不是我预期"的问题。

另外final也在这里参与搅局：final方法不能被override，final类不能被继承。所以面试题经常问"final、finally、finalize的区别"——finally是异常处理的收尾块，finalize是被垃圾回收器调用前的回调方法，已经被标记为废弃，这几个词除了长得像没有任何关系，但就是能在八股题里翻来覆去考。

4. 集合、泛型与函数式词汇，进阶开发绕不开的词

4.1 集合家族：List、Set、Map的语义边界

Java里集合框架（Collection Framework）这片术语非常多。最核心的大类就是Collection接口，下面分成List（列表）、Set（集合）、Queue（队列）三大子接口，另有一个独立的Map（映射）体系。

List强调有序、可重复。有序意味着有索引（index），可重复意味着可以存相同对象。ArrayList基于数组实现，LinkedList基于双向链表实现。面试经典题"ArrayList和LinkedList区别"，背下来很容易，但理解语义更重要：ArrayList适合随机访问（get快），LinkedList适合频繁插入删除（在中间插入时不需要搬移元素）。实际开发里，LinkedList的插入优势也很有限，因为需要额外维护节点指针，而且数组拷贝在大多数场景下并没有那么慢，所以别迷信"链表一定更快"。

Set强调唯一、无序（至少HashSet是无序的）。Set底层很多是用Map实现的，比如HashSet内部就是一个HashMap，元素放在key的位置，value放一个固定的占位对象。理解了这个，你就能理解为什么HashSet的元素必须正确重写equals和hashCode，否则"去重"是去不了的。

Map是键值对，够形象。HashMap基于哈希表，TreeMap基于红黑树，LinkedHashMap在哈希表基础上维护了插入顺序。记这些词时关键是记住一个底层结构对应一种语义：哈希表追求快，树追求有序，链表结构追求顺序稳定。

4.2 泛型：把类型当作参数来传递

generic（泛型）这个词的本质是"类型的参数化"。在你写一个类或方法时，可以不指定具体类型，留一个占位符，比如T、E、K、V，使用时才确定。这带来的最大好处是编译期类型安全。

常见的泛型词汇还有：type parameter（类型参数）、type argument（实际类型参数）、wildcard（通配符，就是?）。?有两种常用姿势：? extends T表示上限通配符，可以接收T或T的子类；? super T表示下限通配符，可以接收T或T的父类。很多资料用PECS原则来记："Producer Extends, Consumer Super"——如果你从集合里"生产"数据往外读，用extends；如果你往集合里"消费"哦不，"投入"数据，用super。

泛型里还有一个最容易出错的词是List<Object>和List<String>之间的关系。很多人以为List<String>是List<Object>的子类型，可以随意赋值，但这是错的，因为泛型默认是不变的（invariant）。如果要让两个不同的泛型类型之间有父子关系，必须显式使用通配符。这个坑在写一个通用的方法参数时太常见了。

4.3 Lambda、Stream与函数式接口，用"流"的方式重看集合

Java 8之后出现了一大批新词汇：lambda expression（lambda表达式）、functional interface（函数式接口）、stream（流）、method reference（方法引用）、optional（可选值）。这些词背后其实是一个思想：把"行为"作为参数传递，而不是纯把"数据"作为参数传递。

以forEach为例：

list.forEach(item -> System.out.println(item));

这里item -> ...就是一个lambda表达式，它本质上实现了一个函数式接口（比如Consumer）。::是方法引用，list.forEach(System.out::println)就是上面那句的简化写法。

Stream本身的词义强调"流水线处理"。它的典型操作分两类：中间操作（intermediate operation）和终端操作（terminal operation）。中间操作比如map、filter、sorted，它们返回的是一个新的stream，延迟执行；终端操作比如forEach、collect、count，它们触发真正的计算，执行完stream就关闭了。

这里有个实战提醒：stream不是集合，它不存储数据，只是对数据源的一个视图。而且stream只能消费一次，第二次遍历就会报"stream has already been operated upon or closed"。这些词搞清楚之后，你再看网上那些流式处理代码就不会一头雾水了。

5. 异常、并发与JVM词汇，进阶路上的拦路虎

5.1 异常体系：从throwable到exception再到error

Java的异常体系顶层的词是Throwable，它下面两大家族：Exception（异常，程序可以恢复处理）和Error（错误，通常是JVM级别的问题，比如内存耗尽OutOfMemoryError）。编程时我们要处理的主要是Exception。

Exception又分checked exception（编译期异常/受检异常）和unchecked exception（运行期异常/非受检异常）。受检异常比如IOException、SQLException，编译器强制你捕获或者声明抛出，否则无法编译。非受检异常比如NullPointerException、ArrayIndexOutOfBoundsException，它继承自RuntimeException，编译器不强制处理，代码运行时才暴露。

我经常跟人说，理解异常的关键词是"职责分离"：throws是方法级别声明"我可能会抛出这个异常，调用者你来管"；throw是主动抛出一个异常对象。三者的配合关系经常让新手混乱。举个标准例子：

public void checkAge(int age) { if (age < 0) { throw new IllegalArgumentException("年龄不能为负数"); } }

这里的IllegalArgumentException是RuntimeException的子类，所以不需要throws声明，但它一抛出来，调用方没接住就会导致线程终止。处理异常时还有try、catch、finally三个词，try圈定监控范围，catch捕获对应类型的异常，finally保证无论如何都会执行的善后代码。Java 7之后又多了一个"try-with-resources"语法，配合AutoCloseable接口，资源可以不写在finally里手动关。

5.2 并发编程核心词：线程、锁、同步与内存可见性

并发这块是面试重灾区，也是词汇密度最高的部分。

thread（线程）是操作系统能调度的最小执行单元。Java里标准创建线程的方式是继承Thread类或实现Runnable接口，但因为有线程池的存在，现在更推荐提交Callable到线程池，拿到Future去拿结果。这里Runnable和Callable的区别是：Runnable的run方法没有返回值，也不抛受检异常；Callable的call方法有返回值，可以抛异常。

synchronized是Java最基础的同步机制。它可以用在方法上，也可以用在代码块上，底层是监视器锁（monitor）。之所以叫synchronized，就是保证多个线程访问共享资源时"同步进行"，不互相踩踏。与synchronized相对或配合出现的词有：lock（锁）、volatile（易变的/可见的）、atomic（原子的）。volatile是最容易误解的词：它保证的是可见性和禁止指令重排序，不保证原子性。比如i++这种操作，就算声明了volatile，多线程下依然可能丢数据，因为"读-改-写"不是原子的。

deadlock（死锁）也是个高频词。两个或更多线程互相持有对方等待的锁，谁都等不到，程序就卡死了。排查死锁可以通过jstack工具抓线程转储（thread dump）看锁状态。这是每个Java开发都该掌握的基本操作。

5.3 JVM内存词汇：堆、栈、元空间与垃圾回收

JVM（Java Virtual Machine）本身的词就不少，其中跟日常写代码最相关的是内存区域划分。

• heap（堆）：存放对象实例，是垃圾回收（GC）的主要区域。
• stack（虚拟机栈）：每个线程私有，存局部变量表、操作数栈、方法调用信息。方法调用一次，就有一个栈帧（stack frame）入栈。
• meta space（元空间）：JDK 8之后替代“永久代”存放类的元数据信息。
• PC register（程序计数器）：记录当前线程正在执行的字节码地址。

垃圾回收相关的词主要有GC Roots（根引用）、reachable（可达）、mark-sweep（标记-清除）、copying（复制）、generational（分代），以及各种收集器名称如G1、ZGC。面试问到GC时，重点不是你记住所有收集器的参数，而是能说清楚"判断对象可以被回收的起点是GC Roots，通过引用链可达性分析，如果对象不可达就会被标记，然后视具体收集器算法回收"。

JVM调优相关还有两个实用命令词汇：jmap（堆内存快照）和jstat（JVM统计信息）。写代码时不容易碰到，但内存溢出排查时它们就是救命的词。学JVM词汇的节奏，我建议不要一上来啃整本实践书，先把堆、栈、方法区、GC Roots、类加载器、双亲委派这些名词吃透，再配合一次真实的线上OOM排查，全记住了。

6. 工程化与框架词汇，从语言走向真实项目

6.1 容器与框架：Spring、Spring Boot、MyBatis的必备术语

Java程序员脱离纯语言之后，第一个面对的大词就是framework（框架），国内Java生态里绕不开的是Spring。

Spring的核心词首先是IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）。IoC的意思是"控制权反转"，以前你自己new对象，现在把创建和装配对象的控制权交给Spring容器；DI是实现IoC的主要方式，你只声明"我需要什么依赖"，容器会负责把对应实例塞进来。@Autowired这个注解干的活就是依赖注入，按类型去找Bean。

Bean这个单词更是贯穿始终。Spring里的bean就是被容器管理的一个对象实例。它的生命周期有：实例化、属性填充、初始化（InitializingBean、@PostConstruct）、使用、销毁（DisposableBean、@PreDestroy）。这些词如果你没梳理过，看到Spring启动日志里的"Creating bean"就会很懵。

AOP（面向切面编程）也是Spring生态的核心词，配套术语包括aspect（切面）、pointcut（切点）、advice（通知）、joinpoint（连接点）。常见场景就是事务管理：声明一个@Transactional注解，Spring在方法调用前开启事务、方法成功则提交、异常则回滚，这就是典型的AOP思路。

MyBatis这个持久层框架的术语相对直白：Mapper接口、SqlSession、parameterType、resultType。但有一个词值得特别注意：#{}和${}的区别。面试里高频出现，#{}是预编译参数占位符，会转成JDBC的?，能防止SQL注入；${}是字符串拼接，直接替换进去，有注入风险。这两个符号在SQL里的语义差别就是你工程安全意识的体现。

6.2 构建工具与版本控制：Maven、Gradle、Git的高频词

工程化另一个绕不开的词族是构建工具。Maven里的核心概念：POM（Project Object Model，项目对象模型，就是pom.xml文件）、dependency（依赖）、groupId、artifactId、version（这三个合起来定位一个依赖的坐标）、repository（仓库，分本地仓库、中央仓库、私有仓库）、lifecycle（生命周期，比如clean、validate、compile、test、package、verify、install、deploy）。

Gradle较于Maven更灵活，它引入了task（任务）的概念，用Groovy或Kotlin DSL写构建逻辑。实际开发中，你不需要把每个任务都理解透彻，但至少要知道assemble、build、clean这几个入门任务词，以及dependencies配置块。

版本控制里，Git是现在全世界的标配。核心词汇包括repository（仓库）、clone（克隆）、commit（提交）、branch（分支）、merge（合并）、rebase（变基）、fetch（拉取）、pull（拉取并合并）、push（推送）、conflict（冲突）。其中merge和rebase是很多人纠结的两个词。简单区分：merge会保留一条完整的分支合并记录，提交历史里有分叉再合回的形状；rebase是把你的提交"重放到"目标分支的最顶端，历史是线性干净的。合代码时用merge更保守，整理历史时用rebase更优雅，但要记住rebase会改写提交，协作分支上慎用。

6.3 面试题场景词汇：八股文的正确打开方式

如果你在准备Java面试，会经常听到一个词叫"八股文"，它代指那些高频出现的原理性问答。与其抵触它，不如把它理解为"每个词都要能展开讲三分钟"的能力训练。比如面试官问"HashMap是怎么实现的"，你需要能随口说出这些词：数组加链表、红黑树、哈希扰动、负载因子、扩容、头插法尾插法、线程安全。这些词串起来就是完整的答案。

面试里还有一批常考的"底层词汇"：反射（reflection）、代理（proxy）、序列化（serialization）、克隆（clone）。反射这个词的意思是程序在运行时能够获取一个类的完整结构（字段、方法、注解），甚至动态调用方法。很多框架的底层原理都靠反射实现。动态代理有JDK动态代理和CGLib代理两个方向，前者要求目标类实现接口，后者通过生成子类字节码实现，Spring AOP默认策略就会在这两者间做选择。

序列化也有两个词要分清：Serializable（Java原生序列化接口）和Externalizable（自定义序列化接口）。实际开发中，我更推荐用JSON这种文本格式做数据传输，Java原生序列化容易踩版本兼容的坑（serialVersionUID不一致就反序列化失败），这种细节如果没人提醒，确实容易掉进去。我提这些不是让你背答案，而是希望你把这些术语当作"定位工具"，遇到一个陌生的概念时，先在自己的词汇网上找它挂在哪个节点下，再顺着节点去补上下文。

7. 整套词汇的记忆方法与实操避坑心得

7.1 我整理Java单词卡的方法：按"报错驱动"来记

很多初学者背单词是按顺序背，比如今天背ArrayList、LinkedList，明天背HashMap、TreeMap，这样背完很容易串。我自己的实践是反过来，"报错驱动"——代码里报什么错，就去把对应的一串术语查明白。

比如第一次看到ConcurrentModificationException，这个异常单词很长，但它其实就在告诉你：在迭代集合的时候，集合被其他线程或者同线程内的操作修改了。顺着这个异常，你自然会查到fail-fast（快速失败）、modCount（修改计数器）、Iterator（迭代器）这几个词。一串词都记下来，以后在遍历时用removeIf或者直接收集到新列表再批量删除，就不会再踩这个坑。

用这个方法整理词汇的好处是每个词都有"使用场景"作为锚点，你回忆起来的是"当时那个报错是怎么解决的"，而不是单纯的单词表。我这套step系列里的词汇汇总，本质上就是按"学习路线+报错场景"两个维度串起来的，比按字母表排要容易吸收得多。

7.2 高频混淆点速查：我的个人纠错清单

下面是几个我在带新人和复习面试时反复强调的易混词对比，放到一张表里方便随时查。

这张表我没有放所有对比，只挑了我实际看到的、大家混淆概率最高的十组。把这张表的内容真正搞明白，胜过背一百个偏门API。

7.3 实操中容易忽略的三个细节

第一，hashCode和equals的结对关系。只要重写了equals，就必须重写hashCode，因为HashMap这类集合先算hashCode定位桶，再用equals在桶内比较。如果你只重写equals，同一个对象放进HashSet时，两次add会算到不同的桶，去重完全失效。这句话我几乎每次带人都会说一遍，百试百灵地让人恍然大悟。

第二，线程池的corePoolSize和maximumPoolSize别看英文名理解。core是常驻线程数，maximum是最多线程数，当队列（workQueue）满了，线程数才会从core往max扩。很多人把这两个词当成"一开始有几个、最后有几个"来用，导致线上线程数配置完全失真。

第三，transient关键字。它修饰的成员变量在序列化时会被跳过，很多老项目里缓存对象没注意这个，序列化后才发现大字段没有被存下来，数据恢复时是空的。尤其是在使用Redis缓存对象时，如果对象的某个字段标记了transient，那就默认不写入缓存，这不是bug，但它很容易被当成bug排查一整天。

7.4 后续怎么扩展这套词汇树

如果你已经把这篇里的单词都消化了，我觉得下一步可以按两条线走。一条是横向扩展：把Java生态里的常用框架逐个挑出一组核心词来学。比如Netty里的EventLoop、Channel、ByteBuf；Kafka里的topic、partition、offset、consumer group。每个框架学15个核心词，比看冗长的官方文档更容易建立骨架。另一条是纵向深入：选一个你工作中最常出问题的方向，比如并发，往下钻到AQS（AbstractQueuedSynchronizer）、CAS（Compare-And-Swap）、ReentrantLock的公平锁与非公平锁。这些词每弄懂一个，你对Java的理解就会扎深一层。

我自己的习惯是，每接触一个新的中间件或框架，都会先建一个20到30个术语的小清单，对着清单去查文档。等清单上的词都能不看资料说清楚，再开始写代码。这个习惯帮我在学新东西的时候少走了很多弯路。词汇表不是终点，它是你进入一门新知识的"先遣队"——先把地形摸清楚，再安排大军进场。

这套Java单词汇总写到这，基础语法、面向对象、集合、并发、JVM、工程框架这几个大块的词基本都覆盖了。你可以把它当作复习提纲，也可以当作排查报错时的思路索引。我个人在实际学习中最受益的做法，是每次遇到不确定的术语，就回到这篇文章里看看它挂在哪个主题下，然后顺着关联词往下追一层。Java知识的边界很大，但常用的、高频的词就那么一批，把这批词的语义彻底打通，你的Java就算真正入门了。