下载地址：

本书是布鲁斯·埃克尔时隔 15 年，继 Thinking in Java 之后又一力作，基于 Java 的 3 个长期支持版（Java 8、11、17），讲解 Java 核心语法，并对 Java 的核心变化进行详述。全书内容通俗易懂，配合示例讲解逐步深入，并结合实际开发需要，从语言底层设计出发，有效帮读者规避一些常见的开发陷阱。

 

主体部分共 22 章，内容包含对象、操作符、控制流、初始化和清理、复用、多态、接口、内部类、集合、函数式编程、流、异常、代码校验、文件、字符串、泛型等。

第 1章 什么是对象 / 001

 

1.1抽象的历程 / 002

 

1.2 对象具有接口 / 003

 

1.3 对象可以提供服务 / 005

 

1.4 隐藏的实现 / 006

 

1.5 复用实现 / 008

 

1.6 继承 / 008

 

is-a关系与is-like-a关系 / 012

 

1.7 多态 / 013

 

1.8 单根层次结构 / 016

 

1.9 集合 / 017

 

参数化类型（泛型） / 018

 

1.10 对象的创建和生命周期 / 019

 

1.11 异常处理 / 021

 

1.12 总结 / 022

 

第 2章 安装Java和本书示例 / 023

 

2.1 编辑器 / 023

 

2.2 shell / 024

 

2.2.1 运行shell / 024

 

2.2.2 目录（文件夹） / 025

 

2.2.3 shell基础操作 / 025

 

2.3 安装Java / 026

 

2.4 确认安装成功 / 027

 

2.5 安装和运行本书示例 / 028

 

Gradle基础任务 / 028

 

第3章 对象无处不在 / 029

 

3.1 通过引用操作对象 / 030

 

3.2 必须创建所有对象 / 031

 

3.2.1 数据保存在哪里 / 031

 

3.2.2 特殊情况：基本类型 / 032

 

3.2.3 Java中的数组 / 034

 

3.3 注释 / 034

 

3.4 无须销毁对象 / 035

 

3.4.1 作用域 / 035

 

3.4.2 对象的作用域 / 036

 

3.5 使用class关键字创建新类型 / 037

 

字段 / 037

 

3.6 方法、参数以及返回值 / 039

 

参数列表 / 039

 

3.7 编写Java程序 / 041

 

3.7.1 名称可见性 / 041

 

3.7.2 使用其他组件 / 042

 

3.7.3 static关键字 / 043

 

3.8 你的第 一个Java程序 / 045

 

编译和运行 / 047

 

3.9 编程风格 / 048

 

3.10 总结 / 049

 

第4章 操作符 / 050

 

4.1 使用Java操作符 / 050

 

4.2 优先级 / 051

 

4.3 赋值 / 051

 

方法调用中的别名 / 053

 

4.4 算术操作符 / 054

 

一元加操作符和一元减操作符 / 055

 

4.5 自动递增和自动递减 / 056

 

4.6 关系操作符 / 057

 

测试对象是否相等 / 057

 

4.7 逻辑操作符 / 061

 

短路 / 062

 

4.8 字面量 / 063

 

4.8.1 字面量里的下划线 / 065

 

4.8.2 科学记数法（又称“指数

 

记数法”） / 066

 

4.9 按位操作符 / 067

 

4.10 移位操作符 / 067

 

4.11 三元操作符 / 071

 

4.12 字符串操作符 和 = / 072

 

4.13 使用操作符时常犯的错误 / 073

 

4.14 类型转换操作符 / 074

 

4.14.1 截尾和舍入 / 075

 

4.14.2 提升 / 076

 

4.15 Java没有sizeof() / 076

 

4.16 操作符小结 / 076

 

4.17 总结 / 081

 

第5章 控制流 / 082

 

5.1 true和false / 082

 

5.2 if-else / 083

 

5.3 迭代语句 / 084

 

5.3.1 do-while / 085

 

5.3.2 for / 085

 

5.3.3 逗号操作符 / 086

 

5.4 for-in语法 / 087

 

5.5 return / 089

 

5.6 break和continue / 090

 

5.7 臭名昭著的goto / 091

 

5.8 switch / 095

 

5.9 字符串作为选择器 / 096

 

5.10 总结 / 098

 

第6章 初始化和清理 / 099

 

6.1 用构造器保证初始化 / 100

 

6.2 方法重载 / 102

 

6.2.1 区分重载的方法 / 103

 

