Java语言具有面向对象、与平台无关、安全、稳定和多线程等优良特性，是目前极为强大的编程语言。本书首先采用“从对象开始”的方式引导读者，全面系统地讲述如何利用Java语言解决实际问题，包括Java语言程序设计的基础知识、基本语法、编程技巧、面向对象的特征、控制结构、数据结构、图形界面设计、网络编程、异常处理，及多线程与并发编程，套接字和网络，输入/输出和文件操作等内容，并通过大量示例向读者展示面向对象程序设计理念的精髓。

本书重点关注问题分解和问题设计，并采用分治和逐步求精的原则，对知识点溯本求源，力求给出合理的解释，做到言之有物，绝不含糊其辞。书中提供了丰富的典型示例，具有可操作性，便于读者学习与应用；各章附有大量的习题，便于读者思考和复习。本书的编写注重循序渐进的原则，教师可以根据具体情况适当地选讲高级主题。

适合作为高等院校计算机专业或相关专业的Java程序设计或面向对象程序设计课程的教材，也非常适合专业技术人员参考和阅读。

前    言

　　《Java面向对象程序设计》(第3版)是为计算机科学经典入门课程或以Java作为第二门语言的课程而设计的。这一版保持了前两版“从对象开始”的方法讲述编程和求解问题的特点。贯穿整本书，我们强调尽可能全面细致地覆盖Java语言的特点、基本的编程概念和面向对象设计的原则。

　　第3版保留了前两版的以下特征：

* 以介绍对象开始

* 强调面向对象设计(Object Oriented Design，OOD)

* 统一建模语言(Unified Modeling Language，UML)图示

* 自测题及答案

* 编程、调试及设计技巧

* Java库成员

* “面向对象设计”部分

* 章末练习

* 配套网站提供PowerPoint幻灯片和其他资源

　　前两版的实验部分已经移至本书配套网站。

第3版新增内容

　　第3版有以下显著的变化。

* 尽管本书仍然强调实例，在好几章中仍然可见到前版的例子，然而CyberPet类例子已经被一系列游戏和难题类的例子所取代。不过前两版的CyberPet类例子仍然可以在本书配套网站上找到。

* 我们重新组织了第0章和第1章，并进行了大量的修订。在编排上，新版采用更加循序渐进的方法引入新的概念。新版在编排上放慢了介绍新概念的步伐。关于面向对象(OO)和UML概念的处理也简化了，一些更具有挑战性的OO主题，比如多态性，安排在新增的第8章。

* 第2章引入了新的Java 1.5 Scanner类，用于执行简单的输入操作。

* 第4章单独介绍命令行界面和图形用户界面(GUI)。教师可以选择更符合自己教学风格的界面。命令行界面基于BufferedReader类并且贯穿后面的章节。GUI适用于图形应用或applet。两种方式都能很好地突出用户界面设计的基础。章末用一个可选的部分来使用新的类Scanner，以此介绍文件I/O。

* 继承和多态性的讨论集中安排在第8章。

* 第15章包含近来出现的更高级的Java技术，包括servlet和Java Server Page。

* 第16章重新强调怎样运用数据结构。它更多地使用Java的集合框架，包括LinkedList和Stack类以及List界面。它已经扩展为包括一些高级的数据结构，比如集合、图和二叉查找树。

* (CodeKey和各章练习集成在一起！)CodeKey是一种在线交互的编程教程，用来突出Java的编程概念和技术。在练习编号前的CodeKey图标表示在练习末尾包含CodeKey部分。使用CodeKey，学生能够收到他们所写的代码的自动反馈，并且老师可以很容易地控制作业和学生的进度。在线CodeKey练习能够使学生在交作业前测试程序。教师可以在任何时候轻松地在线跟踪个人和班级的编程尝试和表现。如果必要，CodeKey提供提示来改进和调试代码。学生会收到错误警告和编程提示来改正错误。CodeKey是Morelli和Walde所使用的另一种方式，使编程更容易、有趣和便于管理！

为什么从对象开始

