Java核心技术 卷I 基础知识 第10版 英文版 上下册 pdf epub mobi txt 电子书 下载 2025

简体网页||繁体网页

☆☆☆☆☆

[美] 凯·S.霍斯特曼（Cay，S.，Horstmann） 著

图书标签:

• Java
• Core Java
• Java 10
• Programming
• Computer Science
• 基础知识
• 英文版
• 教材
• 技术
• 计算机

出版社： 人民邮电出版社

ISBN：9787115420114

版次：1

商品编码：11948364

品牌：异步图书

包装：平装

开本：16开

出版时间：2016-06-01

用纸：胶版纸

页数：955

正文语种：英文版

编辑推荐

1.Java经典图书新版，第8版曾获得第13届Jolt生产效率大奖。
2.Java平台的杰出指南，新版做了全面更新。
3.本书专为做实际项目的程序员编写，是一本真实可信、不偏不倚且简单直接的Java教程，书中使用了全面测试过的代码示例来阐述关键的Java语言与库的特性，体现了编程实践。
4.本书两位作者均是业内杰出人物，有丰富的写作和实战经验。

内容简介

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

作者简介

Cay S. Horstmann 是Scala for the Impatient的作者，还与人合著了Core JavaServer Faces。他是圣何塞州立大学计算机科学专业的教授，还是一名Java Champion，并经常在很多开发者大会上演讲。

目录