6.2.2 使用基本类型的重载 / 104

 

6.2.3 通过返回值区分重载方法 / 107

 

6.3 无参构造器 / 108

 

6.4 this关键字 / 109

 

6.4.1 在构造器中调用构造器 / 111

 

6.4.2 static的含义 / 112

 

6.5 清理：终结和垃圾收集 / 113

 

6.5.1 finalize()的作用 / 114

 

6.5.2 你必须执行清理 / 115

 

6.5.3 终止条件 / 115

 

6.5.4 垃圾收集器的工作原理 / 117

 

6.6 成员初始化 / 120

 

指定初始化 / 121

 

6.7 构造器初始化 / 122

 

6.7.1 初始化顺序 / 123

 

6.7.2 静态数据的初始化 / 124

 

6.7.3 显式的静态初始化 / 126

 

6.7.4 非静态实例初始化 / 127

 

6.8 数组初始化 / 128

 

6.8.1 动态数组创建 / 129

 

6.8.2 可变参数列表 / 132

 

6.9 枚举类型 / 136

 

6.10 新特性：局部变量类型

 

推断 / 138

 

6.11 总结 / 140

 

第 7章 实现隐藏 / 141

 

7.1 package：库单元 / 142

 

7.1.1 代码组织 / 144

 

7.1.2 创建独一无二的包名 / 145

 

7.1.3 定制工具库 / 148

 

7.1.4 用import来改变行为 / 149

 

7.1.5 关于包的忠告 / 150

 

7.2 Java访问权限修饰符 / 150

 

7.2.1 包访问 / 150

 

7.2.2 public：接口访问权限 / 151

 

7.2.3 private：你无法访问它 / 153

 

7.2.4 protected：继承访问权限 / 154

 

7.2.5 包访问权限与公共构造器 / 155

 

7.3 接口和实现 / 156

 

7.4 类的访问权限 / 157

 

7.5 新特性：模块 / 160

 

7.6 总结 / 162

 

第8章 复用 / 164

 

8.1 组合语法 / 165

 

8.2 继承语法 / 167

 

初始化基类 / 169

 

8.3 委托 / 171

 

8.4 组合与继承相结合 / 173

 

8.4.1 确保正确的清理 / 175

 

8.4.2 名称隐藏 / 177

 

8.5 选择组合还是继承 / 178

 

8.6 protected关键字 / 180

 

8.7 向上转型 / 181

 

再论组合与继承 / 182

 

8.8 final关键字 / 182

 

8.8.1 final数据 / 183

 

8.8.2 final方法 / 186

 

8.8.3 final类 / 188

 

8.8.4 关于final的忠告 / 189

 

8.9 初始化及类的加载 / 190

 

继承与初始化 / 190

 

8.10 总结 / 191

 

第9章 多态 / 193

 

9.1 再论向上转型 / 194

 

忘记对象类型 / 195

 

9.2 难点 / 196

 

9.2.1 方法调用绑定 / 197

 

9.2.2 产生正确的行为 / 197

 

9.2.3 可扩展性 / 201

 

9.2.4 陷阱：“重写”private

 

方法 / 203

 

9.2.5 陷阱：字段与静态方法 / 205

 

9.3 构造器和多态 / 206

 

9.3.1 构造器的调用顺序 / 206

 

9.3.2 继承与清理 / 208

 

9.3.3 构造器内部的多态方法

 

行为 / 213

 

9.4 协变返回类型 / 215

 

9.5 用继承进行设计 / 216

 

9.5.1 替换与扩展 / 217

 

9.5.2 向下转型与反射 / 218

 

9.6 总结 / 220

 

第 10章 接口 / 221

 

10.1 抽象类和抽象方法 / 221

 

10.2 接口定义 / 226

 

10.2.1 默认方法 / 228

 

10.2.2 多重继承 / 230

 

10.2.3 接口中的静态方法 / 233

 

10.2.4 作为接口的Instrument / 234

 

10.3 抽象类与接口 / 236

 

10.4 完全解耦 / 237

 

10.5 组合多个接口 / 242

 

10.6 通过继承来扩展接口 / 244

 

组合接口时的名称冲突 / 245

 

10.7 适配接口 / 246

 

10.8 接口中的字段 / 249

 

初始化接口中的字段 / 249

 

10.9 嵌套接口 / 250

 

10.10 接口和工厂 / 252

 

10.11 新特性：接口的private

 

方法 / 255

 

