Java SE 6.0编程指南PDF电子书下载

第一篇 起步篇 3

第1章 初识Java 3

1.1 Java简介 3

1.1.1 Java的不同平台 3

1.1.2 Java发展的历程 3

1.1.3 Java的特点 4

1.2 安装开发工具包 5

1.2.1 下载JDK 5

1.2.2 安装JDK 6

1.2.3 安装后Java目录的解读 7

1.3 学会使用API 7

1.4 第一个Java程序 8

1.4.1 开发源代码 8

1.4.2 编译运行 9

1.5 小结 11

第2章 基本数据类型——构建Java大厦的基础 12

2.1 源代码注释 12

2.1.1 单行注释 12

2.1.2 区域注释 12

2.1.3 文档注释 13

2.2 基本数据类型 14

2.2.1 整型 15

2.2.2 浮点型 17

2.2.3 char型 17

2.2.4 boolean型 18

2.3 基本数据类型值间的转换 18

2.3.1 自动转换 18

2.3.2 手动强制转换 19

2.3.3 隐含强制转换 19

2.4 标识符命名规范 20

2.4.1 正确的命名标识符 20

2.4.2 提倡的命名习惯 21

2.5 小结 21

第3章 表达式——描述行为的元素 22

3.1 不简单的算术运算符 22

3.1.1 “＋”运算符 22

3.1.2 “－”运算符 24

3.1.3 “＊”运算符 25

3.1.4 “／”运算符 25

3.1.5 “％”运算符 26

3.2 自增自减运算 27

3.3 关系运算 28

3.3.1 等于／不等于运算 28

3.3.2 比较大小运算 29

3.4 逻辑运算 30

3.4.1 “与”运算 30

3.4.2 “或”运算 31

3.4.3 “非”运算 32

3.5 三元运算符 32

3.6 位运算 33

3.7 移位运算 34

3.7.1 “＜＜”左移 35

3.7.2 “＞＞”右移 35

3.7.3 “＞＞＞”无符号右移 36

3.7.4 令人困扰的例子 37

3.8 赋值运算 37

3.8.1 普通赋值运算 37

3.8.2 运算赋值运算 38

3.9 括号及运算符间的优先级关系 38

3.10 常用数学工具包——java.lang.Math类 39

3.10.1 数学常量 39

3.10.2 常用数学函数 40

3.11 小结 41

第4章 流程控制——Java世界的航行舵手 42

4.1 if条件语句 42

4.1.1 简略形式 42

4.1.2 完全形式 43

4.1.3 语句的嵌套 43

4.2 switch多分支语句 45

4.2.1 基本语法 45

4.2.2 合法的判断表达式 46

4.2.3 合法的case表达式 47

4.2.4 详细执行流程 49

4.3 while循环语句 50

4.4 do-while循环语句 52

4.5 for循环语句 53

4.5.1 基本语法 53

4.5.2 声明的三大组成部分 54

4.5.3 复杂的for循环案例 55

4.5.4 用for实现其他循环 55

4.6 break中断语句 56

4.7 continue继续语句 57

4.8 小结 58

第5章 数组——以不变应万变的哲学 59

5.1 数组的声明及创建 59

5.1.1 声明数组引用 59

5.1.2 创建数组对象 60

5.2 Java中数组的实现机制 61

5.3 数组的初始化 63

5.3.1 默认初始化 63

5.3.2 利用循环初始化 64

5.3.3 枚举初始化 66

5.4 数组的相互赋值 67

5.4.1 基本类型数组赋值规则 67

5.4.2 引用型数组赋值规则 68

5.5 数组的常用操作 69

5.5.1 数组复制 69

5.5.2 数组排序 71

5.5.3 搜索指定元素 72

5.5.4 比较数组中的元素 73

5.6 关于args[] 73

5.7 小结 74

第二篇 基础篇 77

第6章 对象和类——Java世界的细胞 77

6.1 面向对象概述 77

6.1.1 面向对象程序设计思想的诞生 77

6.1.2 面向过程与面向对象思想的对比 78

6.1.3 面向对象技术的背景和特点 79

6.2 类的定义与对象的创建 80

6.3 成员变量 81

6.3.1 成员变量的开发与使用 81

6.3.2 成员变量的初始值 82

6.3.3 对象引用变量的比较 84

6.4 方法 85

6.5 变长参数 86

6.6 引用问题 87

6.6.1 调用不存在的方法或成员变量 87

6.6.2 用空引用进行调用 88

6.6.3 数组的空引用问题 89

6.7 局部变量 89

6.7.1 局部变量的作用域 89