目录

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 / 安全 4
1．2．6　Architecture-Neutral / 体系结构中立 5
1．2．7　Portable / 可移植 6
1．2．8　Interpreted / 解释型 7
1．2．9　High-Performance / 高性能 7
1．2．10　Multithreaded / 多线程 7
1．2．11　Dynamic / 动态 8
1．3　Java Applets and the Internet / Java Applet与Internet 8
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 / 使用集成开发环境 26
2．4　Running a Graphical Application / 运行图形化应用程序 30
2．5　Building and Running Applets / 构建并运行Applet 33
Chapter 3： Fundamental Programming Structures in Java / Java的基本编程结构 41
3．1　A Simple Java Program / 一个简单的Java程序 42
3．2　Comments / 注释 46
3．3　Data Types / 数据类型 47
3．3．1　Integer Types / 整型 47
3．3．2　Floating-Point Types / 浮点型 48
3．3．3　The char Type / char类型 50
3．3．4　Unicode and the char Type / Unicode与char类型 51
3．3．5　The boolean Type / boolean类型 52
3．4　Variables / 变量 53
3．4．1　Initializing Variables / 初始化变量 54
3．4．2　Constants / 常量 55
3．5　Operators / 运算符 56
3．5．1　Mathematical Functions and Constants / 数学函数与常量 57
3．5．2　Conversions between Numeric Types / 数值类型之间的转换 59
3．5．3　Casts / 强制类型转换 60
3．5．4　Combining Assignment with Operators / 组合赋值运算符 61
3．5．5　Increment and Decrement Operators / 自增运算符与自减运算符 61
3．5．6　Relational and Boolean Operators / 关系与boolean运算符 62
3．5．7　Bitwise Operators / 位运算符 63
3．5．8　Parentheses and Operator Hierarchy / 括号与运算符优先级 64
3．5．9　Enumerated Types / 枚举类型 65
3．6　Strings / 字符串 65
3．6．1　Substrings / 子串 66
3．6．2　Concatenation / 拼接 66
3．6．3　Strings Are Immutable / String是不可变的 67
3．6．4　Testing Strings for Equality / 测试字符串是否相等 68
3．6．5　Empty and Null Strings / 空串与null串 69
3．6．6　Code Points and Code Units / 码位与编码单元 70
3．6．7　The String API / String 类的API 71
3．6．8　Reading the Online API Documentation / 阅读在线API文档 74
3．6．9　Building Strings / 构建字符串 77
3．7　Input and Output / 输入输出 78
3．7．1　Reading Input / 读取输入 79
3．7．2　Formatting Output / 格式化输出 82
3．7．3　File Input and Output / 文件输入输出 87
3．8　Control Flow / 控制流 89
3．8．1　Block Scope / 块作用域 89
3．8．2　Conditional Statements / 条件语句 90
3．8．3　Loops / 循环 94
3．8．4　Determinate Loops / 确定性循环 99
3．8．5　Multiple Selections—The switch Statement / 多重选择：switch语句 103
3．8．6　Statements That Break Control Flow / 用于跳出控制流的语句 106
3．9　Big Numbers / 大数 108
3．10 Arrays / 数组 111
3．10．1　The “for each” Loop / “for each”循环 113
3．10．2　Array Initializers and Anonymous Arrays / 数组初始化与匿名数组 114
3．10．3　Array Copying / 数组复制 114
3．10．4　Command-Line Parameters / 命令行参数 116
3．10．5　Array Sorting / 数组排序 117
3．10．6　Multidimensional Arrays / 多维数组 120
3．10．7　Ragged Arrays / 不规则数组 124
Chapter 4： Objects and Classes /对象与类 129
4．1　Introduction to Object-Oriented Programming / 面向对象编程简介 130
4．1．1　Classes / 类 131
4．1．2　Objects / 对象 132
4．1．3　Identifying Classes / 识别类 133
4．1．4　Relationships between Classes / 类之间的关系 133
4．2　Using Predefined Classes / 使用预定义类 135
4．2．1　Objects and Object Variables / 对象与对象变量 136
4．2．2　The LocalDate Class of the Java Library / Java 库中的LocalDate类 139
4．2．3　Mutator and Accessor Methods / 更改器方法与访问器方法 141
4．3　Defining Your Own Classes / 定义自己的类 145
4．3．1　An Employee Class / Employee类 145
4．3．2　Use of Multiple Source Files / 使用多个源文件 149
4．3．3　Dissecting the Employee Class / 分析Employee类 149
4．3．4　First Steps with Constructors / 从构造器开始 150
4．3．5　Implicit and Explicit Parameters / 隐式参数与显式参数 152
4．3．6　Benefits of Encapsulation / 封装的好处 153
4．3．7　Class-Based Access Privileges / 基于类的访问权限 156
4．3．8　Private Methods / 私有方法 156
4．3．9　Final Instance Fields / final实例字段 157
4．4　Static Fields and Methods / 静态字段与静态方法 158
4．4．1　Static Fields / 静态字段 158
4．4．2　Static Constants / 静态常量 159
4．4．3　Static Methods / 静态方法 160
4．4．4　Factory Methods / 工厂方法 161
4．4．5　The main Method / main方法 161
4．5　Method Parameters / 方法参数 164
4．6　Object Construction / 对象构建 171
4．6．1　Overloading / 重载 172
4．6．2　Default Field Initialization / 默认字段初始化 172
4．6．3　The Constructor with No Arguments / 无参构造器 173
4．6．4　Explicit Field Initialization / 显式字段初始化 174
4．6．5　Parameter Names / 参数名 175
4．6．6　Calling Another Constructor / 调用另一个构造器 176
4．6．7　Initialization Blocks / 初始化块 177
4．6．8　Object Destruction and the finalize Method / 对象析构与finalize方法 181
4．7　Packages / 包 182
4．7．1　Class Importation / 导入类 183
4．7．2　Static Imports / 静态导入 185
4．7．3　Addition of a Class into a Package / 将类添加到某个包中 185
4．7．4　Package Scope / 包作用域 189
4．8　The Class Path / 类路径 190
4．8．1　Setting the Class Path / 设置类路径 193
4．9　Documentation Comments / 文档注释 194
4．9．1　Comment Insertion / 插入注释 194
4．9．2　Class Comments / 类注释 195
4．9．3　Method Comments / 方法注释 195
4．9．4　Field Comments / 字段注释 196
4．9．5　General Comments / 通用注释 196
4．9．6　Package and Overview Comments / 包与概述注释 198
4．9．7　Comment Extraction / 提取注释 198
4．10 Class Design Hints / 类设计建议 200
Chapter 5： Inheritance / 继承 203
5．1　Classes， Superclasses， and Subclasses / 类、超类与子类 204
5．1．1　Defining Subclasses / 定义子类 204
5．1．2　Overriding Methods / 覆盖方法 206
5．1．3　Subclass Constructors / 子类构造器 207
5．1．4　Inheritance Hierarchies / 继承层次 212
5．1．5　Polymorphism / 多态 213
5．1．6　Understanding Method Calls / 理解方法调用 214
5．1．7　Preventing Inheritance： Final Classes and Methods / 阻止继承：final修饰的类和方法 217
5．1．8　Casting / 强制类型转换 219
5．1．9　Abstract Classes / 抽象类 221
5．1．10　Protected Access / 受保护访问 227
5．2　Object： The Cosmic Superclass / Object：所有类的超类 228
5．2．1　The equals Method / equals方法 229
5．2．2　Equality Testing and Inheritance / 相等测试与继承 231
5．2．3　The hashCode Method / hashCode方法 235
5．2．4　The toString Method / toString方法 238
5．3　Generic Array Lists / 泛型数组列表 244
5．3．1　Accessing Array List Elements / 访问泛型数组列表的元素 247
5．3．2　Compatibility between Typed and Raw Array Lists / 泛型数组列表与原始数组列表的兼容性 251
5．4　Object Wrappers and Autoboxing / 对象包装器与自动装箱 252
5．5　Methods with a Variable Number of Parameters / 参数数量可变的方法 256
5．6　Enumeration Classes / 枚举类 258
5．7　Reflection / 反射 260
5．7．1　The Class Class / Class类 261
5．7．2　A Primer on Catching Exceptions / 捕获异常简介 263
5．7．3　Using Reflection to Analyze the Capabilities of Classes / 使用反射分析类的能力 265
5．7．4　Using Reflection to Analyze Objects at Runtime / 在运行时使用反射分析对象 271
5．7．5　Using Reflection to Write Generic Array Code / 使用反射编写泛型数组代码 276
5．7．6　Invoking Arbitrary Methods / 调用任意方法 279
5．8　Design Hints for Inheritance / 继承的设计建议 283
Chapter 6： Interfaces， Lambda Expressions， and Inner Classes / 接口、Lambda表达式和内部类 287
6．1　Interfaces / 接口 288
6．1．1　The Interface Concept / 接口的概念 288
6．1．2　Properties of Interfaces / 接口的特性 295
6．1．3　Interfaces and Abstract Classes / 接口与抽象类 297
6．1．4　Static Methods / 静态方法 298
6．1．5　Default Methods / 默认方法 298
6．1．6　Resolving Default Method Conflicts / 解决默认方法的冲突 300
6．2　Examples of Interfaces / 接口示例 302
6．2．1　Interfaces and Callbacks / 接口与回调 302
6．2．2　The Comparator Interface / Comparator接口 305
6．2．3　Object Cloning / 对象克隆 306
6．3　Lambda Expressions / Lambda表达式 314
6．3．1　Why Lambdas? / 为什么引入Lambda表达式 314
6．3．2　The Syntax of Lambda Expressions / Lambda表达式的语法 315
6．3．3　Functional Interfaces / 函数式接口 318
6．3．4　Method References / 方法引用 319
6．3．5　Constructor References / 构造器引用 321
6．3．6　Variable Scope / 变量作用域 322
6．3．7　Processing Lambda Expressions / 处理Lambda表达式 324
6．3．8　More about Comparators / 再谈Comparator 328
6．4　Inner Classes / 内部类 329
6．4．1　Use of an Inner Class to Access Object State / 使用内部类访问对象状态 331
6．4．2　Special Syntax Rules for Inner Classes /
内部类的特殊语法规则 334
6．4．3　Are Inner Classes Useful? Actually Necessary? Secure? / 内部类是否有用、必要和安全 335
6．4．4　Local Inner Classes / 局部内部类 339
6．4．5　Accessing Variables from Outer Methods / 从外部方法访问变量 339
6．4．6　Anonymous Inner Classes / 匿名内部类 342
6．4．7　Static Inner Classes / 静态内部类 346
6．5　Proxies / 代理 350
6．5．1　When to Use Proxies / 何时使用代理 350
6．5．2　Creating Proxy Objects / 创建代理对象 350
6．5．3　Properties of Proxy Classes / 代理类的特性 355
Chapter 7： Exceptions， Assertions， and Logging /异常、断言与日志 357
7．1　Dealing with Errors / 处理错误 358
7．1．1　The Classification of Exceptions / 异常分类 359
7．1．2　Declaring Checked Exceptions / 声明检查型异常 361
7．1．3　How to Throw an Exception / 如何抛出异常 364
7．1．4　Creating Exception Classes / 创建异常类 365
7．2　Catching Exceptions / 捕获异常 367
7．2．1　Catching an Exception / 捕获一个异常 367
7．2．2　Catching Multiple Exceptions / 捕获多个异常 369
7．2．3　Rethrowing and Chaining Exceptions / 再次抛出异常与异常链 370
7．2．4　The finally Clause / finally子句 372
7．2．5　The Try-with-Resources Statement / try-with-resources语句 376
7．2．6　Analyzing Stack Trace Elements / 分析栈轨迹元素 377
7．3　Tips for Using Exceptions / 异常使用技巧 381
7．4　Using Assertions / 使用断言 384
7．4．1　The Assertion Concept / 断言的概念 384
7．4．2　Assertion Enabling and Disabling / 启用和禁用断言 385
7．4．3　Using Assertions for Parameter Checking / 使用断言检查参数 386
7．4．4　Using Assertions for Documenting Assumptions / 使用断言保证文档中假定成立的条件 387
7．5　Logging / 日志 389
7．5．1　Basic Logging / 基本日志 389
7．5．2　Advanced Logging / 高级日志 390
7．5．3　Changing the Log Manager Configuration / 修改日志管理器配置 392
7．5．4　Localization / 本地化 393
7．5．5　Handlers / 处理器 394
7．5．6　Filters / 过滤器 398
7．5．7　Formatters / 格式化器 399
7．5．8　A Logging Recipe / 常见日志操作总结 399
7．6　Debugging Tips / 调试技巧 409
Chapter 8： Generic Programming /泛型编程 415
8．1　Why Generic Programming? / 为什么要使用泛型编程 416
8．1．1　The Advantage of Type Parameters / 类型参数的好处 416
8．1．2　Who Wants to Be a Generic Programmer? / 哪些人想成为泛型程序员 417
8．2　Defining a Simple Generic Class / 定义简单的泛型类 418
8．3　Generic Methods / 泛型方法 421
8．4　Bounds for Type Variables / 类型变量的绑定 422
8．5　Generic Code and the Virtual Machine / 泛型代码与虚拟机 425
8．5．1　Type Erasure / 类型擦除 425
8．5．2　Translating Generic Expressions / 翻译泛型表达式 426
8．5．3　Translating Generic Methods / 翻译泛型方法 427
8．5．4　Calling Legacy Code / 调用遗留代码 429
8．6　Restrictions and Limitations / 约束与局限性 430
8．6．1　Type Parameters Cannot Be Instantiated with Primitive Types / 类型参数不能用基本类型来实例化 430
8．6．2　Runtime Type Inquiry Only Works with Raw Types / 运行时类型查询只适用于原始类型 431
8．6．3　You Cannot Create Arrays of Parameterized Types / 不能创建参数化类型的数组 431
8．6．4　Varargs Warnings / 注意变长参数情况 432
8．6．5　You Cannot Instantiate Type Variables / 不能实例化类型变量 433
8．6．6　You Cannot Construct a Generic Array / 不能构造泛型数组 434
8．6．7　Type Variables Are Not Valid in Static Contexts of Generic Classes / 类型变量在泛型类的静态上下文中无效 436
8．6．8　You Cannot Throw or Catch Instances of a Generic Class / 不能抛出或捕获泛型类的实例 436
8．6．9　You Can Defeat Checked Exception Checking / 可以打破“检查型异常必须检查”的规则 437
8．6．10　Beware of Clashes after Erasure / 注意类型擦除后的冲突 439
8．7　Inheritance Rules for Generic Types / 泛型类型的继承规则 440
8．8　Wildcard Types / 通配符类型 442
8．8．1　The Wildcard Concept / 通配符的概念 442
8．8．2　Supertype Bounds for Wildcards / 通配符的超类型限定 444
8．8．3　Unbounded Wildcards / 无限定通配符 447
8．8．4　Wildcard Capture / 通配符捕获 448
8．9　Reflection and Generics / 反射与泛型 450
8．9．1　The Generic Class Class / 泛型的Class类 450
8．9．2　Using Class Parameters for Type Matching / 使用Class参数进行类型匹配 452
8．9．3　Generic Type Information in the Virtual Machine / 虚拟机中的泛型类型信息 452
Chapter 9： Collections /集合类 459
9．1　The Java Collections Framework / Java 集合类框架 460
9．1．1　Separating Collection Interfaces and Implementation / 将集合类的接口与实现分离 460
9．1．2　The Collection Interface / Collection接口 463
9．1．3　Iterators / 迭代器 463
9．1．4　Generic Utility Methods / 泛型的实用方法 466
9．1．5　Interfaces in the Collections Framework / 集合类框架中的接口 469
9．2　Concrete Collections / 具体的集合类 472
9．2．1　Linked Lists / 链表 474
9．2．2　Array Lists / 数组列表 484
9．2．3　Hash Sets / 散列集 485
9．2．4　Tree Sets / 树形集 489
9．2．5　Queues and Deques / 队列与双端队列 494
9．2．6　Priority Queues / 优先级队列 495
9．3　Maps / 映射 497
9．3．1　Basic Map Operations / 基本映射操作 497
9．3．2　Updating Map Entries / 更新映射表项 500
9．3．3　Map Views / 映射视图 502
9．3．4　Weak Hash Maps / 弱散列映射 504
9．3．5　Linked Hash Sets and Maps / LinkedHashSet与LinkedHashMap 504
9．3．6　Enumeration Sets and Maps / EnumSet与EnumMap 506
9．3．7　Identity Hash Maps / IdentityHashMap 507
9．4　Views and Wrappers / 视图与包装器 509
9．4．1　Lightweight Collection Wrappers / 轻量级集合包装器 509
9．4．2　Subranges / 子范围 510
9．4．3　Unmodifiable Views / 不可修改视图 511
9．4．4　Synchronized Views / 同步视图 512
9．4．5　Checked Views / 检查用视图 513
9．4．6　A Note on Optional Operations / 可选操作说明 514
9．5　Algorithms / 算法 517
9．5．1　Sorting and Shuffiing / 排序与混排 518
9．5．2　Binary Search / 二分查找 521
9．5．3　Simple Algorithms / 简单算法 522
9．5．4　Bulk Operations / 主要操作 524
9．5．5　Converting between Collections and Arrays / 集合与数组之间的转换 525
9．5．6　Writing Your Own Algorithms / 编写自己的算法 526
9．6　Legacy Collections / 遗留的集合类 528
9．6．1　The Hashtable Class / Hashtable类 528
9．6．2　Enumerations / Enumeration 528
9．6．3　Property Maps / 属性映射 530
9．6．4　Stacks / 栈 531
9．6．5　Bit Sets / 位集 532
Chapter 10： Graphics Programming /图形界面编程 537
10．1　Introducing Swing / Swing简介 538
10．2　Creating a Frame / 创建框架 543
10．3　Positioning a Frame / 设定框架的显示位置 546
10．3．1　Frame Properties / 框架属性 549
10．3．2　Determining a Good Frame Size / 确定合适的框架大小 549
10．4　Displaying Information in a Component / 在组件中显示信息 554
10．5　Working with 2D Shapes / 处理2D图形 560
10．6　Using Color / 使用颜色 569
10．7　Using Special Fonts for Text / 使用特殊的文本字体 573
10．8　Displaying Images / 显示图片 582
Chapter 11： Event Handling /事件处理 587
11．1　Basics of Event Handling / 事件处理基础 587
11．1．1　Example： Handling a Button Click / 示例：处理按钮点击事件 591
11．1．2　Specifying Listeners Concisely / 设置监听器的简洁方法 595
11．1．3　Example： Changing the Look-and-Feel / 示例：修改观感 598
11．1．4　Adapter Classes / 适配器类 603
11．2　Actions / 动作 607
11．3　Mouse Events / 鼠标事件 616
11．4　The AWT Event Hierarchy / AWT事件层次 624
11．4．1　Semantic and Low-Level Events / 语义与底层事件 626
Chapter 12： User Interface Components with Swing / Swing用户界面组件 629
12．1　Swing and the Model-View-Controller Design Pattern / Swing与模型-视图-控制器设计模式 630
12．1．1　Design Patterns / 设计模式 630
12．1．2　The Model-View-Controller Pattern / 模型-视图-控制器模式 632
12．1．3　A Model-View-Controller Analysis of Swing Buttons / Swing按钮的模型-视图-控制器分析 636
12．2　Introduction to Layout Management / 布局管理简介 638
12．2．1　Border Layout / 边框布局 641
12．2．2　Grid Layout / 网格布局 644
12．3　Text Input / 文本输入 648
12．3．1　Text Fields / 文本框 649
12．3．2　Labels and Labeling Components / 标签与标签组件 651
12．3．3　Password Fields / 密码框 652
12．3．4　Text Areas / 文本区域 653
12．3．5　Scroll Panes / 滚动窗格 654
12．4　Choice Components / 选择组件 657
12．4．1　Checkboxes / 复选框 657
12．4．2　Radio Buttons / 单选按钮 660
12．4．3　Borders / 边框 664
12．4．4　Combo Boxes / 组合框 668
12．4．5　Sliders / 滑动条 672
12．5　Menus / 菜单 678
12．5．1　Menu Building / 菜单构建 679
12．5．2　Icons in Menu Items / 菜单项中的图标 682
12．5．3　Checkbox and Radio Button Menu Items / 复选框和单选按钮菜单项 683
12．5．4　Pop-Up Menus / 弹出菜单 684
12．5．5　Keyboard Mnemonics and Accelerators / 键盘助记符与快捷键 686
12．5．6　Enabling and Disabling Menu Items / 启用和禁用菜单项 689
12．5．7　Toolbars / 工具栏 694
12．5．8　Tooltips / 工具提示 696
12．6　Sophisticated Layout Management / 复杂的布局管理 699
12．6．1　The Grid Bag Layout / 网格布局管理 701
12．6．2　Group Layout / 组布局 713
12．6．3　Using No Layout Manager / 不使用布局管理器 723
12．6．4　Custom Layout Managers / 定制布局管理器 724
12．6．5　Traversal Order / 遍历顺序 729
12．7　Dialog Boxes / 对话框 730
12．7．1　Option Dialogs / 选项对话框 731
12．7．2　Creating Dialogs / 创建对话框 741
12．7．3　Data Exchange / 数据交换 746
12．7．4　File Dialogs / 文件对话框 752
12．7．5　Color Choosers / 颜色选择器 764
12．8　Troubleshooting GUI Programs / GUI程序的问题定位 770
12．8．1　Debugging Tips / 调试技巧 770
12．8．2　Letting the AWT Robot Do the Work / 把工作交给AWT Robot 774
Chapter 13： Deploying Java Applications / 部署Java应用程序 779
13．1　JAR Files / JAR文件 780
13．1．1　Creating JARfiles / 创建JAR文件 780
13．1．2　The Manifest / 清单文件 781
13．1．3　Executable JAR Files / 可执行的JAR文件 782
13．1．4　Resources / 资源 783
13．1．5　Sealing / 封闭 787
13．2　Storage of Application Preferences / 应用偏好信息的存储 788
13．2．1　Property Maps / 属性映射 788
13．2．2　The Preferences API / Properties API 794
13．3　Service Loaders / 服务加载器 800
13．4　Applets / Applet 802
13．4．1　A Simple Applet / 一个简单的Applet 803
13．4．2　The applet HTML Tag and Its Attributes / applet HTML标记及其属性 808
13．4．3　Use of Parameters to Pass Information to Applets / 使用参数向Applet传递信息 810
13．4．4　Accessing Image and Audio Files / 访问图片和音频文件 816
13．4．5　The Applet Context / Applet上下文 818
13．4．6　Inter-Applet Communication / Applet间的通信 818
13．4．7　Displaying Items in the Browser / 在浏览器中显示信息 819
13．4．8　The Sandbox / 沙箱 820
13．4．9　Signed Code / 签名代码 822
13．5　Java Web Start / Java Web Start 824
13．5．1　Delivering a Java Web Start Application / 交付一个Java Web Start应用 824
13．5．2　The JNLP API / JNLP API 829
Chapter 14： Concurrency /并发 839
14．1　What Are Threads? / 什么是线程 840
14．1．1　Using Threads to Give Other Tasks a Chance / 使用线程为其他任务提供执行机会 846
14．2　Interrupting Threads / 中断线程 851
14．3　Thread States / 线程状态 855
14．3．1　New Threads / 新创建线程 855
14．3．2　Runnable Threads / 可运行线程 855
14．3．3　Blocked and Waiting Threads / 被阻塞线程与等待线程 856
14．3．4　Terminated Threads / 被终止的线程 857
14．4　Thread Properties / 线程属性 858
14．4．1　Thread Priorities / 线程优先级 858
14．4．2　Daemon Threads / 守护线程 859
14．4．3　Handlers for Uncaught Exceptions / 未捕获异常的处理器 860
14．5　Synchronization / 同步 862
14．5．1　An Example of a Race Condition / 竞争条件的一个案例 862
14．5．2　The Race Condition Explained / 竞争条件详解 866
14．5．3　Lock Objects / 锁对象 868
14．5．4　Condition Objects / 条件对象 872
14．5．5　The synchronized Keyword / synchronized关键字 878
14．5．6　Synchronized Blocks / 同步块 882
14．5．7　The Monitor Concept / 监视器概念 884
14．5．8　Volatile Fields / volatile字段 885
14．5．9　Final Variables / final变量 886
14．5．10　Atomics / 原子 886
14．5．11　Deadlocks / 死锁 889
14．5．12　Thread-Local Variables / 线程局部变量 892
14．5．13　Lock Testing and Timeouts / 锁测试与超时 893
14．5．14　Read / Write Locks / 读/写锁 895
14．5．15　Why the stop and suspend Methods Are Deprecated / 为什么弃用stop和suspend方法 896
14．6　Blocking Queues / 阻塞队列 898
14．7　Thread-Safe Collections / 线程安全的集合 905
14．7．1　Efficient Maps， Sets， and Queues / 高效的映射、集和队列 905
14．7．2　Atomic Update of Map Entries / 映射表项的原子更新 907
14．7．3　Bulk Operations on Concurrent Hash Maps / 并发散列映射上的主要操作 909
14．7．4　Concurrent Set Views / 并发的集视图 912
14．7．5　Copy on Write Arrays / 写时复制的数组 912
14．7．6　Parallel Array Algorithms / 并行数组算法 912
14．7．7　Older Thread-Safe Collections / 较早的线程安全的集合 914
14．8　Callables and Futures / Callable与Future 915
14．9　Executors / 执行器 920
14．9．1　Thread Pools / 线程池 921
14．9．2　Scheduled Execution / 预订执行 926
14．9．3　Controlling Groups of Tasks / 控制任务组 927
14．9．4　The Fork-Join Framework / Fork-Join框架 928
14．9．5　Completable Futures / CompletableFuture 931
14．10　Synchronizers / 同步器 934
14．10．1　Semaphores / 信号量 935
14．10．2　Countdown Latches / 倒计时门栓 936
14．10．3　Barriers / 障栅 936
14．10．4　Exchangers / 交换器 937
14．10．5　Synchronous Queues / 同步队列 937
14．11　Threads and Swing / 线程与Swing 937
14．11．1　Running Time-Consuming Tasks / 运行耗时任务 939
14．11．2　Using the Swing Worker / 使用Swing工作线程 943
14．11．3　The Single-Thread Rule / 单线程规则 951
Appendix / 附录 953

