简介：这份资源是《Java语言程序设计第八版》基础篇与进阶篇的配套示例代码合集，面向Java初学者及希望系统巩固语言基础的开发者，帮助读者在阅读教材的同时动手运行、调试代码，打通从理论到实践的环节。压缩包为zip格式，整体约8.82MB，内含示例程序代码，并附带音频、图片及必要的jar包等辅助资源，可用于多媒体应用或Swing、JavaFX图形界面示例的运行与调试。基础篇覆盖变量、数据类型、控制结构、函数与数组等核心概念；进阶篇则围绕类与对象、封装、继承、多态，以及异常处理、文件I/O、集合框架和线程编程展开，jar包可支撑JDBC、Socket、XML解析等扩展功能。目前已有278人学习关注。通过逐行研读并动手修改这些代码，读者能够理解背后的设计决策，逐步建立解决实际问题的能力，为Java编程打下扎实根基。
1. 从一份教材示例代码说起：为什么值得逐行拆
很多人第一次接触 Java 集合、泛型、多线程、I/O 流，都是跟着《Java语言程序设计第八版》基础篇和进阶篇的示例代码敲出来的。这套示例代码最大的价值不在于“能跑”，而在于它把每个语法点都压缩成了一段最小可运行片段——你改一个参数就能看到行为变化，删一行就能复现编译错误。对刚入门的同学，它是脚手架；对已经工作几年的工程师，它是查漏补缺的索引。我见过太多人把示例代码当“参考答案”抄一遍就过，结果面试被问到HashMap扩容阈值、try-with-resources的关闭顺序时直接卡壳。这篇笔记就按“基础篇语法示例 → 进阶篇并发与集合 → 工程化改造 → 避坑 → 进阶技巧”的顺序，把这份示例代码拆成能复现、能验证、能迁移到真实项目的操作路径。适合正在跟这套教材自学的人，也适合想用示例代码做教学或代码评审参考的从业者。
2. 基础篇示例代码怎么跑：环境、目录与最小验证
2.1 环境准备与目录结构约定
基础篇示例代码通常按章节组织，常见做法是每章一个包，包名对应章节号，比如chapter02、chapter05。我一般会先建一个纯 Java 项目，不引入 Maven 或 Gradle，避免构建工具干扰对语法本身的观察。JDK 版本选 17 或 21 都行，但要注意示例代码里如果用了var或文本块，JDK 8 会直接编译失败。
# 创建项目根目录 mkdir java-demo-book && cd java-demo-book # 按章节建源码目录，这里以第2章和第5章为例 mkdir -p src/chapter02 src/chapter05 # 确认 JDK 版本，建议 17 以上 java -version javac -version目录结构定下来之后，每个示例文件单独一个.java，类名和文件名严格一致。基础篇很多示例是单文件单类，直接javac加java就能跑。如果遇到一个文件里有多个类，只有public类需要匹配文件名，其他类可以是包级私有，这一点在示例代码里经常被忽略，导致新手复制后报“类名不匹配”。
提示：不要急着把示例代码全部导入 IDE。先用命令行编译运行三五个文件，确认 JDK 版本和编码格式没问题，再批量导入。编码统一用 UTF-8，否则中文字符串输出会乱码。
2.2 用命令行跑通第一个示例并观察字节码
拿一个最典型的循环和数组示例来验证。假设chapter02下有一个ComputeArea.java，内容是用半径算圆面积。先编译，再用javap看字节码，能直观看到局部变量表和操作数栈的变化。
// src/chapter02/ComputeArea.java public class ComputeArea { public static void main(String[] args) { double radius = 5.0; // 半径，改成其他值可观察输出变化 double area = radius * radius * 3.14159; // 面积计算 System.out.println("半径为 " + radius + " 的圆面积是 " + area); } }# 编译 javac -encoding UTF-8 -d out src/chapter02/ComputeArea.java # 运行 java -cp out chapter02.ComputeArea # 查看字节码，重点看局部变量表和指令序列 javap -c -l -p out/chapter02/ComputeArea.class编译参数-d out把 class 文件统一放到out目录，避免源码目录被污染。javap -c -l -p分别输出反汇编、行号表和私有成员。你会看到double在局部变量表里占两个槽位，这是基础篇里容易被忽略的细节——很多同学以为double和int一样只占一个位置，写复杂表达式时对栈深度判断失误。运行结果里半径改成 10.0，面积应该变成四倍，如果没变，检查是不是把radius * radius写成了radius * 2。
2.3 基础篇里最值得反复改的三个参数
基础篇示例代码里，有三类参数改动收益最高。第一类是循环边界，比如for (int i = 0; i < n; i++)里的n，改成 0、负数、Integer.MAX_VALUE，观察是否死循环或数组越界。第二类是数组长度和索引，把new int[5]改成new int[0]，看args为空时程序怎么走。第三类是方法参数传递，基础篇讲值传递时用的交换方法示例，把基本类型和对象引用各传一次，打印方法内外的变量值。
// src/chapter05/SwapDemo.java public class SwapDemo { public static void swap(int a, int b) { int temp = a; a = b; b = temp; // 基本类型交换，方法外无效 } public static void main(String[] args) { int x = 1, y = 2; swap(x, y); System.out.println("x=" + x + ", y=" + y); // 输出 x=1, y=2 } }这段代码跑出来永远是x=1, y=2，因为 Java 只有值传递。基础篇用这个例子讲清楚“方法内交换不影响方法外”，但很多新手在写排序或链表操作时会踩这个坑。把int换成数组或对象，再在方法里改元素内容，方法外就能看到变化——区别在于改的是引用指向的对象，而不是引用本身。这三个参数改动花不了十分钟，但能把基础篇最核心的内存模型串起来。
3. 进阶篇示例代码怎么拆：集合、并发与 I/O 的验证路径
3.1 集合示例：从 HashMap 扩容到迭代器失效
进阶篇集合部分示例代码通常包含ArrayList、LinkedList、HashSet、HashMap的基本操作。光跑一遍增删改查没意义，要验证的是扩容和迭代器行为。下面这段代码模拟HashMap在插入过程中触发扩容，并观察迭代器在修改集合后抛出的异常。
// src/advanced/MapResizeDemo.java import java.util.*; public class MapResizeDemo { public static void main(String[] args) { Map<Integer, String> map = new HashMap<>(4, 0.75f); // 初始容量4，负载因子0.75 for (int i = 0; i < 20; i++) { map.put(i, "v" + i); if (i == 2 || i == 3 || i == 5) { System.out.println("插入 " + i + " 后 size=" + map.size()); } } // 迭代器失效演示 Iterator<Integer> it = map.keySet().iterator(); while (it.hasNext()) { Integer key = it.next(); if (key == 5) { map.remove(key); // 直接修改集合，下一次 it.next() 抛 ConcurrentModificationException } } } }构造参数new HashMap<>(4, 0.75f)里，4 是初始容量，0.75f 是负载因子。阈值等于容量乘负载因子，插入第 4 个元素时触发第一次扩容到 8，第 7 个元素时扩容到 16。运行后看输出，能对上这个节奏。迭代器部分，map.remove(key)之后继续it.next()会抛ConcurrentModificationException，正确做法是用it.remove()。这个坑在进阶篇示例里经常一笔带过，但真实项目里多线程遍历集合时翻车概率极高。
3.2 并发示例：线程池参数与可见性验证
进阶篇并发部分示例代码一般从Thread、Runnable讲到ExecutorService。我建议重点拆两个点：线程池的核心参数，以及volatile的可见性。下面这段代码用固定大小线程池提交任务，并演示不加volatile时主线程可能读不到子线程的修改。
// src/advanced/ThreadPoolDemo.java import java.util.concurrent.*; public class ThreadPoolDemo { private static boolean flag = false; // 去掉 volatile 观察可见性问题 public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(2); // 核心=最大=2 pool.submit(() -> { try { Thread.sleep(100); } catch (InterruptedException e) {} flag = true; System.out.println("子线程已修改 flag"); }); pool.submit(() -> { while (!flag) { /* 自旋等待 */ } System.out.println("主逻辑看到 flag 变化"); }); pool.shutdown(); pool.awaitTermination(3, TimeUnit.SECONDS); } }newFixedThreadPool(2)的核心线程数和最大线程数都是 2，队列是无界LinkedBlockingQueue。如果任务提交速度远大于处理速度，队列会一直涨，最终 OOM——这是进阶篇示例里不会强调但生产环境必须知道的边界。flag不加volatile时，第二个任务可能永远自旋，因为线程工作内存里的flag一直是 false。加上volatile后能稳定看到输出。这个验证不需要复杂工具，跑几次就能感受到可见性问题的“玄学”。
3.3 I/O 与 NIO 示例：缓冲流和通道的关闭顺序
进阶篇 I/O 部分示例代码会对比FileInputStream、BufferedInputStream、Files.newInputStream以及 NIO 的FileChannel。重点验证两件事：缓冲流不flush会丢数据，以及try-with-resources的关闭顺序是后进先出。
// src/advanced/IODemo.java import java.io.*; import java.nio.file.*; public class IODemo { public static void main(String[] args) throws IOException { Path path = Paths.get("demo.txt"); // 缓冲流写入，不 flush 直接结束，文件可能为空 try (BufferedWriter bw = Files.newBufferedWriter(path)) { bw.write("第一行"); bw.write("第二行"); // bw.flush(); // 注释掉这行，观察文件内容 } // 读取并打印 try (BufferedReader br = Files.newBufferedReader(path)) { String line; while ((line = br.readLine()) != null) { System.out.println(line); } } } }Files.newBufferedWriter返回的BufferedWriter在try-with-resources块结束时会自动关闭，关闭前会flush，所以这里不手动flush也能写入。但如果把bw声明在 try 外面、手动close前忘了flush，就会丢数据。NIO 的FileChannel写完后需要force(true)才能保证落盘，普通write只写到页缓存。这些细节在示例代码里往往只出现一次，但生产环境里丢一行日志就可能排查半天。
4. 把示例代码改造成可复用工具类：三个工程化动作
4.1 抽离公共常量与配置
示例代码里到处是硬编码的3.14159、"demo.txt"、1000。工程化第一步是把这些值抽到常量类或配置文件。我一般建一个Constants.java，把路径、超时、容量都放进去，示例代码里只留引用。
// src/util/Constants.java public final class Constants { private Constants() {} // 禁止实例化 public static final double PI = 3.141592653589793; public static final String DEMO_FILE = "demo.txt"; public static final int THREAD_POOL_SIZE = 4; public static final long AWAIT_TIMEOUT_SECONDS = 3; }抽离之后，改路径或线程数只需要动一个文件。注意final类加私有构造，防止被继承和实例化。示例代码里如果用了Scanner读控制台，也建议把输入源改成可配置的InputStream，方便单元测试时替换成ByteArrayInputStream。
4.2 给关键方法补上参数校验和日志
示例代码为了简洁，通常不校验参数。工程化时要补上Objects.requireNonNull、范围检查，并用java.util.logging或 SLF4J 替换System.out.println。下面是一个改造前后的对比。
// 改造前：示例风格 public static double computeArea(double radius) { return radius * radius * Constants.PI; } // 改造后：工程风格 import java.util.Objects; import java.util.logging.Logger; public static double computeArea(double radius) { if (radius < 0) { throw new IllegalArgumentException("半径不能为负: " + radius); } Logger.getGlobal().fine(() -> "计算面积, radius=" + radius); return radius * radius * Constants.PI; }参数校验放在方法入口，日志用惰性求值避免无谓字符串拼接。IllegalArgumentException比返回-1或NaN更容易定位问题。示例代码里如果用了System.exit，工程化时一定要去掉，改成抛异常或返回状态码，否则单元测试会被直接终止。
4.3 用 JUnit 给示例代码写回归测试
示例代码最大的问题是改一行就可能悄悄改变行为。给核心方法写 JUnit 测试，能把“能跑”变成“可验证”。下面是一个针对面积计算和集合扩容的测试片段。
// src/test/ComputeAreaTest.java import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; public class ComputeAreaTest { @Test void testAreaPositive() { assertEquals(78.53975, ComputeArea.computeArea(5.0), 0.0001); } @Test void testAreaZero() { assertEquals(0.0, ComputeArea.computeArea(0.0), 0.0001); } @Test void testAreaNegative() { assertThrows(IllegalArgumentException.class, () -> ComputeArea.computeArea(-1)); } }assertEquals的第三个参数是误差范围，浮点比较必须给。assertThrows验证异常类型，比 try-catch 加 fail 更简洁。把示例代码里的每个 public 方法都补上正常值、边界值、异常值三组测试，后面再改代码就有后悔药可吃。
5. 避坑与排查：示例代码里最容易翻车的五处
5.1 现象：javac报“编码 GBK 的不可映射字符”
原因：源码文件是 UTF-8，但命令行默认编码是 GBK，中文字符串或注释触发编译错误。解决：编译时显式加-encoding UTF-8，或者把系统环境变量JAVA_TOOL_OPTIONS设为-Dfile.encoding=UTF-8。如果用的是 IDE，检查项目编码设置和文件实际编码是否一致。
5.2 现象：HashMap遍历时删元素抛ConcurrentModificationException
原因：用map.remove或list.remove直接修改集合，而迭代器依赖modCount做快速失败检查。解决：用Iterator.remove()，或者改用ConcurrentHashMap、CopyOnWriteArrayList。注意ConcurrentHashMap的迭代器是弱一致的，不抛异常但不保证看到最新值。
5.3 现象：线程池任务提交后主线程直接退出，任务没执行完
原因：Executors.newFixedThreadPool返回的线程池默认是非守护线程，但main方法结束后 JVM 不会等线程池。如果没调shutdown和awaitTermination，任务可能被中断。解决：提交完任务后调pool.shutdown()，再用awaitTermination等待指定时间。生产环境建议用ThreadPoolExecutor显式设置核心数、最大数、队列和拒绝策略。
5.4 现象：try-with-resources里多个资源关闭顺序搞反
原因：多个资源按声明顺序的逆序关闭，即最后声明的先关。如果资源之间有依赖，比如先关输入流再关输出流，顺序反了会抛异常。解决：把依赖方声明在后面，或者手动管理关闭顺序。示例代码里如果嵌套了多层流，建议拆成独立 try 块。
5.5 现象：double计算结果和预期差一点，==比较失败
原因：浮点数二进制表示不精确，0.1 + 0.2 != 0.3。解决：比较时用误差范围，或者用BigDecimal做精确计算。示例代码里如果用了float存金额，工程化时一定要换成BigDecimal，构造参数用字符串而不是double。
6. 进阶技巧：用示例代码做基准测试与教学演示
示例代码除了跑通语法，还能改造成微型基准测试。比如把ArrayList和LinkedList的随机插入、顺序遍历各跑十万次，用System.nanoTime()记录耗时，能直观看到数据结构差异。注意基准测试要预热，前几轮结果不可信，至少跑五轮取后三轮平均。
// src/advanced/BenchmarkDemo.java import java.util.*; public class BenchmarkDemo { public static void main(String[] args) { int n = 100_000; List<Integer> array = new ArrayList<>(); List<Integer> linked = new LinkedList<>(); // 预热 for (int i = 0; i < 1000; i++) { array.add(i); linked.add(i); } long t1 = System.nanoTime(); for (int i = 0; i < n; i++) array.add(0, i); // 头部插入 long t2 = System.nanoTime(); for (int i = 0; i < n; i++) linked.add(0, i); long t3 = System.nanoTime(); System.out.println("ArrayList 头部插入: " + (t2 - t1) / 1_000_000 + " ms"); System.out.println("LinkedList 头部插入: " + (t3 - t2) / 1_000_000 + " ms"); } }System.nanoTime()比currentTimeMillis精度高，适合测短耗时。add(0, i)在ArrayList里要移动整个数组，复杂度 O(n)，LinkedList只需改指针，复杂度 O(1)。跑出来ArrayList会慢几个数量级。这个对比比看文字描述印象深得多。教学演示时还可以把n调小到 1000，让学生自己改参数观察趋势。
另一个技巧是用示例代码做代码评审练习。把基础篇的switch示例改成switch表达式，把匿名内部类改成 lambda，把for循环改成Stream，每一步都跑测试确认行为不变。这种“重构不改变行为”的练习，比单纯抄代码更能提升工程能力。我自己习惯每学完一章，就把该章示例代码按“常量抽离 → 参数校验 → 单元测试 → 重构”四步走一遍，走完再回头看教材，很多当时没注意的边界条件会自己冒出来。希望帮到你。
本文还有配套的精品资源，点击获取
