Java核心技术 卷I 基础知识 第11版 英文版 上下册

出版者:人民邮电出版社

作者:Cay S. Horstmann

出品人:异步图书

页数:842

出版时间:2019-5-1

价格:149.00 元

装帧:平装

isbn号码:9787115504920

具体描述

本书是经典的《Java核心技术 卷I：基础知识》的新版。这一版对全书进行了全面更新，以反映Java SE 9、Java SE 10和Java SE 11的特性。书中囊括了Java的全部基础知识，提供了大量完整且具有实际意义的应用示例，详细介绍了Java语言基础、面向对象编程、反射与代理、接口与内部类、事件监听器模型、使用Swing UI工具进行图形用户界面程序设计、打包应用程序、异常处理、登录与调试、泛型编程、集合框架、多线程和并发等内容。

作者简介

凯·S. 霍斯特曼（Cay S. Horstmann） 圣何塞州立大学计算机科学教授，“Java大师”（Java Champion）。他是多卷本的《Java核心技术》《写给大忙人看的Java核心技术（第2 版）》以及《快学Scala（第2 版）》的作者。他还编写了很多针对专业程序员和计算机科学专业学生的其他图书。

目录信息

Chapter　1： An Introduction to Java / Java概述　1
1．1　Java as a Programming Platform / Java程序设计平台　1
1．2　The Java“White Paper”Buzzwords / Java“白皮书”中的口号　2
1．2．1　Simple / 简单　3
1．2．2　Object-Oriented / 面向对象　4
1．2．3　Distributed / 分布式　4
1．2．4　Robust / 健壮　4
1．2．5　Secure / 安全　5
1．2．6　Architecture-Neutral / 体系结构中立　6
1．2．7　Portable / 可移植　6
1．2．8　Interpreted / 解释型　7
1．2．9　High-Performance / 高性能　7
1．2．10　Multithreaded / 多线程　8
1．2．11　Dynamic / 动态　8
1．3　Java Applets and the Internet / Java Applet与Internet　9
1．4　A Short History of Java / Java简史　10
1．5　Common Misconceptions about Java / 对Java的常见误解　13
Chapter　2： The Java Programming Environment / Java编程环境　17
2．1　Installing the Java Development Kit / 安装Java开发包（JDK）　18
2．1．1　Downloading the JDK / 下载JDK　18
2．1．2　Setting up the JDK / 设置JDK　20
2．1．3　Installing Source Files and Documentation / 安装源文件和文档　22
2．2　Using the Command-Line Tools / 使用命令行工具　23
2．3　Using an Integrated Development Environment / 使用集成开发环境　29
2．4　JShell　32
Chapter　3： Fundamental Programming Structures in Java / Java的基本编程结构　37
3．1　A Simple Java Program / 一个简单的Java程序　38
3．2　Comments / 注释　41
3．3　Data Types / 数据类型　42
3．3．1　Integer Types / 整型　43
3．3．2　Floating-Point Types / 浮点型　44
3．3．3　The char Type / char类型　46
3．3．4　Unicode and the char Type / Unicode与char类型　47
3．3．5　The boolean Type / boolean类型　48
3．4　Variables and Constants / 变量和常量　48
3．4．1　Declaring Variables / 声明变量　48
3．4．2　Initializing Variables / 初始化变量　50
3．4．3　Constants / 常量　51
3．4．4　Enumerated Types / 枚举类型　52
3．5　Operators / 运算符　52
3．5．1　Arithmetic Operators / 算术运算符　52
3．5．2　Mathematical Functions and Constants / 数学函数和常量　54
3．5．3　Conversions between Numeric Types / 数值类型之间的转换　56
3．5．4　Casts / 强制类型转换　57
3．5．5　Combining Assignment with Operators / 组合赋值运算符　58
3．5．6　Increment and Decrement Operators / 自增与自减运算符　58
3．5．7　Relational and boolean Operators / 关系与boolean运算符　59
3．5．8　Bitwise Operators / 位运算符　60
3．5．9　Parentheses and Operator Hierarchy / 括号与运算符优先级　61
3．6　Strings / 字符串　62
3．6．1　Substrings / 子串　62
3．6．2　Concatenation / 拼接　63
3．6．3　Strings Are Immutable / String是不可变的　63
3．6．4　Testing Strings for Equality / 测试字符串是否相等　65
3．6．5　Empty and Null Strings / 空串与null串　66
3．6．6　Code Points and Code Units / 码位与编码单元　66
3．6．7　The String API / String API　68
3．6．8　Reading the Online API Documentation / 阅读在线API文档　71
3．6．9　Building Strings / 构建字符串　74
3．7　Input and Output / 输入和输出　75
3．7．1　Reading Input / 读取输入　75
3．7．2　Formatting Output / 格式化输出　78
3．7．3　File Input and Output / 文件输入和输出　83
3．8　Control Flow / 控制流　86
3．8．1　Block Scope / 块作用域　86
3．8．2　Conditional Statements / 条件语句　87
3．8．3　Loops / 循环　91
3．8．4　Determinate Loops / 确定性循环　95
3．8．5　Multiple Selections—The switch Statement / 多重选择：switch语句　99
3．8．6　Statements That Break Control Flow / 用于跳出控制流的语句　102
3．9　Big Numbers / 大数　105
3．10　Arrays / 数组　108
3．10．1　Declaring Arrays / 声明数组　108
3．10．2　Accessing Array Elements / 访问数组元素　109
3．10．3　The “for each” Loop / “for each”循环　110
3．10．4　Array Copying / 数组复制　111
3．10．5　Command-Line Parameters / 命令行参数　112
3．10．6　Array Sorting / 数组排序　113
3．10．7　Multidimensional Arrays / 多维数组　116
3．10．8　Ragged Arrays / 不规则数组　120
Chapter　4： Objects and Classes / 对象与类　125
4．1　Introduction to Object-Oriented Programming / 面向对象编程简介　126
4．1．1　Classes / 类　127
4．1．2　Objects / 对象　128
4．1．3　Identifying Classes / 识别类　129
4．1．4　Relationships between Classes / 类之间的关系　129
4．2　Using Predefined Classes / 使用预定义类　131
4．2．1　Objects and Object Variables / 对象与对象变量　132
4．2．2　The LocalDate Class of the Java Library / Java库中的LocalDate类　135
4．2．3　Mutator and Accessor Methods / 更改器方法与访问器方法　138
4．3　Defining Your Own Classes / 定义自己的类　141
4．3．1　An Employee Class / Employee类　142
4．3．2　Use of Multiple Source Files / 使用多个源文件　145
4．3．3　Dissecting the Employee Class / 分析Employee类　146
4．3．4　First Steps with Constructors / 从构造器开始　146
4．3．5　Declaring Local Variables with var / 使用var声明局部变量　148
4．3．6　Working with null References / 使用null引用　148
4．3．7　Implicit and Explicit Parameters / 隐式参数与显式参数　150
4．3．8　Benefits of Encapsulation / 封装的好处　151
4．3．9　Class-Based Access Privileges / 基于类的访问权限　154
4．3．10　Private Methods / 私有方法　155
4．3．11　Final Instance Fields / final实例字段　155
4．4　Static Fields and Methods / 静态的字段与方法　156
4．4．1　Static Fields / 静态字段　156
4．4．2　Static Constants / 静态常量　157
4．4．3　Static Methods / 静态方法　158
4．4．4　Factory Methods / 工厂方法　159
4．4．5　The main Method / main方法　160
4．5　Method Parameters / 方法参数　163
4．6　Object Construction / 对象构建　170
4．6．1　Overloading / 重载　170
4．6．2　Default Field Initialization / 默认字段初始化　171
4．6．3　The Constructor with No Arguments / 无参构造器　172
4．6．4　Explicit Field Initialization / 显式字段初始化　173
4．6．5　Parameter Names / 参数名　174
4．6．6　Calling Another Constructor / 调用另一个构造器　175
4．6．7　Initialization Blocks / 初始化块　175
4．6．8　Object Destruction and the finalize Method / 对象析构与finalize方法　180
4．7　Packages / 包　180
4．7．1　Package Names / 包名　181
4．7．2　Class Importation / 导入类　181
4．7．3　Static Imports / 静态导入　183
4．7．4　Addition of a Class into a Package / 将类添加到某个包中　184
4．7．5　Package Access / 包访问权限　187
4．7．6　The Class Path / 类路径　189
4．7．7　Setting the Class Path / 设置类路径　191
4．8　JAR Files / JAR文件　192
4．8．1　Creating JAR files / 创建JAR文件　192
4．8．2　The Manifest / 清单文件　193
4．8．3　Executable JAR Files / 可执行的JAR文件　194
4．8．4　Multi-Release JAR Files / 支持多个Java版本的JAR文件　195
4．8．5　A Note about Command-Line Options / 关于命令行选项的说明　197
4．9　Documentation Comments / 文档注释　198
4．9．1　Comment Insertion / 插入注释　199
4．9．2　Class Comments / 类注释　199
4．9．3　Method Comments / 方法注释　200
4．9．4　Field Comments / 字段注释　201
4．9．5　General Comments / 通用注释　201
4．9．6　Package Comments / 包注释　202
4．9．7　Comment Extraction / 提取注释　203
4．10　Class Design Hints / 类设计建议　204
Chapter　5： Inheritance / 继承　207
5．1　Classes， Superclasses， and Subclasses / 类、超类与子类　208
5．1．1　Defining Subclasses / 定义子类　208
5．1．2　Overriding Methods / 覆盖方法　210
5．1．3　Subclass Constructors / 子类构造器　211
5．1．4　Inheritance Hierarchies / 继承层次　216
5．1．5　Polymorphism / 多态　217
5．1．6　Understanding Method Calls / 理解方法调用　218
5．1．7　Preventing Inheritance： Final Classes and Methods / 阻止继承：final修饰的类和方法　221
5．1．8　Casting / 强制类型转换　223
5．1．9　Abstract Classes / 抽象类　225
5．1．10　Protected Access / 受保护访问　231
5．2　Object： The Cosmic Superclass / Object：所有类的超类　232
5．2．1　Variables of Type Object / Object类型的变量　232
5．2．2　The equals Method / equals方法　233
5．2．3　Equality Testing and Inheritance / 相等测试与继承　234
5．2．4　The hashCode Method / hashCode方法　238
5．2．5　The toString Method / toString方法　241
5．3　Generic Array Lists / 泛型数组列表　248
5．3．1　Declaring Array Lists / 声明数组列表　248
5．3．2　Accessing Array List Elements / 访问数组列表的元素　251
5．3．3　Compatibility between Typed and Raw Array Lists / 类型化和原始数组列表的兼容性　255
5．4　Object Wrappers and Autoboxing / 对象包装器与自动装箱　256
5．5　Methods with a Variable Number of Parameters / 参数数量可变的方法　260
5．6　Enumeration Classes / 枚举类　261
5．7　Reflection / 反射　264
5．7．1　The Class Class / Class类　264
5．7．2　A Primer on Declaring Exceptions / 初步了解如何声明异常　267
5．7．3　Resources / 资源　268
5．7．4　Using Reflection to Analyze the Capabilities of Classes / 使用反射分析类的能力　271
5．7．5　Using Reflection to Analyze Objects at Runtime / 使用反射在运行时分析对象　277
5．7．6　Using Reflection to Write Generic Array Code / 使用反射编写泛型数组代码　283
5．7．7　Invoking Arbitrary Methods and Constructors / 调用任意方法和构造器　286
5．8　Design Hints for Inheritance / 继承的设计建议　290
Chapter　6： Interfaces， Lambda Expressions， and Inner Classes / 接口、Lambda表达式和内部类　295
6．1　Interfaces / 接口　296
6．1．1　The Interface Concept / 接口的概念　296
6．1．2　Properties of Interfaces / 接口的特性　303
6．1．3　Interfaces and Abstract Classes / 接口与抽象类　305
6．1．4　Static and Private Methods / 静态和私有方法　306
6．1．5　Default Methods / 默认方法　307
6．1．6　Resolving Default Method Conflicts / 解决默认方法的冲突　308
6．1．7　Interfaces and Callbacks / 接口与回调　310
6．1．8　The Comparator Interface / Comparator接口　313
6．1．9　Object Cloning / 对象克隆　314
6．2　Lambda Expressions / Lambda表达式　322
6．2．1　Why Lambdas / 为什么引入Lambda表达式　322
6．2．2　The Syntax of Lambda Expressions / Lambda表达式的语法　323
6．2．3　Functional Interfaces / 函数式接口　326
6．2．4　Method References / 方法引用　328
6．2．5　Constructor References / 构造器引用　332
6．2．6　Variable Scope / 变量作用域　333
6．2．7　Processing Lambda Expressions / 处理Lambda表达式　335
6．2．8　More about Comparators / 再谈Comparator　339
6．3　Inner Classes / 内部类　340
6．3．1　Use of an Inner Class to Access Object State / 使用内部类访问对象状态　341
6．3．2　Special Syntax Rules for Inner Classes / 内部类的特殊语法规则　345
6．3．3　Are Inner Classes Useful Actually Necessary Secure / 内部类是否有用、必要和安全　346
6．3．4　Local Inner Classes / 局部内部类　349
6．3．5　Accessing Variables from Outer Methods / 从外部方法访问变量　350
6．3．6　Anonymous Inner Classes / 匿名内部类　352
6．3．7　Static Inner Classes / 静态内部类　356
6．4　Service Loaders / 服务加载器　360
6．5　Proxies / 代理　362
6．5．1　When to Use Proxies / 何时使用代理　363
6．5．2　Creating Proxy Objects / 创建代理对象　363
6．5．3　Properties of Proxy Classes / 代理类的特性　368
Chapter　7： Exceptions， Assertions， and Logging / 异常、断言与日志　371
7．1　Dealing with Errors / 处理错误　372
7．1．1　The Classification of Exceptions / 异常分类　373
7．1．2　Declaring Checked Exceptions / 声明检查型异常　375
7．1．3　How to Throw an Exception / 如何抛出异常　378
7．1．4　Creating Exception Classes / 创建异常类　380
7．2　Catching Exceptions / 捕获异常　381
7．2．1　Catching an Exception / 捕获一个异常　381
7．2．2　Catching Multiple Exceptions / 捕获多个异常　383
7．2．3　Rethrowing and Chaining Exceptions / 再次抛出异常与异常链　384
7．2．4　The finally Clause / finally子句　386
7．2．5　The try-with-Resources Statement / try-with-resources语句　389
7．2．6　Analyzing Stack Trace Elements / 分析栈轨迹元素　391
7．3　Tips for Using Exceptions / 异常使用技巧　396
7．4　Using Assertions / 使用断言　399
7．4．1　The Assertion Concept / 断言的概念　399
7．4．2　Assertion Enabling and Disabling / 启用和禁用断言　400
7．4．3　Using Assertions for Parameter Checking / 使用断言检查参数　401
7．4．4　Using Assertions for Documenting Assumptions / 使用断言保证文档中假定成立的条件　402
7．5　Logging / 日志　403
7．5．1　Basic Logging / 基本日志　404
7．5．2　Advanced Logging / 高级日志　405
7．5．3　Changing the Log Manager Configuration / 修改日志管理器配置　407
7．5．4　Localization / 本地化　409
7．5．5　Handlers / 处理器　410
7．5．6　Filters / 过滤器　414
7．5．7　Formatters / 格式化器　415
7．5．8　A Logging Recipe / 常见日志操作总结　415
7．6　Debugging Tips / 调试技巧　425
Chapter　8： Generic Programming / 泛型编程　431
8．1　Why Generic Programming / 为什么要使用泛型编程　432
8．1．1　The Advantage of Type Parameters / 类型参数的好处　432
8．1．2　Who Wants to Be a Generic Programmer / 哪些人想成为泛型程序员　433
8．2　Defining a Simple Generic Class / 定义简单的泛型类　434
8．3　Generic Methods / 泛型方法　437
8．4　Bounds for Type Variables / 类型变量的绑定　438
8．5　Generic Code and the Virtual Machine / 泛型代码与虚拟机　441
8．5．1　Type Erasure / 类型擦除　441
8．5．2　Translating Generic Expressions / 翻译泛型表达式　442
8．5．3　Translating Generic Methods / 翻译泛型方法　443
8．5．4　Calling Legacy Code / 调用遗留代码　445
8．6　Restrictions and Limitations / 约束与局限性　447
8．6．1　Type Parameters Cannot Be Instantiated with Primitive Types / 类型参数不能用基本类型来实例化　447
8．6．2　Runtime Type Inquiry Only Works with Raw Types / 运行时类型查询只适用于原始类型　447
8．6．3　You Cannot Create Arrays of Parameterized Types / 不能创建参数化类型的数组　448
8．6．4　Varargs Warnings / 注意变长参数情况　448
8．6．5　You Cannot Instantiate Type Variables / 不能实例化类型变量　450
8．6．6　You Cannot Construct a Generic Array / 不能构造泛型数组　451
8．6．7　Type Variables Are Not Valid in Static Contexts of Generic Classes / 类型变量在泛型类的静态上下文中无效　452
8．6．8　You Cannot Throw or Catch Instances of a Generic Class / 不能抛出或捕获泛型类的实例　453
8．6．9　You Can Defeat Checked Exception Checking / 可以打破“检查型异常必须检查”的规则　454
8．6．10　Beware of Clashes after Erasure / 意类型擦除后的冲突　455
8．7　Inheritance Rules for Generic Types / 泛型类型的继承规则　457
8．8　Wildcard Types / 通配符类型　459
8．8．1　The Wildcard Concept / 通配符的概念　459
8．8．2　Supertype Bounds for Wildcards / 通配符的超类型限定　461
8．8．3　Unbounded Wildcards / 无限定通配符　464
8．8．4　Wildcard Capture / 通配符捕获　465
8．9　Reflection and Generics / 反射与泛型　467
8．9．1　The Generic Class Class / 泛型的Class类　467
8．9．2　Using Class Parameters for Type Matching / 使用Class参数进行类型匹配　469
8．9．3　Generic Type Information in the Virtual Machine / 虚拟机中的泛型类型信息　469
8．9．4　Type Literals / TypeLiteral　473
Chapter　9： Collections / 集合类　481
9．1　The Java Collections Framework / Java集合类框架　482
9．1．1　Separating Collection Interfaces and Implementation / 将集合类的接口与实现分离　482
9．1．2　The Collection Interface / Collection接口　485
9．1．3　Iterators / 迭代器　485
9．1．4　Generic Utility Methods / 泛型的实用方法　489
9．2　Interfaces in the Collections Framework / 集合类框架中的接口　492
9．3　Concrete Collections / 具体的集合类　494
9．3．1　Linked Lists / 链表　496
9．3．2　Array Lists / 数组列表　507
9．3．3　Hash Sets / 散列集　507
9．3．4　Tree Sets / 树形集　511
9．3．5　Queues and Deques / 队列与双端队列　516
9．3．6　Priority Queues / 优先级队列　518
9．4　Maps / 映射　519
9．4．1　Basic Map Operations / 基本映射操作　519
9．4．2　Updating Map Entries / 更新映射表项　523
9．4．3　Map Views / 映射视图　525
9．4．4　Weak Hash Maps / 弱散列映射　526
9．4．5　Linked Hash Sets and Maps / LinkedHashSet与LinkedHashMap　527
9．4．6　Enumeration Sets and Maps / EnumSet与EnumMap　529
9．4．7　Identity Hash Maps / IdentityHashMap　530
9．5　Views and Wrappers / 视图与包装器　532
9．5．1　Small Collections / 小型集合　532
9．5．2　Subranges / 子范围　534
9．5．3　Unmodifiable Views / 不可修改视图　535
9．5．4　Synchronized Views / 同步视图　536
9．5．5　Checked Views / 检查用视图　536
9．5．6　A Note on Optional Operations / 可选操作说明　537
9．6　Algorithms / 算法　541
9．6．1　Why Generic Algorithms / 为什么要使用泛型算法　541
9．6．2　Sorting and Shuffling / 排序与混排　543
9．6．3　Binary Search / 二分查找　546
9．6．4　Simple Algorithms / 简单算法　547
9．6．5　Bulk Operations / 主要操作　549
9．6．6　Converting between Collections and Arrays / 集合与数组之间的转换　550
9．6．7　Writing Your Own Algorithms / 编写自己的算法　551
9．7　Legacy Collections / 遗留的集合类　552
9．7．1　The Hashtable Class / Hashtable类　553
9．7．2　Enumerations / Enumeration　553
9．7．3　Property Maps / 属性映射　555
9．7．4　Stacks / 栈　558
9．7．5　Bit Sets / 位集　559
Chapter　10： Graphical User Interface Programming / 图形用户界面编程　565
10．1　A History of Java User Interface Toolkits / Java用户界面工具包的历史　565
10．2　Displaying Frames / 显示框架　567
10．2．1　Creating a Frame / 创建框架　568
10．2．2　Frame Properties / 框架属性　570
10．3　Displaying Information in a Component / 在组件中显示信息　574
10．3．1　Working with 2D Shapes / 处理2D图形　579
10．3．2　Using Color / 使用颜色　587
10．3．3　Using Fonts / 使用字体　589
10．3．4　Displaying Images / 显示图片　597
10．4　Event Handling / 事件处理　598
10．4．1　Basic Event Handling Concepts / 事件处理的基本概念　598
10．4．2　Example： Handling a Button Click / 示例：处理按钮点击事件　600
10．4．3　Specifying Listeners Concisely / 设置监听器的简洁方法　604
10．4．4　Adapter Classes / 适配器类　605
10．4．5　Actions / 动作　608
10．4．6　Mouse Events / 鼠标事件　614
10．4．7　The AWT Event Hierarchy / AWT事件层次　620
10．5　The Preferences API / Preferences API　624
Chapter　11： User Interface Components with Swing / Swing用户界面组件　631
11．1　Swing and the Model-View-Controller Design Pattern / Swing与模型-视图-控制器设计模式　632
11．2　Introduction to Layout Management / 布局管理简介　636
11．2．1　Layout Managers / 布局管理器　637
11．2．2　Border Layout / 边框布局　639
11．2．3　Grid Layout / 网格布局　642
11．3　Text Input / 文本输入　643
11．3．1　Text Fields / 文本框　643
11．3．2　Labels and Labeling Components / 标签与标签组件　645
11．3．3　Password Fields / 密码框　647
11．3．4　Text Areas / 文本区域　647
11．3．5　Scroll Panes / 滚动窗格　648
11．4　Choice Components / 选择组件　651
11．4．1　Checkboxes / 复选框　651
11．4．2　Radio Buttons /单选按钮　654
11．4．3　Borders / 边框　658
11．4．4　Combo Boxes / 组合框　661
11．4．5　Sliders / 滑动条　665
11．5　Menus / 菜单　671
11．5．1　Menu Building / 菜单构建　672
11．5．2　Icons in Menu Items / 菜单项中的图标　675
11．5．3　Checkbox and Radio Button Menu Items / 复选框和单选按钮菜单项　676
11．5．4　Pop-Up Menus / 弹出菜单　677
11．5．5　Keyboard Mnemonics and Accelerators / 键盘助记符与快捷键　679
11．5．6　Enabling and Disabling Menu Items / 启用和禁用菜单项　682
11．5．7　Toolbars / 工具栏　687
11．5．8　Tooltips / 工具提示　689
11．6　Sophisticated Layout Management / 复杂的布局管理　690
11．6．1　The Grid Bag Layout / 网格袋布局　691
11．6．2　Custom Layout Managers / 定制布局管理器　702
11．7　Dialog Boxes / 对话框　706
11．7．1　Option Dialogs / 选项对话框　707
11．7．2　Creating Dialogs / 创建对话框　712
11．7．3　Data Exchange / 数据交换　716
11．7．4　File Dialogs / 文件对话框　723
Chapter　12： Concurrency / 并发　733
12．1　What Are Threads / 什么是线程　734
12．2　Thread States / 线程状态　739
12．2．1　New Threads / 新创建线程　740
12．2．2　Runnable Threads / 可运行线程　740
12．2．3　Blocked and Waiting Threads / 被阻塞线程与等待线程　741
12．2．4　Terminated Threads / 被终止的线程　742
12．3　Thread Properties / 线程属性　743
12．3．1　Interrupting Threads / 中断线程　743
12．3．2　Daemon Threads / 守护线程　746
12．3．3　Thread Names / 线程名　747
12．3．4　Handlers for Uncaught Exceptions / 未捕获异常的处理器　747
12．3．5　Thread Priorities / 线程优先级　749
12．4　Synchronization / 同步　750
12．4．1　An Example of a Race Condition / 竞争条件的一个案例　750
12．4．2　The Race Condition Explained / 竞争条件详解　752
12．4．3　Lock Objects / 锁对象　755
12．4．4　Condition Objects / 条件对象　758
12．4．5　The synchronized Keyword / synchronized关键字　764
12．4．6　Synchronized Blocks / 同步块　768
12．4．7　The Monitor Concept / 监视器概念　770
12．4．8　Volatile Fields / volatile字段　771
12．4．9　Final Variables / final变量　772
12．4．10　Atomics / 原子　773
12．4．11　Deadlocks / 死锁　775
12．4．12　Thread-Local Variables / 线程局部变量　778
12．4．13　Why the stop and suspend Methods Are Deprecated / 为什么弃用stop和suspend方法　779
12．5　Thread-Safe Collections / 线程安全的集合　781
12．5．1　Blocking Queues / 阻塞队列　781
12．5．2　Efficient Maps， Sets， and Queues / 高效的映射、集和队列　789
12．5．3　Atomic Update of Map Entries / 映射表项的原子更新　790
12．5．4　Bulk Operations on Concurrent Hash Maps / 并发散列映射上的主要操作　794
12．5．5　Concurrent Set Views / 并发的集视图　796
12．5．6　Copy on Write Arrays / 写时复制的数组　797
12．5．7　Parallel Array Algorithms / 并行数组算法　797
12．5．8　Older Thread-Safe Collections / 较早的线程安全的集合　799
12．6　Tasks and Thread Pools / 任务和线程池　800
12．6．1　Callables and Futures / Callable与Future　800
12．6．2　Executors / 执行器　802
12．6．3　Controlling Groups of Tasks / 控制任务组　806
12．6．4　The Fork-Join Framework / Fork-Join框架　811
12．7　Asynchronous Computations / 异步计算　814
12．7．1　Completable Futures / CompletableFuture　815
12．7．2　Composing Completable Futures / 组合CompletableFuture　817
12．7．3　Long-Running Tasks in User Interface Callbacks / 用户界面回调中的长期运行任务　823
12．8　Processes / 进程　831
12．8．1　Building a Process / 构建进程　832
12．8．2　Running a Process / 运行进程　834
12．8．3　Process Handles / 进程handle　835
Appendix　/ 附录　839
· · · · · · (收起)