前言/序言

深入理解 Java 编程的基石——《Java 核心技术 卷 I：基础知识（第 10 版）》 本书是享誉全球的 Java 权威指南的最新版，专注于深入浅出地讲解 Java 语言的核心概念与基础知识。对于任何希望掌握 Java 编程、构建健壮应用程序的开发者而言，这都是一本不可或缺的参考书。第 10 版在继承前代版本严谨、全面的优点的基础上，紧跟 Java 语言的发展步伐，引入了最新的特性和最佳实践，确保读者能够学习到最实用、最前沿的 Java 知识。 本书分为上下两册，精心编排，循序渐进，旨在帮助读者打下坚实的 Java 编程基础。第一卷（即本书）聚焦于 Java 语言本身的基础机制、核心类库以及面向对象编程的思想，为后续更深入的学习和更复杂的应用开发奠定坚实的基础。 内容精要与知识体系： 本书的内容涵盖了 Java 编程的方方面面，从最基本的语法结构到面向对象设计的精髓，再到 Java 平台的强大能力，都进行了详尽的阐述。其核心内容可以概括为以下几个主要方面： 第一部分：Java 语言基础与语法 Java 平台概览： 在正式进入编程之前，本书首先会介绍 Java 平台的整体架构，包括 Java 虚拟机（JVM）、Java 应用程序接口（API）以及 Java 开发工具包（JDK）。理解这些底层概念对于编写高效、可移植的 Java 程序至关重要。它解释了 Java 如何实现“一次编写，到处运行”的跨平台特性，并简要介绍了 JVM 的工作原理，为后续深入理解 Java 内存模型和垃圾回收机制打下基础。 Java 程序结构与基础语法： 本部分详细讲解了 Java 程序的基本构成元素，包括类、方法、变量、表达式和语句。读者将学习如何定义类，如何创建对象，以及如何使用基本数据类型（如整型、浮点型、布尔型和字符型）和引用数据类型。本书还会深入讲解 Java 的运算符，包括算术运算符、关系运算符、逻辑运算符、赋值运算符以及位运算符，并阐述它们的优先级和结合性。 控制流程： 掌握程序流程的控制是编写逻辑清晰、功能强大的程序的前提。本书将详细介绍 Java 中的条件语句（`if-else`、`switch`）和循环语句（`for`、`while`、`do-while`），帮助读者理解如何根据不同的条件执行特定的代码块，以及如何重复执行一段代码。此外，还会涉及跳转语句，如 `break` 和 `continue`，以及 `return` 语句在方法中的应用。 字符串： 字符串是 Java 编程中最常用的数据类型之一。本书将深入探讨 `String` 类的特性，包括字符串的创建、拼接、查找、替换、分割等操作。读者将了解 `String` 对象的不可变性，以及 `StringBuilder` 和 `StringBuffer` 在处理大量字符串操作时的优势。 数组： 数组是用于存储同类型元素的集合。本书将讲解如何声明、初始化和访问一维数组和多维数组，以及如何利用 Java 提供的工具类（如 `Arrays` 类）进行数组的排序、查找等操作。 第二部分：面向对象编程（OOP）核心概念 类与对象： 面向对象编程是 Java 的核心思想。本书将从最基础的类和对象的概念讲起，解释类的定义、属性（成员变量）和行为（成员方法）。读者将学习如何实例化对象，如何通过对象访问其属性和调用其方法，以及如何理解封装、继承和多态这三大面向对象编程的基石。 继承： 继承是实现代码复用和构建类层次结构的关键。本书将详细讲解 `extends` 关键字的使用，父类与子类的关系，以及方法的重写（Override）和属性的继承。它还会探讨 `super` 关键字的应用，以及如何通过继承构建灵活、可扩展的系统。 多态： 多态是面向对象编程的强大之处，它允许不同类的对象对同一个消息做出不同的响应。本书将深入讲解多态的概念，包括方法重载（Overload）和方法重写（Override），以及运行时多态（Dynamic Dispatch）的实现机制。理解多态对于编写更加灵活和可维护的代码至关重要。 抽象类与接口： 抽象类和接口是实现抽象化和定义规范的重要工具。本书将阐述抽象类的用途，如何定义抽象方法和抽象类，以及接口的定义、实现和多实现。它会详细对比抽象类和接口的异同，帮助读者根据实际需求选择合适的机制。 封装： 封装是将数据和操作数据的方法捆绑在一起，隐藏内部细节，只对外提供公共接口的机制。本书将详细讲解访问修饰符（`public`、`private`、`protected`、默认）的作用，以及如何通过 getter 和 setter 方法来控制对类属性的访问，实现数据的安全性和可管理性。 第三部分：Java 核心类库与实用工具 对象与 getClass()： 本部分将深入讲解 `Object` 类作为所有 Java 类的根类。读者将学习 `Object` 类提供的通用方法，如 `equals()`、`hashCode()`、`toString()` 等，并理解它们在对象比较、集合存储等方面的作用。`getClass()` 方法的使用和反射机制的初步介绍也会包含在内。 参数可变的列表——ArrayList： `ArrayList` 是 Java 中最常用的动态数组实现。本书将详细讲解 `ArrayList` 的创建、添加、删除、查找等操作，以及其内部的工作原理，包括容量的自动扩充。 字符串与文本处理： 除了基本的字符串操作，本书还会涉及 `Scanner` 类用于从各种输入源（如控制台、文件）读取数据，以及 `StringTokenizer` 和 `regex`（正则表达式）等更高级的文本处理工具。 日期与时间： Java 提供了丰富的日期和时间处理类。本书将介绍 `LocalDate`、`LocalTime`、`LocalDateTime`、`Instant`、`Duration`、`Period` 等 `java.time` 包中的新一代日期时间 API，以及如何进行日期时间的格式化、解析、计算和比较。 数值处理： 本书将介绍 `BigInteger` 和 `BigDecimal` 类，用于处理超过基本数据类型范围的整数和浮点数，这在金融计算等领域尤为重要。此外，还会涉及 `Math` 类的常用数学函数。 异常处理： 健壮的程序离不开有效的异常处理。本书将详细讲解 `try-catch-finally` 语句块，不同类型的异常（检查型异常和运行时异常），以及如何定义和抛出自定义异常。掌握异常处理能够帮助开发者编写出更稳定、更易于调试的程序。 文件输入/输出（I/O）： 文件操作是应用程序与外部世界交互的重要方式。本书将讲解 Java I/O 流的体系结构，包括字节流和字符流，以及如何使用 `FileInputStream`、`FileOutputStream`、`BufferedReader`、`BufferedWriter` 等类进行文件的读写操作。 本书的特色与价值： 权威性与全面性： 作为“Java 核心技术”系列图书的最新版本，本书汇集了作者在 Java 领域深厚的知识积累和多年的教学经验，内容严谨，覆盖全面，是学习 Java 基础知识最权威的参考资料之一。 循序渐进的教学法： 本书的结构设计非常合理，从最基础的概念入手，逐步深入，让读者能够轻松理解并掌握复杂的编程主题。每章都包含大量示例代码，帮助读者将理论知识转化为实践。 实践导向： 大量的代码示例贯穿全书，这些示例不仅仅是功能的展示，更是解决实际问题的范例。读者可以通过运行、修改和扩展这些示例，加深对知识点的理解，并培养实际编程能力。 对新特性的关注： 第 10 版紧密跟踪 Java 语言的最新发展，引入了 Java 17 以及更早版本中的重要新特性，例如 `var` 关键字、record 类型、sealed classes 的初步介绍等，确保读者学习到的知识是最新、最实用的。 优秀的语言与排版： 英文原版以其清晰、准确的语言而著称，即使是初学者也能轻松理解。配合精心设计的排版，使得阅读体验更加舒适，有助于集中注意力。 适用读者： 本书适合所有希望系统学习 Java 编程的读者，包括： 编程初学者： 对编程有兴趣，希望从 Java 入门，打下坚实基础的初学者。 有其他语言基础的开发者： 希望转入 Java 开发，或希望巩固和深化 Java 基础知识的开发者。 在校学生： 计算机科学、软件工程等相关专业的学生，用于课堂学习和课程辅助。 软件工程师： 希望提升 Java 编程技能，深入理解 Java 核心机制的在职工程师。 总之，《Java 核心技术 卷 I：基础知识（第 10 版）》不仅是一本教材，更是一本指南，它将带领您走进 Java 的世界，为您开启一段精彩的编程之旅。通过对本书内容的深入学习和反复实践，您将能够自信地运用 Java 语言解决各种编程挑战，为未来更高级的 Java 开发打下坚实的基础。