　　第3版仍采用首先引入对象的概念这一方式来讲授Java，以便尽早给初学者一个总体印象，让他们有更多的时间来掌握面向对象编程的原理。随着越来越多的老师开始欣赏从面向对象的角度来讲授，这种讲授方法变得非常流行。

　　面向对象(OO)是一种基于问题求解与设计的观念，而不仅仅是另一个应该归入教材(或课程)中后期的语言细节。如果很晚才介绍OO的概念，非常容易在课程进度紧张时将其   略过。

　　我们第一次在CS1课程中讲授Java时，采用的方法与讲授C和C++时相同，即从基本的语言特性和结构化编程的概念开始，然后在课程中期的某个时候开始介绍面向对象。这种方法是大家都很熟悉的，因为大多数Java与C++教材都使用这种方法。

　　这种方法的一个问题是很多学生都得不到一个总体印象。他们能弄清楚循环、if-else结构和算术表达式，但很难把一个编程问题分解成结构良好的Java程序。另外，这种过程化的方法似乎无法利用Java面向对象的强大功能。如果要像对待C或者Pascal那样对待它，那么为什么还要讲授面向对象的语言呢？

　　这也使我想起Pascal是流行的CS1课程时的相似情况。当时，初学者最大的障碍就是过程抽象，即学习过程调用与参数传递的基本机制，学习如何将程序设计成一系列过程的集合。“Oh！Pascal！”，我们最喜欢的入门书籍采用的就是典型的“从过程开始”的方法。在第1章讲述赋值与I/O结构之后，紧接着就在第2章中讲述过程与参数。然后，第3章开始讲述程序设计与组织方式。直到第4章才陆续开始讲述循环、if-else和其他结构化编程的概念。

　　现在，初学者的主要障碍在于“对象抽象”。初学编程者必须能把程序看成多个相互作用的对象的集合，而且必须学会如何将编程问题分解成多个精心设计的对象。面向对象同时包容来自Pascal时代的过程抽象与结构化编程的概念。“从对象开始”的讲授方式自顶向下清楚地介绍了这3个重要的概念。越早介绍对象和类，学生就越能更好地掌握面向对象的重要原则。

　　Java是一种非常适合介绍面向对象概念的语言。它的对象模型比C++组织得更好。在C++中，很容易忽略OO的特点并把它当成C来对待。在Java中，有很好的机会来激发关于面向对象的讨论。例如，几乎不可能不讨论继承和多态性就讨论基于GUI的applet。这样，教师可以用Java的某些基本特点，如类库、Swing和GUI组件，自然而然地引发这些讨论，而不必另外准备一些使用OO概念的例子。

本书的组织结构

　　本书分为3部分。第Ⅰ部分(第0章～第4章)介绍面向对象的基本概念和Java语言的基本特点；第Ⅱ部分(第5章～第9章)关注其余语言要素，包括数据类型，控制结构，字符串和数组处理，继承和多态性。第Ⅲ部分(第10章～第16章)讲述各种高级的内容，包括异常，文件I/O，递归，GUI，线程和并发编程，套接字和网络，数据结构，servlet和Java Server Pages。

　　前两部分覆盖了一般的CS1入门课程的内容。第Ⅲ部分各章自成体系，如果时间允许，可以加在CS1课程的末尾。

　　第Ⅰ部分(第0章～第4章)介绍面向对象的基本概念，包括对象、类、方法、参数传递、继承和多态性。这几章主要集中引入一个基本概念，即面向对象编程是一组对象间相互交流与合作来解决问题的集合。在介绍Java语言要素时根据需要加强这种概念。学生将从基础出发，学习编写Java程序的基本技能和方法。

　　尽管前几章的程序就控制结构和数据类型而言有一定的局限性，但其侧重于对象的构造，以及它们怎样通过方法调用和参数传递来相互作用。

　　第Ⅱ部分(第5章～第9章)重点关注其余语言要素，包括数据类型和操作符(第5章)、控制结构(第6章)、字符串(第7章)和数组(第9章)。还详细讲述了面向对象的主要机制，即继承和多态性(第8章)。

　　第Ⅲ部分(第10章～第16章)讲述一些高级的内容。教师可根据学生的兴趣选择性地讲解这几章的内容。

