Java SE 17认证1Z0-829备考全攻略：核心考点、避坑与刷题策略

简介：面向备考Oracle认证专业开发者考试（1Z0-829）的Java开发者，这份PDF完整收录了《Java SE 17认证考试指南》的核心精华内容。全书从数据类型、运算符、控制流等基础语言特性讲起，逐步延伸到并发编程、模块化系统、输入输出与数据库连接等高级主题，覆盖认证考试的主要考点，并且对Java的细微差别和常见易错点做了重点标注，能帮助考生避开实战与考场中的典型陷阱。资源为单文件PDF，压缩包大小约35.07MB，结构清晰，便于在电脑或平板中按章节系统阅读、反复查阅。目前已有85人学习下载，适合正在冲刺Oracle 1Z0-829认证或希望巩固Java 17新特性的开发者。除考点讲解外，文件内还附有较多练习题与模拟考试内容，读者可以边学边测、查漏补缺，在熟悉真实考题风格的同时提升实际编程能力，为顺利通过认证并成长为更专业的Java开发者打下扎实基础。

1. Java SE 17 认证考试到底考什么：为什么值得花三个月去拿这张证

Java SE 17 认证（考试代码 1Z0-829）不是给刚写完入门程序的人准备的。它默认你已经在代码里泡过一段时间，有 Java 8 或 11 的使用经验，然后把你扔进一堆代码片段里，问你：这段能编译吗？输出是什么？抛不抛异常？最反直觉的地方是，很多业务开发在 IDE 里写代码很流畅，一看到这种题就懵，因为 IDE 已经帮你把编译错误和类型推断都处理掉了。这个考试本质是一次带出题人视角的语言体检，能帮你把 Java 17 这一版真正改了什么、类型系统怎么运作、Stream 和 lambda 在底层如何流转，一次性理清楚。适合正在用老版本、想升 17，或者团队需要一张硬核开发证书的人。三个月从零准备，不算慢。

2. 考试结构与备考路线：模块、题量、及格线，先把硬指标定准

备考要先看考试的硬指标和覆盖范围，再决定要不要投入时间。这个认证的考试形式比较固定，提前定好答题策略，后面刷题才知道按什么节奏来。常见做法是把备考拆成两个动作：第一阶段画知识地图，第二阶段才是刷题。先看硬指标。

2.1 考试硬指标：题量、时长、及格线，以及它们怎么影响答题策略

官方每年会微调考纲，但 1Z0-829 的整体框架相对稳定。以常规版为例，考试约 50 道题，时长 90 分钟，及格线在 63% 上下。也就是说，你可以错 18 道左右，容错率不算低，但考试里有多选题和代码判断题，一旦操作失误，实际扣分比预期更重。这套数字带来的第一个结论是：平均每题只有 1.8 分钟左右，遇到长代码题不能恋战。

下面是考试参数对照表，方便你规划每天的模拟训练。

这组参数还有一个隐藏信息：考试不考察 IDE 操作，也不需要手写完整工程，大量题目是“给一小段代码 + 四个选项”。所以训练重点不是搭项目，而是快速判断代码的编译期和运行期行为。平时在 IDE 里写代码，编译器会替你处理类型检查；考试里没有这个辅助，你必须把编译器的判断规则记在脑子里。

2.2 按模块拆知识树：把 50 道题映射到六个复习单元

把官方考纲翻译成自己的知识树，我习惯分成六个单元。这个分法不是教材目录，而是按“容易丢分的程度”重新归堆。基础语法和面向对象是地基，Stream 和 lambda 是分值高地，模块化、JDBC 这类离业务开发远的内容反而要花死记的功夫。

