<b>thinking in java</b>[Java编程]

写在前面的话

引言:

第1章 对象入门
1.1 抽象的进步
1.2 对象的接口
1.3 实现筹划的躲藏
1.4 筹划的反复利用
1.5 担当:重新利用接口
1.5.1 改进底子类:
固然extends关键字表示着我们要为接口“扩大”新功效,但实情并非必定如此.为辨别我们的新类,第二个办法是改变底子类一个现有函数的行为.我们将其称作“改进”那个函数.
为改进一个函数,只需为衍生类的函数成立一个新定义便可.我们的目标是:“固然利用的函数接口未变,但它的新版本具有差别的表现”.
1.5.2 等价和近似关系
1.6 多形对象的交换利用
1.6.1 动态绑定
1.6.2 抽象的底子类和接口
1.7 对象的成立和存在时间
1.7.1 调集与担当器
1.7.2 单根构造
1.7.3 调集库与便利利用调集
1.7.4 排除时的窘境:由谁负责排除?
1.8 违例掌握:办理错误
1.9 多线程
1.10 永久性
1.11 Java和因特网:
既然Java不过另一种范例的程序计划语言,大家大概会奇特它为什么值得如此器重,为什么还有这么多的人认为它是计算机程序计划的一个里程碑呢?假如您来自一个传统的程序计划后台,那么答案在刚开始的时刻并非很明显.Java除了可办理传统的程序计划问题以外,还能办理World Wide Web（万维网）上的编程问题.
1.11.1 什么是Web?
1.11.2 客户端编程
1.11.3 服务器端编程
1.11.4 一个独立的范畴:利用程序
1.12 解析和计划
1.12.1 不要丢失:
在整个开辟历程中,最重要的事情就是:不要将自己丢失!但事实上这种事情很简单发生.大大都办法都计划用来办理最大范围内的问题.当然,也存在一些分外艰难的项目,需求作者付出更为艰苦的勤奋,大概付出更大的代价.但是,大大都项目都是对比“通例”的,所以普通都能作出成功的解析与计划,并且只需用到举荐的一小部份办法.但无论多么有限,某些情势的处理老是有益的,这可以使整个项目的开辟越发简单,总比直接了当开始编码好!
也就是说,假定你正在观察一种特别的办法,此中包含了大量细节,并举荐了很多步骤和文档,那么仍旧很难精确判断自己该在什么时刻终止.时刻提醒自己注意以下几个问题:
(1) 对象是什么?（怎样将自己的项目分割成一系列单独的组件?）
(2) 它们的接口是什么?（需求将什么消息发给每一个对象?）
在肯定了对象和它们的接口后,便可着手编写一个程序.出于对多方面缘由的考虑,大概还需求比这更多的阐明及文档,但要求掌握的资料绝对不能比这还少.
整个历程可划分为四个阶段,阶段0方才开始采取某些情势的构造.
1.12.2 阶段0:拟出一个筹划:

1.12.3 阶段1:要制作什么?:

1.12.4 阶段2:若何构建?
1.12.5 阶段3:正式成立
1.12.6 阶段4:校正
1.12.7 筹划的回报
1.13 Java还是C++?

第2章 一切都是对象
“固然以C++为底子,但Java是一种更纯粹的面向对象程序计划语言”.
无论C++还是Java都属于杂合语言.但在Java中,计划者认为这种杂归并不象在C++里那么重要.杂合语言答应采取多种编程气势;之所以说C++是一种杂合语言,是因为它支持与C语言的向后兼容本领.由于C++是C的一个超集,所以包含的很多特点都是后者不具有的,这些特点使C++在某些地方显得过于复杂.
Java语言首先便假定了我们只但愿举行面向对象的程序计划.也就是说,正式用它计划之前,必须先将自己的思惟转入一个面向对象的世界（除非早已习惯了这个世界的思维方法）.只有做好这个预备工作,与其他OOP语言相比,才能领会到Java的易学易用.在本章,我们将探究Java程序的基本组件,并领会为什么说Java乃至Java程序内的一切都是对象.
2.1 用句柄操作对象
2.2 必须成立全部对象:
成立句柄时,我们但愿它同一个新对象衔接.普通用new关键字到达这一目的.new的意思是:“把我变成这些对象的一种新范例”.所以在上面的例子中,可以说:
String s = new String("asdf");
它不但指出“将我变成一个新字串”,也通过供应一个初始字串,指出了“若何生成这个新字串”.
当然,字串（String）并非唯一的范例.Java配套供应了数目众多的现成范例.对我们来说,最重要的就是记着能自行成立范例.事实上,这应是Java程序计划的一项基本操作,是持续本书后余部份学习的底子.
2.2.1 保存在什么地方
2.2.2 特别情形:主范例
2.2.3 Java中的数组
2.3 绝对不要排除对象:在大大都程序计划语言中,变量的“存在时间”（Lifetime）一向是程序员需求侧重考虑的问题.变量应持续多长的时间?假如想排除它,那么什么时刻举行?在变量存在时间上胶葛不清会造成大量的程序错误.在下面的小节里,将阐示Java若何帮忙我们完成全部排除工作,从而极大了简化了这个问题.

