万本电子书0元读

万本电子书0元读

顶部广告

On Java 中文版 基础卷电子书

基于Java 8、11、17,Thinking in系列书籍作者Bruce Eckel重讲Java的编程! 1.查漏宝典:涵盖Java关键特性的设计原理和应用方法 2.避坑指南:以产业实践的得失为鉴,指明Java发者不可不知的设计陷阱 3.小白大神皆可读:适合不同层次的Java发者反复翻阅 4.大咖领读:3位一线技术专家带你拆解书中难内容,总结Java发精要

售       价:¥

纸质售价:¥87.00购买纸书

0人正在读 | 0人评论 6.4

作       者:[美]布鲁斯·埃克尔(Bruce Eckel) 著

出  版  社:人民邮电出版社有限公司

出版时间:2022-03-01

字       数:38.3万

所属分类: 科技 > 计算机/网络 > 程序设计

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
本书是布鲁斯·埃克尔时隔 15 年,继 Thinking in Java 之后又一力作,基于 Java 的 3 个长期支持版(Java 8、11、17),讲解 Java 核心语法,并对 Java 的核心变化行详述。全书内容通俗易懂,配合示例讲解逐步深,并结合实际发需要,从语言底层设计出发,有效帮读者规避一些常见的发陷阱。 主体部分共 22 章,内容包含对象、操作符、控制流、初始化和清理、复用、多态、口、内部类、集合、函数式编程、流、异常、代码校验、文件、字符串、泛型等。 本书适合各个层次的 Java 发者阅读,同时也可作为面向对象程序设计语言以及 Java 语言的参考教材。<br/>【推荐语】<br/>基于Java 8、11、17,Thinking in系列书籍作者Bruce Eckel重讲Java的编程! 1.查漏宝典:涵盖Java关键特性的设计原理和应用方法 2.避坑指南:以产业实践的得失为鉴,指明Java发者不可不知的设计陷阱 3.小白大神皆可读:适合不同层次的Java发者反复翻阅 4.大咖领读:3位一线技术专家带你拆解书中难内容,总结Java发精要<br/>【作者】<br/>【作者简介】 布鲁斯·埃克尔(Bruce Eckel) C 标准委员会的创始成员之一,技术顾问,专注于编程语言和软件系统设计方面的研究,常活跃于世界各大技术研讨会。他自 1986 年以来,累计出版 Thinking in C 、Thinking in Java、On Java 8 等十余部计算机,曾多次荣获 Jolt 图书奖(被誉为“软件业界的奥斯卡”),其代表作 Thinking in Java 被译为中文、日文、俄文、意大利文、波兰文、韩文等十几种语言,在世界范围内产生了广泛影响。 【译者简介】 陈德伟,深耕软件研发十余年,目前专注于金融系统研发工作。 臧秀涛,InfoQ 前会议内容总编。现于涛思数据负责源时序数据库 TDengine 的社区生态。代表译作有《Java性能权威指南》《C API 设计》《Groovy 程序设计》等。 孙卓,现任职于百度健康研发中心,百度技术委员会成员。从业十余年,熟悉 Java、PHP 等语言体系,同时也是一名语言文字爱好者。 秦彬,现任腾讯游戏高级项目经理,曾翻译《体验引擎》《游戏设计梦工厂》《游戏制作的本质》等书。<br/>
目录展开

扉页

内容提要

致谢

中文版序

前言

本书导读

01 什么是对象

1.1 抽象的历程

1.2 对象具有接口

1.3 对象可以提供服务

1.4 隐藏的实现

1.5 复用实现

1.6 继承

is-a关系与is-like-a关系

1.7 多态

1.8 单根层次结构

1.9 集合

参数化类型(泛型)

1.10 对象的创建和生命周期

1.11 异常处理

1.12 总结

02 安装Java和本书示例

2.1 编辑器

2.2 shell

2.2.1 运行shell

2.2.2 目录(文件夹)

2.2.3 shell基础操作

2.3 安装Java

2.4 确认安装成功

2.5 安装和运行本书示例

Gradle基础任务

03 对象无处不在

3.1 通过引用操作对象

3.2 必须创建所有对象

3.2.1 数据保存在哪里

3.2.2 特殊情况:基本类型

3.2.3 Java中的数组