6.7.2 局部变量的初始化 90

6.8 this预定义对象引用 92

6.9 擅用系统已有的类 94

6.9.1 Java中的Date类 94

6.9.2 Java中的GregorianCalendar类 96

6.9.3 擅用系统已有类的思想 98

6.10 小结 99

第7章 访问控制——Java世界的卫兵 100

7.1 包的使用 100

7.1.1 声明创建包 100

7.1.2 引入包内的资源 102

7.1.3 静态引入 104

7.2 类的访问控制 105

7.2.1 公有访问级别 105

7.2.2 默认访问级别 106

7.2.3 类与源代码文件的搭配 106

7.3 成员的访问控制 107

7.3.1 公共类型 107

7.3.2 私有类型 108

7.3.3 默认类型 109

7.3.4 保护类型 109

7.3.5 Java中封装的实现 110

7.4 final的变量 112

7.4.1 final的成员变量 113

7.4.2 final的局部变量 115

7.5 static关键字的使用 116

7.5.1 静态成员 116

7.5.2 静态成员的访问 117

7.5.3 静态最终成员变量 119

7.6 小结 121

第8章 继承——多态的支柱 122

8.1 继承概述 122

8.1.1 类之间的关系 122

8.1.2 面向对象中的继承性 124

8.2 类的继承 125

8.3 成员变量的继承与隐藏 126

8.3.1 成员变量的继承规则 126

8.3.2 成员变量的隐藏 129

8.4 对象引用的使用 130

8.4.1 对象引用能指向的对象类型 130

8.4.2 对象引用的强制类型转换 131

8.4.3 对象引用所能调用的成员 132

8.4.4 对象引用的赋值与比较 133

8.5 方法的继承与重写 135

8.5.1 方法的继承规则 135

8.5.2 方法重写的基本知识 136

8.5.3 构成重写的条件 137

8.5.4 返回类型的规则 138

8.5.5 访问级别的要求 140

8.5.6 重写基于继承 141

8.5.7 静态方法没有重写 141

8.5.8 通过重写扩展父类方法的功能 143

8.5.9 替代性原理 144

8.6 方法的重载 145

8.6.1 方法重载的规则 145

8.6.2 重载方法的匹配 145

8.6.3 重写与重载的区别 149

8.7 final与继承 149

8.7.1 最终的类 149

8.7.2 最终的方法 150

8.8 abstract与继承 151

8.8.1 抽象的类 151

8.8.2 抽象的方法 152

8.9 基于继承的多态 154

8.10 小结 155

第9章 接口——灵活性的基石 156

9.1 概述及其特性 156

9.2 成员变量在接口中的使用 157

9.2.1 语法规则 157

9.2.2 接口中成员变量的作用 158

9.3 方法在接口中的使用 159

9.3.1 语法规则 159

9.3.2 如何实现接口 160

9.3.3 接口引用的使用 162

9.3.4 接口中方法无法使用的修饰符 165

9.4 接口与抽象类 166

9.4.1 语法上的不同 167

9.4.2 具体含义的不同 167

9.5 基于接口的多态 169

9.6 接口与回调 170

9.7 instanceof的使用 172

9.7.1 基本语法与使用 172

9.7.2 不允许进行测试的情况 174

9.8 小结 175

第10章 构造器——对象制造的工厂 176

10.1 基础知识 176

10.1.1 编写构造器的语法规则 176

10.1.2 访问限制修饰符与构造器 176

10.1.3 构造器与返回类型 179

10.2 创建对象 180

10.3 重载构造器 181

10.4 级联调用的构造器 182

10.4.1 构造器的调用流程及默认构造器 182

10.4.2 自定义构造器需要注意的问题 185

10.4.3 不能继承构造器 186

10.4.4 调用兄弟构造器 187

10.5 单列模式 189

10.6 Java程序的加载过程 190

10.7 小结 192

第三篇 高级基础篇 195

第11章 异常处理Java世界的医生 195

11.1 异常处理的基本知识 195

11.1.1 try和catch捕获异常 195

11.1.2 异常的传播过程 198

11.1.3 finally语句块的使用 199

11.1.4 try、catch及finally语句块之间需要注意的问题 201

11.2 异常的层次结构 203

11.2.1 捕获异常 203

11.2.2 未捕获异常 205

11.3 再次抛出异常 206

11.3.1 什么是异常的再抛出 206

11.3.2 显性再抛出 207

11.3.3 隐性再抛出 209

11.3.4 方法重写对抛出异常声明的约束 210

11.4 定义自己的异常 212