2.3.1 作用域
2.3.2 对象的作用域
2.4 新建数据范例:类
2.4.1 字段和办法
2.5 办法、自变量和返回值
2.5.1 自变量列表
2.6 构建Java程序:正式构建自己的第一个Java程序前,还有几个问题需求注意.
2.6.1 名字的可见性
2.6.2 利用其他组件
2.6.3 static关键字
2.7 我们的第一个Java程序
2.8 注释和嵌入文档
2.8.1 注释文档
2.8.2 具体语法
2.8.3 嵌入HTML
2.8.4 @see:引用其他类
2.8.5 类文档标志
2.8.6 变量文档标志:变量文档只能包含嵌入的HTML以及@see引用.
2.8.7 办法文档标志
2.8.8 文档示例:
下面还是我们的第一个Java程序,只不过已加入了完好的文档注释:

92页程序

第一行:
//: Property.java
采取了我自己的办法:将一个“:”作为特别的暗号,指出这是包含了源文件名字的一个注释行.最后一行也用这样的一条注释末尾,它标志着源代码清单的完毕.这样一来,可将代码从本书的正文中便利地提取出来,并用一个编译器查抄.这方面的细节在第17章报告.
2.9 编码款式
2.10 总结:
通过本章的学习,大家已接触了充足多的Java编程知识,已知道若何自行编写一个简单的程序.此外,对语言的总体情形以及一些基本思惟也有了一定程度的熟习.但是,本章全部例子的情势都是单线情势的“这样做,再那样做,然后再做另一些事情”.假如想让程序作出一项挑选,又该若何计划呢?比方,“假定这样做的后果是红色,就那样做;假如不是,就做另一些事情”.关于这种基本的编程办法,下一章会具体阐明在Java里是若何实现的.
2.11 操练:
(1) 参照本章的第一个例子,成立一个“Hello,World”程序,在屏幕上简单地显示这句话.注意在自己的类里只需一个办法（“main”办法会在程序启动时履行）.记着要把它设为static情势,并置入自变量列表——即便根本不会用到这个列表.用javac编译这个程序,再用java运行它.
(2) 写一个程序,打印出从号令行获得的三个自变量.
(3) 找出Property.java第二个版本的代码,这是一个简单的注释文档示例.请对文件履行javadoc,并在自己的Web浏览器里傍观后果.
(4) 以操练(1)的程序为底子,向此中加入注释文档.操纵javadoc,将这个注释文档提取为一个HTML文件,并用Web浏览器傍观.

第3章 掌握程序流程:
“就象任何有感知的生物一样,程序必须能操作自己的世界,在履行历程中作出判断与挑选.”

在Java里,我们操纵运算符操作对象和数据,并用履行掌握语句作出挑选.Java是成立在C++底子上的,所以对C和C++程序员来说,对Java这方面的大大都语句和运算符都应是非常熟习的.当然,Java也举行了自己的一些改良与简化工作.
3.1 利用Java运算符
3.1.1 优先级
3.1.2 赋值
3.1.3 算术运算符
3.1.4 自动递增和递减
3.1.5 关系运算符
3.1.6 逻辑运算符
3.1.7 按位运算符
3.1.8 移位运算符
3.1.9 三元if-else运算符
3.1.10 逗号运算符:
在C和C++里,逗号不但作为函数自变量列表的脱离符利用,也作为举行后续计算的一个运算符利用.在Java里需求用到逗号的唯一场所就是for循环,本章稍后会对此详加注释.
3.1.11 字串运算符+
3.1.12 运算符通例操作法则
3.1.13 造型运算符
3.1.14 Java没有“sizeof”
3.1.15 复习计算次序
3.1.16 运算符总结
3.2 履行掌握:
Java利用了C的全部掌握语句,所以假期您从前用C或C++编程,此中大大都都应是非常熟习的.大大都程序化的编程语言都供应了某种情势的掌握语句,这在语言间普通是共通的.在Java里,触及的关键字包含if-else、while、do-while、for以及一个名为switch的挑选语句.但是,Java并不支持非常有害的goto（它还是办理某些特别问题的权宜之计）.仍旧可以举行象goto那样的跳转,但比典型的goto要范围多了.
3.2.1 真和假:
全部条件语句都操纵条件表达式的真或假来决意履行流程.条件表达式的一个例子是A==B.它用条件运算符“==”来判断A值能否等于B值.该表达式返回true或false.本章早些时刻接触到的全部关系运算符都可拿来构造一个条件语句.注意Java不答应我们将一个数字作为布尔值利用,即便它在C和C++里是答应的（真是非零,而假是零）.若想在一次布尔测试中利用一个非布尔值——比方在if(a)里,那么首先必须用一个条件表达式将其转换成一个布尔值,比方if(a!=0).
3.2.2 if-else
3.2.3 反复
3.2.4 do-while
3.2.5 for
3.2.6 中止和持续
3.2.7 切换
3.3 总结:
本章总结了大大都程序计划语言都具有的基本特点:计算、运算符优先次序、范例转换以及挑选和循环等等.目前,我们作好了呼应的预备,可持续向面向对象的程序计划范畴迈进.在下一章里,我们将谈论对象的初始化与排除问题,再背面则报告躲藏的基本实现办法.
3.4 操练:
(1) 写一个程序,打印出1到100间的整数.
(2) 改正操练(1),在值为47时用一个break退出程序.亦可换成return试试.
(3) 成立一个switch语句,为每一种case都显示一条消息.并将switch置入一个for循环里,令其尝试每一种case.在每个case背面都安排一个break,并对其举行测试.然后,删除break,看看会有什么情形呈现.