评分☆☆☆☆☆

说实话，接触这本《Java核心技术》第十版之前，我对Java的理解停留在“会写”的层面，很多东西都是照猫画虎，知其然不知其所以然。拿到这本书，就像是给我打开了一扇通往Java世界深层的大门。我记得在学习集合框架的时候，对于`List`、`Set`、`Map`这些接口和它们的具体实现类，比如`ArrayList`、`LinkedList`、`HashSet`、`HashMap`，到底有什么区别，以及它们的性能特点，之前都是模模糊糊的。这本书就用非常直观的图示和详细的性能分析，把我彻底搞明白了。它不仅解释了插入、删除、查找的复杂度，还解释了它们在内部实现上的差异，比如`ArrayList`的动态数组扩容，`LinkedList`的双向链表结构，`HashMap`的哈希表和链表/红黑树结合的实现。我之前在项目中选择集合类型的时候，常常是凭感觉，看了这本书之后，我能根据实际需求，选择最合适的集合，这在很多时候能显著提升程序的性能。另外，它对异常处理的讲解也非常深入，不仅讲了如何抛出和捕获异常，还讲了checked exception和unchecked exception的区别，以及如何设计合理的异常处理机制，这对于编写健壮的Java程序至关重要。这本书的内容是如此丰富，我感觉每读一遍都会有新的收获，它是那种值得反复研读的经典之作。