　　本书通过一些简单、易懂的例子来讲述这些关键概念。很多概念被用来生成一些游戏例子，这些例子贯穿全书。我们的教学方式聚焦于设计。程序示例是在强调面向对象的原则的基础上发展而来的，而不是以语言的细节开始的。

　　下表是以我们一学期的CS1课程为例的课程表。一学期为13周(加上一周不上课的阅读时间)。在最后两周，我们将根据学生的兴趣和技能水平选择性地介绍高级主题。

一学期的课程安排

周 主题 章 1 面向对象，UML

程序设计和开发 第0章

第1章 2~3 对象和类的定义

方法和参数

选择结构(if-else) 第2章

第3章 4 用户界面和I/O 第4章 5 数据类型和操作符 第5章 6~7 控制结构(循环)

结构化编程 第6章

                                                                       续表

周 主题 章  8 字符串处理(循环) 第7章 9 继承和多态性 第8章 10 数组处理 第9章 11 递归 第12章 12 高级主题(异常) 第10章 13 高级主题(GUI) 第11章 高级主题(线程) 第15章 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　??

　　

　　??

　　

　　??

　　

　　??

　　

VI

Java面向对象程序设计(第3版)

　　

V

　　

　　

　　

　　

　　

　　

　　

　　

　　

目    录

第0章  计算机、对象和Java 1

0.1  欢迎 2

0.2  什么是计算机 2

0.3  网络、Internet和万维网 4

0.4  为什么要学习编程 5

0.5  编程语言 6

0.6  为什么要学习Java 7

0.7  什么是面向对象编程 9

0.7.1  面向对象编程的基本特征：

交互对象 9

0.7.2  什么是对象 9

0.7.3  属性和值 10

0.7.4  操作和消息 10

0.7.5  什么是类 11

0.7.6  变量和方法 12

0.7.7  实例与类变量、类方法 12

0.7.8  类层次结构和类继承 13

0.7.9  面向对象的原则 15

本章小结 16

习题  18

第1章  Java程序设计与开发 21

1.1  概述 22

1.2  设计优秀的程序 22

1.3  设计一个猜谜程序 24

1.3.1  问题分解 24

1.3.2  对象设计 24

1.3.3  数据、方法与算法 26

1.3.4  用Java编写代码 28

1.3.5  语法和语义 28

1.3.6  测试、调试与修改 29

1.3.7  编写易读的程序 30

1.4  Java语言元素 30

1.4.1  注释 31

1.4.2  程序布局 32

1.4.3  关键字和标识符 32

1.4.4  数据类型和变量 33

1.4.5  语句 34

1.4.6  表达式和操作符 36

1.4.7  类定义 37

1.4.8  声明一个实例变量 37

1.4.9  定义实例方法 38

1.4.10  Java应用程序 38

1.4.11  生成和使用对象 39

1.4.12  Java applet 40

1.4.13  Java类库包 40

1.4.14  import语句 41

1.4.15  Java中的限定名称 41

1.5  编辑、编译与运行Java程序 42

1.5.1  Java开发环境 42

1.5.2  编辑程序 43

1.5.3  编译程序 44

1.5.4  运行Java 应用程序 44

1.5.5  运行Java applet 45

1.6  Java库：System和PrintStream 46

本章小结 48

习题  50

第2章  对象的定义、创建和使用 55

2.1  概述 56

2.2  使用String对象 56

2.3  用Graphics对象画图形(选读) 59

2.4  类的定义 63

2.4.1  Riddle类 63

2.4.2  RiddleUser类 65

2.4.3  对象实例化：创建Riddle

实例 66

2.4.4  与Riddle交互 66

2.4.5  定义、创建和使用 67

2.5  案例学习：模拟两人游戏 67

2.5.1  设计OneRowNim类 68

2.5.2  定义OneRowNim类 69

2.5.3  测试OneRowNim类 74

2.5.4  流程控制：方法调用与返回 75

2.5.5  跟踪OneRowNim程序 76

2.5.6  面向对象设计：基本原则 77