第4章 初始化和排除:
“随着计算机的进步,‘不安全’的程序计划已成为造成编程代价昂扬的罪魁祸首之一.”

“初始化”和“排除”是这些安全问题的此中两个.很多C程序的错误都是由于程序员忘掉初始化一个变量造成的.关于现成的库,若用户不知道若何初始化库的一个组件,就常常会呈现这一类的错误.排除是另一个特别的问题,因为用完一个元素后,由于不再关心,所以很简单把它忘掉.这样一来,那个元素占用的资源会一向保存下去,极易产生资源（主如果内存）用尽的后果.
C++为我们引入了“构建器”的概念.这是一种特别的办法,在一个对象成立之后自动调用.Java也相沿了这个概念,但新增了自己的“垃圾汇集器”,能在资源不再需求的时刻自动释放它们.本章将谈论初始化和排除的问题,以及Java若何供应它们的支持.
4.1 由构建器保证初始化
4.2 办法过载
4.2.1 辨别过载办法
4.2.2 主范例的过载
4.2.3 返回值过载
4.2.4 默许构建器
4.2.5 this关键字
4.3 排除:收尾和垃圾汇集
4.3.1 finalize()用处安在
4.3.2 必须履行排除
4.4 成员初始化
4.4.1 规定初始化
4.4.2 构建器初始化
4.5 数组初始化
4.5.1 多维数组
4.6 总结
4.7 操练:
(1) 用默许构建器成立一个类（没有自变量）,用它打印一条消息.成立属于这个类的一个对象.
(2) 在操练1的底子上增添一个过载的构建器,令其采取一个String自变量,并伴随自己的消息打印出来.
(3) 以操练2成立的类为底子上,成立属于它的对象句柄的一个数组,但不要实际成立对象并分配到数组里.运路程序时,注意能否打印出来自构建器调用的初始化消息.
(4) 成立同句柄数组接洽起来的对象,终究完成操练3.
(5) 用自变量“before”,“after”和“none”运路程序,试验Garbage.java.反复这个操作,察看能否从输出中看出了一些固定的情势.改变代码,使System.runFinalization()在System.gc()之前调用,再察看后果.

第5章 躲藏实施历程
5.1 包:库单元
5.1.1 成立举世无双的包名
5.1.2 自定义工具库
5.1.3 操纵导入改变行为
5.1.4 包的停用:
大家应注意这样一个问题:每次成立一个包后,都在为包取名时间接地指定了一个目录构造.这个包必须存在（驻留）于由它的名字规定的目录内.并且这个目录必须能从CLASSPATH开始搜索并发现.最开始的时刻,package关键字的应用大概会令人迷惑,因为除非保持服从按照目录途径指定包名的法则,不然就会在运行期得到大量莫名其妙的消息,指出找不到一个特定的类——即便那个类明显就在相同的目录中.若得到象这样的一条消息,请试着将package语句作为注释标志出去.假如这样做行得通,便可知道问题到底出在哪儿.
5.2 Java拜候指导符:

5.2.1 “友好的”
5.2.2 public:接口拜候
5.2.3 private:不能接触
5.2.4 protected:“友好的一种”
5.3 接口与实现
5.4 类拜候
5.5 总结
5.6 操练

第6章 类再生
6.1 合成的语法
6.2 担当的语法
6.2.1 初始化底子类
6.3 合成与担当的结合
6.3.1 确保精确的排除
6.3.2 名字的躲藏
6.4 到底挑选合成还是担当
6.5 protected
6.6 递增开辟
6.7 上溯造型
6.7.1 何谓“上溯造型”?
6.8 final关键字:
由于语境（利用环境）差别,final关键字的含义大概会略微产生一些差别.但它最普通的意思就是声明“这个东西不能改变”.之所以要禁止改变,大概是考虑到两方面的因素:计划或效率.由于这两个缘由颇有些辨别,所以大概会造成final关键字的误用.
在接下去的小节里,我们将谈论final关键字的三种利用场所:数据、办法以及类.