评分☆☆☆☆☆

我得说，这套《Java核心技术》第十版，绝对是我近几年来遇到的最扎实、最全面的Java入门到进阶读物了。拿到上下册，沉甸甸的，但翻开来，那种精炼的语言和清晰的逻辑立刻吸引了我。初学者可能会觉得一些概念有点晦涩，比如堆和栈的区别，对象的生命周期，甚至是异常处理的各种细节，但作者的处理方式非常有条理，他会先给出核心概念，然后通过精心设计的代码示例来演示，让你在实践中去体会。我特别喜欢它讲解反射和注解的部分，一开始我对这些东西感到非常神奇，觉得它们怎么能实现动态调用和元数据处理，看了书里细致的讲解，配合着`Class`类、`Method`类等API的演示，我才豁然开朗，原来这一切都有迹可循。还有一个让我印象深刻的章节是关于IO流的部分，它把字节流和字符流、缓冲流、对象流等等都讲得非常透彻，并且解释了它们各自的应用场景和优缺点，我之前在处理文件读写的时候经常会遇到各种乱码或者性能问题，看了这部分之后，我能更准确地选择合适的流类，并且优化代码，效率提升不少。这本书的内容覆盖面非常广，从最基本的类、对象、继承、多态，到更高级的并发编程、泛型、网络编程，甚至是一些底层原理，都涉及到了。它不是那种只教你写代码的“速成手册”，而是让你真正理解Java这门语言的精髓。