读后感

《Java核心技术卷一》是唯一可以和《[Java编程思想]》媲美的一本 Java 入门书。单从技术的角度来看，前者更好一些。但上升到思想层面嘛，自然后者更好，两者的偏重点不同。 思想不会变，所以《Java编程思想》还停留在第 4 版（2007 年）；而技术是要更新迭代的，所以《Java核心...  

本书的内容很全面，但是不得不吐糟一下翻译，比如在P231，倒数第8行，“这个方法的调用者可以34使用……”，推测这里的34应该是没有用的，这种错误太低级了。另外翻译的表达不清晰，有效的降低了我对本书的理解，建议大家看原版  

每次我的朋友来问我，学java看什么书好，我总是说：《Thinking in Java》是你一定要看的，但不是现在，那本书不适合入门。要入门，来，借这本书去吧，然后递给他这本《Core Java》（卷一）。 Java十年，发展如此迅速，J2EE之火热，令我大感惊讶，我为我几年前选择学Java刚到庆...  

《Java核心技术卷一》是唯一可以和《[Java编程思想]》媲美的一本 Java 入门书。单从技术的角度来看，前者更好一些。但上升到思想层面嘛，自然后者更好，两者的偏重点不同。 思想不会变，所以《Java编程思想》还停留在第 4 版（2007 年）；而技术是要更新迭代的，所以《Java核心...  