3.3 注释

3.4 无须销毁对象

3.4.1 作用域

3.4.2 对象的作用域

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

字段

3.6 方法、参数以及返回值

参数列表

3.7 编写Java程序

3.7.1 名称可见性

3.7.2 使用其他组件

3.7.3 static关键字

3.8 你的第一个Java程序

编译和运行

3.9 编程风格

3.10 总结

04 操作符

4.1 使用Java操作符

4.2 优先级

4.3 赋值

方法调用中的别名

4.4 算术操作符

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

4.5 自动递增和自动递减

4.6 关系操作符

测试对象是否相等

4.7 逻辑操作符

短路

4.8 字面量

4.8.1 字面量里的下划线

4.8.2 科学记数法(又称“指数记数法”)

4.9 按位操作符

4.10 移位操作符

4.11 三元操作符

4.12 字符串操作符+和+=

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

4.14 类型转换操作符

4.14.1 截尾和舍入

4.14.2 提升

4.15 Java没有sizeof()

4.16 操作符小结

4.17 总结

05 控制流

5.1 true和false

5.2 if-else

5.3 迭代语句

5.3.1 do-while

5.3.2 for

5.3.3 逗号操作符

5.4 for-in语法

5.5 return

5.6 break和continue

5.7 臭名昭著的goto

5.8 switch

5.9 字符串作为选择器

5.10 总结

06 初始化和清理

6.1 用构造器保证初始化

6.2 方法重载

6.2.1 区分重载的方法

6.2.2 使用基本类型的重载

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

6.3 无参构造器

6.4 this关键字

6.4.1 在构造器中调用构造器

6.4.2 static的含义

6.5 清理:终结和垃圾收集

6.5.1 finalize()的作用

6.5.2 你必须执行清理

6.5.3 终止条件

6.5.4 垃圾收集器的工作原理

6.6 成员初始化

指定初始化

6.7 构造器初始化

6.7.1 初始化顺序

6.7.2 静态数据的初始化

6.7.3 显式的静态初始化

6.7.4 非静态实例初始化

6.8 数组初始化

6.8.1 动态数组创建

6.8.2 可变参数列表

6.9 枚举类型

6.10 新特性:局部变量类型推断

6.11 总结

07 实现隐藏

7.1 package:库单元

7.1.1 代码组织

7.1.2 创建独一无二的包名

7.1.3 定制工具库

7.1.4 用import来改变行为

7.1.5 关于包的忠告

7.2 Java访问权限修饰符

7.2.1 包访问

7.2.2 public:接口访问权限

7.2.3 private:你无法访问它

7.2.4 protected:继承访问权限

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

7.3 接口和实现

7.4 类的访问权限

7.5 新特性:模块

7.6 总结

08 复用

8.1 组合语法

8.2 继承语法

初始化基类

8.3 委托

8.4 组合与继承相结合

8.4.1 确保正确的清理

8.4.2 名称隐藏

8.5 选择组合还是继承

8.6 protected关键字

8.7 向上转型

再论组合与继承

8.8 final关键字

8.8.1 final数据

8.8.2 final方法

8.8.3 final类

8.8.4 关于final的忠告

8.9 初始化及类的加载

继承与初始化

8.10 总结

09 多态

9.1 再论向上转型

忘记对象类型

9.2 难点

9.2.1 方法调用绑定

9.2.2 产生正确的行为

9.2.3 可扩展性

9.2.4 陷阱:“重写”private方法

9.2.5 陷阱:字段与静态方法

9.3 构造器和多态

9.3.1 构造器的调用顺序

9.3.2 继承与清理

9.3.3 构造器内部的多态方法行为

9.4 协变返回类型

9.5 用继承进行设计

9.5.1 替换与扩展

9.5.2 向下转型与反射

9.6 总结

10 接口

10.1 抽象类和抽象方法

10.2 接口定义

10.2.1 默认方法

10.2.2 多重继承

10.2.3 接口中的静态方法

10.2.4 作为接口的Instrument

10.3 抽象类与接口

10.4 完全解耦

10.5 组合多个接口

10.6 通过继承来扩展接口

组合接口时的名称冲突

10.7 适配接口

10.8 接口中的字段

初始化接口中的字段

10.9 嵌套接口

10.10 接口和工厂