2.6  Java库：java.util.Scanner 79

2.6.1  用 Scanner类进行键盘输入 79

2.6.2  使用KeyboardReader类进行

键盘输入 81

本章小结 82

习题  84

第3章  方法：与对象进行通信 89

3.1  概述 90

3.2  给对象传递信息 90

3.2.1  实参和形参 92

3.2.2  传递一个int值给OneRowNim

方法 94

3.2.3  传递键盘输入值给

takeSticks() 95

3.3  构造函数 96

3.3.1  默认构造函数 97

3.3.2  构造函数重载与方法签名 98

3.3.3  构造函数的调用 99

3.4  从对象获取信息 99

3.4.1  调用一个有返回值的方法 100

3.4.2  扩展的OneRowNim类 100

3.5  值传递与引用传递 102

3.6  控制流：控制结构 104

3.6.1  简单的if语句 105

3.6.2  if-else语句 107

3.6.3  嵌套的if-else多路选择结构 108

3.6.4  while结构 110

3.7  测试改进后的OneRowNim类 112

3.8  Java库：java.lang.Object 116

3.9  面向对象设计：继承与多态 117

3.10  画线与定义图形方法(选读) 118

本章小结 120

习题  123

第4章  输入/输出：用户界面设计 129

4.1  概述 130

4.2  用户界面 130

4.3  命令行界面 131

4.3.1  用BufferedReader实现从键盘

输入字符串 132

4.3.2  从键盘输入数字 133

4.3.3  设计一个键盘读取类 134

4.3.4  设计一个命令行界面 136

4.4  图形用户界面 138

4.4.1  Java的GUI组件 139

4.4.2  类继承：超类的扩展 140

4.4.3  顶层窗口 141

4.4.4  输入、输出和控制的

GUI组件 143

4.4.5  在顶层窗口中添加

GUI组件 145

4.4.6  控制GUI的动作 146

4.4.7  ActionListener接口 148

4.4.8  GUI和计算对象之间的

连接 149

4.4.9  在Java应用程序中

使用GUI 151

4.4.10  在Java applet中使用GUI 152

4.5  案例学习：The One-Row Nim

游戏 154

4.5.1  OneRowNim的命令行界面 154

4.5.2  为OneRowNim类设计GUI 157

4.6  Java库：java.io.File和

文件输入(选读) 160

本章小结 164

习题  167

第5章  Java数据与运算符 171

5.1  概述 172

5.2  布尔数据与运算符 173

5.2.1  布尔(或逻辑)运算 173

5.2.2  运算优先级与运算结合性 174

5.2.3  短路计算 175

5.2.4  在OneRowNim中使用

布尔类型 176

5.3  数值数据与运算符 179

5.3.1  数值运算 180

5.3.2  运算符优先级 183

5.3.3  自增与自减运算符 184

5.3.4  赋值运算符 186

5.3.5  关系运算符 186

5.4  Java库：java.lang.Math 188

5.5  数值处理范例 189

5.5.1  范例：保留两位小数 189

5.5.2  范例：转换华氏温度为

摄氏温度 190

5.5.3  范例：使用类常量 194

5.5.4  面向对象设计：信息隐藏 196

5.5.5  范例：One-Row Nim游戏的

必胜算法 197

5.6  Java库：java.text.NumberFormat 200

5.7  字符数据与运算符 202

5.7.1  把字符转换为整数 203

5.7.2  字典顺序 204

5.7.3  关系运算符 205

5.8  范例：字符转换 205

5.9  问题解决=描述+行为 207

本章小结 208

习题  213

第6章  控制结构 219

6.1  概述 220

6.2  流控制：循环结构 220

6.3  可计数循环 221

6.3.1  for结构 222

6.3.2  循环边界 224

6.3.3  无限循环 224

6.3.4  循环缩进 225

6.3.5  嵌套循环 227

6.4  范例：汽车贷款 228

6.5  绘图范例：绘制棋盘 230

6.6  条件循环 234

6.6.1  再谈while结构 235

6.6.2  do-while结构 236

6.7  范例：计算平均数 239