我从来没有看过一本这样轻松的计算机的书，我是有生以来第一次读到这么好的翻译的书。在我对翻译的书绝对无望的时候，它力挽狂澜的告诉我，事情还没有坏到这个地步。 我以前发誓此生不再看XXX人编著的书，不再看XXXX等人和著的书，我只看XXX著的书。 但看过了cove java 之后...  

用户评价

在我的编程学习生涯中，《Java核心技术 卷I 基础知识 第11版》这本书无疑是一座灯塔，指引我前行的方向。我曾尝试过不少Java的书籍，但总觉得它们要么过于肤浅，要么就跳跃性太强，让人难以跟上。这套书，尤其是其英文原版，以其严谨的逻辑、详实的论证和丰富的实例，为我构建了一个扎实的Java知识体系。我尤其欣赏它在讲解泛型（Generics）时，那种循序渐进的讲解方式。它从问题的引入，到泛型的基本语法，再到通配符的深入运用，层层递进，让我能够清晰地理解泛型的强大之处，以及它如何帮助我们编写更安全、更具可读性的代码。在讲解并发编程时，这本书也做得非常出色。它从最基础的线程创建和生命周期开始，逐步深入到同步、锁、并发工具类等概念，并且还会探讨一些常见的并发问题，如死锁、竞态条件等，并给出解决方案。这对于我这样一个之前对多线程有些畏惧的开发者来说，简直是福音。我曾经因为不理解多线程的并发机制，导致程序出现过一些难以调试的bug，而这本书的讲解，帮助我彻底理清了思路。此外，这本书还对Java的反射（Reflection）和注解（Annotations）机制进行了深入的介绍。这些是Java中相对高级的概念，但通过这本书的讲解，我能够理解它们是如何工作的，以及它们在实际开发中的应用场景，为我今后学习框架和源码打下了坚实的基础。虽然阅读英文原版需要更多的耐心和精力，需要随时查阅词典，但它带来的准确性和权威性是翻译本无法比拟的。这本书的语言风格非常务实、客观，每一句话都饱含信息量，没有丝毫的冗余，就像一位技艺精湛的工匠，一丝不苟地雕琢着一件艺术品。