11.4.1 创建自己的异常类 212

11.4.2 使用自定义的异常类 213

11.4.3 显性再抛出作用的体现 215

11.5 异常的匹配 217

11.5.1 同时捕获多种异常 217

11.5.2 多个catch语句的先后顺序 218

11.6 断言 219

11.6.1 什么是断言 219

11.6.2 如何启用／关闭断言 220

11.6.3 防止滥用断言 222

11.7 小结 222

第12章 封装类——鸿沟之上的桥梁 223

12.1 封装类的基本知识 223

12.1.1 封装类概述 223

12.1.2 创建封装类对象 223

12.1.3 封装类对象的其他知识 225

12.2 数据转换功能 226

12.2.1 基本数据类型值转换为字符串 226

12.2.2 字符串转换为基本数据类型值 229

12.3 其他常用方法 231

12.3.1 静态工厂方法 231

12.3.2 isNaN方法 232

12.3.3 equals方法 233

12.4 自动打包／解包 235

12.4.1 自动打包 235

12.4.2 自动解包 236

12.5 特殊的数值计算 237

12.5.1 特大整数的计算 237

12.5.2 浮点数的精确计算 239

12.6 小结 242

第13章 字符串——优异的内存组织机制 243

13.1 String类的基础知识 243

13.1.1 对象的创建 243

13.1.2 巧用构造器 244

13.1.3 String类的重要方法 245

13.2 String对象的内存机制 248

13.2.1 一段令人困惑的字符串程序 248

13.2.2 “一次投入，终身回报”的String内存机制 249

13.2.3 String对象特殊机制付出的代价 252

13.3 StringBuffer类 253

13.3.1 弥补String不足的StringBuffer类 253

13.3.2 编写方法链以及StringBuffer类的重要方法 255

13.4 StringBuilder类 258

13.5 正则表达式 259

13.5.1 正则表达式的基本语法 259

13.5.2 Pattern类简介 262

13.5.3 Matcher类简介 263

13.5.4 Pattern与Matcher类的综合应用 264

13.6 String类中正则式的应用 266

13.6.1 模式匹配检查 266

13.6.2 利用正则式进行查找替换 267

13.6.3 利用正则式对字符串进行分析 268

13.7 小结 269

第14章 集合框架——强大的对象管理器 270

14.1 Object类——所有类的超类 270

14.1.1 toString方法的重写 270

14.1.2 equals方法的意义 271

14.1.3 hashCode方法的意义 272

14.2 重写equals与hashCode方法  273

14.2.1 重写equals方法 273

14.2.2 重写hashCode方法 275

14.3 集合框架的层次结构 277

14.4 Ordered与Sorted的接口 278

14.4.1 Ordered的排序 278

14.4.2 Sorted的排序 279

14.5 列表 279

14.5.1 列表接口——st 279

14.5.2 列表的数组实现 281

14.5.3 历史悠久的向量 282

14.5.4 列表的链接实现 284

14.5.5 依赖性倒置原理 285

14.5.6 将数组转换为列表 285

14.6 集合 286

14.6.1 Set接口及含义 286

14.6.2 HashSet类的使用 287

14.6.3 equals与hashCode方法重写规定的作用 288

14.6.4 LinkedHashSet类的使用 291

14.6.5 SortedSet接口与TreeSet类 292

14.6.6 自定义满足Sorted集合的类 293

14.6.7 定制SortedSet的排序规则 296

14.6.8 集合的遍历 298

14.6.9 使用for-each循环遍历集合 300

14.7 映射集 301

14.7.1 Map接口及含义 301

14.7.2 HashMap类的使用 302

14.7.3 Hashtable类的使用 303

14.7.4 LinkedHashMap类的使用 304

14.7.5 SortedMap接口与TreeMap类 305

14.7.6 映射的遍历 308

14.8 栈在Java中的实现 309

14.8.1 Stack类的使用 309

14.8.2 Deque接口的使用 310

14.8.3 利用栈计算数学表达式 311

14.9 集合元素的常用操作 314

14.9.1 元素排序 315

14.9.2 搜索特定元素 316

14.9.3 任意打乱元素顺序 317

14.9.4 其他的简单操作 318

14.10 小结 320

第15章 内部类——Java世界的多面手 321

15.1 非静态内部类 321

15.1.1 语法规则 321

15.1.2 外部类之内创建内部类对象 322

15.1.3 外部类之外创建内部类对象 323

15.1.4 内部类与外部类之间的成员互访 324

15.1.5 内部类与外部类的预定义对象引用this 327

15.2 局部内部类 328

