疯狂Java讲义（第3版）(含CD光盘1张)

• == 图书版权 ==
• 疯狂Java讲义（第3版）(含CD光盘1张)（Java经典畅销书基于Java 8全面升级，北京大学刘洋老师力荐）
• 李刚 编著
• ISBN 978-7-121-23669-3
• 2014年7月出版
• 定价：109.00元
• 868页
• 16开

• == 编辑推荐 ==
• 国内知名IT图书作家、国家级奖项获得者李刚先生针对Java 8推出的全新升级版
• 《疯狂Java讲义》被多所985，211院校选做教材或中文推荐参考书
• 最受程序员欢迎、影响力最大的国人原创Java必读经典
• == 内容提要 ==
• 《疯狂Java讲义（第3版）(含CD光盘1张)》是《疯狂Java讲义》的第3版，第3版保持了前两版系统、全面、讲解浅显、细致的特性，全面新增介绍了Java 8的新特性，《疯狂Java讲义（第3版）(含CD光盘1张)》大部分示例程序都采用Lambda表达式、流式API进行了改写，因此务必使用Java 8的JDK来编译、运行。
• 《疯狂Java讲义（第3版）(含CD光盘1张)》深入介绍了Java编程的相关方面，全书内容覆盖了Java的基本语法结构、Java的面向对象特征、Java集合框架体系、Java泛型、异常处理、Java GUI编程、JDBC数据库编程、Java注释、Java的IO流体系、Java多线程编程、Java网络通信编程和Java反射机制。覆盖了java.lang、java.util、java.text、java.io和java.nio、java.sql、java.awt、javax.swing包下绝大部分类和接口。本书全面介绍了Java 8的新的接口语法、Lambda表达式、方法引用、构造器引用、函数式编程、流式编程、新的日期、时间API、并行支持、改进的类型推断、重复注解、JDBC 4.2新特性等新特性。
• 与前两版类似，《疯狂Java讲义（第3版）(含CD光盘1张)》并不单纯从知识角度来讲解Java，而是从解决问题的角度来介绍Java语言，所以《疯狂Java讲义（第3版）(含CD光盘1张)》中涉及大量实用案例开发：五子棋游戏、梭哈游戏、仿QQ的游戏大厅、MySQL企业管理器、仿EditPlus的文本编辑器、多线程、断点下载工具、Spring框架的IoC容器……这些案例既能让读者巩固每章的知识，又可以让读者学以致用，激发编程自豪感，进而引爆内心的编程激情。《疯狂Java讲义（第3版）(含CD光盘1张)》光盘里包含书中所有示例的代码和《疯狂Java实战演义》的所有项目代码，这些项目可以作为《疯狂Java讲义（第3版）(含CD光盘1张)》课后练习的“非标准答案”，如果读者需要获取关于课后习题的解决方法、编程思路，可以登录http://www.crazyit.org站点与笔者及《疯狂Java讲义（第3版）(含CD光盘1张)》庞大的读者群相互交流。
• 《疯狂Java讲义（第3版）(含CD光盘1张)》为所有打算深入掌握Java编程的读者而编写，适合各种层次的Java学习者和工作者阅读，也适合作为大学教育、培训机构的Java教材。但如果只是想简单涉猎Java，则本书过于庞大，不适合阅读。
• == 目录 ==
• 第1章 Java语言概述与开发环境 1
• 1.1 Java语言的发展简史 2
• 1.2 Java的竞争对手及各自优势 4
• 1.2.1 C#简介和优势 4
• 1.2.2 Ruby简介和优势 5
• 1.2.3 Python简介和优势 5
• 1.3 Java程序运行机制 6
• 1.3.1 高级语言的运行机制 6
• 1.3.2 Java程序的运行机制和JVM 6
• 1.4 开发Java的准备 8
• 1.4.1 下载和安装Java 8的JDK 8
• 不是说JVM是运行Java程序的虚拟机吗？那JRE和JVM的关系是怎样的呢？ 8
• 为什么不安装公共JRE呢？ 9
• 1.4.2 设置PATH环境变量 10
• 为什么选择用户变量？用户变量与系统变量有什么区别？ 11
• 1.5 第一个Java程序 12
• 1.5.1 编辑Java源代码 12
• 1.5.2 编译Java程序 12
• 当编译C程序时，不仅需要指定存放目标文件的位置，也需要指定目标文件的文件名，这里使用javac编译Java程序时怎么不需要指定目标文件的文件名呢？ 13
• 1.5.3 运行Java程序 13
• 1.5.4 根据CLASSPATH环境变量定位类 14
• 1.6 Java程序的基本规则 15
• 1.6.1 Java程序的组织形式 15
• 1.6.2 Java源文件的命名规则 16
• 1.6.3 初学者容易犯的错误 17
• 1.7 垃圾回收机制 19
• 1.8 何时开始使用IDE工具 20
• 我想学习Java编程，到底是学习Eclipse好，还是学习NetBeans好呢？ 21
• 1.9 本章小结 21
• 第2章　理解面向对象 22
• 2.1 面向对象 23
• 2.1.1 结构化程序设计简介 23
• 2.1.2 程序的三种基本结构 24
• 2.1.3 面向对象程序设计简介 26
• 2.1.4 面向对象的基本特征 27
• 2.2 UML（统一建模语言）介绍 28
• 2.2.1 用例图 30
• 2.2.2 类图 30
• 2.2.3 组件图 32
• 2.2.4 部署图 33
• 2.2.5 顺序图 33
• 2.2.6 活动图 34
• 2.2.7 状态机图 35
• 2.3 Java的面向对象特征 36
• 2.3.1 一切都是对象 36
• 2.3.2 类和对象 36
• 2.4 本章小结 37
• 第3章　数据类型和运算符 38
• 3.1 注释 39
• 3.1.1 单行注释和多行注释 39
• 3.1.2 文档注释 40
• API文档是什么? 40
• 为什么要学习查看API文档的方法？
• 3.2 标识符和关键字 46
• 3.2.1 分隔符 46
• 3.2.2 标识符规则 47
• 3.2.3 Java关键字 47
• 3.3 数据类型分类 48
• 什么是变量？变量有什么用？ 48
• 3.4 基本数据类型 49
• 3.4.1 整型 49
• 3.4.2 字符型 51
• 什么是字符集？ 51
• 3.4.3 浮点型 53
• 3.4.4 数值中使用下画线分隔 54
• 3.4.5 布尔型 54
• 3.5 基本类型的类型转换 55
• 3.5.1 自动类型转换 55
• 3.5.2 强制类型转换 56
• 3.5.3 表达式类型的自动提升 58
• 3.6 直接量 59
• 3.6.1 直接量的类型 59
• 3.6.2 直接量的赋值 59
• 3.7 运算符 60
• 3.7.1 算术运算符 60
• 3.7.2 赋值运算符 63
• 3.7.3 位运算符 63
• 3.7.4 扩展后的赋值运算符 66
• 3.7.5 比较运算符 66
• 3.7.6 逻辑运算符 67
• 3.7.7 三目运算符 68
• 3.7.8 运算符的结合性和优先级 69
• 3.8 本章小结 70
• 第4 章　流程控制与数组 71
• 4.1 顺序结构 72
• 4.2 分支结构 72
• 4.2.1 if条件语句 72
• 4.2.2 Java 7增强后的switch分支语句 76
• 4.3 循环结构 78
• 4.3.1 while循环语句 78
• 4.3.2 do while循环语句 79
• 4.3.3 for循环 80
• 4.3.4 嵌套循环 83
• 4.4 控制循环结构 84
• 4.4.1 使用break结束循环 84
• 4.4.2 使用continue忽略本次循环剩下语句 85
• 4.4.3 使用return结束方法 86
• 4.5 数组类型 86
• 4.5.1 理解数组：数组也是一种类型 86
• int[]是一种类型吗？怎么使用这种类型呢？ 87
• 4.5.2 定义数组 87
• 4.5.3 数组的初始化 88
• 能不能只分配内存空间，不赋初始值呢？ 88
• 4.5.4 使用数组 89
• 为什么要我记住这些异常信息？ 89
• 4.5.5 foreach循环 90
• 4.6 深入数组 91
• 4.6.1 内存中的数组 91
• 为什么有栈内存和堆内存之分？ 92
• 4.6.2 基本类型数组的初始化 94
• 4.6.3 引用类型数组的初始化 95
• 4.6.4 没有多维数组 97
• 我是否可以让图4.13中灰色覆盖的数组元素再次指向另一个数组？这样不就可以扩展成三维数组，甚至扩展成更多维的数组吗？ 98
• 4.6.5 Java 8增强的工具类：Arrays 99
• 4.6.6 数组的应用举例 102
• 4.7 本章小结 105
• 本章练习 105
• 第5 章　面向对象（上） 106
• 5.1 类和对象 107
• 5.1.1 定义类 107
• 构造器不是没有返回值吗？为什么不能用void声明呢？ 109
• 5.1.2 对象的产生和使用 110
• 5.1.3 对象、引用和指针 110
• 5.1.4 对象的this引用 111
• 5.2 方法详解 115
• 5.2.1 方法的所属性 115
• 5.2.2 方法的参数传递机制 116
• 5.2.3 形参个数可变的方法 119
• 5.2.4 递归方法 120
• 5.2.5 方法重载 122
• 为什么方法的返回值类型不能用于区分重载的方法？ 122
• 5.3 成员变量和局部变量 123
• 5.3.1 成员变量和局部变量 123
• 5.3.2 成员变量的初始化和内存中的运行机制 126
• 5.3.3 局部变量的初始化和内存中的
• 运行机制 128
• 5.3.4 变量的使用规则 129
• 5.4 隐藏和封装 130
• 5.4.1 理解封装 130
• 5.4.2 使用访问控制符 130
• 5.4.3 package、import和import static 133
• 5.4.4 Java的常用包 138
• 5.5 深入构造器 138
• 5.5.1 使用构造器执行初始化 138
• 构造器是创建Java对象的途径，是不是说构造器完全负责创建Java对象？ 139
• 5.5.2 构造器重载 139
• 为什么要用this来调用另一个重载的构造器？我把另一个构造器里的代码复制、粘贴到这个构造器里不就可以了吗？ 141
• 5.6 类的继承 141
• 5.6.1 继承的特点 141
• 5.6.2 重写父类的方法 142
• 5.6.3 super限定 144
• 5.6.4 调用父类构造器 146
• 为什么我创建Java对象时从未感觉到java.lang. Object类的构造器被调用过？ 148
• 5.7 多态 148
• 5.7.1 多态性 148
• 5.7.2 引用变量的强制类型转换 150
• 5.7.3 instanceof运算符 151
• 5.8 继承与组合 152
• 5.8.1 使用继承的注意点 152
• 5.8.2 利用组合实现复用 153
• 使用组合关系来实现复用时，需要创建两个Animal对象，是不是意味着使用组合关系时系统开销更大？ 156
• 5.9 初始化块 156
• 5.9.1 使用初始化块 156
• 5.9.2 初始化块和构造器 158
• 5.9.3 静态初始化块 159
• 5.10 本章小结 161
• 第6 章　面向对象（下） 162
• 6.1 Java 8增强的包装类 163
• Java为什么要对这些数据进行缓存呢? 166
• 6.2 处理对象 167
• 6.2.1 打印对象和toString方法 167
• 6.2.2 ==和equals方法 169
• 上面程序中判断obj是否为Person类的实例时，为何不用obj instanceof Person来判断呢？ 172
• 6.3 类成员 172
• 6.3.1 理解类成员 172
• 6.3.2 单例（Singleton）类 173
• 6.4 final修饰符 174
• 6.4.1 final成员变量 175
• 6.4.2 final局部变量 176
• 6.4.3 final修饰基本类型变量和引用类型变量的区别 177
• 6.4.4 可执行“宏替换”的final变量 178
• 6.4.5 final方法 180
• 6.4.6 final类 180
• 6.4.7 不可变类 181
• 6.4.8 缓存实例的不可变类 183
• 6.5 抽象类 186
• 6.5.1 抽象方法和抽象类 186
• 6.5.2 抽象类的作用 189
• 6.6 Java 8改进的接口 190
• 6.6.1 接口的概念 190
• 6.6.2 Java 8中接口的定义 190
• 6.6.3 接口的继承 193
• 6.6.4 使用接口 193
• 6.6.5 接口和抽象类 195
• 6.6.6 面向接口编程 195
• 6.7 内部类 199
• 6.7.1 非静态内部类 199
• 非静态内部类对象和外部类对象的关系是怎样的？ 203
• 6.7.2 静态内部类 203
• 为什么静态内部类的实例方法也不能访问外部类的实例属性呢？ 204
• 接口里是否能定义内部接口？ 205
• 6.7.3 使用内部类 205
• 既然内部类是外部类的成员，那么是否可以为外部类定义子类，在子类中再定义一个内部类来重写其父类中的内部类呢？ 208
• 6.7.4 局部内部类 208
• 6.7.5 Java 8改进的匿名内部类 209
• 6.8 Java 8新增的Lambda表达式 212
• 6.8.1 Lambda表达式入门 212
• 6.8.2 Lambda表达式与函数式接口 214
• 6.8.3 方法引用与构造器引用 216
• 6.8.4 Lambda表达式与匿名内部类的联系和区别 218
• 6.8.5 使用Lambda表达式调用Arrays的类方法 219
• 6.9 枚举类 220
• 6.9.1 手动实现枚举类 220
• 6.9.2 枚举类入门 221
• 6.9.3 枚举类的成员变量、方法和构造器 222
• 6.9.4 实现接口的枚举类 224
• 枚举类不是用final修饰了吗？怎么还能派生子类呢？ 225
• 6.9.5 包含抽象方法的枚举类 225
• 6.10 对象与垃圾回收 226
• 6.10.1 对象在内存中的状态 227
• 6.10.2 强制垃圾回收 227
• 6.10.3 finalize方法 229
• 6.10.4 对象的软、弱和虚引用 230
• 6.11 修饰符的适用范围 233
• 6.12 使用JAR文件 234
• 6.12.1 jar命令详解 235
• 6.12.2 创建可执行的JAR包 236
• 6.12.3 关于JAR包的技巧 237
• 6.13 本章小结 238
• 本章练习 238
• 第7 章　Java基础类库 239
• 7.1 与用户互动 240
• 7.1.1 运行Java程序的参数 240
• 7.1.2 使用Scanner获取键盘输入 241
• 7.2 系统相关 243
• 7.2.1 System类 243
• 7.2.2 Runtime类 245
• 7.3 常用类 246
• 7.3.1 Object类 246
• 7.3.2 Java 7新增的Objects类 247
• 7.3.3 String、StringBuffer和
• StringBuilder类 248
• 7.3.4 Math类 251
• 7.3.5 Java 7的ThreadLocalRandom与Random 253
• 7.3.6 BigDecimal类 255
• 7.4 Java 8的日期、时间类 257
• 7.4.1 Date类 257
• 7.4.2 Calendar类 258
• 7.4.3 Java 8新增的日期、时间包 261
• 7.5 正则表达式 263
• 7.5.1 创建正则表达式 263
• 7.5.2 使用正则表达式 266
• 7.6 国际化与格式化 270
• 7.6.1 Java国际化的思路 270
• 7.6.2 Java支持的国家和语言 270
• 7.6.3 完成程序国际化 271
• 7.6.4 使用MessageFormat处理包含占位符的字符串 273
• 7.6.5 使用类文件代替资源文件 274
• 7.6.6 使用NumberFormat格式化数字 274
• 7.6.7 使用DateFormat格式化日期、时间 276
• 7.6.8 使用SimpleDateFormat格式化日期 277
• 7.7 Java 8新增的日期、时间格式器 278
• 7.7.1 使用DateTimeFormatter完成格式化 278
• 7.7.2 使用DateTimeFormatter解析字符串 279
• 7.8 本章小结 280
• 本章练习 280
• 第8 章　Java集合 281
• 8.1 Java集合概述 282
• 8.2 Collection和Iterator接口 283
• 8.2.1 使用Lambda表达式遍历集合 285
• 8.2.2 使用Java 8增强的Iterator遍历集合元素 286
• 8.2.3 使用Lambda表达式遍历Iterator 287
• 8.2.4 使用foreach循环遍历集合元素 288
• 8.2.5 使用Java 8新增的Predicate操作集合 288
• 8.2.6 使用Java 8新增的Stream操作集合 289
• 8.3 Set集合 291
• 8.3.1 HashSet类 292
• hashCode()方法对于HashSet是不是十分重要？ 293
• 8.3.2 LinkedHashSet类 295
• 8.3.3 TreeSet类 296
• 8.3.4 EnumSet类 302
• 8.3.5 各Set实现类的性能分析 303
• 8.4 List集合 304
• 8.4.1 Java 8改进的List接口和ListIterator接口 304
• 8.4.2 ArrayList和Vector实现类 307
• 8.4.3 固定长度的List 308
• 8.5 Queue集合 308
• 8.5.1 PriorityQueue实现类 309
• 8.5.2 Deque接口与ArrayDeque实现类 309
• 8.5.3 LinkedList实现类 311
• 8.5.4 各种线性表的性能分析 312
• 8.6 Java 8增强的Map集合 313
• 8.6.1 Java 8为Map新增的方法 315
• 8.6.2 Java 8改进的HashMap和Hashtable实现类 316
• 8.6.3 LinkedHashMap实现类 319
• 8.6.4 使用Properties读写属性文件 319
• 8.6.5 SortedMap接口和TreeMap实现类 320
• 8.6.6 WeakHashMap实现类 323
• 8.6.7 IdentityHashMap实现类 323
• 8.6.8 EnumMap实现类 324
• 8.6.9 各Map实现类的性能分析 325
• 8.7 HashSet和HashMap的性能选项 325
• 8.8 操作集合的工具类：Collections 326
• 8.8.1 排序操作 326
• 8.8.2 查找、替换操作 329
• 8.8.3 同步控制 330
• 8.8.4 设置不可变集合 330
• 8.9 烦琐的接口：Enumeration 331
• 8.10 本章小结 332
• 本章练习 332
• 第9 章　泛型 333
• 9.1 泛型入门 334
• 9.1.1 编译时不检查类型的异常 334
• 9.1.2 使用泛型 334
• 9.1.3 Java 7泛型的“菱形”语法 335
• 9.2 深入泛型 336
• 9.2.1　定义泛型接口、类 336
• 9.2.2 从泛型类派生子类 338
• 9.2.3 并不存在泛型类 339
• 9.3 类型通配符 339
• 9.3.1 使用类型通配符 341
• 9.3.2 设定类型通配符的上限 341
• 9.3.3 设定类型形参的上限 343
• 9.4 泛型方法 344
• 9.4.1 定义泛型方法 344
• 9.4.2 泛型方法和类型通配符的区别 346
• 9.4.3 Java 7的“菱形”语法与泛型构造器 347
• 9.4.4 设定通配符下限 348
• 9.4.5 泛型方法与方法重载 350
• 9.4.6 Java 8改进的类型推断 351
• 9.5 擦除和转换 352
• 9.6 泛型与数组 353
• 9.7 本章小结 355
• 第10 章　异常处理 356
• 10.1 异常概述 357
• 10.2 异常处理机制 358
• 10.2.1 使用try...catch捕获异常 358
• 10.2.2 异常类的继承体系 360
• 10.2.3 Java 7提供的多异常捕获 362
• 10.2.4 访问异常信息 363
• 10.2.5 使用finally回收资源 364
• 10.2.6 异常处理的嵌套 366
• 10.2.7 Java 7的自动关闭资源的try语句 366
• 10.3 Checked异常和Runtime异常体系 368
• 10.3.1 使用throws声明抛出异常 368
• 10.4 使用throw抛出异常 370
• 10.4.1 抛出异常 370
• 10.4.2 自定义异常类 371
• 10.4.3 catch和throw同时使用 372
• 10.4.4 Java 7增强的throw语句 373
• 10.4.5 异常链 374
• 10.5 Java的异常跟踪栈 376
• 10.6 异常处理规则 377
• 10.6.1 不要过度使用异常 378
• 10.6.2 不要使用过于庞大的try块 379
• 10.6.3 避免使用Catch All语句 379
• 10.6.4 不要忽略捕获到的异常 379
• 10.7 本章小结 380
• 本章练习 380
• 第11 章　AWT编程 381
• 11.1 GUI（图形用户界面）和AWT 382
• 11.2 AWT容器 383
• 11.3 布局管理器 386
• 11.3.1 FlowLayout布局管理器 386
• 11.3.2 BorderLayout布局管理器 387
• BorderLayout最多只能放置5个组件吗？那它也太不实用了吧？ 388
• 11.3.3 GridLayout布局管理器 389
• 11.3.4 GridBagLayout布局管理器 390
• 11.3.5 CardLayout布局管理器 392
• 11.3.6 绝对定位 394
• 11.3.7 BoxLayout布局管理器 395
• 图11.15和图11.16显示的所有按钮都紧挨在一起，如果希望像FlowLayout、GridLayout等布局管理器那样指定组件的间距应该怎么办？ 396
• 11.4 AWT常用组件 397
• 11.4.1 基本组件 397
• 11.4.2 对话框（Dialog） 399
• 11.5 事件处理 401
• 11.5.1 Java事件模型的流程 401
• 11.5.2 事件和事件监听器 403
• 11.5.3 事件适配器 407
• 11.5.4 使用内部类实现监听器 408
• 11.5.5 使用外部类实现监听器 408
• 11.5.6 类本身作为事件监听器类 409
• 11.5.7 匿名内部类实现监听器 410
• 11.6 AWT菜单 410
• 11.6.1 菜单条、菜单和菜单项 410
• 11.6.2 右键菜单 412
• 为什么即使我没有给多行文本域编写右键菜单，但当我在多行文本域上单击右键时也一样会弹出右键菜单？ 414
• 11.7 在AWT中绘图 414
• 11.7.1 画图的实现原理 414
• 11.7.2 使用Graphics类 415
• 11.8 处理位图 419
• 11.8.1 Image抽象类和BufferedImage实现类 419
• 11.8.2 使用ImageIO输入/输出位图 421
• 11.9 剪贴板 425
• 11.9.1 数据传递的类和接口 426
• 11.9.2 传递文本 426
• 11.9.3 使用系统剪贴板传递图像 428
• 11.9.4 使用本地剪贴板传递对象引用 430
• 11.9.5 通过系统剪贴板传递Java对象 433
• 11.10 拖放功能 435
• 11.10.1 拖放目标 436
• 11.10.2 拖放源 439
• 11.11 本章小结 440
• 本章练习 440
• 第12 章　Swing编程 441
• 12.1 Swing概述 442
• 12.2 Swing基本组件的用法 443
• 12.2.1 Java 7 的Swing组件层次 443
• 12.2.2 AWT组件的Swing实现 444
• 为什么单击Swing多行文本域时不是弹出像AWT多行文本域中的右键菜单？ 450
• 12.2.3 为组件设置边框 450
• 12.2.4 Swing组件的双缓冲和键盘驱动 452
• 12.2.5 使用JToolBar创建工具条 453
• 12.2.6 使用JFileChooser和Java 7增强的JColorChooser 455
• 12.2.7 使用JOptionPane 462
• 12.3 Swing中的特殊容器 467
• 12.3.1 使用JSplitPane 467
• 12.3.2 使用JTabbedPane 469
• 12.3.3 使用JLayeredPane、JdesktopPane和JInternalFrame 473
• 12.4 Swing简化的拖放功能 480
• 12.5 Java 7新增的Swing功能 481
• 12.5.1 使用JLayer装饰组件 481
• 12.5.2 创建透明、不规则形状窗口 487
• 12.6 使用JProgressBar、ProgressMonitor和BoundedRangeModel创建进度条 489
• 12.6.1 创建进度条 489
• 12.6.2 创建进度对话框 492
• 12.7 使用JSlider和BoundedRangeModel创建滑动条 494
• 12.8 使用JSpinner和SpinnerModel创建微调控制器 497
• 12.9 使用JList、JComboBox创建列表框 500
• 12.9.1 简单列表框 500
• 12.9.2 不强制存储列表项的ListModel和ComboBoxModel 503
• 12.9.3 强制存储列表项的DefaultListModel和DefaultComboBoxModel 506
• 为什么JComboBox提供了添加、删除列表项的方法？而JList没有提供添加、删除列表项的方法呢？ 508
• 12.9.4 使用ListCellRenderer改变列表项外观 508
• 12.10 使用JTree和TreeModel创建树 510
• 12.10.1 创建树 511
• 12.10.2 拖动、编辑树节点 513
• 12.10.3 监听节点事件 517
• 12.10.4 使用DefaultTreeCellRenderer改变节点外观 519
• 12.10.5 扩展DefaultTreeCellRenderer改变节点外观 520
• 12.10.6 实现TreeCellRenderer改变节点外观 523
• 12.11 使用JTable和TableModel创建表格 524
• 12.11.1 创建表格 525
• 我们指定的表格数据、表格列标题都是Object类型的数组，JTable如何显示这些Object对象？ 525
• 12.11.2 TableModel和监听器 530
• 12.11.3 TableColumnModel和监听器 534
• 12.11.4 实现排序 537
• 12.11.5 绘制单元格内容 540
• 12.11.6 编辑单元格内容 543
• 12.12 使用JFormattedTextField和JtextPane创建格式文本 546
• 12.12.1 监听Document的变化 547
• 12.12.2 使用JPasswordField 549
• 12.12.3 使用JFormattedTextField 549
• 12.12.4 使用JEditorPane 557
• 12.12.5 使用JTextPane 557
• 12.13 本章小结 564
• 本章练习 564
• 第13 章　MySQL数据库与JDBC编程 565
• 13.1 JDBC基础 566
• 13.1.1 JDBC简介 566
• 13.1.2 JDBC驱动程序 567
• 13.2 SQL语法 568
• 13.2.1 安装数据库 568
• 13.2.2 关系数据库基本概念和MySQL基本命令 570
• 13.2.3 SQL语句基础 572
• 13.2.4 DDL语句 573
• 13.2.5 数据库约束 577
• 13.2.6 索引 584
• 13.2.7 视图 585
• 13.2.8 DML语句语法 585
• 13.2.9 单表查询 588
• 13.2.10 数据库函数 592
• 13.2.11 分组和组函数 594
• 13.2.12 多表连接查询 596
• 13.2.13 子查询 599
• 13.2.14 集合运算 601
• 13.3 JDBC的典型用法 602
• 13.3.1 JDBC 4.2常用接口和类简介 602
• 13.3.2 JDBC编程步骤 604
• 前面给出的仅仅是MySQL和Oracle两种数据库的驱动，我看不出驱动类字符串有什么规律啊。如果我希望使用其他数据库，那怎么找到其他数据库的驱动类呢？ 604
• 13.4 执行SQL语句的方式 607
• 13.4.1 使用Java 8新增的executeLargeUpdate方法执行DDL和DML语句 607
• 13.4.2 使用execute方法执行SQL语句 608
• 13.4.3 使用PreparedStatement执行SQL语句 610
• 13.4.4 使用CallableStatement调用存储过程 614
• 13.5 管理结果集 615
• 13.5.1 可滚动、可更新的结果集 615
• 13.5.2 处理Blob类型数据 617
• 13.5.3 使用ResultSetMetaData分析结果集 622
• 13.6 Java 7的RowSet 1.1 624
• 13.6.1 Java 7新增的RowSetFactory与RowSet 625
• 13.6.2 离线RowSet 627
• 13.6.3 离线RowSet的查询分页 629
• 13.7 事务处理 630
• 13.7.1 事务的概念和MySQL事务支持 630
• 13.7.2 JDBC的事务支持 632
• 13.7.3 Java 8增强的批量更新 634
• 13.8 分析数据库信息 635
• 13.8.1 使用DatabaseMetaData分析数据库信息 635
• 13.8.2 使用系统表分析数据库信息 636
• 13.8.3 选择合适的分析方式 637
• 13.9 使用连接池管理连接 638
• 13.9.1 DBCP数据源 638
• 13.9.2 C3P0数据源 639
• 13.10 本章小结 640
• 本章练习 640
• 第14 章　Annotation（注释） 641
• 14.1 基本Annotation 642
• 14.1.1 限定重写父类方法：@Override 642
• 14.1.2 标示已过时：@Deprecated 643
• 14.1.3 抑制编译器警告：@SuppressWarnings 644
• 14.1.4 Java 7的“堆污染”警告与@SafeVarargs 644
• 14.1.5 Java 8的函数式接口与@FunctionalInterface 645
• 14.2 JDK的元Annotation 646
• 14.2.1 使用@Retention 646
• 14.2.2 使用@Target 647
• 14.2.3 使用@Documented 647
• 14.2.4 使用@Inherited 648
• 14.3 自定义Annotation 649
• 14.3.1 定义Annotation 649
• 14.3.2 提取Annotation信息 650
• 14.3.3 使用Annotation的示例 652
• 14.3.4 Java 8新增的重复注解 656
• 14.3.5 Java 8新增的Type Annotation 658
• 14.4 编译时处理Annotation 659
• 14.5 本章小结 663
• 第15 章　输入/输出 664
• 15.1 File类 665
• 15.1.1 访问文件和目录 665
• 15.1.2 文件过滤器 667
• 15.2 理解Java的IO流 668
• 15.2.1 流的分类 668
• 15.2.2 流的概念模型 669
• 15.3 字节流和字符流 670
• 15.3.1 InputStream和Reader 670
• 15.3.2 OutputStream和Writer 672
• 15.4 输入/输出流体系 673
• 15.4.1 处理流的用法 674
• 15.4.2 输入/输出流体系 674
• 15.4.3 转换流 677
• 怎么没有把字符流转换成字节流的转换流呢？ 677
• 15.4.4 推回输入流 678
• 15.5 重定向标准输入/输出 679
• 15.6 Java虚拟机读写其他进程的数据 680
• 15.7 RandomAccessFile 682
• 15.8 对象序列化 686
• 15.8.1 序列化的含义和意义 686
• 15.8.2 使用对象流实现序列化 686
• 15.8.3 对象引用的序列化 688
• 15.8.4 自定义序列化 692
• 15.8.5 另一种自定义序列化机制 696
• 15.8.6 版本 698
• 15.9 NIO 699
• 15.9.1 Java新IO概述 699
• 15.9.2 使用Buffer 699
• 15.9.3 使用Channel 702
• 15.9.4 字符集和Charset 705
• 二进制序列与字符之间如何对应呢？ 706
• 15.9.5 文件锁 707
• 15.10 Java 7的NIO.2 709
• 15.10.1 Path、Paths和Files核心API 709
• 15.10.2 使用FileVisitor遍历文件和目录 710
• 15.10.3 使用WatchService监控文件变化 711
• 15.10.4 访问文件属性 712
• 15.11 本章小结 714
• 本章练习 714
• 第16 章　多线程 715
• 16.1 线程概述 716
• 16.1.1 线程和进程 716
• 16.1.2 多线程的优势 717
• 16.2 线程的创建和启动 718
• 16.2.1 继承Thread类创建线程类 718
• 16.2.2 实现Runnable接口创建线程类 719
• 16.2.3 使用Callable和Future创建线程 720
• 16.2.4 创建线程的三种方式对比 722
• 16.3 线程的生命周期 722
• 16.3.1 新建和就绪状态 722
• 16.3.2 运行和阻塞状态 724
• 16.3.3 线程死亡 725
• 16.4 控制线程 726
• 16.4.1 join线程 726
• 16.4.2 后台线程 727
• 16.4.3 线程睡眠：sleep 728
• 16.4.4 线程让步：yield 729
• 16.4.5 改变线程优先级 730
• 16.5 线程同步 731
• 16.5.1 线程安全问题 731
• 16.5.2 同步代码块 733
• 16.5.3 同步方法 735
• 16.5.4 释放同步监视器的锁定 737
• 16.5.5 同步锁（Lock） 737
• 16.5.6 死锁 739
• 16.6 线程通信 741
• 16.6.1 传统的线程通信 741
• 16.6.2 使用Condition控制线程通信 744
• 16.6.3 使用阻塞队列（BlockingQueue）控制线程通信 746
• 16.7 线程组和未处理的异常 749
• 16.8 线程池 752
• 16.8.1 Java 8改进的线程池 752
• 16.8.2 Java 8增强的ForkJoinPool 754
• 16.9 线程相关类 757
• 16.9.1 ThreadLocal类 757
• 16.9.2 包装线程不安全的集合 759
• 16.9.3 线程安全的集合类 759
• 16.10 本章小结 760
• 第17 章　网络编程 761
• 17.1 网络编程的基础知识 762
• 17.1.1 网络基础知识 762
• 17.1.2 IP地址和端口号 763
• 17.2 Java的基本网络支持 764
• 17.2.1 使用InetAddress 764
• 17.2.2 使用URLDecoder和URLEncoder 765
• 17.2.3 URL、URLConnection和URLPermission 766
• 17.3 基于TCP协议的网络编程 772
• 17.3.1 TCP协议基础 772
• 17.3.2 使用ServerSocket创建TCP服务器端 773
• 17.3.3 使用Socket进行通信 773
• 17.3.4 加入多线程 776
• 17.3.5 记录用户信息 778
• 17.3.6 半关闭的Socket 785
• 17.3.7 使用NIO实现非阻塞Socket通信 786
• 17.3.8 使用Java 7的AIO实现非阻塞通信 792
• 上面程序中好像没用到④⑤号代码的get()方法的返回值，这两个地方不调用get()方法行吗？ 795
• 17.4 基于UDP协议的网络编程 798
• 17.4.1 UDP协议基础 799
• 17.4.2 使用DatagramSocket发送、接收数据 799
• 17.4.3 使用MulticastSocket实现多点广播 803
• 17.5 使用代理服务器 813
• 17.5.1 直接使用Proxy创建连接 813
• 17.5.2 使用ProxySelector自动选择代理服务器 814
• 17.6 本章小结 817
• 本章练习 817
• 第18 章　类加载机制与反射 818
• 18.1 类的加载、连接和初始化 819
• 18.1.1 JVM和类 819
• 18.1.2 类的加载 820
• 18.1.3 类的连接 821
• 18.1.4 类的初始化 821
• 18.1.5 类初始化的时机 822
• 18.2 类加载器 823
• 18.2.1 类加载器简介 823
• 18.2.2 类加载机制 824
• 18.2.3 创建并使用自定义的类加载器 826
• 18.2.4 URLClassLoader类 829
• 18.3 通过反射查看类信息 830
• 18.3.1 获得Class对象 830
• 18.3.2 从Class中获取信息 831
• 18.3.3 Java 8新增的方法参数反射 835
• 18.4 使用反射生成并操作对象 836
• 18.4.1 创建对象 836
• 18.4.2 调用方法 838
• 18.4.3 访问成员变量值 840
• 18.4.4 操作数组 841
• 18.5 使用反射生成JDK动态代理 842
• 18.5.1 使用Proxy和InvocationHandler创建动态代理 843
• 18.5.2 动态代理和AOP 844
• 18.6 反射和泛型 848
• 18.6.1 泛型和Class类 848
• 18.6.2 使用反射来获取泛型信息 850
• 18.7 本章小结 851
• 本章练习 851
• == 精彩节摘 ==
• 如何学习Java
• ——谨以此文献给打算以编程为职业、并愿意为之疯狂的人
• 经常看到有些学生、求职者捧着一本类似JBuilder入门、Eclipse指南之类的图书学习Java，当他们学会了在这些工具中拖出窗体、安装按钮之后，就觉得自己掌握、甚至精通了Java；又或是找来一本类似JSP动态网站编程之类的图书，学会使用JSP脚本编写一些页面后，就自我感觉掌握了Java开发。
• 还有一些学生、求职者听说J2EE、Spring或EJB很有前途，于是立即跑到书店或图书馆找来一本相关图书。希望立即学会它们，然后进入软件开发业、大显身手。
• 还有一些学生、求职者非常希望找到一本既速成、又大而全的图书，比如突击J2EE开发、一本书精通J2EE之类的图书（包括笔者曾出版的《轻量级J2EE企业应用实战》一书，据说销量不错)，希望这样一本图书就可以打通自己的“任督二脉”，一跃成为J2EE开发高手。
• 也有些学生、求职者非常喜欢J2EE项目实战、项目大全之类的图书，他们的想法很单纯：我按照书上介绍，按图索骥、依葫芦画瓢，应该很快就可学会J2EE，很快就能成为一个受人羡慕的J2EE程序员了。
• ……
• 凡此种种，不一而足。但最后的结果往往是失败，因为这种学习没有积累、没有根基，学习过程中困难重重，每天都被一些相同、类似的问题所困扰，起初热情十足，经常上论坛询问，按别人的说法解决问题之后很高兴，既不知道为什么错？也不知道为什么对？只是盲目地抄袭别人的说法。最后的结果有两种：
• 久而久之，热情丧失，最后放弃学习。
• 大部分常见问题都问遍了，最后也可以从事一些重复性开发，但一旦遇到新问题，又将束手无策。
• 第二种情形在普通程序员中占了极大的比例，笔者多次听到、看到（在网络上）有些程序员抱怨：我做了2年多Java程序员了，工资还是3000多点。偶尔笔者会与他们聊聊工作相关内容，他们会告诉笔者：我也用Spring了啊，我也用EJB了啊……他们感到非常不平衡，为什么我的工资这么低？其实笔者很想告诉他们：你们太浮躁了！你们确实是用了Spring、Hibernate又或是EJB，但你们未想过为什么要用这些技术？用这些技术有什么好处？如果不用这些技术行不行？
• 很多时候，我们的程序员把Java当成一种脚本，而不是一门面向对象的语言。他们习惯了在JSP脚本中使用Java，但从不去想JSP如何运行，Web服务器里的网络通信、多线层机制，为何一个JSP页面能同时向多个请求者提供服务？更不会想如何开发Web服务器；他们像代码机器一样编写Spring Bean代码，但从不去理解Spring容器的作用，更不会想如何开发Spring容器。
• 有时候，笔者的学生在编写五子棋、梭哈等作业感到困难时，会向他们的大学师兄、朋友求救，这些程序员告诉他：不用写了，网上有下载的！听到这样回答，笔者不禁感到哑然：网上还有Windows下载呢！网上下载和自己编写是两码事。偶尔，笔者会怀念以前黑色屏幕、绿荧荧字符时代，那时候程序员很单纯：当我们想偷懒时，习惯思维是写一个小工具；现在程序员很聪明：当他们想偷懒时，习惯思维是从网上下一个小工具。但是，谁更幸福？
• 当笔者的学生把他们完成的小作业放上互联网之后，然后就有许多人称他们为“高手”！这个称呼却让他们万分惭愧；惭愧之余，他们也感到万分欣喜，非常有成就感，这就是编程的快乐。编程的过程，与寻宝的过程完全一样：历经辛苦，终于找到心中的梦想，这是何等的快乐？
• 如果真的打算将编程当成职业，那就不应该如此浮躁，而是应该扎扎实实先学好Java语言，然后按Java本身的学习规律，踏踏实实一步一个脚印地学习，把基本功练扎实了才可获得更大的成功。
• 实际情况是，有多少程序员真正掌握了Java的面向对象？真正掌握了Java的多线程、网络通信、反射等内容？有多少Java程序员真正理解了类初始化时内存运行过程？又有多少程序员理解Java对象从创建到消失的全部细节？有几个程序员真正独立地编写过五子棋、梭哈、桌面弹球这种小游戏？又有几个Java程序员敢说：我可以开发Struts？我可以开发Spring？我可以开发Tomcat？很多人又会说：这些都是许多人开发出来的！实际情况是：许多开源框架的核心最初完全是由一个人开发的。现在这些优秀程序已经出来了！你，是否深入研究过它们，是否深入掌握了它们？
• 如果要真正掌握Java，包括后期的Java EE相关技术（例如Struts、Spring、Hibernate和EJB等），一定要记住笔者的话：绝不要从IDE（如JBuilder、Eclipse和NetBeans）工具开始学习！IDE工具的功能很强大，初学者学起来也很容易上手，但也非常危险：因为IDE工具已经为我们做了许多事情，而软件开发者要全部了解软件开发的全部步骤。
• 李刚
• 2011年12月17日
• 作者简介
• 李刚，十多年软件行业开发从业经验，疯狂软件教育中心教学总监。
• 疯狂Java实训营创始人，疯狂Java体系原创图书作者。
• 广东技术师范学院计算机科学系兼职副教授，51cto专家门诊特邀嘉宾。
• 培训的学生已在华为、IBM、阿里软件、网易、电信盈科等名企就职。
• 国内著名高端IT技术作家，已出版《疯狂Java讲义》《疯狂Android讲义》《轻量级Java EE企业应用实战》《疯狂iOS讲义》《疯狂Ajax讲义》《疯狂XML讲义》《经典Java EE企业应用实战》《疯狂HTML 5/CSS 3/JavaScript讲义》《Struts 2.x权威指南》等著作。其中疯狂Java体系图书经多年沉淀，赢得极高的市场认同，多次重印成为超级畅销书，并被多所“985”“211”院校选作教材。部分图书已被翻译成繁体中文版、授权到台湾地区。
• 媒体评论
• 我在Java编程教学中把《疯狂Java讲义》列为重要的中文参考资料。它覆盖了“够用”的Java语言和技术，作者有实际的编程和教学经验，也尽力把相关问题讲解明白、分析清楚，这在同类书籍中是比较难得的。
• 北京大学信息科学技术学院副教授 刘扬
• == 前言 ==
• 2014年3月18日，Oracle发布了Java 8正式版。Java 8是自Java 5以来最重要的版本更新，Java 8引入了大量新特性——重新设计的接口语法、Lambda表达式、方法引用、构造器引用、函数式编程、流式编程、新的日期、时间API等，这些新特性进一步增强了Java语言的功能。
• 为了向广大工作者、学习者介绍最新、最前沿的Java知识，在Java 8正式发布之前，笔者已经深入研究过Java 8绝大部分可能新增的功能；当Java 8正式发布之后，笔者在第一时间开始了《疯狂Java讲义（第2版）》的升级：使用Java 8改写了全书所有程序，全面介绍了Java 8的各种新特性。
• 在以“疯狂Java体系”图书为教材的疯狂软件教育中心（www.fkjava.org），经常有学生询问：为什么叫疯狂Java这个名字？也有一些读者通过网络、邮件来询问这个问题。其实这个问题的答案可以在本书第1版的前言中找到。疯狂的本质是一种“享受编程”的状态。在一些不了解编程的人看来：编程的人总面对着电脑，在键盘上敲打，这种生活实在太枯燥了，但实际上是因为他们并未真正了解编程，并未真正走进编程。在外人眼中：程序员不过是在敲打键盘；但在程序员心中：程序员敲出的每个字符，都是程序的一部分。
• 程序是什么呢？程序是对现实世界的数字化模拟。开发一个程序，实际是创造一个或大或小的“模拟世界”。在这个过程中，程序员享受着“创造”的乐趣，程序员沉醉在他所创造的“模拟世界”里：疯狂地设计、疯狂地编码实现。实现过程不断地遇到问题，然后解决它；不断地发现程序的缺陷，然后重新设计、修复它——这个过程本身就是一种享受。一旦完全沉浸到编程世界里，程序员是“物我两忘”的，眼中看到的、心中想到的，只有他正在创造的“模拟世界”。
• 在学会享受编程之前，编程学习者都应该采用“案例驱动”的方式，学习者需要明白程序的作用是：解决问题——如果你的程序不能解决你自己的问题，如何期望你的程序去解决别人的问题呢？那你的程序的价值何在？——知道一个知识点能解决什么问题，才去学这个知识点，而不是盲目学习！因此本书强调编程实战，强调以项目激发编程兴趣。
• 仅仅只是看完这本书，你不会成为高手！在编程领域里，没有所谓的“武林秘笈”，再好的书一定要配合大量练习，否则书里的知识依然属于作者，而读者则仿佛身入宝山而一无所获的笨汉。本书配合了大量高强度的练习，希望读者强迫自己去完成这些项目。这些习题的答案可以参考本书所附光盘中《疯狂Java实战演义》的配套代码。如果需要获得编程思路和交流，可以登录http://www.crazyit.org与广大读者和笔者交流。
• 本书前两版面市的近6年时间里，无数读者已经通过本书步入了Java编程世界，而且第2版的年销量比第1版的年销量大幅提升，这说明“青山遮不住”，优秀的作品，经过时间的沉淀，往往历久弥新。
• 广大读者对疯狂Java的肯定，读者认同、赞誉既让笔者十分欣慰，也鞭策笔者以更高的热情、更严谨的方式创作图书。时至今日，每次笔者创作或升级图书时，总有一种诚惶诚恐、如履薄冰的感觉，惟恐辜负广大读者的厚爱。
• 笔者非常欢迎所有热爱编程、愿意推动中国软件业的学习者、工作者对本书提出宝贵的意见，非常乐意与大家交流。中国软件业还处于发展阶段，所有热爱编程、愿意推动中国软件业的人应该联合起来，共同为中国软件行业贡献自己的绵薄之力。
• 本书有什么特点
• 本书并不是一本简单的Java入门教材，也不是一门“闭门造车”式的Java读物。本书来自于笔者8年多的Java培训经历，凝结了笔者近8000个小时的授课经验，总结了几千个Java学员学习过程中的典型错误。
• 因此，本书具有如下三个特点：
• 1．案例驱动，引爆编程激情
• 本书不再是知识点的铺陈，而是致力于将知识点融入实际项目的开发中，所以本书中涉及了大量Java案例：仿QQ的游戏大厅、MySQL企业管理器、仿EditPlus的文本编辑器、多线程、断点下载工具……希望读者通过编写这些程序找到编程的乐趣。
• 2．再现李刚老师课堂氛围
• 本书的内容是笔者8年多授课经历的总结，知识体系取自疯狂Java实战的课程体系。
• 本书力求再现笔者的课堂氛围：以浅显比喻代替乏味的讲解，以疯狂实战代替空洞的理论。
• 书中包含了大量“注意”、“学生提问”部分，这些正是几千个Java学员所犯错误的汇总。
• 3．注释详细，轻松上手
• 为了降低读者阅读的难度，书中代码的注释非常详细，几乎每两行代码就有一行注释。不仅如此，本书甚至还把一些简单理论作为注释穿插到代码中，力求让读者能轻松上手。
• 本书所有程序中关键代码以粗体字标出，也是为了帮助读者能迅速找到这些程序的关键点。
• 本书写给谁看
• 如果你仅仅想对Java有所涉猎，那么本书并不适合你；如果你想全面掌握Java语言，并使用Java来解决问题、开发项目，或者希望以Java编程作为你的职业，那么本书将非常适合你。希望本书能引爆你内心潜在的编程激情，如果本书能让你产生废寝忘食的感觉，那笔者就非常欣慰了。
• 李刚
• 2014-06-15