我购买《Java核心技术 卷I 基础知识 第11版》这本书，是因为我寻求的是一本能够真正帮助我理解Java“为什么”的书，而不是仅仅停留在“怎么做”的层面。这本书，从我翻开的第一页开始，就给了我这种感觉。它不是那种“拿来主义”的书，而是带着你去探索、去思考。我尤其喜欢它在讲解对象、类、封装、继承、多态这些面向对象编程的核心概念时，那种深入浅出的方式。它不仅仅是告诉你这些概念是什么，更重要的是，它会通过一系列的实际例子，让你理解这些概念的实际应用，以及它们之间的内在联系。比如，在讲解继承时，它会用动物和狗的例子，让你理解“is-a”的关系；在讲解多态时，它会用图形绘制的例子，让你理解如何通过父类引用指向子类对象，从而实现方法的动态绑定。这些例子非常生动形象，让我能够轻松地理解这些抽象的概念。在讲解异常处理方面，这本书也做得非常出色。它不仅仅教你如何使用try-catch-finally，更重要的是，它会让你理解异常的本质，Checked Exception和Unchecked Exception的区别，以及如何设计健壮的异常处理策略。这对于我来说，是之前学习Java时一直觉得模糊不清的一个概念，而这本书的讲解，让我豁然开朗。此外，这本书在讲解集合框架（Collections Framework）时，也提供了非常详尽的说明。它对各种集合类，如ArrayList, LinkedList, HashMap, HashSet等，都进行了详细的分析，包括它们的内部实现原理、时间复杂度、空间复杂度，以及各自的适用场景。这让我能够根据实际需求，选择最合适的集合类型，从而优化程序的性能。虽然阅读英文原版需要花费更多的时间和精力，需要随时查阅词典，但它带来的精准性和权威性是无可比拟的。这本书的语言风格严谨、客观，没有任何废话，每一句话都充满了信息量，就像是在进行一场严密的学术研究。