15.2.1 局部内部类的定义及创建 328

15.2.2 局部变量与局部内部类 329

15.2.3 静态方法中的局部内部类 331

15.3 静态内部类 332

15.3.1 语法规则 332

15.3.2 创建静态内部类的对象 332

15.3.3 静态／非静态内部类的区别 333

15.4 匿名内部类 334

15.4.1 基于继承的匿名内部类 334

15.4.2 基于接口实现的匿名内部类 335

15.4.3 匿名内部类的初始化 337

15.4.4 匿名内部类作用的体现 337

15.5 理解内部类 339

15.6 内部接口 340

15.6.1 定义在类中的内部接口 340

15.6.2 定义在接口中的内部接口 341

15.7 小结 342

第16章 多线程——Java中的并发协作 343

16.1 线程的基本知识 343

16.1.1 多线程编程的意义 343

16.1.2 定义自己的线程 344

16.1.3 创建线程对象 345

16.1.4 启动线程 347

16.1.5 同时使用多个线程 348

16.2 线程的状态 350

16.3 线程的调度 351

16.3.1 睡眠 351

16.3.2 线程的优先级 353

16.3.3 线程的让步 355

16.3.4 守护线程 357

16.4 线程的同步 359

16.4.1 同步方法简介 359

16.4.2 简单使用同步方法 360

16.4.3 线程同步调度的方法 362

16.4.4 “生产者—消费者”案例的框架 362

16.4.5 “生产者—消费者”案例的实际运行 365

16.4.6 notify方法的使用 366

16.4.7 同步的语句块 367

16.4.8 线程的死锁 369

16.4.9 防止错误的使用wait、notify、notifyAll方法 371

16.5 获取当前正在运行的线程 372

16.6 volatile关键字的含义与使用 372

16.7 小结 373

第17章 高级线程开发 374

17.1 线程池的使用 374

17.1.1 线程池的基本思想 374

17.1.2 JavaSE 5.0中固定尺寸线程池的基本知识 374

17.1.3 自定义尺寸固定线程池的使用 375

17.1.4 单任务线程池的使用 377

17.1.5 可变尺寸线程池的使用 378

17.1.6 延迟线程池的使用 380

17.1.7 使用自定义参数的线程池 381

17.2 有返回值的线程调用 384

17.2.1 Callable接口简介 384

17.2.2 Future接口简介 384

17.2.3 Callable与Future接口的具体使用 385

17.3 资源的封锁 386

17.3.1 Lock接口与ReentrantLock类简介 386

17.3.2 ReentrantLock锁的具体使用 387

17.3.3 ReadWriteLock接口与ReentrantReadWriteLock类简介 390

17.3.4 ReentrantReadWriteLock读／写锁的具体使用 391

17.4 信号量的使用 393

17.4.1 Semaphore类简介 393

17.4.2 Semaphore类的具体使用 394

17.5 队列 396

17.5.1 Queue接口介绍 396

17.5.2 PriorityQueue类的知识与使用 397

17.5.3 BlockingQueue接口介绍 399

17.6 阻塞的栈操作 401

17.6.1 BlockingDeque接口与LinkedBlockingDeque类简介 401

17.6.2 LinkedBlockingDeque类的具体使用 402

17.7 线程安全的单变量操作 403

17.7.1 atomic包简介 403

17.7.2 atomic包中类的具体使用 404

17.8 障碍器 406

17.8.1 CyclicBarrier类简介 406

17.8.2 CyclicBarrier类的具体使用 407

17.9 小结 408

第18章 内存管理与垃圾收集——自动化的典范 409

18.1 什么是“垃圾” 409

18.1.1 对象成为“垃圾”的条件 409

18.1.2 符合条件的几种情况 409

18.2 垃圾收集器 411

18.2.1 垃圾收集器的基本介绍 411

18.2.2 申请垃圾收集器运行 412

18.3 垃圾收集前的处理工作 413

18.3.1 finalize方法的重写 414

18.3.2 finalize方法的安全问题 415

18.3.3 最终守护者模式 417

18.3.4 再谈非线程“垃圾” 418

18.3.5 再谈线程“垃圾” 419

18.4 3种特殊的引用 420

18.4.1 弱引用 421

18.4.2 软引用 422

18.4.3 幻影引用 424

18.5 小结 424

第四篇 Swing GUI篇 427

第19章 初识Swing 427

19.1 Swing概述 427

19.2 一个简单的Swing程序 428

19.3 Swing的过人之处 429

19.3.1 完全轻量级的控件 430

19.3.2 可插拔的感观风格 430