6.8  范例：数据校验 242

6.9  循环设计原则 244

6.10  switch多路选择结构 245

6.11  面向对象设计：结构化编程 248

本章小结 255

习题  261

第7章  字符串和字符串处理 265

7.1  概述 266

7.2  String基本知识 266

7.2.1  构造String 267

7.2.2  字符串连接 269

7.2.3  字符串索引 270

7.2.4  将数据转换为字符串 271

7.3  字符串查找 272

7.4  范例：关键字查找 274

7.5  Java库：java.lang.StringBuffer 275

7.6  检索字符串中的一部分 278

7.7  范例：处理名称和口令 279

7.8  处理字符串中的每个字符 280

7.8.1  差1错误 281

7.8.2  范例：字符计数 281

7.8.3  范例：倒置字符串 282

7.8.4  范例：首字母大写 282

7.8.5  其他String方法 283

7.9  比较字符串 283

7.9.1  对象相同与对象相等的

对比 285

7.9.2  字符串相同与字符串相等的

对比 287

7.10  Java库：java.util.StringTokenizer 289

7.11  处理图形上下文中的文本(选读) 290

7.11.1  Font和FontMetrics类 291

7.11.2  字体规格 292

7.11.3  范例：文本居中 293

本章小结 295

习题  298

第8章  继承与多态 301

8.1  概述 302

8.2  Java的继承机制 302

8.2.1  使用继承方法 303

8.2.2  覆盖继承方法 304

8.2.3  静态绑定、动态绑定以及

多态 305

8.2.4  多态和面向对象设计 306

8.2.5  使用super引用超类 308

8.2.6  继承和构造函数 308

8.3  抽象类、接口以及多态 310

8.3.1  实现一个抽象方法 311

8.3.2  实现一个Java接口 314

8.4  范例：Toggle按钮 315

8.5  范例：Ciper类层次结构 319

8.5.1  类设计：Caesar类 321

8.5.2  算法设计：移位字符 322

8.5.3  类设计：Transpose类 323

8.5.4  测试和调试 324

8.6  案例学习：一个两人游戏的

类层次结构 325

8.6.1  设计目的 325

8.6.2  设计Two Player Game类 325

8.6.3  TwoPlayerGame超类 327

8.6.4  CLUIPlayableGame接口 330

8.6.5  面向对象设计：

接口还是抽象类 332

8.6.6  修改后的OneRowNim类 332

8.6.7  IPlayer接口 335

8.6.8  运行OneRowNim 337

8.6.9  扩展TwoPlayerGame的

层次结构 339

8.7  面向对象设计原则 344

本章小结 345

习题  347

第9章  数组与数组处理 351

9.1  概述 352

9.2  一维数组 352

9.2.1  声明和创建数组 354

9.2.2  数组分配 354

9.2.3  初始化数组 357

9.2.4  数组赋值和使用数组值 358

9.3  简单的数组例子 358

9.4  范例：计算字母频度 361

9.4.1  保存一个字母频度的类 361

9.4.2  计算字母频度的类 362

9.5  数组算法：排序 364

9.5.1  插入排序 364

9.5.2  选择排序 367

9.5.3  算法：交换内存元素 368

9.5.4  值传递和引用传递 368

9.6  数组算法：查找 370

9.6.1  顺序查找 370

9.6.2  折半查找 371

9.7  二维数组 373

9.7.1  二维数组方法 376

9.7.2  把部分数组传递给方法 377

9.8  多维数组(选学) 380

9.9  面向对象设计：多态排序(选学) 381

9.10  Java库：java.lang.Vector 385

9.11  案例学习：N个玩家的

计算机游戏 386

9.11.1  ComputerGame类层次 386

9.11.2  ComputerGame类 387

9.11.3  WordGuess类和

 WordGuesser类 390

9.12  基于GUI的游戏(图形选学) 393

9.12.1  GUIPlayableGame接口 394

9.12.2  SlidingTilePuzzle 395

9.12.3  SlidingGUI类 398

本章小结 400

习题  405

第10章  异常：出现问题的时候 409

10.1  概述 410

10.2  异常情况处理 410