这本《Java核心技术 卷I 基础知识 第11版》，说实话，我一开始是被它的装帧吸引的。两本加起来，分量十足，封面设计虽然算不上惊艳，但那种经典、沉稳的感觉，就是告诉你“我是干货”。我之前也尝试过几本Java的书，有的是网络上的免费教程，有的是其他出版社的，但总感觉差了点什么。要么代码示例太简单，脱离实际；要么概念讲得太抽象，摸不着头脑。唯独这本书，给我一种“厚积薄发”的感觉。它不是那种一上来就给你灌输各种高深概念的书，而是从最最基础的“Hello World”开始，一步一步地引导你走进Java的世界。我尤其喜欢它在讲解变量、数据类型、运算符这些基础内容时，那种刨根问底的态度。它不仅仅告诉你这些东西是什么，更会告诉你为什么是这样，背后的原理是什么。比如，它会详细解释不同数据类型的内存占用，以及为什么会发生数据溢出，这种细致的讲解，让我对Java有了更深刻的理解，而不是仅仅停留在“会用”的层面。而且，它在讲解面向对象编程（OOP）时，也做了非常详尽的阐述，从类、对象、封装、继承、多态，到接口、抽象类，几乎把OOP的每一个概念都用清晰的例子进行了说明，甚至还探讨了设计模式的雏形。这对于我这种从零开始学习编程的人来说，是至关重要的。有时候，我会花很长时间去琢磨书上的一个例子，然后自己动手去修改，去尝试，在这个过程中，我能感受到知识一点点内化成自己的东西。这本书的作者，肯定是对Java有着极其深刻的理解，他能够把如此复杂的知识，用一种逻辑清晰、条理分明的方式呈现出来，并且在每一章的结尾，都会有一些练习题，这些题目往往能够巩固你本章所学的知识，甚至还能启发你思考更深层次的问题。虽然是英文原版，对我这种英文阅读能力一般的人来说，确实是一个挑战，但我认为，直接阅读原版，才能最准确地把握作者的意图，理解那些在翻译中可能会失传的细微之处。