19.3.3 更多的控件扩展 430

19.4 Swing和AWT的对比 432

19.4.1 Swing与AWT之间的关系 432

19.4.2 Swing与AWT的控件的混用建议 432

19.5 小结 433

第20章 开始创建Swing应用程序 434

20.1 窗体——JFrame类 434

20.1.1 JFrame类简介 434

20.1.2 创建简单窗体 436

20.2 AW/T1.1事件处理模型 438

20.2.1 事件的处理模型简介 438

20.2.2 事件的层次结构 439

20.2.3 窗体事件 440

20.2.4 事件适配器 442

20.3 面板——JPanel类 444

20.3.1 容器的基本知识 444

20.3.2 JPanel类简介 445

20.3.3 JPanel的简单使用 445

20.4 标签——JLabel类 446

20.4.1 JLabel类简介 446

20.4.2 使用JLabel类 448

20.5 按钮——JButton类 449

20.5.1 JButton类简介 449

20.5.2 动作事件 450

20.5.3 监听器与事件源对应关系的研究 451

20.6 小结 454

第21章 布局管理器——界面设计的利器 455

21.1 布局管理器设计思想概述 455

21.2 常用布局管理器简介 455

21.3 流布局 456

21.3.1 流布局简介 456

21.3.2 使用流布局 458

21.4 网格布局 459

21.4.1 网格布局简介 459

21.4.2 使用网格布局 460

21.5 边框布局 462

21.5.1 边框布局简介 462

21.5.2 使用边框布局 464

21.6 空布局 465

21.6.1 空布局简介 465

21.6.2 使用空布局 466

21.7 卡片布局 467

21.7.1 卡片布局简介 467

21.7.2 使用卡片布局 468

21.8 箱式布局 470

21.8.1 箱式布局简介 471

21.8.2 Box容器简介 472

21.8.3 Box容器与BoxLayout布局管理器的使用 473

21.9 弹簧布局 475

21.9.1 弹簧布局的基本思想 475

21.9.2 SpringLayout类简介 478

21.9.3 SpringLayoutConstraints内部类简介 479

21.9.4 Spring类简介 480

21.9.5 弹簧布局的简单使用 480

21.9.6 描述法弹簧布局的具体使用 482

21.10 小结 483

第22章 Swing常用基本控件 484

22.1 控件类概述 484

22.2 文本框与密码框 487

22.2.1 JTextField类简介 487

22.2.2 JPasswordField类简介 488

22.2.3 登录窗口的案例 489

22.3 Swing中的文本区 491

22.3.1 JTextArea类简介 491

22.3.2 JScrollPane类详细介绍 493

22.3.3 文本区与滚动窗口的组合使用 494

22.4 可以记录状态的开关按钮 496

22.4.1 JToggleButton类简介 496

22.4.2 开关按钮的使用 497

22.5 单选按钮与复选框 499

22.5.1 JRadioButton类简介 499

22.5.2 ButtonGroup类简介 500

22.5.3 JCheckBox类简介 500

22.5.4 ItemEvent事件 501

22.5.5 一个关于ItemEvent事件的例子 502

22.5.6 单选按钮与复选框的综合案例 504

22.6 小结 506

第23章 Swing常用高级控件 507

23.1 选项卡的相关知识与使用 507

23.1.1 JTabbedPane类简介 507

23.1.2 ChangeEvent事件 509

23.1.3 JTabbedPane实现选项卡的例子 509

23.2 分割窗格 511

23.2.1 JSplitPane类简介 511

23.2.2 分割窗格的嵌套使用 513

23.3 滑块与进度条 514

23.3.1 JSlider类简介 514

23.3.2 JProgressBar类简介 516

23.3.3 滑块与进度条的使用 518

23.4 格式化文本框 519

23.4.1 JFormattedTextField类简介 520

23.4.2 JFormattedTextField中的格式器 521

23.4.3 格式化文本框的具体使用 523

23.5 编辑器面板 525

23.5.1 JEditorPane类简介 525

23.5.2 HyperlinkEvent事件 527

23.5.3 使用JEditorPane实现简单的浏览器 527

23.6 列表框的知识与使用 529

23.6.1 JList类简介 530

23.6.2 ListSelectionEvent事件 531

23.6.3 控件MVC设计模式简介 532

23.6.4 JList类的使用 533

23.7 下拉列表框 534

23.7.1 JComboBox类简介 534

23.7.2 下拉列表框的具体使用 536

23.8 微调控制器 538

23.8.1 JSpinner类简介 538

23.8.2 微调控制器模型简介 539