评分☆☆☆☆☆

我必须承认，《Java核心技术 卷I 基础知识 第10版》这套书，真的是把我从一个Java的“小白”推向了一个“进阶者”。在我学习的初期，我曾被各种繁杂的概念搞得晕头转向，比如JVM的内存区域划分，堆、栈、方法区等等，抽象而又难以捉摸。这本书的独特之处在于，它并没有一味地灌输知识点，而是用一种循序渐进的方式，结合大量的代码示例，把这些概念讲得既清晰又易懂。我记得我曾花了整整一个周末，去研究书里关于垃圾回收机制的那部分，从新生代、老年代，到各种回收算法，比如Serial、Parallel、CMS、G1，虽然听起来很复杂，但作者通过类比和图示，让我逐渐理解了它们的工作原理和适用场景。这对于我之后优化Java程序的内存占用，避免内存泄漏，起到了至关重要的作用。而且，这本书的语言风格也很亲切，不像很多技术书籍那样冰冷枯燥，它会时不时地穿插一些作者的经验之谈，让你感觉像是在和一个资深的开发者交流。我特别喜欢它在讲解多线程编程时，对`synchronized`关键字、`Lock`接口、`Volatile`关键字的详细阐述，以及对线程池的讲解，这让我能够写出更安全、更高效的多线程代码，避免了之前经常遇到的数据竞争和死锁问题。总而言之，这本书的内容深度和广度都非常惊人，它为我构建了一个扎实的Java知识体系。