6.8.1 final数据
6.8.2 final办法
6.8.3 final类
6.8.4 final的注意事项
6.9 初始化和类装载
6.9.1 担当初始化
6.10 总结
6.11 操练:
(1) 用默许构建器（空自变量列表）成立两个类:A和B,令它们自己声明自己.从A担当一个名为C的新类,并在C内成立一个成员B.不要为C成立一个构建器.成立类C的一个对象,并察看后果.
(2) 改正操练1,使A和B都有含有自变量的构建器,则不是采取默许构建器.为C写一个构建器,并在C的构建器中履行全部初始化工作.
(3) 利用文件Cartoon.java,将Cartoon类的构建器代码变成注释内容标注出去.注释会发生什么事情.
(4) 利用文件Chess.java,将Chess类的构建器代码作为注释标注出去.一样注释会发生什么.

第7章 多形性
7.1 上溯造型
7.1.1 为什么要上溯造型
7.2 深化理解:
关于Music.java的艰难性,可通过运路程序加以领会.输出是Wind.play().这当然是我们但愿的输出,但它看起来仿佛并不肯按我们的但愿行事.请察看一下tune()办法:

public static void tune(Instrument i) {
// ...
i.play(Note.middleC);
}

它接纳Instrument句柄.所以在这种情形下,编译器怎样才能知道Instrument句柄指向的是一个Wind,而不是一个Brass或Stringed呢?编译器无从得知.为了深化了理解这个问题,我们有必要探究一下“绑定”这个主题.
7.2.1 办法调用的绑定
7.2.2 产生精确的行为
7.2.3 扩大性
7.3 覆盖与过载
7.4 抽象类和办法
7.5 接口
7.5.1 Java的“多重担当”
7.5.2 通过担当扩大接口
7.5.3 常数分组
7.5.4 初始化接口中的字段
7.6 内部类
7.6.1 内部类和上溯造型
7.6.2 办法和作用域中的内部类
7.6.3 链接到外部类
7.6.4 static内部类
7.6.5 引用外部类对象
7.6.6 从内部类担当
7.6.7 内部类可以覆盖吗?
7.6.8 内部类标识符
7.6.9 为什么要用内部类:掌握框架
7.7 构建器和多形性:
同平常一样,构建器与其他种类的办法是有辨别的.在触及到多形性的问题后,这种办法仍然成立.固然构建器并不具有多形性（即便可以利用一种“虚拟构建器”——将在第11章介绍）,但仍旧非常有必要理解构建器如安在复杂的分级构造中以及伴随多形性利用.这一理解将有助于大家避免陷入一些令人不快的纠葛.
7.7.1 构建器的调用次序
7.7.2 担当和finalize()
7.7.3 构建器内部的多形性办法的行为
7.8 通过担当举行计划
7.8.1 纯担当与扩大
7.8.2 下溯造型与运行期范例标识
7.9 总结
7.10 操练:
(1) 成立Rodent（啮齿动物）:Mouse（老鼠）,Gerbil（鼹鼠）,Hamster（大颊鼠）等的一个担当分级构造.在底子类中,供应实用于全部Rodent的办法,并在衍生类中覆盖它们,从而按照差别范例的Rodent采纳差别的行动.成立一个Rodent数组,在此中填充差别范例的Rodent,然后调用自己的底子类办法,看看会有什么情形发生.
(2) 改正操练1,使Rodent成为一个接口.
(3) 改正WindError.java中的问题.
(4) 在GreenhouseControls.java中,增添Event内部类,使其能翻开和关闭电扇.

第8章 对象的包容
8.1 数组
8.1.1 数组和第一类对象
8.1.2 数组的返回
8.2 调集
8.2.1 缺陷:范例未知
8.3 列举器（反复器）
8.4 调集的范例:
尺度Java 1.0和1.1库配套供应了非常少的一系列调集类.但关于自己的大大都编程要求,它们基本上都能胜任.正如大家到本章末尾会看到的,Java 1.2供应的是一套重新计划过的大型调集库.
8.4.1 Vector
8.4.2 BitSet
8.4.3 Stack
8.4.4 Hashtable
8.4.5 再论列举器
8.5 排序
8.6 通用调集库
8.7 新调集
8.7.1 利用Collections
8.7.2 利用Lists
8.7.3 利用Sets
8.7.4 利用Maps
8.7.5 决意实施筹划
8.7.6 未支持的操作
8.7.7 排序和搜索
8.7.8 实用工具
8.8 总结
8.9 操练