23.8.3 微调控制器的具体使用 542

23.9 小结 543

第24章 菜单、工具栏与对话框 544

24.1 Swing中的菜单 544

24.1.1 Swing菜单的基本知识 544

24.1.2 JMenuBar类简介 545

24.1.3 JMenultem类简介 546

24.1.4 JMenu类简介 549

24.1.5 JRadioButtonMenultem类简介 550

24.1.6 JCheckBoxMenultem类简介 551

24.1.7 菜单使用综合案例 551

24.2 Swing中的弹出式菜单 554

24.2.1 JPopupMenu类简介 554

24.2.2 弹出式菜单的显示 555

24.3 鼠标事件 555

24.3.1 鼠标事件简介 555

24.3.2 弹出式菜单的具体使用 557

24.4 工具栏的开发 559

24.4.1 JToolBar类简介 559

24.4.2 工具栏的具体使用 560

24.5 Swing中的对话框 562

24.5.1 JDialog类简介 562

24.5.2 JOptionPane类简介 563

24.5.3 JOptionPane对话框的具体使用 566

24.5.4 文件选择器 568

24.5.5 颜色选择器 571

24.5.6 文件、颜色对话框综合案例 572

24.6 小结 574

第25章 Swing中的树状列表 575

25.1 与树有关的专有名词 575

25.2 JTree类简介 576

25.2.1 JTree类构造器简介 576

25.2.2 JTree类的常用方法说明 577

25.2.3 一个简单JTree的实例 579

25.3 树模型 580

25.3.1 TreeModel接口简介 580

25.3.2 默认树模型DefaultTreeModel类 581

25.4 树的节点 582

25.4.1 TreeNode接口简介 582

25.4.2 MutableTreeNode接口简介 583

25.4.3 DefaultMutableTreeNode类简介 583

25.5 树的路径 586

25.6 树的相关事件 587

25.6.1 TreeSelectionEvent事件 587

25.6.2 TreeExpansionEvent事件 589

25.6.3 TreeModelEvent事件 589

25.7 树节点的绘制 590

25.7.1 TreeCellRenderer接口简介 590

25.7.2 DefaultTreeCellRenderer类简介 590

25.7.3 自定义绘制器案例 592

25.8 树状列表的综合案例 593

25.8.1 案例概述 593

25.8.2 搭建界面 594

25.8.3 添加信息提示功能 595

25.8.4 开发节点增删功能 597

25.8.5 添加图标更改功能 600

25.9 小结 602

第26章 Swing中的表格 603

26.1 初识表格 603

26.2 JTable类 604

26.2.1 JTable类简介 604

26.2.2 使用JTable的简单案例 606

26.3 表格的数据模型 608

26.3.1 TableModel接口简介 608

26.3.2 AbstractTableModel类简介 608

26.3.3 DefaultTableModel类简介 609

26.3.4 使用表格模型的简单案例 611

26.4 表格列 612

26.5 表格列模型 613

26.5.1 TableColumnModel接口简介 614

26.5.2 DefaultTableColumnModel类简介 614

26.6 表格的相关事件 616

26.6.1 表格相关事件简介 616

26.6.2 表格事件的示例程序 618

26.7 表格绘制器与编辑器 620

26.7.1 表格绘制器简介 620

26.7.2 表格编辑器简介 622

26.8 自定义表格编辑器与绘制器的综合案例 624

26.8.1 案例概述 624

26.8.2 界面框架的搭建 624

26.8.3 自定义表格模型的开发以及表格控件的添加 625

26.8.4 自定义绘制器的开发 627

26.8.5 添加自定义编辑器 628

26.9 表格中的排序与过滤 630

26.9.1 RowSorter类简介 631

26.9.2 DefaultRowSorter类简介 631

26.9.3 TableRowSorter类简介 632

26.9.4 RowFilter类简介 633

26.10 表格排序与过滤的综合案例 635

26.10.1 案例概述 635

26.10.2 搭建界面框架 636

26.10.3 添加表格 637

26.10.4 为表格添加排序器 638

26.10.5 添加设置过滤条件的控件 639

26.10.6 为表格设置过滤器 641

26.11 小结 643

第27章 高级Swing开发 644

27.1 Swing线程 644

27.1.1 事件分发线程简介 644

27.1.2 事件分发线程单线程模型带来的问题 644

27.1.3 解决不当使用事件分发线程引发的问题 645

27.2 Robot类的知识与应用 648

27.2.1 Robot类简介 648

27.2.2 利用Robot类实现自动演示功能 649

27.3 Desktop类的知识与应用 652