10.11 新特性:接口的private方法

10.12 新特性:密封类和密封接口

10.13 总结

11 内部类

11.1 创建内部类

11.2 到外部类的链接

11.3 使用.this和.new

11.4 内部类和向上转型

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

11.6 匿名内部类

11.7 嵌套类

11.7.1 接口中的类

11.7.2 从多层嵌套的内部类中访问外部成员

11.8 为什么需要内部类

11.8.1 闭包与回调

11.8.2 内部类与控制框架

11.9 继承内部类

11.10 内部类可以被重写吗

11.11 局部内部类

11.12 内部类标识符

11.13 总结

12 集合

12.1 泛型和类型安全的集合

新特性:类型推断和泛型

12.2 基本概念

12.3 添加一组元素

12.4 打印集合

12.5 List

12.6 Iterator

ListIterator

12.7 LinkedList

12.8 Stack

12.9 Set

12.10 Map

12.11 新特性:记录(record)类型

12.12 Queue

PriorityQueue

12.13 Collection和Iterator的对比

12.14 for-in和迭代器

适配器方法惯用法

12.15 总结

13 函数式编程

13.1 旧方式与新方式

13.2 lambda表达式

递归

13.3 方法引用

13.3.1 Runnable

13.3.2 未绑定方法引用

13.3.3 构造器方法引用

13.4 函数式接口

13.4.1 带有更多参数的函数式接口

13.4.2 解决缺乏基本类型函数式接口的问题

13.5 高阶函数

13.6 闭包

内部类作为闭包

13.7 函数组合

13.8 柯里化和部分求值

13.9 纯函数式编程

13.10 总结

14 流

14.1 Java 8对流的支持

14.2 流的创建

14.2.1 随机数流

14.2.2 int类型的区间范围

14.2.3 generate()

14.2.4 iterate()

14.2.5 流生成器

14.2.6 Arrays

14.2.7 正则表达式

14.3 中间操作

14.3.1 跟踪与调试

14.3.2 对流元素进行排序

14.3.3 移除元素

14.3.4 将函数应用于每个流元素

14.3.5 在应用map()期间组合流

14.4 Optional类型

14.4.1 便捷函数

14.4.2 创建Optional

14.4.3 Optional对象上的操作

14.4.4 由Optional组成的流

14.5 终结操作

14.5.1 将流转换为一个数组

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

14.5.3 收集操作

14.5.4 组合所有的流元素

14.5.5 匹配

14.5.6 选择一个元素

14.5.7 获得流相关的信息

14.6 小结

15 异常

15.1 概念

15.2 基本的异常

异常参数

15.3 捕捉异常

15.3.1 try块

15.3.2 异常处理程序

15.4 创建自己的异常

异常与日志记录

15.5 异常说明

15.6 捕捉任何异常

15.6.1 多重捕捉

15.6.2 栈轨迹

15.6.3 重新抛出异常

15.6.4 异常链

15.7 标准Java异常

特例:RuntimeException

15.8 新特性:更好的NullPointerException报告机制

15.9 使用finally执行清理

15.9.1 finally是干什么用的

15.9.2 在return期间使用finally

15.9.3 缺陷:异常丢失

15.10 异常的约束

15.11 构造器

15.12 try-with-resources语句

15.12.1 细节揭秘

15.12.2 新特性:try-with-resources中的实际上的最终变量

15.13 异常匹配

15.14 其他可选方式

15.14.1 历史

15.14.2 观点

15.14.3 把异常传递到控制台

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

15.15 异常使用指南

15.16 小结

附记 异常的奇异世界

16 代码校验

16.1 测试

16.1.1 单元测试

16.1.2 测试覆盖率的幻觉

16.2 前置条件

16.2.1 断言

16.2.2 DbC+单元测试

16.2.3 使用Guava里的前置条件

16.3 测试驱动开发

测试驱动与测试优先

16.4 日志

日志级别

16.5 调试

16.5.1 使用JDB进行调试

16.5.2 图形调试器

16.6 基准测试

16.6.1 微基准测试

16.6.2 介绍JMH

16.7 分析与优化

优化指南

16.8 样式检查

16.9 静态错误分析

16.10 代码审查

16.11 结对编程

16.12 重构

重构的基础

16.13 持续集成

16.14 总结