评分☆☆☆☆☆

这本书，我断断续续啃了好几个月了，简直是开发路上的“圣经”。拿到手的时候，就被它厚重的分量镇住了，感觉就像抱着一本宝典，里面藏着无数通往Java武林秘籍的钥匙。刚开始学的时候，确实有点力不从心，那些抽象的概念，像什么JVM、内存模型，还有各种设计模式，第一次接触，脑袋里跟浆糊一样。但是，这套书的好处就在于，它不会急于求成，而是循序渐进，从最基础的语法、数据类型讲起，一点点地渗透，让你感觉自己是真正在打牢地基。我记得有一次，为了弄懂多线程的同步问题，我反复看了好几遍，书里举的例子，还有各种流程图，配合着代码，才慢慢理清了里面的门道。更重要的是，它不仅仅是告诉你“是什么”，还会告诉你“为什么”，这种刨根问底的精神，让我在面对实际开发中的各种疑难杂症时，多了一份底气。有时候，即便我没遇到书里直接提及的问题，但通过理解了书里的原理，也能自己举一反三，找到解决问题的思路。而且，这本书的代码示例都非常经典，我常常把它们当作模板，在自己的项目中进行修改和扩展，这极大地提高了我的学习效率和开发速度。虽然书很厚，但内容充实，每一页都凝聚着作者的经验和智慧，真的是物超所值。