27.3.1 Desktop类简介 652

27.3.2 使用Desktop的综合案例 654

27.4 Swing应用程序的感观 656

27.4.1 UlManager类简介 657

27.4.2 MetalLookAndFeel类简介 658

27.4.3 动态切换外观风格的案例 658

27.5 系统托盘 661

27.5.1 SystemTray类简介 661

27.5.2 Traylcon类简介 662

27.5.3 使用系统托盘的简单案例 663

27.6 应用程序的监控与管理 665

27.7 小结 666

第五篇 图形图像篇 669

第28章 图形绘制与动画 669

28.1 绘制简单图形 669

28.1.1 画布的相关知识 669

28.1.2 画笔的相关知识 670

28.1.3 颜色的调配 672

28.1.4 图形绘制的简单案例 673

28.2 绘制各种文本 674

28.2.1 drawString方法简介 675

28.2.2 字体的控制 675

28.2.3 文本绘制的简单案例 676

28.3 Java 2D 677

28.3.1 Graphics 2D类简介 677

28.3.2 控制线条的粗细 679

28.3.3 使用颜渐变色 680

28.3.4 图形变换 681

28.3.5 异或模式绘图 683

28.3.6 抗锯齿 685

28.4 动画的开发 685

28.4.1 动画实现的原理 685

28.4.2 Timer类简介 686

28.4.3 简单动画的案例 687

28.5 小结 689

第29章 图像处理 690

29.1 图像的加载与绘制 690

29.1.1 Image类简介 690

29.1.2 绘制Image图像 692

29.2 图标的使用 693

29.2.1 Icon接口简介 694

29.2.2 Imagelcon类简介 695

29.3 图像的编码处理 697

29.3.1 JPEG编码器简介 697

29.3.2 GifEncoder编码器简介 698

29.4 屏幕图像抓取 700

29.4.1 createScreenCapture方法简介 700

29.4.2 抓屏功能的案例 700

29.5 图像滤镜的开发 703

29.5.1 图像的灰度处理的基本知识 703

29.5.2 图像灰度处理的案例 705

29.5.3 RGB色彩通道过滤的基本知识 707

29.5.4 RGB色彩通道过滤的案例 708

29.5.5 卷积滤镜的基本知识 711

29.5.6 卷积滤镜的案例 712

29.6 小结 714

第六篇 高级应用篇 717

第30章 JDBC数据库开发 717

30.1 数据库应用的两种架构模型 717

30.1.1 两层结构数据库应用的架构模型 717

30.1.2 三层结构数据库应用的架构模型 718

30.2 JDBC的层次结构 718

30.3 JDBC编程基础 719

30.3.1 创建数据库 720

30.3.2 JDBC-ODBC连接桥 721

30.3.3 加载JDBC驱动 722

30.3.4 建立数据库连接 723

30.3.5 执行SQL命令 725

30.3.6 结果集 725

30.3.7 连接数据库的简单案例 726

30.3.8 预编译语句 728

30.4 访问其他数据库 730

30.4.1 访问MySQL数据库 730

30.4.2 访问Oracle数据库 732

30.5 事务 733

30.5.1 编写事务 734

30.5.2 批处理 736

30.6 可滚动结果集 738

30.6.1 获得可滚动的结果集 738

30.6.2 可滚动与不可滚动结果集的比较 739

30.6.3 控制游标移动 739

30.7 元数据 742

30.7.1 数据库元数据 742

30.7.2 结果集元数据 744

30.8 数据库综合案例——DBManager 746

30.8.1 案例概述 746

30.8.2 搭建主界面 747

30.8.3 开发输入数据库连接信息的对话框 749

30.8.4 初始化树状列表根节点 751

30.8.5 初始化树状列表表节点 753

30.8.6 初始化树状列表列节点 754

30.8.7 添加显示表数据的功能 756

30.8.8 添加显示列信息的功能 758

30.8.9 自定义树节点图标 759

30.8.10 连接其他类型数据库 761

30.8.11 案例小结 761

30.9 小结 761

第31章 Derby数据库的应用 762

31.1 Derby数据库简介 762

31.1.1 Derby的发展史及特性概述 762

31.1.2 JavaSE 6.0中Derby的目录结构 762

31.2 管理工具ij 763

31.2.1 准备工作 763

31.2.2 简单使用 764

31.3 Derby数据库的嵌入式应用 767

31.3.1 嵌入式Derby的工作原理 767

31.3.2 嵌入式Derby应用的开发步骤 767

31.3.3 使用嵌入式Derby的简单案例 768