17 文件

17.1 文件和目录路径

17.1.1 选择Path的片段

17.1.2 分析Path

17.1.3 添加或删除路径片段

17.2 目录

17.3 文件系统

17.4 监听Path

17.5 查找文件

17.6 读写文件

17.7 小结

18 字符串

18.1 不可变的字符串

18.2 重载+与StringBuilder

18.3 无意识的递归

18.4 对字符串的操作

18.5 格式化输出

18.5.1 printf()

18.5.2 System.out.format()

18.5.3 Formatter类

18.5.4 格式说明符

18.5.5 Formatter转换

18.5.6 String.format()

18.6 新特性:文本块

18.7 正则表达式

18.7.1 基础

18.7.2 创建正则表达式

18.7.3 量词

18.7.4 Pattern和Matcher

18.7.5 split()

18.7.6 替换操作

18.7.7 reset()

18.7.8 正则表达式和JavaI/O

18.8 扫描输入

18.8.1 Scanner分隔符

18.8.2 使用正则表达式扫描

18.9 StringTokenizer

18.10 总结

19 反射

19.1 为什么需要反射

19.2 Class对象

19.2.1 类字面量

19.2.2 泛型类的引用

19.2.3 cast()方法

19.3 转型前检查

19.3.1 使用类字面量

19.3.2 动态的instanceof

19.3.3 递归计数

19.4 注册工厂

19.5 Instanceof与Class的等价性

19.6 运行时的类信息

类方法提取器

19.7 动态代理

19.8 使用Optional

19.8.1 标签接口

19.8.2 模拟对象和桩

19.9 接口和类型信息

19.10 总结

20 泛型

20.1 和C++的对比

20.2 简单泛型

20.2.1 元组库

20.2.2 栈类

20.2.3 RandomList

20.3 泛型接口

20.4 泛型方法

20.4.1 可变参数和泛型方法

20.4.2 通用Supplier

20.4.3 简化元组的使用

20.4.4 Set实用工具

20.5 构建复杂模型

20.6 类型擦除的奥秘

20.6.1 C++的实现方法

20.6.2 迁移的兼容性

20.6.3 类型擦除存在的问题

20.6.4 边界的行为

20.7 对类型擦除的补偿

20.7.1 创建类型实例

20.7.2 泛型数组

20.8 边界

20.9 通配符

20.9.1 编译器有多聪明?

20.9.2 逆变性

20.9.3 无界通配符

20.9.4 捕获转换

20.10 问题

20.10.1 基本类型不可作为类型参数

20.10.2 实现参数化接口

20.10.3 类型转换和警告

20.10.4 重载

20.10.5 基类会劫持接口

20.11 自限定类型

20.11.1 奇异递归泛型

20.11.2 自限定

20.11.3 参数协变性

20.12 动态类型安全

20.13 异常

20.14 混型

20.14.1 C++中的混型

20.14.2 与接口混合

20.14.3 使用装饰器模式

20.14.4 与动态代理混合

20.15 潜在类型机制

20.15.1 Python中的潜在类型机制

20.15.2 C++中的潜在类型机制

20.15.3 Go中的潜在类型机制

20.15.4 Java中的直接潜在类型机制

20.16 对于缺少(直接的)潜在类型机制的补偿

20.16.1 反射

20.16.2 将方法应用于序列

20.17 Java 8中的辅助潜在类型机制

使用Supplier的泛型方法

20.18 总结:转型真的这么糟糕吗?

延伸阅读

21 数组

21.1 数组为何特殊

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

21.2 数组是一等对象

21.3 返回数组

21.4 多维数组

21.5 数组和泛型

21.6 Arrays.fill()

21.7 Arrays.setAll()

21.8 增量生成器

21.9 随机数生成器

21.10 泛型和基本类型数组

21.11 修改已有的数组元素

21.12 关于数组并行

21.12.1 策略

21.12.2 parallelSetAll()

21.13 数组实用工具

21.14 数组复制

21.15 数组比较

21.16 流和数组

21.17 数组排序

21.17.1 使用Arrays.sort()

21.17.2 并行排序

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

21.19 用parallelPrefix()进行累积计算

21.20 总结

A 补充内容

B 积极看待C++与Java的遗产

•作者简介•

•译者简介•

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部