• 语言基础：数据类型、String、数组、var、运算符、控制流。这里没有太多抽象概念，但陷阱密集，比如Integer的缓存范围、String的不可变性、>>与>>>的区别。
• 面向对象：封装、继承、多态、抽象类、接口。重点不是会写，而是能判断“哪一个方法会被调用”。重载与重写、隐藏字段、默认方法冲突是必考点。
• 异常与断言：受检异常与非受检异常的分类、try-with-resources的资源关闭顺序、finally与return的相互影响。这部分题目短，但错误率很高。
• 集合、泛型、函数式编程：这里占的分值最高。ArrayList和LinkedList的区别、HashMap的遍历顺序、泛型擦除后的签名，以及 lambda 与 Stream 的串联。
• 并发与 IO/NIO.2：线程生命周期、synchronized与并发集合、Files与Path的读写操作。并发题的不确定性很强，需要理解内存可见性，而不是背输出。
• 模块化、JDBC、注解：记忆点密集。module-info.java的声明规则、JDBC 四个关键接口、注解的保留策略。适合放在备考后半程集中背。

每个单元分配多少时间，取决于你的基础。如果你平时主要在写 Web 业务，面向对象和异常问题不大，重点会落在 Stream、并发和模块化上。如果是从 Java 8 升上来的，还要额外花一周处理新语法。

2.3 备考路线：从 Java 8/11 迁移视角切入，比从零学快一倍

很多人上来就拿着考点列表背，结果背完就忘。更高效的路子是先建立“从旧版本迁移到 17”的视角：真正要补的不是 Java 基础，而是 17 相对 8/11 多出来的那部分，以及考试特别喜欢考的旧版语义。先跑通下面这条命令，确认你的本地环境是 JDK 17。

java -version javac --release 17 Hello.java java Hello

第一行确认 JVM 版本，第二行用--release 17编译，而不是只写-source 17或-target 17。这里有个常见误区：-source只是控制源码语法版本，-target控制字节码版本，并不限制 API 是否引用了更高版本的方法；--release会同时锁定源码、字节码和系统 API，避免你在 Java 17 里写着写着用上 Java 20 的 API。

把备考周期切成五个阶段，每阶段都要有验证动作，而不是“看完了”就算过。

• 第 1 到第 2 周：语言基础 + 面向对象 + 异常。验证方式：每天写 10 个“会不会编译、输出什么”的小判断，写在笔记里。
• 第 3 到第 4 周：集合、泛型、lambda、Stream。验证方式：每学一个流操作，用手写代码验证惰性执行，再对照结果。
• 第 5 周：并发 + IO/NIO.2。验证方式：用 20 行以内的代码分别跑一个线程生命周期案例和一个文件复制案例。
• 第 6 周：模块化 + JDBC + 注解。验证方式：本地建一个最小的模块化工程，写完module-info.java并成功编译运行。
• 考前 10 天：混合模拟题 + 错题复盘。验证方式：每周至少 3 套限时模拟，正确率逐步稳定到 70% 以上。

这个路线的核心逻辑是：先把能靠理解拿分的硬知识打牢，再集中处理需要死记的模块化、JDBC。别把时间花在反复看相同的视频讲义上，代码判断能力只能靠做题练出来。到第 4 周如果 Stream 题目正确率还不到一半，那就把刷题量加一倍，再看一遍结论，不要急着进入并发章节。

3. 核心考点逐个拆：lambda、stream、switch、record、sealed 这些新特性的底层逻辑

Java 17 相比 8/11，在语言层面最明显的增量是var、record、sealed class、switch表达式和文本块。这些新特性不只在考纲里占分，还会改变你看老代码的方式。很多陷阱题不是考 API 记没记住，而是考你对他背后的类型系统、编译规则和运行语义是否理解。下面按考试出现频率逐个拆。

3.1 var：局部变量类型推断不是随便替换类型名

var会从初始化表达式的静态类型推断变量类型，但它不是“万能类型”，也不是动态类型。它只能用于局部变量，不能用于成员字段、方法参数、返回值。lambda 参数可以用var，但一旦某个参数用了var，其他参数也必须都用var，而且不能混用具体类型。