第9章 违例不对掌握
9.1 基本违例
9.1.1 违例自变量
9.2 违例的捕捉:
若某个办法产生一个违例,必须保证该违例能被捕捉,并得到精确对待.关于Java的违例掌握机制,它的一个好处就是答应我们在一个地方将精神集合在要办理的问题上,然后在另一个地方对待来自那个代码内部的错误.
为理解违例是若何捕捉的,首先必须掌握“鉴戒区”的概念.它代表一个特别的代码区域,有大概产生违例,并在背面跟随用于掌握那些违例的代码.
9.2.1 try块
9.2.2 违例掌握器
9.2.3 违例标准
9.2.4 捕捉全部违例
9.2.5 重新“掷”出违例
9.3 尺度Java违例
9.3.1 RuntimeException的特别情形
9.4 成立自己的违例
9.5 违例的限制
9.6 用finally排除
9.6.1 用finally做什么
9.6.2 缺陷:丧失的违例
9.7 构建器
9.8 违例匹配
9.8.1 违例原则
9.9 总结:
通过先进的错误改正与恢复机制,我们可以有效地加强代码的结实程度.对我们编写的每个程序来说,错误恢复都属于一个基本的考虑目标.它在Java中显得尤为重要,因为该语言的一个目标就是成立差别的程序组件,以便其他用户（客户程序员）利用.为构建一套结实的系统,每个组件都必须非常结实.
在Java里,违例掌握的目的是利用尽大概精简的代码成立大型、坚固的利用程序,同时解除程序里那些不能掌握的错误.
违例的概念很难掌握.但只有很好地应用它,才可以使自己的项目当即得到明显的收益.Java逼迫服从违例全部方面的问题,所以无论库计划者还是客户程序员,都可以持续一致地利用它.
9.10 操练:
(1) 用main()成立一个类,令其掷出try块内的Exception类的一个对象.为Exception的构建器赋予一个字串参数.在catch从句内捕捉违例,并打印出字串参数.增添一个finally从句,并打印一条消息,证明自己真正到达那边.
(2) 用extends关键字成立自己的违例类.为这个类写一个构建器,令其采取String参数,并伴随String句柄把它保存到对象内.写一个办法,令其打印出保存下来的String.成立一个try-catch从句,操练实际操作新违例.
(3) 写一个类,并令一个办法掷出在操练2中成立的范例的一个违例.试着在没有违例标准的前提下编译它,察看编译器会报告什么.接着增添得当的违例标准.在一个try-catch从句中尝试自己的类以及它的违例.
(4) 在第5章,找到调用了Assert.java的两个程序,并改正它们,令其掷出自己的违例范例,而不是打印到System.err.该违例应是扩大了RuntimeException的一个内部类.

第10章 Java IO系统
10.1 输入和输出
10.1.1 InputStream的范例
10.1.2 OutputStream的范例
10.2 增添属性和有效的接口
10.2.1 通过FilterInputStream从InputStream里读入数据
10.2.2 通过FilterOutputStream向OutputStream里写入数据
10.3 本身的缺陷:RandomAccessFile
10.4 File类:
File类有一个拐骗性的名字——普通会认为它对付的是一个文件,但实情并非如此.它既代表一个特定文件的名字,也代表目录内一系列文件的名字.若代表一个文件集,便可用list()办法查询这个集,返回的是一个字串数组.之所以要返回一个数组,而非某个机动的调集类,是因为元素的数目是固定的.并且若想得到一个差别的目录列表,只需成立一个差别的File对象便可.事实上,“FilePath”（文件途径）仿佛是一个更好的名字.本节将向大家完好地例示若何利用这个类,此中包含相关的FilenameFilter（文件名过滤器）接口.
10.4.1 目录列表器
10.4.2 查抄与成立目录
10.5 IO流的典型利用
10.5.1 输入流
10.5.2 输出流
10.5.3 快速文件处理

10.5.4 从尺度输入中读取数据
10.5.5 管道数据流:
本章已扼要介绍了PipedInputStream（管道输入流）和PipedOutputStream（管道输出流）.固然描写不非常具体,但并非说它们作用不大.但是,只有在掌握了多线程处理的概念后,才可真正领会它们的代价所在.缘由很简单,因为管道化的数据流就是用于线程之间的通信.这方面的问题将在第14章用一个示例阐明.

10.6 StreamTokenizer
10.6.1 StringTokenizer
10.7 Java 1.1的IO流
10.7.1 数据的发动与接纳
10.7.2 改正数据流的行为
10.7.3 未改变的类:
明显,Java库的计划人员认为从前的一些类毫无问题,所以没有对它们作任何改正,可象从前那样持续利用它们:

没有对应Java 1.1类的Java 1.0类

DataOutputStream
File
RandomAccessFile
SequenceInputStream