拿到《Java核心技术 卷I 基础知识 第11版》这两本书时，我正在为我的编程学习之旅寻找一本“定海神针”。市面上太多的技术书籍，良莠不齐，让人眼花缭乱。而这套书，尤其是它的英文原版，在我心目中，已经占据了“圣经”般的地位。我一直坚信，学习一门编程语言，最权威的资料永远是它的官方文档和经典著作。这本书，毫无疑问，就是Java领域的经典之作。它不仅仅是罗列语法和API，更重要的是，它深入剖析了Java语言的设计理念和运行机制。我特别欣赏它在讲解类加载机制、内存管理（堆、栈、方法区）、垃圾回收等底层原理时，那种深入浅出的方式。很多其他书籍可能只是简单提一下，而这本书会花大量篇幅去解释，并且配以图示，让你能够直观地理解这些“幕后英雄”是如何工作的。这对于我这样的开发者来说，是非常宝贵的，因为它能帮助我写出更健壮、更高效的代码，避免一些难以捉摸的bug。在理解异常处理方面，这本书也做得非常出色。它不仅仅告诉你如何使用try-catch-finally，更会深入探讨异常的层次结构，Checked Exception和Unchecked Exception的区别，以及如何设计合理的异常处理策略。这让我明白，异常处理不仅仅是为了捕获错误，更是一种重要的程序设计手段。当然，我必须承认，阅读英文原版对我来说确实需要付出更多的努力，尤其是在一些晦涩的术语上，需要反复查阅。但正是这种挑战，让我对Java的理解更加深刻。这本书的写作风格非常严谨，逻辑性极强，每一步都像是在为你搭建一座知识的金字塔，地基打得牢固，才能建得更高。对于想要深入理解Java，而不仅仅是停留在表面使用的读者来说，这本书绝对是不可错过的。它就像一位经验丰富的老匠人，手把手地教你如何打磨出精美的玉器，而不是简单地给你一个成品。