评分☆☆☆☆☆

这本书，尤其是它第十版的上下册，已经成为了我开发生涯中的一个重要里程碑。我经常把里面的知识点翻出来对照，就好像有一位经验丰富的导师在我身边随时指导。在我学习泛型的时候，我之前只是知道怎么用，但对于`<? extends T>`和`<? super T>`这种通配符的理解一直都很模糊，不知道什么时候该用哪个，有什么区别。直到我读了这本书，它用非常形象的比喻和详细的代码示例，把泛型的“生产-消费”原则以及协变、逆变的概念讲得明明白白。这让我能够写出更安全、更灵活的泛型代码，并且理解了为什么很多Java库的设计要使用泛型。此外，它对Java反射机制的讲解也是我非常欣赏的一部分，我之前觉得反射是一门“黑魔法”，可以动态地创建对象、调用方法，但不知道背后的原理。这本书让我了解了`Class`对象、`Method`对象、`Field`对象等等，以及如何使用它们来在运行时操作类和对象。这对于我实现一些框架性的功能，比如ORM框架或者单元测试框架，提供了非常重要的基础。而且，它还深入探讨了Java的内存模型，解释了happens-before关系，这对于理解并发编程中的原子性、可见性、有序性至关重要。可以说，这本书不仅教我“如何做”，更让我理解了“为什么这么做”，这种深刻的理解，让我在面对复杂的技术问题时，能够更加游刃有余。

评分☆☆☆☆☆

努力读书，努力学习，京东送货速度非常快，支持啦！

评分☆☆☆☆☆

没想到这次买书使用了纸箱包装，印刷很清晰。

评分☆☆☆☆☆

好好好好好好好好好好好好好好好好好好好好好好好好

评分☆☆☆☆☆

总体上还是可以的，就是书本末页有点脏东西，但不影响阅读。

评分☆☆☆☆☆

到货很快，纸张印刷也很好！

评分☆☆☆☆☆

为了让男朋友学好编程，在英语上多下功夫也是拼了，我也啃啃吧

评分☆☆☆☆☆

是新书，塑料薄膜都有！但是包装太差劲，导致书角有不同程度损伤；这和去二手市场购买有何差别？当然，你这更贵。

评分☆☆☆☆☆

这是一个非常不错的产品

评分☆☆☆☆☆

很好的书，价格合适，京东买书划得来！