10.2.1  传统的错误处理 410

10.2.2  Java的默认异常处理 411

10.3  Java的异常体系 412

10.3.1  可控式异常和不可控异常 413

10.3.2  Exception类 415

10.4  处理程序中的异常 415

10.4.1  测试、抛出和捕获异常 415

10.4.2  分离错误检查和错误处理 418

10.4.3  try/throw/catch的语法和

 语义 419

10.4.4  对try/catch/finally指令的

 限制 420

10.4.5  动态作用域法和

 静态作用域法 421

10.4.6  异常的传播：寻找一个catch

 区块 422

10.5  错误处理和健壮程序设计 425

10.5.1  打印一条消息并终止 426

10.5.2  记录错误并继续 426

10.5.3  修复错误并继续 426

10.5.4  修复还是不修复 429

10.6  创建并抛出你自己的异常 433

10.7  Java库：javax.swing.JOptionPane 436

本章小结 438

习题  441

第11章  文件与流：输入/输出技术 445

11.1  概述 446

11.2  流和文件 446

11.2.1  数据层次 446

11.2.2  二进制文件和文本文件 448

11.2.3  输入和输出流 448

11.3  案例学习：读/写文本文件 452

11.3.1  文本文件格式 452

11.3.2  写入一个文本文件 453

11.3.3  代码重用：设计文本文件

 输出 455

11.3.4  读取一个文本文件 456

11.3.5  代码重用：设计文本文件

 输入 459

11.3.6  TextIO应用程序 460

11.4  File类 463

11.4.1  名称和路径 463

11.4.2  验证文件名 463

11.5  案例学习：读/写二进制文件 465

11.5.1  写二进制数据 466

11.5.2  读二进制数据 469

11.5.3  BinaryIO应用程序 471

11.5.4  从文件中提取数据 474

11.6  对象序列化：读/写对象 475

11.7  Java库：javax.swing.JFileChooser 479

11.8  在程序中使用文件数据 480

本章小结 483

习题  485

第12章  递归问题求解 489

12.1  概述 490

12.1.1  替代循环功能的递归调用 490

12.1.2  利用递归求解问题 492

12.2  递归的定义 492

12.2.1  阶乘：N! 492

12.2.2  嵌套图案的绘制 493

12.3  递归的字符串方法 495

12.3.1  输出字符串 495

12.3.2  逆序输出字符串 497

12.3.3  字符串中的字符计数 499

12.3.4  转换字符串 501

12.3.5  输出掷N枚硬币时的

 所有可能结果 502

12.4  数组的递归处理 504

12.4.1  利用递归进行顺序查找 504

12.4.2  信息隐藏 506

12.4.3  利用递归实现选择排序 507

12.5  范例：绘制(递归的)分形 509

12.5.1  嵌套正方形 510

12.5.2  Sierpinski垫片 511

12.6  面向对象设计：尾递归 513

12.7  面向对象设计：递归还是迭代 514

12.8  Java库：javax.swing.JComboBox 516

本章小结 521

习题  525

第13章  图形用户界面 529

13.1  概述 530

13.2  Java GUI：从AWT到Swing 530

13.3  Swing组件集 532

13.4  面向对象设计：模型-视图-控制器

 结构 533

13.5  Java事件模型 535

13.6  案例学习：设计基本的GUI 539

13.6.1  米制转换器应用程序 539

13.6.2  内部类和适配器类 543

13.6.3  GUI设计缺点 544

13.6.4  扩展基本GUI：按钮数组 546

13.6.5  GUI设计缺点 550

13.7  容器和布局管理器 551

13.7.1  布局管理器 551

13.7.2  GridLayout管理器 552

13.7.3  GUI设计缺点 553

13.7.4  BorderLayout管理器 553

13.8  复选框、单选按钮和边框 556

13.8.1  复选框和单选按钮数组 557

13.8.2  Swing边框 559

13.8.3  BoxLayout管理器 559

13.8.4  ItemListener接口 560

13.8.5  OrderApplet程序 561

13.9  菜单和滚动条 564

13.9.1  添加菜单栏到应用程序 564