分外未加窜改的是DataOutputStream,所认为了用一种可转移的格局保存和获得数据,必须相沿InputStream和OutputStream层次构造.
10.7.4 一个例子
10.7.5 重定向尺度IO
10.8 压缩
10.8.1 用GZIP举行简单压缩
10.8.2 用Zip举行多文件保存
10.8.3 Java归档（jar）实用程序
10.9 对象串通
10.9.1 探求类
10.9.2 序列化的掌握
10.9.3 操纵“长期性”
10.10 总结
10.11 操练

第11章 运行期范例断定:
运行期范例断定（RTTI）的概念初看非常简单——手上只有底子范例的一个句柄时,操纵它判断一个对象的精确范例.
但是,对RTTI的需求表暴露了面向对象计划很多风趣（并且常常是令人困惑的）的问题,并把程序的构造问题正式摆上了桌面.
本章将谈论若何操纵Java在运行期间查找对象和类信息.这主要采纳两种情势:一种是“传统”RTTI,它假定我们已在编译和运行期拥有全部范例;另一种是Java1.1特有的“反射”机制,操纵它可在运行期独立查找类信息.首先谈论“传统”的RTTI,再谈论反射问题.
11.1 对RTTI的需求
11.1.1 Class对象
11.1.2 造型前的查抄
11.2 RTTI语法
11.3 反射:运行期类信息
11.3.1 一个类办法提取器
11.4 总结
11.5 操练:
(1) 写一个办法,向它传送一个对象,循环打印出对象层次构造中的全部类.
(2) 在ToyTest.java中,将Toy的默许构建器标志成注释信息,注释随之发生的事情.
(3) 新建一种范例的调集,令其利用一个Vector.捕捉置入此中的第一个对象的范例,然后从当时起只答应用户插入那种范例的对象.
(4) 写一个程序,判断一个Char数组属于基本数据范例,还是一个真正的对象.
(5) 按照本章的阐明,实现clearSpitValve().
(6) 实现本章介绍的rotate(Shape)办法,令其查抄能否已经旋转了一个圆（若已旋转,就不再履行旋转操作）.

第12章 传送和返回对象
12.1 传送句柄
12.1.1 别名问题
12.2 制作本地副本
12.2.1 按值传送
12.2.2 克隆对象
12.2.3 使类具有克隆本领
12.2.4 成功的克隆
12.2.5 Object.clone()的效果
12.2.6 克隆合成对象
12.2.7 用Vector举行深层复制
12.2.8 通过序列化举行深层复制
12.2.9 使克隆具有更大的深度
12.2.10 为什么有这个奇特的计划
12.3 克隆的掌握
12.3.1 副本构建器
12.4 只读类
12.4.1 成立只读类
12.4.2 “一成不变”的弊端
12.4.3 不变字串
12.4.4 String和StringBuffer类
12.4.5 字串的特别性:
目前,大家已知道String类并非仅仅是Java供应的另一个类.String里含有大量特别的类.通过编译器和特别的覆盖或过载运算符+和+=,可将引号字符串转换成一个String.在本章中,大家已见识了剩下的一种特别情形:用同志StringBuffer尽心构造的“不可变”本领,以及编译器中呈现的一些风趣现象.
12.5 总结
12.6 操练

第13章 成立窗口和程序片
13.1 为什么要用AWT?
13.2 基本程序片
13.2.1 程序片的测试
13.2.2 一个更图形化的例子
13.2.3 框架办法的演示
13.3 制作按钮
13.4 捕捉事件
13.5 文本字段
13.6 文本区域
13.7 标签
13.8 复选框
13.9 单选钮
13.10 下拉列表
13.11 列表框
13.11.1 handleEvent()
13.12 筹划的掌握
13.12.1 FlowLayout
13.12.2 BorderLayout
13.12.3 GridLayout
13.12.4 CardLayout
13.12.5 GridBagLayout
13.13 action的替用品
13.14 程序片的范围
13.14.1 程序片的长处
13.15 视窗化利用
13.15.1 菜单
13.15.2 对话框
13.16 新型AWT
13.16.1 新的事件模子
13.16.2 事件和接纳者范例
13.16.3 用Java 1.1 AWT制作窗口和程序片
13.16.4 再探早期示例
13.16.5 动态绑定事件
13.16.6 将商业逻辑与UI逻辑区脱离
13.16.7 举荐编码办法
13.17 Java 1.1 UI API:
Java 1.1版一样增添了一些重要的新功效,包含核心遍历,桌面色彩拜候,打印“沙箱内”赶早期的剪贴板支持.
核心遍历非常的简单,因为它明显存在于AWT库里的组件并且我们没必要为使它工作而去做任何事.假如我们制造我们自己组件并且想使它们去处理核心遍历,我们过载isFocusTraversable()以使它返回真值.假如我们想在一个鼠标单击上捕捉键盘核心,我们可以捕捉鼠标按下事件并且调用requestFocus()需求核心办法.