10.12 新特性：密封类和密封

 

接口 / 256

 

10.13 总结 / 259

 

第 11章 内部类 / 260

 

11.1 创建内部类 / 261

 

11.2 到外部类的链接 / 262

 

11.3 使用.this和.new / 264

 

11.4 内部类和向上转型 / 266

 

11.5 在方法和作用域中的内部类 / 267

 

11.6 匿名内部类 / 269

 

11.7 嵌套类 / 273

 

11.7.1 接口中的类 / 274

 

11.7.2 从多层嵌套的内部类中

 

访问外部成员 / 275

 

11.8 为什么需要内部类 / 276

 

11.8.1 闭包与回调 / 278

 

11.8.2 内部类与控制框架 / 281

 

11.9 继承内部类 / 287

 

11.10 内部类可以被重写吗 / 287

 

11.11 局部内部类 / 289

 

11.12 内部类标识符 / 291

 

11.13 总结 / 291

 

第 12章 集合 / 292

 

12.1 泛型和类型安全的集合 / 293

 

新特性：类型推断和泛型 / 296

 

12.2 基本概念 / 297

 

12.3 添加一组元素 / 298

 

12.4 打印集合 / 300

 

12.5 List / 302

 

12.6 Iterator / 306

 

ListIterator / 309

 

12.7 LinkedList / 310

 

12.8 Stack / 312

 

12.9 Set / 314

 

12.10 Map / 318

 

12.11 新特性：记录（record）

 

类型 / 321

 

12.12 Queue / 325

 

PriorityQueue / 327

 

12.13 Collection和Iterator的

 

对比 / 328

 

12.14 for-in和迭代器 / 332

 

适配器方法惯用法 / 334

 

12.15 总结 / 338

 

第 13章 函数式编程 / 342

 

13.1 旧方式与新方式 / 344

 

13.2 lambda表达式 / 346

 

递归 / 348

 

13.3 方法引用 / 349

 

13.3.1 Runnable / 350

 

13.3.2 未绑定方法引用 / 351

 

13.3.3 构造器方法引用 / 353

 

13.4 函数式接口 / 354

 

13.4.1 带有更多参数的函数式

 

接口 / 361

 

13.4.2 解决缺乏基本类型函数

 

式接口的问题 / 361

 

13.5 高阶函数 / 363

 

13.6 闭包 / 364

 

内部类作为闭包 / 369

 

13.7 函数组合 / 370

 

13.8 柯里化和部分求值 / 372

 

13.9 纯函数式编程 / 373

 

13.10 总结 / 374

 

第 14章 流 / 375

 

14.1 Java 8对流的支持 / 377

 

14.2 流的创建 / 378

 

14.2.1 随机数流 / 379

 

14.2.2 int类型的区间范围 / 382

 

14.2.3 generate() / 383

 

14.2.4 iterate() / 385

 

14.2.5 流生成器 / 385

 

14.2.6 Arrays / 386

 

14.2.7 正则表达式 / 387

 

14.3 中间操作 / 388

 

14.3.1 跟踪与调试 / 389

 

14.3.2 对流元素进行排序 / 389

 

14.3.3 移除元素 / 390

 

14.3.4 将函数应用于每个流

 

元素 / 390

 

14.3.5 在应用map()期间组

 

合流 / 392

 

14.4 Optional类型 / 395

 

14.4.1 便捷函数 / 397

 

14.4.2 创建Optional / 399

 

14.4.3 Optional对象上的操作 / 400

 

14.4.4 由Optional组成的流 / 404

 

14.5 终结操作 / 405

 

14.5.1 将流转换为一个数组 / 405

 

14.5.2 在每个流元素上应用某个终结操作 / 406

 

14.5.3 收集操作 / 407

 

14.5.4 组合所有的流元素 / 410

 

14.5.5 匹配 / 411

 

14.5.6 选择一个元素 / 412

 

14.5.7 获得流相关的信息 / 413

 

14.6 小结 / 415

 

第 15章 异常 / 416

 

15.1 概念 / 417

 

15.2 基本的异常 / 418

 

异常参数 / 419

 

15.3 捕捉异常 / 420

 

15.3.1 try块 / 420

 

15.3.2 异常处理程序 / 420

 

15.4 创建自己的异常 / 421

 

异常与日志记录 / 424

 

15.5 异常说明 / 427

 

15.6 捕捉任何异常 / 428

 

15.6.1 多重捕捉 / 430

 