13.9.2  菜单层次 565

13.9.3  处理菜单行为 566

13.9.4  添加滚动条到文本区 568

本章小结 572

习题  575

第14章  线程和并发编程 577

14.1  概述 578

14.2  什么是线程 578

14.2.1  线程的并发执行 579

14.2.2  多线程编号 580

14.3  Java库：java.lang.Thread 582

14.3.1  线程控制 584

14.3.2  线程优先级 584

14.3.3  强制线程睡眠 585

14.3.4  多线程的异步特征 586

14.4  线程状态与生命周期 587

14.5  运用线程改善界面的响应性能 588

14.5.1  单线程设计 588

14.5.2  多线程绘图：Dotty线程 592

14.5.3  多线程设计的优越之处 595

14.6  案例学习：协作线程 596

14.6.1  问题描述 596

14.6.2  设计：TakeANumber类 597

14.6.3  Java监视器和互斥 598

14.6.4  Customer类 599

14.6.5  Clerk类 600

14.6.6  Bakery类 601

14.6.7  问题：临界区 603

14.6.8  运用wait/notify

 来协调线程 606

14.7  案例学习：Pong游戏 609

14.7.1  多线程设计 609

14.7.2  Pong程序的实现 611

14.7.3  KeyListener接口 613

14.7.4  弹球动画 615

本章小结 616

习题  618

第15章  套接字和网络 621

15.1  概述 622

15.2  网络概述 622

15.2.1  网络的规模和拓扑结构 622

15.2.2  互联网络 623

15.2.3  网络协议 624

15.2.4  客户端/服务器应用程序 625

15.2.5  较低层的网络协议 626

15.2.6  java.net包 627

15.3  在applet中使用网络资源 628

15.4  Java库：java.net.URL 629

15.5  放映幻灯片的applet 630

15.5.1  SlideShowApplet类 632

15.5.2  Timer类 634

15.6  在应用程序中使用网络资源 635

15.6.1  从Web上下载文本文件 635

15.6.2  代码重用 644

15.7  通过socket进行客户端/服务器

 通信 644

15.7.1  服务器协议 645

15.7.2  客户端协议 646

15.7.3  双向流通信 647

15.8  案例学习：通用客户端/服务器类 648

15.8.1  面向对象设计 649

15.8.2  EchoServer类 651

15.8.3  EchoClient类 654

15.9  开发网络版One-Row Nim游戏 658

15.9.1  NimServer类 661

15.9.2  NimClient类 663

15.9.3  测试Nim服务 664

15.10  Java网络安全约束 664

15.11  Java Servlet和Java Server Page

? (JSP) 665

15.11.1  Java Server Pages 666

15.11.2  Java servlet 667

15.11.3  一个简单的servlet程序 668

15.11.4  Nim servlet 669

15.11.5  设置并使用Java Servlets 673

本章小结 673

习题  675

第16章  数据结构：列表、栈和队列 677

16.1  概述 678

16.2  链表数据结构 678

16.2.1  使用引用来链接对象 678

16.2.2  范例：动态电话链表 680

16.2.3  操作电话列表 682

16.3 面向对象设计：链表 ADT 689

16.4  栈ADT 695

16.4.1  Stack 类 696

16.4.2  测试Stack类 697

16.5  队列ADT 698

16.6  Java库：Java集合框架和泛型 701

16.6.1  Java中的泛型 701

16.6.2  List<E>接口和

 LinkedList<E>类 703

16.7  使用Set和Map接口 705

16.7.1  使用Set接口 705

16.7.2  使用接口Map<K,V> 707

16.8  二叉查找树数据结构 708

本章小结 710

习题  714

附录A  编码约定 717

附录B  Java开发工具包 724

附录C  ASCII码和Unicode字符集 732

附录D  Java关键字 733

附录E  运算符的优先级结构 734

附录F  Java内部类 735

附录G  自动装箱和枚举 740

附录H  Java和UML资源 744

　　

　　??

　　

　　??

　　

　　??

　　

　　??

　　

VIII

Java面向对象程序设计(第3版)

　　

XIII