13.17.1 桌面颜色
13.17.2 打印
13.17.3 剪贴板
13.18 可视编程和Beans
13.18.1 什么是Bean
13.18.2 用Introspector提取BeanInfo
13.18.3 一个更复杂的Bean
13.18.4 Bean的封装
13.18.5 更复杂的Bean支持
13.18.6 Bean更多的知识:
别的有关的争议是Bean不能被编址.无论什么时刻我们成立一个Bean,都但愿它会在一个多线程的环境中运行.这意味着我们必须理解线程的出口,我们将在下一章中介绍.我们会发现有一段称为“Java Beans的回想”的节会注意到这个问题和它的办理筹划.
13.19 Swing入门
13.19.1 Swing有哪些长处
13.19.2 便利的转换
13.19.3 显示框架
13.19.4 工具提醒:
几近全部我们操纵来成立我们用户接口的来自于JComponent的类都包含一个称为setToolTipText(string）的办法.因此,几近任何我们所需求表示的（关于一个对象jc来说就是一些来自JComponent的类）都可以安设在窗体中:
jc.setToolTipText("My tip");
并且当鼠标停在JComponent上一个超越预先设置的一个时间,一个包含我们的文字的小框就会从鼠标下弹出.
13.19.5 边框
13.19.6 按钮
13.19.7 按钮组
13.19.8 图标
13.19.9 菜单
13.19.10 弹出式菜单
13.19.11 列表框和组合框
13.19.12 滑杆和进度指导条
13.19.13 树
13.19.14 表格
13.19.15 卡片式对话框
13.19.16 Swing消息框:
开窗的环境普通包含一个尺度的信息框集,答应我们很快传送消息给用户大概从用户那边捕捉消息.在Swing里,这些信息窗被包含在JOptionPane里的.我们有一些差别的大概实现的事件（有一些非常复杂）,但有一点,我们必须尽大概的操纵static JOptionPane.showMessageDialog()和 JOptionPane.showConfirmDialog()办法,调用消息对话框和确认对话框.
13.19.17 Swing更多的知识
13.20 总结
13.21 操练

第14章 多线程
14.1 反映矫捷的用户界面
14.1.1 从线程担当
14.1.2 针对用户界面的多线程
14.1.3 用主类归并线程
14.1.4 制作多个线程
14.1.5 Daemon线程
14.2 同享有限的资源:
可将单线程程序想象成一种孤独的实体,它能遍历我们的问题空间,并且一次只能做一件事情.由于只有一个实体,所以永久没必要耽忧会有两个实体同时试牟利用相同的资源,就象两个人同时都想停到一个车位,同时都想通过一扇门,乃至同时发话.
进入多线程环境后,它们则再也不是孤独的.大概会有两个乃至更多的线程试图同时同一个有限的资源.必须对这种潜在资源冲突举行预防,不然便大概发生两个线程同时拜候一个银行帐号,打印到同一台计算机,以及对同一个值举行调整等等.
14.2.1 资源拜候的错误办法
14.2.2 Java若何同享资源
14.2.3 回想Java Beans
14.3 堵塞
14.3.1 为什么会堵塞
14.3.2 死锁
14.4 优先级
14.4.1 线程组
14.5 回想runnable
14.5.1 过量的线程
14.6 总结
14.7 操练

第15章 网络编程
15.1 机械的标识
15.1.1 服务器和客户机
15.1.2 端口:机械内举世无双的场所
15.2 套接字
15.2.1 一个简单的服务器和客户机程序
15.3 服务多个客户
15.4 数据报
15.5 一个Web利用
15.5.1 服务器利用
15.5.2 NameSender程序片
15.5.3 要注意的问题
15.6 Java与CGI的沟通
15.6.1 CGI数据的编码
15.6.2 程序片
15.6.3 用C++写的CGI程序
15.6.4 POST的概念
15.7 用JDBC衔接数据库
15.7.1 得到学习示例
15.7.2 查找程序的GUI版本
15.7.3 JDBC API为什么若何复杂
15.8 远程办法:
为通过网络履行其他机械上的代码,传统的办法不但难以学习和掌握,也极易出错.考虑这个问题最佳的方法是:某些对象恰好位于另一台机械,我们可向它们发送一条消息,并得到返回后果,就象那些对象位于自己的本地机械一样.Java 1.1的“远程办法调用”（RMI）采取的恰是这种抽象.本节将指导大家阅历一些必要的步骤,成立自己的RMI对象.
15.8.1 远程接口概念
15.8.2 远程接口的实施
15.8.3 成立根与干
15.8.4 利用远程对象
15.8.5 RMI的替选筹划
15.9 总结:
由于篇幅所限,还有其他很多触及连网的概念没有介绍给大家.Java也为URL供应了相当全面的支持,包含为因特网上差别范例的客户供应协议掌握器等等.
除此以外,一种正在渐渐风行的技术叫作Servlet Server.它是一种因特网服务器利用,通过Java掌握客户恳求,而非利用从前那种速度很慢、且相当麻烦的CGI（通用网关接口）协议.这意味着为了在服务器那一端供应服务,我们可以用Java编程,没必要利用自己不熟习的其他语言.由于Java具有优异的移植本领,所以没必要关心具体包容这个服务器是什么平台.
全部这些以及其他特点都在《Java Network Programming》一书中得到了具体报告.该书由Elliotte Rusty Harold编著,O'Reilly于1997年出版.

15.10 操练

第16章 计划范式
16.1 范式的概念
16.1.1 单子
16.1.2 范式分类
16.2 察看器范式
16.3 模拟垃圾回收站
16.4 改良计划
16.4.1 “制作更多的对象”
16.4.2 用于原型成立的一个范式
16.5 抽象的利用
16.6 多重调派
16.6.1 实现双重调派
16.7 拜候器范式
16.8 RTTI有害吗
16.9 总结
16.10 操练:
(1) 将SingletonPattern.java作为起点,成立一个类,用它管理自己固定数目的对象.
(2) 为TrashVisitor.java增添一个名为Plastic（塑料）的类.
(3) 为DynaTrash.java一样增添一个Plastic（塑料）类.

第17章 项目:
本章包含了一系列项目,它们都以本书介绍的内容为底子,并对早期的章节举行了一定程度的扩大.
与从前阅历过的项目相比,这儿的大大都项目都明显要复杂得多,它们充分演示了新技术以及类库的应用.
17.1 文字处理
17.1.1 提代替码列表
17.1.2 查抄大小写款式
17.2 办法查找工具
17.3 复杂性理论
17.4 总结:
通过本章的学习,大家知道应用Java可做到一些较复杂的事情.通过这些例子亦可看出,固然Java一定有自己的范围,但受那些范围影响的主如果性能（比方写好文字处理程序后,会发现C++的版本要快得多——这部份是由于IO库做得不完善造成的;而在你读到本书的时刻,情形大概已发生了改变.但Java的范围也仅此罢了,它在语言表达方面的本领是无以伦比的.操纵Java,几近可以表达出我们想得到的任何事情.而与此同时,Java在表达的便利性和易读性上,也做足了工夫.所以在利用Java时,普通不会陷入其他语言常见的那种复杂地步.利用那些语言时,会感受它们象一个爱唠叨的老妇人,哪有Java那样清纯、简洁!并且通过Java 1.2的JFC/Swing库,AWT的表达本领和易用性乃至又得到了进一步的加强.

17.5 操练:

(1) （略微有些难度）改写FieldOBeasts.java,使它的状况可以保持固定.加上一些按钮,答应用户保存和恢复差别的状况文件,并从它们断掉的地方开始持续运行.请先参考第10章的CADState.java,再决意具体怎样做.
(2) （大功课）以FieldOBeasts.java作为起点,构造一个自动化交通仿真系统.
(3) （大功课）以ClassScanner.java作为起点,构造一个特别的工具,用它找出那些固然定义但从未用过的办法和字段.
(4) （大功课）操纵JDBC,构造一个联结管理程序.让这个程序以一个平面文件数据库为底子,此中包含了名字、地址、电话号码、E-mail地址等接洽资料.应当能向数据库里便利地加入新名字.键入要查找的名字时,请采取在第15章的VLookup.java里介绍过的那种名字自动填充技术.

附录A 利用非Java代码
A.1 Java固有接口
A.1.1 调用固有办法
A.1.2 拜候JNI函数:JNIEnv自变量
A.1.3 传送和利用Java对象
A.1.4 JNI和Java违例
A.1.5 JNI和线程处理
A.1.6 利用现成代码
A.2 微软的办理筹划
A.3 J/Direct
A.3.1 @dll.import指导号令
A.3.2 com.ms.win32包
A.3.3 堆积
A.3.4 编写回调函数
A.3.5 其他J/Direct特点
A.4 本原接口（RNI）
A.4.1 RNI总结:
RNI与Microsoft JVM精密集成这一事实既是它的长处,也是它的缺陷.RNI比JNI复杂得多,但它也为我们供应了对JVM内部活动的高度掌握;此中包含垃圾汇集.此外,它明显针对速度举行了优化,采取了C程序员熟习的一些折衷筹划和技术.但除了微软的JVM之外,它并不适于其他JVM.
A.5 Java/COM集成
A.5.1 COM底子
A.5.2 MS Java/COM集成
A.5.3 用Java计划COM服务器
A.5.4 用Java计划COM客户
A.5.5 ActiveX/Beans集成
A.5.6 固有办法与程序片的注意事项
A.6 CORBA
A.6.1 CORBA底子
A.6.2 一个例子
A.6.3 Java程序片和CORBA
A.6.4 对比CORBA与RMI
A.7 总结

附录B 比较C++和Java

附录C Java编程法则

附录D 性能


附录E 关于垃圾汇集的一些话

附录F 举荐读物