var list = new ArrayList<String>(); // list 的编译类型是 ArrayList<String> list.add("exam"); java.util.function.Function<String, Integer> f = (var s) -> s.length(); // 合法，但很少这么写 // var bad = null; // 编译错误：null 没有可推断的具体类型 // var bad2 = (a, b) -> a + b; // 编译错误：lambda 缺少目标类型

第一个例子说明var推断出来的是最具体类型，而不是接口类型。如果你写var list = new ArrayList<String>()，后面的代码可以调用ArrayList独有的方法，这跟声明成List<String>的行为不一样。第二行是 lambda 参数的合法用法，但在考试里经常作为干扰项出现，你要记住它“编译合法”，只是实际项目里不会这么写。第三行和第四行是常见的编译错误选项，null没有任何类型信息，lambda 在赋值给var时没有目标类型可以推断。

考试里还有一种考法：var在循环变量里能正常使用，但在数组初始化简写里有讲究。var arr = new int[] {1, 2, 3}是合法的，var arr = {1, 2, 3}是非法的，因为数组初始化器不能作为独立的表达式推断类型。这种题目没有技巧，就是见一次记一次。

3.2 record：数据载体也有自己的规则

record是 Java 16 转为正式特性的，17 考试里一定会出现。它本质是一种不可变数据载体，编译器会根据组件自动生成构造器、equals、hashCode、toString和访问器方法。但自动生成不等于你可以完全不关心规则。

public record Person(String name, int age) { public Person { if (age < 0) { throw new IllegalArgumentException("age must be positive"); } } } Person p = new Person("u001", 20); System.out.println(p.name()); // 访问器是 name()，不是 getName() System.out.println(p);

这段代码里有三个考点。第一，紧凑构造器（compact constructor）不需要写参数列表，它会先执行你写的校验逻辑，再把参数自动赋值给字段。第二，访问器命名是name()、age()，不是getName()、getAge()，不少人在这一步被误导。第三，record的底层是 final 类，不能继承，也不能被继承，字段都是private final。

有的题会问：record 里能不能加实例字段？答案是不能。但你可以在 record 里加静态字段、静态方法和普通方法。还有一道高频题是问equals的语义：两个 record 实例只要组件值相等，equals就返回 true，这一点和普通类的默认Object.equals完全不同。

3.3 sealed：继承约束的边界条件

sealed的核心是限制谁能继承自己。你用permits把直接子类列表写清楚，列表之外的类如果强行继承，编译器直接报错。这个特性看起来简单，但考试会围绕三个边界条件出题。

sealed interface Shape permits Circle, Square {} final class Circle implements Shape {} non-sealed class Square implements Shape {} // class Triangle implements Shape {} // 编译错误：Triangle 不在 permits 列表中

第一，直接子类必须要么是final，要么是sealed，要么是non-sealed。漏掉这个修饰符基本都是编译错误。第二，permits列表里的子类必须和 sealed 类型在同一个模块里；如果没有模块，就在同一个包里。第三，匿名类不能成为 sealed 类型的直接子类，因为匿名类没法出现在permits列表里。

常见的陷阱题是：sealed 接口里允许有default方法吗？允许。sealed 类能同时用permits指定子类，子类又继续non-sealed往下放开吗？可以，non-sealed相当于解除了后续继承限制。你需要记住的是，permits管的是直接子类，不是整个继承树的全部后代。

3.4 switch 表达式：从语句到表达式的语义变化

Java 14 之后switch可以作为表达式使用，这会带来很多老开发者不适应的新规则。最重要的变化是：每个分支都有值，整个 switch 会返回一个结果；使用箭头语法时不会再发生 fall-through（穿透）。

String label = switch (day) { case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "workday"; case SATURDAY, SUNDAY -> "weekend"; default -> "unknown"; };

箭头右侧直接写返回值，不需要break。如果某个分支需要多行逻辑，用yield返回值。箭头语法的 case 标签可以列多个值，用逗号分隔。另外，如果使用传统的冒号语法，switch表达式里仍然要小心穿透，穿透规则和旧版一致。