这本书，嗯，《Java核心技术 卷I 基础知识 第11版》，拿到手的第一感觉就是厚重，沉甸甸的，拿在手里就觉得内容扎实。我当初买它，主要还是因为它的名声在外，再加上身边不少朋友都推荐，说这是学Java绕不开的一本经典。翻开第一页，就被它的排版和字体吸引了，看着就舒服，没有那些花里胡哨的设计，纯粹的知识堆砌，但这种朴实反而让人觉得可靠。目录很详细，几乎涵盖了Java SE的方方面面，从最基础的语法，到对象导向的概念，再到异常处理、集合框架等等，简直就像一本武功秘籍，每个招式都给你拆解得清清楚楚。我之前也看过一些其他的Java入门书，但总觉得要么讲得太浅，要么就跳跃性太强，让人跟不上。这本书的优点就在于它循序渐进，每个概念都讲得非常透彻，而且例子非常丰富，很多时候你会发现，书上给出的例子，就是你在实际开发中会遇到的场景，这种实用性真的很强。我尤其喜欢它对集合框架的讲解，ArrayList, LinkedList, HashMap, HashSet这些，以前我学的时候总觉得有点绕，但这本书把它们之间的区别和适用场景讲得明明白白，甚至还提到了性能上的考量，这对于我这种初学者来说，简直就是及时雨。而且，这本书的英文原版，我一直觉得英文原版更能体现作者的原意，避免了翻译过程中可能出现的理解偏差，虽然刚开始看的时候会有点吃力，需要借助词典，但慢慢习惯了之后，你会发现，很多技术术语直接看英文，反而更能理解其精髓。这本书的语言风格也比较严谨，不是那种轻松幽默的讲解，但正是这种严谨，让你觉得它在传递的是真正有价值的东西。总之，这本书就像一位严厉但公正的老师，你得花时间和精力去消化它，但一旦你掌握了它里面的知识，你就会发现自己在Java的世界里，已经迈出了坚实的一大步。

在我的编程学习道路上，《Java核心技术 卷I 基础知识 第11版》这本书扮演了“引路人”的角色。我之前也看过不少Java的书籍，但总觉得它们要么太零碎，要么就过于侧重于某个狭窄的领域，无法形成一个系统性的知识框架。这套书，尤其的它的英文原版，就像一本“内功心法”，它从最基础的概念开始，一步一步地引导你深入Java的世界。我尤其欣赏它在讲解异常处理机制时，那种条分缕析的态度。它不仅仅教你如何使用try-catch-finally，更重要的是，它让你理解异常的本质，Checked Exception和Unchecked Exception的区别，以及如何设计健壮的异常处理策略。这对于我来说，是之前学习Java时一直觉得模糊不清的一个概念，而这本书的讲解，让我豁然开朗。在讲解集合框架的部分，这本书也做得非常出色。它对各种集合类，如ArrayList, LinkedList, HashMap, HashSet等，都进行了详细的分析，包括它们的内部实现原理、时间复杂度、空间复杂度，以及各自的适用场景。这让我能够根据实际需求，选择最合适的集合类型，从而优化程序的性能。此外，这本书在讲解反射（Reflection）和注解（Annotations）时，也提供了非常深入的讲解。这些是Java中比较高级的特性，但通过这本书的讲解，我能够理解它们的应用场景和实现原理，为我今后深入学习框架和框架源码打下了基础。虽然阅读英文原版需要花费更多的时间和精力，需要随时查阅词典，但它带来的精准性和权威性是无可比拟的。这本书的语言风格严谨、客观，没有任何废话，每一句话都充满了信息量，就像是在进行一场严密的学术研究。

我对《Java核心技术 卷I 基础知识 第11版》这本书的评价，可以概括为“扎实、全面、深入”。我当初选择它，是因为我希望找到一本能够真正打牢Java基础的书籍，而不是那种“速成”的教程。这本书，确实没有让我失望。我特别喜欢它在讲解面向对象编程（OOP）的章节。它不仅仅是停留在概念的罗列，而是通过大量的实际例子，比如披萨店订餐系统、银行账户管理系统等，来阐述类、对象、继承、多态、封装等概念。这些例子贴近生活，易于理解，让我能够真正体会到OOP的强大之处，以及如何将OOP的思想应用到实际的编程中。在讲解泛型（Generics）时，这本书也做得非常出色。它详细解释了泛型的作用，如何声明和使用泛型类、泛型接口、泛型方法，以及通配符的使用。这对于我来说，是之前学习Java时一直感到困惑的一个地方，而这本书的讲解，让我豁然开朗。此外，这本书在讲解反射（Reflection）和注解（Annotations）时，也提供了非常详尽的说明。这些是Java中比较高级的特性，但通过这本书的讲解，我能够理解它们的应用场景和实现原理，为我今后深入学习框架和框架源码打下了基础。虽然阅读英文原版需要花费更多的时间和精力，需要随时查阅词典，但它带来的精准性和权威性是毋庸置疑的。这本书的语言风格严谨、客观，没有任何废话，每一句话都充满了信息量，就像是在进行一场严密的学术研究。