15.6.2 栈轨迹 / 431

 

15.6.3 重新抛出异常 / 432

 

15.6.4 异常链 / 436

 

15.7 标准Java异常 / 439

 

特例：RuntimeException / 440

 

15.8 新特性：更好的NullPointerException

 

报告机制 / 441

 

15.9 使用finally执行清理 / 443

 

15.9.1 finally是干什么用的 / 444

 

15.9.2 在return期间使用

 

finally / 446

 

15.9.3 缺陷：异常丢失 / 447

 

15.10 异常的约束 / 449

 

15.11 构造器 / 452

 

15.12 try-with-resources语句 / 456

 

15.12.1 细节揭秘 / 459

 

15.12.2 新特性：try-with-resources中的实际

 

上的最终变量 / 463

 

15.13 异常匹配 / 464

 

15.14 其他可选方式 / 465

 

15.14.1 历史 / 466

 

15.14.2 观点 / 468

 

15.14.3 把异常传递到控制台 / 470

 

15.14.4 将“检查型异常”转换为

 

“非检查型异常” / 470

 

15.15 异常使用指南 / 473

 

15.16 小结 / 473

 

附记 异常的奇异世界 / 474

 

第 16章 代码校验 / 476

 

16.1 测试 / 476

 

16.1.1 单元测试 / 477

 

16.1.2 测试覆盖率的幻觉 / 481

 

16.2 前置条件 / 482

 

16.2.1 断言 / 482

 

16.2.2 DbC 单元测试 / 488

 

16.2.3 使用Guava里的前置

 

条件 / 495

 

16.3 测试驱动开发 / 498

 

测试驱动与测试优先 / 505

 

16.4 日志 / 505

 

日志级别 / 507

 

16.5 调试 / 508

 

16.5.1 使用JDB进行调试 / 508

 

16.5.2 图形调试器 / 511

 

16.6 基准测试 / 511

 

16.6.1 微基准测试 / 512

 

16.6.2 介绍JMH / 514

 

16.7 分析与优化 / 520

 

优化指南 / 520

 

16.8 样式检查 / 521

 

16.9 静态错误分析 / 521

 

16.10 代码审查 / 521

 

16.11 结对编程 / 522

 

16.12 重构 / 522

 

重构的基础 / 522

 

16.13 持续集成 / 523

 

16.14 总结 / 525

 

第 17章 文件 / 526

 

17.1 文件和目录路径 / 527

 

17.1.1 选择Path的片段 / 530

 

17.1.2 分析Path / 531

 

17.1.3 添加或删除路径片段 / 532

 

17.2 目录 / 533

 

17.3 文件系统 / 537

 

17.4 监听Path / 538

 

17.5 查找文件 / 541

 

17.6 读写文件 / 543

 

17.7 小结 / 546

 

第 18章 字符串 / 547

 

18.1 不可变的字符串 / 547

 

18.2 重载 与StringBuilder / 548

 

18.3 无意识的递归 / 553

 

18.4 对字符串的操作 / 555

 

18.5 格式化输出 / 556

 

18.5.1 printf() / 556

 

18.5.2 System.out.format() / 557

 

18.5.3 Formatter类 / 557

 

18.5.4 格式说明符 / 558

 

18.5.5 Formatter转换 / 560

 

18.5.6 String.format() / 562

 

18.6 新特性：文本块 / 563

 

18.7 正则表达式 / 565

 

18.7.1 基础 / 566

 

18.7.2 创建正则表达式 / 569

 

18.7.3 量词 / 571

 

18.7.4 Pattern和Matcher / 572

 

18.7.5 split() / 580

 

18.7.6 替换操作 / 580

 

18.7.7 reset() / 582

 

18.7.8 正则表达式和Java 

 

I/O / 583

 

18.8 扫描输入 / 584

 

18.8.1 Scanner分隔符 / 586

 

18.8.2 使用正则表达式扫描 / 586

 

18.9 StringTokenizer / 587

 

18.10 总结 / 588

 

第 19章 反射 / 589

 

19.1 为什么需要反射 / 589

 

19.2 Class对象 / 592

 

19.2.1 类字面量 / 596

 

19.2.2 泛型类的引用 / 598

 

19.2.3 cast()方法 / 602

 

19.3 转型前检查 / 603

 

19.3.1 使用类字面量 / 609

 

19.3.2 动态的instanceof / 611

 

19.3.3 递归计数 / 612

 