一个被反复考的点是：switch表达式是否必须写default？如果 switch 遍历的是一个枚举或 sealed 类型，并且所有可能的值都覆盖到了，编译器认为已经穷尽，可以不写default。但如果 switch 的参数是int或String，理论上可能的值无法穷尽，就必须有default，否则编译失败。这道题几乎每套模拟题里都有。

顺带说下文本块。文本块用"""包裹，可以保留换行和缩进，是 Java 15 的正式特性。考试不会让你写多长的文本块，但可能会拿它和字符串连接做对比，考你最朴素的认知：文本块不是一个新的运行时类型，它编译后就是一个String。

3.5 Stream 与 lambda：惰性求值决定你能看到什么输出

Stream 的题是整个考试里最绕的，因为同样的代码，加上一个limit或findFirst，输出就会完全不同。理解的关键是：中间操作（filter、map、peek）不会执行任何实际计算，只有终端操作出现后，数据才会开始流动。

List.of("a", "bb", "ccc").stream() .peek(s -> System.out.println("peek: " + s)) .limit(2) .forEach(System.out::println);

这段代码的输出是peek: a、a、peek: bb、bb。limit(2)是一个短路操作，它明确告诉流水线只需要前两个元素，所以第三个元素根本不会进入peek。如果把limit换成filter(s -> s.length() > 2)，输出就会变成peek: a、peek: bb、peek: ccc、ccc：filter 不短路，所有元素都要经过上游的peek，但forEach只打印满足条件的ccc。

考试里常见题目是：给你一段map和peek的组合，问哪些元素会被打印。你要记住，终端操作决定返回结果，中间操作的执行是“按需拉取”的。findFirst需要多少个元素就拿多少个，count则需要把所有元素看完才能计数。这类题没有技巧，只能多画几遍数据流。

3.6 模块化：module-info.java 里的三条基本声明

模块化是 Java 9 的大变化，17 考试里依然占一席之地。它的核心不是写一个能跑的模块，而是理解requires、exports、opens三者的边界。下面是最小模块声明。

module com.example.app { requires com.example.util; exports com.example.app.api; }

requires表示当前模块依赖另一个模块，依赖关系在编译期和运行期都要成立。exports只开放指定包给所有其他模块，没有导出的包对模块外部是不可见的。opens用于反射场景，比如框架需要绕过访问控制读取私有字段，只靠exports是不够的，必须opens对应包。

考试题通常考两个方向：一个是漏写requires会不会编译错误，会；另一个是跨模块访问某个没exports的包，运行期会不会报IllegalAccessError，也会。对业务开发来说，模块化平时用得少，这两条规则死记下来就够了。

4. 用真题思路刷题：把代码判断题变成可套用的三步判断框架

刷题不是刷数量，而是建立一个稳定的判断流程。很多人一套题做下来，对答案时看懂了解析，下一套遇到变体又错，原因是他没有把“代码判断”拆成固定的步骤。下面给出一套三步框架，并配合高频陷阱清单说明使用方法。

4.1 读代码题的三步法：先看编译、再看运行时、最后看异常

拿到一道代码题，不管题干问的是“输出是什么”还是“哪一行会报错”，都按下面三步走。第一步永远先回答“这段代码能不能编译”，能编译才继续，否则直接锁定编译错误选项。第二步回答“运行时执行顺序和静态类型是什么”，这决定变量绑定到哪个方法、哪个重载版本。第三步再看有没有异常或短路行为。

public class Main { public static void main(String[] args) { Integer a = 100; Integer b = 100; System.out.println(a == b); Integer c = 1000; Integer d = 1000; System.out.println(c == d); } }

这段代码能编译。接下来看运行时：a和b的值是 100，位于IntegerCache的缓存范围 -128 到 127 内，所以a == b比较的是同一个缓存对象，输出 true。c和d是 1000，超出缓存范围，每次自动装箱都会创建新对象，==比较的是引用，输出 false。如果把100改成1000再问输出，答案就完全不同。这就是先看编译、再看运行时的意义：很多人只记住了“包装类型 == 比较引用”，却没记住缓存边界。

再看一个带异常的题：

public class Test { public static void main(String[] args) { try { throw new RuntimeException("boom"); } finally { System.out.println("finally"); } } }

编译能通过，因为RuntimeException是非受检异常，不一定需要throws声明。运行时先执行finally块打印finally，然后异常继续向外抛出。如果把throw换成new IOException，编译就会失败，因为IOException是受检异常，try块没有catch，方法也没有throws声明。这个对比就很好地演示了“编译期判断”和“运行时判断”的边界。

4.2 高频陷阱清单：重载、泛型、异常层级这三板斧

以下是历年考生最容易反复踩的四个陷阱，我用表格把它们列出来。每一条都值得你在做题前背一遍：

这四个陷阱里，泛型变体是最考验理解的一类。比如考你void add(List<? extends Number> list)能不能接受List<Integer>，答案是可以，因为Integer是Number的子类型，通配符允许这种协变。但如果把它改成List<Number>去接收List<Integer>，就编译失败。这里的关键是：通配符能解决“不确定具体类型”的问题，但它不能改变泛型本身不变的本质。

4.3 模拟题刷法：怎么让错题真正变成你的知识

模拟题最好的用法，是让自己暴露问题，不是获取正确答案。我建议每周至少做三次限时模拟，每次严格按 50 题 / 90 分钟来计时。做完之后，把错题按下面的模板记录下来：

题目：第 07 号模拟题 我的答案：B 正确答案：C 错误原因：把 HashSet 和 LinkedHashSet 的迭代顺序搞混 反推知识点：Set 不保证顺序，LinkedHashSet 保持插入顺序 变体题：把 HashSet 换成 TreeSet，问遍历顺序，答案是按自然顺序

这个模板的关键是最后两行。“反推知识点”是把错题变成考点，“变体题”是让你自己出题考自己。如果变体题写不出来，说明你对这个知识点还没有真正掌握。下一轮复习时，你会发现自己错题里反复出现的知识点就那么十几个，把这些点集中突破，比再刷二十套新题更有效。

5. 避坑：备考期最容易翻车的五个常见问题

下面五条是我最想让你先看的翻车点。很多人的备考过程不是没努力，而是努力的方向在考试里作废。每条按“现象、原因、解决”给完整方案，你可以备考前先建立排查清单，每次错题多了就回来对一次。

5.1 现象：刷题正确率挺高，一上考场却连及格线都没到

这是最常见也最打击人的情况。原因是平时刷题大多按章节或按知识点分组，比如一个专题里全是 lambda，你的大脑已经知道在考哪个方向，看见题目就会自动往这个方向答。考场上题目是乱序混合的，你需要自己识别考点，很多人到这一步就慌了。

解决方法是尽早做混合题。从备考第三周开始，每天至少做一组不按章节分类的随机题，而不是只刷“今天学 Stream 就做 Stream”。每周还要做一次完整限时模拟，完全模拟考试节奏。正确率高但没有经过混合训练的备考，本质上是在给自己降低难度。

5.2 现象：代码题做着做着就忽略了“能不能编译”这个前置问题

很多人看代码题第一眼就去想输出什么，结果选项里有“编译错误”和“运行时异常”，他直接把编译错误排除了。原因很现实：IDE 已经代做了太多判断，日常开发里你很少看到编译错误长什么样，对“哪些情况会编译不通过”的感知很弱。

解决时先把做题顺序固化：先看声明和泛型，再看受检异常，最后看运行时逻辑。养成这种顺序后，遇到List<Object> list = new ArrayList<String>()这样的代码，你会第一时间意识到是编译错误，而不是去猜运行时会怎样。每天专门做 10 道“能不能编译”的判断练习，保持对编译规则的敏感性。

5.3 现象：用 Java 11 的语法习惯去做 Java 17 的题

如果你的项目还停留在 Java 8 或 11，这个坑几乎必踩。比如看到 switch 就默认它是语句，不知道箭头表达式已经不需要 break；看到访问器就默认是 get 前缀，不知道 record 生成的访问器直接叫name()；看到字符串拼接很长，不知道文本块能直接多行书写。

解决方式是做一张“版本差异对照表”，每天花 15 分钟过一遍。下面给你一个最精简的版本：

这张表不要背一天就扔，考前一周还要再过一遍。考试里很多“送分题”考的就是这种版本差异，记错版本容易把简单题做错。

5.4 现象：模块化和 JDBC 题全靠蒙，正确率不到一半

这两个模块离业务开发比较远，特别是模块化，很多人从没用过module-info.java。蒙题的原因是没有建立实际运行经验，只看语法规则很难记住。解决方法是本地建一个最小工程，亲手编译运行一次。

javac -d mods/com.example.app \ src/com.example.app/module-info.java \ src/com.example.app/com/example/app/Main.java java --module-path mods -m com.example.app/com.example.app.Main

第一条命令把模块源码编译到mods目录，第二条命令通过模块路径启动入口类。你需要在module-info.java里至少写module com.example.app { }，并在Main.java里写一个能打印一句话的main。跑通之后，再往module-info.java里加一个exports，观察不导出的包能否被外部类访问。这个动手过程比背 30 条规则都有效。

JDBC 也一样，用内存数据库跑一个连接、查询、关闭的完整流程，把DriverManager、Connection、PreparedStatement、ResultSet这四个接口的顺序记熟。注意实际考试不会让你写完整代码，更多是判断接口调用顺序和资源释放位置。只要你亲手写过一遍，这种判断题基本不会错。

5.5 现象：考试界面不熟，会做的题因为操作失误没分

这是最冤枉的失分方式。考试界面里的多选题会在题干里提示“选择两个”，但如果你平时用惯了本地题库那种点击即提交方式，很容易漏选或提前提交。还有标记功能、下一题/上一题的跳转逻辑，都需要提前熟悉。

解决方法是考前用和真实考试一致的模拟环境完整做一套题，熟悉按钮位置。上了考场后不要急着开始答题，先把界面说明读完，确认题号和剩余时间在哪显示。考试过程中遇到拿不准的题，先用标记功能记下来，继续往后做，不要在一道题上停留太久。交卷前如果时间充裕，再回头处理标记题。这里还要提醒一句：改答案要谨慎，除非有了明确的判断依据，否则不要凭感觉改。

6. 考前一周的验证方法与临场技巧：把正确率稳定在过线之上

考前一周是最容易焦虑的阶段，也是提分效率最高的阶段。这个阶段的重点不是学新知识点，而是验证“你在考试状态下能不能稳定过线”。所谓稳定过线，指的是模拟测试正确率连续两次在 70% 以上，且错题分布不再集中在同一个模块。

硬核清单是我考前必背的几条，它们出现的频率实在太高：IntegerCache范围是 -128 到 127；switch表达式对int或String必须写default；record的访问器是name()而不是getName()；sealed的直接子类必须是final、sealed或non-sealed；try-with-resources的资源按声明逆序关闭。这几条背住，至少能救回五道题。

临场技巧方面，我的习惯是拿到试卷先通读一遍题号分布，看到长代码题先标记，优先做基础题和短判断题。多选提示“选择两个”时，只选两个最确定的，不要因为怕漏选而硬凑第三个。所有代码题先回答“能不能编译”，再回答“输出什么”，能帮你避掉一大半陷阱。整个考试过程要盯着右上角的时间，前 60 分钟必须完成约 40 题，后面留时间回头处理标记题。

我现在的习惯是，考前一周每天只做两件事：限时模考和翻错题本。错题本里每一道题都写清了错误原因和反推知识点，所以复习起来不慌。这个笨方法帮我稳定过线，希望帮到你。

本文还有配套的精品资源，点击获取