我购买《Java核心技术 卷I 基础知识 第11版》这本书，纯粹是因为它是一本“值得反复品味”的书。市面上很多技术书籍，读完一遍就觉得“懂了”，但实际上，很多细节和精髓都只是匆匆而过。而这本书，每一次翻阅，都会有新的收获。我尤其喜欢它在讲解集合框架部分时，那种细致入微的比较。它不仅仅告诉你ArrayList和LinkedList的区别，更会详细分析它们在插入、删除、随机访问等操作上的时间复杂度，以及它们各自的内存使用情况。这种对比分析，让我对何时选择哪种集合有了非常清晰的认识，避免了在实际开发中因为误用集合而导致的性能问题。而且，这本书在讲解多线程编程时，也做得非常到位。它从最基础的Thread类开始，一步步引导你理解同步、锁、并发集合等概念，并且还会探讨一些常见的并发问题，比如死锁、竞态条件等，并给出解决方案。这对于我这样一个之前对多线程有些畏惧的开发者来说，简直是福音。我曾经因为不理解多线程的并发机制，导致程序出现过一些难以调试的bug，而这本书的讲解，帮助我彻底理清了思路。此外，这本书在讲解IO流时，也做得非常系统。从字节流到字符流，从节点流到处理流，各种流的组合和使用场景都讲解得非常清楚，甚至还提到了NIO（New IO）的概念，为我今后学习更高级的IO技术打下了基础。英文原版阅读起来虽然需要一些耐心，但它提供的准确性和权威性是翻译本无法比拟的。这本书的语言风格不是那种煽情或者“抖机灵”的，而是非常朴实、严谨，如同在进行一场严密的科学论证。它要求读者有耐心，有思考，但回报也是巨大的。它能让你真正理解Java的“内功心法”，而不是只学到“花拳绣腿”。

我选择《Java核心技术 卷I 基础知识 第11版》这套书，很大程度上是因为它的“厚度”和“广度”。我需要一本能够系统性地、深入地介绍Java基础知识的书籍，而这套书恰好满足了我的需求。我之前也接触过一些Java的学习资料，但总感觉它们要么过于零散，要么就侧重于某个特定领域，无法形成一个完整的知识体系。这本书，它就像一本百科全书，从Java的基本语法、数据结构、算法，到面向对象编程的核心概念，再到更高级的反射、注解、泛型等，几乎无所不包。我尤其欣赏它在讲解字符串处理方面的内容。它不仅仅是告诉你String的各种方法，还会深入分析String的不可变性，以及StringBuilder和StringBuffer的性能差异，这让我对字符串的操作有了更深层次的理解，知道在什么时候应该使用哪种方式来处理字符串，从而优化程序的性能。在讲解IO操作时，这本书也做得非常全面。它不仅介绍了传统的IO流，还对NIO（Non-blocking IO）进行了详细的阐述，包括Channel、Buffer、Selector等核心概念，这为我打开了新的视角，让我了解到Java在高性能IO方面的强大能力。而且，这本书在讲解日期和时间API时，也进行了重写和更新，引入了Java 8引入的新的日期和时间API（java.time包），这使得这本书始终保持着与时俱进的特性。虽然是英文原版，阅读起来确实需要花费更多的时间和精力，需要随时查阅词典，但它带来的信息量和准确性是无可比拟的。这本书的写作风格比较学术化，但却充满了严谨的逻辑和丰富的细节，就像一位经验丰富的教授，循循善诱地为你讲解一个复杂的课题。

我之所以选择了《Java核心技术 卷I 基础知识 第11版》这本书，是因为我需要一本能够系统性地、深入地帮助我建立Java编程思维的书籍。市面上有很多Java入门书籍，但很多都过于简单，或者侧重于某个特定的技术点，无法形成一个完整的知识体系。这套书，尤其是它的英文原版，恰好满足了我的需求。它不仅仅是罗列语法和API，更重要的是，它深入剖析了Java语言的设计理念和运行机制。我特别欣赏它在讲解类加载机制、内存管理（堆、栈、方法区）、垃圾回收等底层原理时，那种深入浅出的方式。很多其他书籍可能只是简单提一下，而这本书会花大量篇幅去解释，并且配以图示，让你能够直观地理解这些“幕后英雄”是如何工作的。这对于我这样的开发者来说，是非常宝贵的，因为它能帮助我写出更健壮、更高效的代码，避免一些难以捉摸的bug。在理解异常处理方面，这本书也做得非常出色。它不仅仅告诉你如何使用try-catch-finally，更会深入探讨异常的层次结构，Checked Exception和Unchecked Exception的区别，以及如何设计合理的异常处理策略。这让我明白，异常处理不仅仅是为了捕获错误，更是一种重要的程序设计手段。当然，我必须承认，阅读英文原版对我来说确实需要付出更多的努力，尤其是在一些晦涩的术语上，需要反复查阅。但正是这种挑战，让我对Java的理解更加深刻。这本书的写作风格非常严谨，逻辑性极强，每一步都像是在为你搭建一座知识的金字塔，地基打得牢固，才能建得更高。对于想要深入理解Java，而不仅仅是停留在表面使用的读者来说，这本书绝对是不可错过的。它就像一位经验丰富的老匠人，手把手地教你如何打磨出精美的玉器，而不是简单地给你一个成品。