31.4 Derby数据库的网络模式应用 770

31.4.1 网络模式Derby的工作原理 771

31.4.2 操作网络模式的Derby 771

31.4.3 开发启动Derby网络服务的程序 772

31.4.4 使用网络模式Derby的简单案例 774

31.5 小结 775

第32章 I/O流 776

32.1 I/O流的基本原理与分类 776

32.1.1 流的概念 776

32.1.2 节点流与处理流 776

32.1.3 字节流与字符流 777

32.2 节点流 780

32.2.1 常用节点流简介 780

32.2.2 使用节点流的简单案例 782

32.3 处理流 783

32.3.1 常用处理流简介 783

32.3.2 使用处理流的简单案例 785

32.4 系统输入输出 786

32.4.1 系统输入流 787

32.4.2 系统输出流 788

32.4.3 格式化输出的简单案例 790

32.4.4 系统错误流 791

32.4.5 系统输入输出重定向 792

32.5 进程控制 793

32.5.1 Process类简介 793

32.5.2 控制进程的简单案例 794

32.6 目录文件管理 795

32.6.1 File类简介 796

32.6.2 使用File的简单案例 797

32.7 I/O流综合案例——数据库图片查看器 798

32.7.1 案例概述 798

32.7.2 主界面与程序框架的搭建 799

32.7.3 添加图片功能的开发 801

32.7.4 查看图片功能的开发 804

32.7.5 删除图片功能的开发 806

32.7.6 案例小结 806

32.8 小结 806

第33章 套接字网络开发 807

33.1 TCP/IP协议简介 807

33.2 网络开发中的常用工具类 808

33.2.1 URL简介 808

33.2.2 URL类简介与使用 809

33.2.3 InetAddress类简介与使用 811

33.3 Socket编程 812

33.3.1 Socket编程简介 813

33.3.2 ServerSocket类简介 813

33.3.3 Socket类简介 814

33.3.4 C/S架构程序的简单案例 815

33.4 小结 817

第34章 反射与注解 818

34.1 反射 818

34.1.1 Class类简介 818

34.1.2 Class类的简单使用 820

34.1.3 数组与Class类 822

34.1.4 精确判断对象类型 823

34.1.5 Field类的知识与使用 824

34.1.6 Method类的知识与使用 826

34.1.7 Constructor类的知识与使用 828

34.1.8 反射与修饰符 830

34.1.9 取消访问限制 833

34.1.10 利用反射动态创建数组对象 835

34.2 程序注解 836

34.2.1 声明自己的注解 837

34.2.2 确定注解的使用目标 837

34.2.3 确定注解的使用时效 838

34.2.4 通过反射提取注解信息 839

34.2.5 标注性注解的使用 840

34.2.6 常用的系统注解 842

34.2.7 利用注解方便开发Web服务 844

34.2.8 注解与代码自动生成 845

34.3 小结 845

第35章 泛型程序设计 846

35.1 泛型简介 846

35.1.1 没有泛型的烦恼 846

35.1.2 泛型技术的好处 846

35.2 简单泛型程序的开发 847

35.2.1 泛型类或接口的声明 847

35.2.2 泛型方法的开发 849

35.2.3 类型变量的限制 850

35.3 泛型参数的继承以及通配符 851

35.3.1 泛型参数的继承问题 852

35.3.2 泛型通配符 852

35.3.3 泛型通配符使用的特殊注意 854

35.3.4 有限制的通配符 855

35.4 泛型的擦除 857

35.4.1 擦除的基本概念与规则 857

35.4.2 擦除引出的约束与局限性 858

35.5 系统提供的泛型类 859

35.6 小结 859

第36章 安全类型枚举 860

36.1 JavaSE 5.0之前的枚举 860

36.1.1 传统枚举实现方式的案例 860

36.1.2 传统实现方式带来的问题 861

36.2 JavaSE 5.0中的安全类型枚举 862

36.2.1 基本语法与简单使用 862

36.2.2 复杂的枚举类型 864

36.2.3 枚举类 866

36.3 小结 867

第37章 嵌入式脚本开发 868

37.1 基本步骤与知识 868

37.1.1 ScriptEngineManager类简介 868

37.1.2 ScriptEngineFactory接口简介 869

37.1.3 ScriptEngine接口简介 870

37.1.4 基本步骤 870

37.1.5 执行外部的脚本文件 871

37.2 其他第三方脚本引擎 872

37.2.1 引擎支持jar包的下载与安装 872

37.2.2 Ruby脚本的简单案例 873

37.2.3 Groovy脚本的简单案例 874

37.3 小结 874