19.4 注册工厂 / 614

 

19.5 Instanceof与Class的

 

等价性 / 616

 

19.6 运行时的类信息 / 618

 

类方法提取器 / 619

 

19.7 动态代理 / 621

 

19.8 使用Optional / 625

 

19.8.1 标签接口 / 630

 

19.8.2 模拟对象和桩 / 633

 

19.9 接口和类型信息 / 633

 

19.10 总结 / 639

 

第 20章 泛型 / 641

 

20.1 和C 的对比 / 642

 

20.2 简单泛型 / 643

 

20.2.1 元组库 / 645

 

20.2.2 栈类 / 648

 

20.2.3 RandomList / 649

 

20.3 泛型接口 / 650

 

20.4 泛型方法 / 653

 

20.4.1 可变参数和泛型方法 / 654

 

20.4.2 通用Supplier / 655

 

20.4.3 简化元组的使用 / 657

 

20.4.4 Set实用工具 / 658

 

20.5 构建复杂模型 / 663

 

20.6 类型擦除的奥秘 / 665

 

20.6.1 C 的实现方法 / 667

 

20.6.2 迁移的兼容性 / 669

 

20.6.3 类型擦除存在的问题 / 670

 

20.6.4 边界的行为 / 672

 

20.7 对类型擦除的补偿 / 676

 

20.7.1 创建类型实例 / 677

 

20.7.2 泛型数组 / 680

 

20.8 边界 / 686

 

20.9 通配符 / 689

 

20.9.1 编译器有多聪明？ / 692

 

20.9.2 逆变性 / 694

 

20.9.3 无界通配符 / 696

 

20.9.4 捕获转换 / 705

 

20.10 问题 / 707

 

20.10.1 基本类型不可作为

 

类型参数 / 707

 

20.10.2 实现参数化接口 / 709

 

20.10.3 类型转换和警告 / 709

 

20.10.4 重载 / 712

 

20.10.5 基类会劫持接口 / 712

 

20.11 自限定类型 / 714

 

20.11.1 奇异递归泛型 / 714

 

20.11.2 自限定 / 715

 

20.11.3 参数协变性 / 718

 

20.12 动态类型安全 / 721

 

20.13 异常 / 722

 

20.14 混型 / 724

 

20.14.1 C 中的混型 / 724

 

20.14.2 与接口混合 / 726

 

20.14.3 使用装饰器模式 / 727

 

20.14.4 与动态代理混合 / 729

 

20.15 潜在类型机制 / 730

 

20.15.1 Python中的潜在类型

 

机制 / 731

 

20.15.2 C 中的潜在类型

 

机制 / 732

 

20.15.3 Go中的潜在类型

 

机制 / 733

 

20.15.4 Java中的直接潜在

 

类型机制 / 735

 

20.16 对于缺少（直接的）潜在类型机制的补偿 / 736

 

20.16.1 反射 / 736

 

20.16.2 将方法应用于序列 / 737

 

20.17 Java 8中的辅助潜在类型

 

机制 / 741

 

使用Supplier的泛型方法 / 743

 

20.18 总结：转型真的这么糟糕吗？ / 745

 

延伸阅读 / 747

 

第 21 章 数组 / 748

 

21.1 数组为何特殊 / 749

 

一个用于显示数组的常用工具

 

程序 / 751

 

21.2 数组是一等对象 / 752

 

21.3 返回数组 / 755

 

21.4 多维数组 / 757

 

21.5 数组和泛型 / 761

 

21.6 Arrays.fill() / 764

 

21.7 Arrays.setAll() / 765

 

21.8 增量生成器 / 766

 

21.9 随机数生成器 / 775

 

21.10 泛型和基本类型数组 / 783

 

21.11 修改已有的数组元素 / 787

 

21.12 关于数组并行 / 788

 

21.12.1 策略 / 789

 

21.12.2 parallelSetAll() / 789

 

21.13 数组实用工具 / 790

 

21.14 数组复制 / 791

 

21.15 数组比较 / 794

 

21.16 流和数组 / 795

 

21.17 数组排序 / 796

 

21.17.1 使用Arrays.sort() / 800

 

21.17.2 并行排序 / 801

 

21.18 用Arrays.binarySearch()进行二分查找 / 802

 

21.19 用parallelPrefix()进行累积计算 / 804

 

21.20 总结 / 806

 

补充内容 / 809

 

积极看待C 与Java的

 

遗产 / 810