精读一章内容，手工输入一章代码（注1），与书中描述的思想进行印证，实在搞不懂就放过吧。设计模式绝对不会一次就看懂的。

这本书对于理解设计模式很有帮助，就是例子不太符合中国人的思维模式，但是坚持下去肯定会搞明白的。

全书精华：

1. Chap12的Ducks，通过一点点重构Ducks程序，将模式一个个加入其中，帮助对模式的深入理解。

2. Chap12的DJView，通过一个完整的MVC程序，将Observer、Strategy、Composite以及Adapter模式用架构层面的设计整合起来，不仅可以更好地理解单个模式，还可以理解MVC模式。

尽可能对每个模式写出自己的总结

1. Strategy（策略模式）：定义一组算法类，用于运行过程中替换算法。
   • 封装变化
   • 多用组合，少用继承
   • 多针对接口编程，少针对实现编程
2. Observer（观察者模式）：定义一个主题和一组观察者，可以在主题变化时通知订阅了主题的观察者。
   • Strategy封装的是函数调用的算法。
   • Observer封装的是传递数据的内容。
   • 交互对象之间强内聚、松耦合。
3. Decorator（装饰模式）：本质不变，外面增加一层层装饰。例如：Stream的包装。
   • 设计的类，禁止修改，允许扩展。
   • 不采用继承的方式来扩展功能。
4. Factory（工厂模式）：所有的工厂都是用来封装对象的创建。
   • Simple Factory（简单工厂）：将业务逻辑与对象创建操作分离开。
   • Factory Method（工厂方法）：把对象的创建工作委托给子类的工厂方法。
   • Abstract Factory（抽象工厂）：把对象的创建工作委托给实现了接口的工厂方法。
   • 依赖于抽象，而不依赖于具体的类。
5. Singleton（单例模式）：通过禁止其他对象对自己实例化，而改由自己的静态方法对自己实例化，确保一个类只有一个对象。
6. Command（命令模式）：解耦调用者与执行者之间的关系，相互之间的联系通过命令对象完成，调用者只对调用对象的execute()方法发出请求。
7. 改造已有系统接口，使异构系统也可透明地相互调用。
   • Adapter（适配器）：将一个类的接口转换成客户期望的另一个接口。例：数据库连接
   • Facade（门面模式）：将一组接口转换成客户期望的单一接口。例：设备驱动程序
   • 最小知识原则：调用其他方法时，涉及的对象越少越好。
     • 对象调用自己的方法
     • 对象调用作为参数传入的对象的方法
     • 对象调用自己的方法创建的对象或实例的方法
       • （以上三点强调：不要调用其他方法返回的对象的方法）
     • 对象调用自身组件的方法
8. Template（模板模式）：封装算法，在一个方法中定义一个算法的框架，而将具体的实现委托给子类。框架中调用的方法为钩子，从而超类控制一切，子类实现钩子等待超类调用。
   • 好莱坞原则：别找我，我会去找你。
9. Collections（集合）：
   • Iterator（迭代器）：遍历集合而无须暴露集合的实现
   • Composite（组合模式）：可以将对象的集合和单个对象组合在一起。
   • 类应该只有一个改变的理由。
10. State（状态模式）：将状态封闭为对象，将行为封装成方法；新的状态生成新对象，新的行为生成新的方法。
    • 行为不变，状态改变用State
    • 行为改变，状态不变用Strategy
11. Proxy（代理模式）：采用创建代理对象的方式控制客户端对具体对象的访问。
    • 远程代理管理客户端和远程对象之间的交互；
    • 虚拟代理控制实例化开销大的对象；
    • 保护代理控制客户端对具体对象的访问。
12. Compound（复合模式）：MVC-Model，View，Controller
    • Model与View之间使用Observer模式。Model是Subject，View是Observer，当Model改变时通知View发生改变。View只从Model中获取数据（例如：调用Model的getXXX()方法），不修改Model的数据（例如：不调用Model的SetXXX()方法），不操作Model的行为（例如：不调用Model的行为方法）。
    • Controller与View之间是Strategy模式。View只对Controller的接口编程，不与具体的Controller实现耦合，从而可以面对不同的Controller实现不同的行为。
    • View自身使用Composite模式。
    • 还可以使用Adapter模式，使已经存在的Controller和View与Model适配。

注：

1. 源代码一定要去下载，书上的代码内容不够，也可以参考我的代码。

这本书还没看完，但是绝对是案头必备，虽然用C++写的代码，并且是四个牛人写的风格（相关知识背景与程序员不同），但是一旦开始理解设计模式以后，再回过头会发现这本书的定义和描述最容易理解和记忆。

《Head First设计模式》

自学、初学的推荐用书。我也是通过这本书才真正明白设计模式。虽然，GoF提出了23个模式，但是，只要把主要几个搞明白了，就算入门了，其他的模式只有真正实践的时候才会需要，否则看了也就是了解一下。

《Java与模式》

十年前，我绝对认为是本好书。因为那个时候可以参考的中国人写的设计模式的书实在太少，但是现在我对这本书的评价只能算可以了。因为作者的举例跟我的项目经验没有重叠，作者对古典文学的运用反而又给我理解设计模式增加了困难，因此这本书不再作为我推荐的书，只作为看完《Head First设计模式》后的补充阅读，并且不需要太关注书中的代码和那些文学描述，只看作者关于模式与实际应用的描述就可以了。

《设计模式解析》

这本书不推荐。除非你有过一些设计模式的理解，并且还有实际项目的设计经验，否则这本书对初学的帮助不是很大。我的感觉作者应该是用来作为自己上课的教材，因此这本书除非可以跟着作者边学边读，否则自学会觉得只讲了些理念上的东西，能够帮助理解模式的项目或者代码是不足的。

《设计模式初学者指南》

第三次放弃读这本书，主要是对我不太实用，而且作者的思路也与我不同，读起来不太顺畅。每次重读个几次才明白作者想表达什么，作者是个好程序员，写的代码也非常漂亮，只是比较关注细节和自我实现过程中的理解，对于经常写代码的Java程序员可能帮助会更多些，对于只是想了解概念和思路就显得有点啰嗦了。

补充：理解设计模式最好的方法就是项目与代码，并且在不断地重构项目和代码中加深理解。对于别的什么例子，看起来似乎对理解有帮助，但是听多了只会更加糊涂。

自学前需要的条件：已经具备基本的计算机基础。

1）已经对一种编程语言比较熟悉；

2）有过四年计算机专业学习，或者三年以上的软件开发经验，

自学的方法：

1）完全自学：手工输入代码，看懂习题的答案。

注：把下载的代码运行通过是不行的，自行输入代码也是对Java语言的熟悉过程

2）结伴学习：通过讨论深入理解代码，结伴搞定习题。

3）前辈指导：由前辈帮助搭建编程环境，避过自学过程中需要面对的其他干扰。帮助理解与Java相关的其他计算机的知识点，从而避免遇到因此某些地方不懂而升起的退却心理。

总结：最完美的的以上三种结合，但是不管基于什么方法，完全的自学都是必须的。

为什么说这是一本Java入门书？

因为此书只是全面讲述了在Java编程过程中可能遇到的各种知识点，而对这些知识点并没有展开和深入，读完此书后可以对Java编程有个全面的了解，但是如果在工作中遇到这些问题时，仍然需要去找更加专业的书籍来深入学习。

例如：并发编程。作者只是介绍了如何用Java编写多线程的程序，但是对于死锁问题只提供了例子，并没有深入分析，也没有给出更加具体的解决方案，因为这不是此书的关注点。

为什么很多人并不推荐用来入门？

我的感觉这本书可能是一本教材，是作者用来培训Java程序员的，所以书中对许多知识点并没有给出铺垫（因为这本书已经很厚了，所以作者只好在课堂上铺垫了）。那么过多的计算机方面的知识（例如：面向对象、设计模式、IO处理、并发编程等等）很容易使人产生挫折感而放弃这本很厚很厚的书，甚至放弃Java语言。

因此，我的经验是如果你没有多年的软件编程经验，也没有比较全面的计算机知识，那么最好找个前辈指导着学习，因为很多时候兴趣比什么都宝贵。

后记，此书值得反复阅读。“书读千遍，其义自见。”作者不仅在Java语言方面，而且在计算机其他领域方面也有很深的造诣。读透一本书，就可以充分领悟除这本书以外作者在其他方面的心得。

Java编程思想（英文第1版）+源代码

Java编程思想（英文第2版）

Java编程思想（英文第3版）+源代码

Java编程思想（英文第4版）part1 , part2+源代码

Thinking in Patters v0.9（中文版）

Java编程思想是不是一本好书呢？当然，在书中作者详细解释了Java的起源和语言的特点，通过学习这本书可以知其（Java）然也可以知其所以然。读懂这本书后，你不仅仅是个会写程序的编码工人，而是成为一个专业的程序员。

这本书可否作为入门书籍呢？其实，作为Java的入门也未尝不可，只是因为其庞大的块头和相对艰涩的内容会使大部分初学者半途而废。如果完全没有编程功底的人，当然就不要以此入门了，这绝对是自虐。

如何快速学习这本书呢？直接看Java编程思想第3版，跳过第1章，从第2章开始所有理论知识都跳过，手工输入所有代码，调试成功，然后再回过头看相关理论知识，能看懂多少看多少，看不懂的留下来，等以后在实践中碰到了再回头学习。

如何深入学习这套书呢？有强大意志力的可以从第1版开始往后看，看到第4版就可以对Java语言的发展史有个深刻的理解，甚至对于程序设计语言的发展历史也会有所了解（这个很重要），因为所有的语言其实都是相通的。一门语言理解以后，再学其他语言（如：C++、Python等）都会明白这个语言的特点在哪里，为何要这样设计语言，用在什么场合下效果最好。如果这个语言因为设计的需要缺少某些特性的时候，可以通过什么方法来解决。例如：Java 1.4以前是没有泛型的，那么第3版就没有介绍泛型的使用，而第4版才引入了泛型，那么通过对比第3版和第4版，既可以深入理解泛型的好处，也可以知道如何通过其他手段来解决这个问题。

虽然此书完整覆盖了Java的知识点和数据结构的基础问题，并且对每个部分都做了基本说明。但是因为没有深入展开，对于以自学的方式阅读此书的读者，如果没有基础的会感觉内容太多太杂，学习过程会觉得摸不着头脑；但是对于基础较好的读者又会觉得书中的描述有种隔靴搔痒的感觉，读完一遍没啥收获。

但是如果作为教材则具有自己的优势，作者从Java语言入手，一步步推进到数据结构，使Java语言和数据结构的学习自然的结合在一起，从而避免了在许多学校教学过程中因为分别设置两门课程而带来的脱节问题。例如：许多同学都是先学语言，再学数据结构。可能会遇到一个学期学Java语言，另一个学期学数据结构，结果Java的语法早就在考试后还给老师了，从而使学习数据结构的过程比较困难。更糟糕的是学习数据结构时使用的编程语言不是Java，结果就算学完数据结构了依然不会使用Java来解决数据结构中的许多经典问题。

但是，如果老师使用这个教材，可以根据自己的需要调整讲解的深度和需要展开的内容，还可以帮助学生直接利用Java语言的特性来解决某些数据结构的问题，比如：Java的泛型和集合类来实现数据结构的链表，使学习很有针对性，也更容易产生兴趣。

2. 通过我对本书的学习，建议其他读者也像作者一样，从实践出发。一定要自己把书中的代码都输入到计算机中，按照作者的思路熟悉编程工具和JAVA的知识点。在阅读过程中，我发现本书中文版的代码排版有误，那么读者可以根据自己的能力进行纠错，通过纠错也可以加深对代码的理解，实在搞不定了再参考作者或者我提供的源代码。

重要事情说三遍：一定要自己输入代码。

因为代码光看懂是不够的，一定要自己输入、调试和发现问题，还可以修改代码从而加入自己的一些想法，只有通过反复的实践才能真正理解JAVA的知识点，也就是俗话说的学成自己的东西。

3. 读完这本书，其实并不能帮你立刻就成为一定合格的JAVA程序员，甚至你还是不太会写程序，但是恭喜你“入门了”。

4.如果想节省时间和精力，那就请个专业的老师带着你阅读。因为，时间就是金钱！

原作者的代码，我自己输入和做了部分修改的代码。

只记录了P213后面的错误代码，如果后面发现P213页前面的错误代码，会继续补齐。但我提供的代码都是可以正常运行的，如果有使用者发现中文版书中其他的错误代码请告诉我，方便我在这里补齐，谢谢。

P213，重构代码有误，作者在源代码中提供的正确代码如下：

public ShootingGalleryTargetRow(Image sprite, int value) {
        targetValue = value;
        newTargetTicker = 0;
        this.sprite = (BufferedImage)sprite;
    }

P220，函数中的System.exit(1)因为前面抛出了异常，所以永远无法执行，直接删除。

public Image getSpriteBySize(int size) {
    ...

    throw new IllegalArgumentException("Unknown Sprite Size: " + size);
    System.exit(1);
    ...
    }

P250，使用泛型GenericRole<String, String>未定义类型。

public class GenericRoleProgram {

    public static void main(String[] args) {
        LinkedList<GenericRole<String,String>> roleMap=new LinkedList<GenericRole<String, String>>();
        ...
    }

原作者的代码，我自己输入和做了部分修改的代码。

搜索了网上，给了许多解释，这个作者的说明还要详尽些：http://blog.csdn.net/czmchen/article/details/6176178

但是，我个人认为问题就是出在32位的Eclipse应用和64位的JDK的冲突上，因此直接采用上文中提到的第二种方法：修改Eclipse.ini文件，增加

-vm
C:/Java/jdk1.6.0_10/bin/javaw.exe  // 这行就是32位JDK的安装位置，不同的电脑可能JDK的位置不同

当然，也可以在本机上直接安装32位和64位两种JDK，系统启动时就会自动选择，但是自动选择就会导致刚开始启动时速度有点慢。

为了重新拣起对Java的回忆，只好又找了本基础书。由于成都高新图书馆的计算机书实在不多，只能找到这本了。简单读了下Java部分，总结如下：

优点：虽然本书也是作者编的而不是作者著的，但是可以看出作者编写此书时是有个自己的思路的。与10年前的中国人编写的计算机书相比，不再是简单的转载，而是将手中的资料通过自己的理解贯穿在一起。并且书中的内容和练习也有机地结合在一起，可以边读边练习，增加了对知识的理解。

缺点：

1. 本书不够自完备，如果没有基础进行自学，会碰到的不知道的知识点比较多，从而无法流畅地完成全书。
2. 全书沿用的依然是中国人的学习思路，将重要的知识点总结在一起，方便了解和记忆，但是所有知识点相互之间的关联性不够。也可以说全书的总体目标不够明确，读完后会觉得学了不少，但是实践起来又觉得能力不足。

总结：对于已经有一定语言基础，或者作为老师上课的教材，本书仍是不错的选择。

中间启动了许多次，但又因为各种原因被停。就连闭关学习期间，也多次想放弃，总觉得太简单，最后还是选择了这本书而放弃了其他书，原因是马上要还书了，“书是非借不能读！”不过，坚持自己最初的选择，完成了这本书的学习还是值得的。因为很多年不碰Java语言了，总需要一本书把基础拣起来，通过坚持读完一本书，可以从作者的角度对Java有个完整的回顾。同时，闭关学习期间，通过有所放弃，才觉得专注做好一件事，放下对其他事的贪心，尽量将生活简单化真的很舒服。

不过，这种简单生活也并不容易适应，特别是刚开始闭关，当天任务完成后就会贪心想多看。特别是看到最后几章时，因为还书的时间点快到了，心里莫名的烦躁，总想超额完成任务，结果行为上确开始抵触，甚至想放弃不看。最后，只能以结束这本书为目的，每天都以至少完成当天的任务为基本要求，努力坚持到全书看完的那一天。

今天全书的学习结束了，好像放下一个很重的担子，这本书其实难度并非不可及，为什么还是有心累的感觉呢？

2.合适就是好书。

这是一本可以推荐给Java初学者的教材书，唯一不足就是书中的开发工具不是Eclipse，而是JCreator，要知道JCreator是要收费的，也不是国内主流的开发工具，初学者不容易找到相关资料。因此对于使用此书的初学者要不就需要自己熟悉JCreator这个开发工具，要不就需要自行转换到Eclipse开发工具上。不过，全书涉及开发工具的地方很少，转换工作也不太复杂。

当然，这也不是一本经典的教材，只是本人觉得不用太迷恋经典。这本书仍然是作者多年教学实践后撰写的教材，书中有作者自己的Java教学思路，并且提供了许多容易理解的例子，通过对这本书的学习能够对Java语言建立起一个较为全面的认识。

其实，Java语言的成功不仅仅依赖于语言本身的特色，还有其深刻的语言设计思想和它的软件开发工具包（SDK），这绝对不是几本书就能学会的，当然这本书也不具备这个能力。

3.理解源于实践。

做练习是近几年学习数学的过程中才接受的。因为以前看书，总觉得看懂就可以了，练习做来做去都是些重复劳动，只是巩固一下基础的知识，收获不大。于是，心里就总是想找些有看点的书来读。可是读的书不少了，仍然觉得无法深入，好像总有些地方书里没说清楚。后来实在没有办法了，因为数学书本本都是那么抽象，对于概念没多少解释，只好做习题还可以落实一下那些定理。当习题做到后面的章节，突然发现前面有些不明白的地方豁然开朗了。于是，以后的学习中都把做练习作为必选项，因为在实践的过程中才发觉最初对知识点的理解只是笼统的、抽象的，只有通过做题才能对细节深入，才能把别人写的东西变成自己的理解。

24.2    语言的尺寸
Java语言短小、紧凑，以C++为基础，放弃了一些特定的语言特征（指针和多继承）
注：需要关注的是为什么放弃这两个特征，有没有替代方案，各自的优缺点。

24.2.1    指针（pointer）
指针是一种变量，并且变量中包含了某个存储器地址。
Java不允许使用指针，因为指针指向的是具体的物理地址，直接操纵物理地址中的数据，容易使程序出现不可预料的问题。
Java通过创建引用（）来实现对地址的访问。通过引用也可以把地址作为变量传送。

24.2.2    多继承（multiple inheritance）
多继承允许一个类继承于多个超类。
Java不允许多继承：因为多继承使用不多，且编程复杂，容易出错。
Java允许继承一个基类，实现多个接口的方式实现多继承。

24.3    语言的可靠性
24.3.1    别名（alias）
别名会导致不同的对象变量指向同样的对象。
因为对象变量中存储的对象地址相同，从而出现两个修改同一对象数据的入口，容易造成混淆。
为此Java提供了两种拷贝机制：深拷贝（对象的数据的拷贝）和浅拷贝（对象的引用的拷贝）。
深拷贝可以保护原始对象不受影响，但是需要消耗时间和空间，用于保护数据安全的领域使用。利用clone方法。
浅拷贝提供了原始对象的地址，不需要消耗过多的时间和空间，但是必须小心的使用，以免造成不可预料的问题。利用别名机制。

24.3.2    重写clone方法
protected的方法可以被重写为public的方法，但是public的方法不可以重写为protected方法。
注：因为已经在父类已经是public的方法，就算子类重写为protected方法，那么访问者依然可以通过父类实现访问，所以不容许public方法重写成protected方法。

24.3.3    不变对象
如果对象中不存在变更它们状态的方法，则对象称为不变对象。
如果对象是不可变的，则不必担心创建对象的别名会造成不可预料的问题。

24.3.4    使用Object类的clone方法
Object类的clone方法复制了分配给对象属性的存储器的内容，也称为按位拷贝（bitwise copy）。即完全复制了原始类型（primitive type）的属性的内容，并且复制了属性的引用。
*    如果类的属性都是基本类型的，则重载clone方法只需要调用Object类的clone方法；
*    如果类的属性有对象类型的，并且这些对象都是不可变的，则重载clone方法只需要调用Object类的clone方法。
*    如果类的属性包含非不可变对象，则无法利用Object类的clone方法进行复制，必须自己编写代码来实现clone方法。

如果需要使用Object类的clone方法，需要标识类实现了Cloneable接口，这个接口也是个标识接口，没有包含任何方法。

24.3.5    垃圾收集
Java使用异常处理技术来监视内存耗尽问题，并且可以编写代码来确保程序正常地终止。
Java语言具有一种内嵌的垃圾收集功能，该功能能够释放未被使用的内存。通过搜索程序所使用的内存空间，释放不再被使用的内存。

自测题：
1.    指针与引用的区别：
指针保存了地址，并且可以通过代码修改和操纵这个地址的数据。
引用保存了地址，但是这个地址不能通过代码修改，也不能随便改变访问的类型，例如：不能按字节访问地址中的信息。

2.    多继承：
多继承允许一个类继承于多个超类。
Java不允许多继承：因为多继承使用不多，且编程复杂，容易出错。
Java允许继承一个基类，实现多个接口的方式实现多继承。

3.    Critical.java

a)    因为Critical对象存在变更它们状态的方法，所以是可变对象。

b)    CriticalTest.java

c)    Critical.java

d)    CriticalTest.java

4.
a)    为什么方法返回的都是别名：方便调用的方法修改里面的数据，对于不可变对象也提高传送数据的效率。
b)    为什么别名可能有危险：因为调用方法的代码可能会修改原始数据，造成不可意料的数据错误。
c)    如何避免别名：创建clone方法，返回的对象都采用深拷贝。

5.    垃圾收集功能的优点和缺点：
优点：简化程序员的工作，避免出现内存泄漏或者内存耗尽的问题。
缺点：降低代码执行的速度，对于实时应用会突然出现响应不及时的问题。

编程练习：代码附件
    Critical.java    CriticalTest.java

23.1    引言
服务器（server）程序为其他客户端（client）程序提供某种类型的服务，与客户端程序通常位于不同的机器上。
一个程序可以既是服务器程序也是客户端程序，主要是看它是在为其他程序服务，还是在使用其他程序的服务。
甚至还可以整合其他服务器程序上的服务，打包成自己的服务，提供给客户端程序使用。

23.2    applet
applet是一种Java程序，能够从网页中下载并在浏览器中运行。因为Java运行在虚拟机上，因此可以做到平台独立，使得程序与客户机上的操作系统无关。

23.3    访问远程数据库
Java数据库连接（Java Database Connectivity, JDBC）：是Java访问数据库的通用接口，数据库管理系统提供JDBC驱动，从而保证应用程序不需要关注不同数据库的区别。
驱动（driver）是一种软件，能够使得两个程序进行通信，或者帮助软件与硬件通信。

23.4    Socket
Socket是一种软件机制，能够帮助程序员隐藏传输数据的细节，类似于高级文件处理类帮助程序隐藏外部存储器的细节，
使得程序能够基于流的方式来处理网络连接上的数据的读写。

自测题：
1.    客户--服务器体系结构：
服务器（server）程序为其他客户端（client）程序提供某种类型的服务，与客户端程序通常位于不同的机器上。
一个程序可以既是服务器程序也是客户端程序，主要是看它是在为其他程序服务，还是在使用其他程序的服务。
甚至还可以整合其他服务器程序上的服务，打包成自己的服务，提供给客户端程序使用。

2.    applet和应用程序的区别：
applet和应用程序都是一种Java程序。
applet是运行在浏览器的JVM中；而应用程序是运行在操作系统的JVM中。
applet没有main()方法，因为它运行在浏览器中，控制任务由浏览器负责；应用程序则包含main()方法，main()方法中可以控制程序的所有行为。

3.    专用的applet方法（与paint方法一起运行）
init：applet被浏览器装载（或者重新装载）时，首先调用的方法。
start：init方法被调用后调用的方法；每一次返回页面使得applet可见时，也会调用的方法。
paint：start方法被调用时，立即调用的方法。
stop：当applet被隐藏时（选择了浏览器其他页面），调用的方法。
destroy：当applet被抛弃时（关闭了浏览器），调用的方法。

4.    JDBC技术
Java数据库连接（Java Database Connectivity, JDBC）：是Java访问数据库的通用接口，数据库管理系统提供JDBC驱动，从而保证应用程序不需要关注不同数据库的区别。

5.    Socket类和ServerSocket类的功能和用途。
Socket类的基本功能：
*    连接到远程机器；
*    发送数据；
*    接收数据；
*    关闭一个连接。
ServerSocket类的附加功能：
*    绑定一个端口；
*    在绑定的端口上监听进入的数据；
*    在绑定的端口上接受远程客户端的连接；
编程练习：代码附件
1.    ChangingFaceApplet.java
2.    MetricConverterApplet.java    RedCircleApplet.java
3.    ProductQuery.java
4.    挖坑。。。
5.    JokeServer.java    JokeClient.java    RunJokeServer.java    RunJokeClient.java
6.    挖坑。。。

1）服务提供者框架：

符合JDBC 4.0规范的驱动程序包含了一个文件META-INF/services/java.sql.Driver，在这个文件中提供了JDBC驱动实现的类名。

例如：mysql-connector-java-5.1.40-bin.jar文件中就可以找到java.sql.Driver文件，用文本编辑器打开文件就可以看到：com.mysql.jdbc.Driver类。

JVM的服务提供者框架在启动应用时就会注册服务，例如：mySQL的JDBC驱动就会被注册，而原代码中的Class.forName("com.mysql.jdbc.Driver")仍然可以存在，但是不会起作用。

2）Class.forName("com.mysql.jdbc.Driver");

通过对类com.mysql.jdbc.Driver初始化，执行静态初始化代码，调用DriverManager注册JDBC驱动。

注：通过setProperty的测试，确认类com.mysql.jdbc.Driver也没有加载，那么静态初始化代码肯定被执行了，但是如果服务提供者框架已经注册的服务，这里注册会失败，编程的预期是这样的，可是理论上DriverManager.registerDriver可以重复注册的，为什么这里不能重复注册呢？

3）System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver";);

设置JVM的系统属性，当JVM第一次加载DriverManager类时，会执行类的静态初始化代码，代码中调用loadInitialDrivers()方法，就会加载设置的属性对应的类，执行类的静态初始化代码完成注册。

注：因为注册的机制无法深入理解，只知道没有加载过的类可以注册成功，加载过的就不能重复注册了。

注：setProperty必须在DriverManager第一次运行前才有效，说明”服务提供者”框架注册服务时并没有加载类，因为一旦加载类就会执行类的静态初始化代码，那么注册JDBC驱动就一定会调用DriverManager类的静态初始化代码，那么setProperty就会失效，所以说明注册服务是不加载类的。

4）DriverManager.registerDriver(new com.mysql.jdbc.Driver());

其实前面的2）和3）最终都是通过这个方法注册的，但是这个方法就可以重复注册。

注：对于重复注册后，建立链接时使用哪个驱动我就不明白了，可以取消注册，取消的关键字是基于创建的对象的，所以就算重名也不会出错。

注：这种注册方式没有前面几种好，因为这种注册方式会在代码中与需要注册的驱动程序的类绑定，前面都可以通过配置参数实现注册。

二、各自特点：

1）全自动。只要提供符合规范的JAR文件就可以了。

2）利用反射机制，将驱动类注入到代码中，不需要与代码绑定。

3）基于系统的属性设置方法，将驱动类注入到代码中，但是好像只能绑定一个JDBC驱动。

4）最终的注册机制。会出现重复注册，但是好像对程序没影响，还需要与代码绑定，驱动变了，必须修改代码，维护成本过高，当然也是灵活性最好，管理最方便的。

以下是测试代码：

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Enumeration;

/**
 * @author 朱远翔.Tom 测试JDBC驱动注册
 */
public class JDBCDriverTest {

    public static void main(String[] args) {
        Driver aDriver;
        Connection connection;
        Enumeration em;
        // “org.gjt.mm.mysql.Driver”是“com.mysql.jdbc.Driver”的子类，其构造函数就是调用父类的构造函数。
        String driverString = "com.mysql.jdbc.Driver";
        // String driverString = "org.gjt.mm.mysql.Driver";
        String url = "jdbc:mysql://localhost/ElectricalStore?useSSL=false";
        String username = "admin";
        String password = "123456";

        try {

           // 将DriverManager的日志流输出到Console窗口中，方便监控
           // DriverManager.setLogStream(System.out);
           // DriverManager.println("------DriverManager logs start!------");

           // 只是设置了一个JVM的系统属性，并不建立JDBC驱动程序。
            // 建立JDBC驱动是依赖系统第一次调用DriverManager类时，执行了这个类的静态初始化代码中的loadInitialDrivers()，
            // 加载驱动的方法会把设置的jdbc.drivers属性对应的驱动类通过DriverManager.registerDriver注册到JDBC中。
            // 因此，必须放在DriverManager被第一次调用之间，也就是需要将前面那两行代码注释掉
            System.out.println("1.1> Tried to use setProperty.");
            System.setProperty("jdbc.drivers", driverString);
            System.out.println("---List of all jdbc drivers---");
            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            if (!em.hasMoreElements()) {
                System.out.println("There is no JDBC drivers");
            } else {
                while (em.hasMoreElements()) {
                    aDriver = (Driver) em.nextElement();
                    System.out.println(aDriver);
                }
            }

            System.out.println("1.2> we tried to use Class.forName");
            // Class.forName(driverString)在JavaSE 6.0后符合JDBC 4.0规范的驱动可以不用
            // 基于服务提供机制（ Service Provider mechanism），
            // 系统会自动搜索mysql-connector-java-???-bin.jar中的META-INF/services/java.sql.Driver
            // 这个文件会包含mysql jdbc驱动程序的入口：com.mysql.jdbc.Driver
            // 应用程序调用Class.forName()也不会出错，只是什么都不会执行。
            // 因为Class.forName()就是执行静态初始化代码，已经初始化过的类就无法激活这段代码了
            // System.setProperty("jdbc.drivers",driverString);与Class.forName()一样。
            try {
                Class.forName("com.mysql.fabric.jdbc.FabricMySQLDriver");
            } catch (ClassNotFoundException e) {
                System.out.println("Driver not found");
            }

            System.out.println("---List of all jdbc drivers---");
            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            if (!em.hasMoreElements()) {
                System.out.println("There is no JDBC drivers");
            } else {
                while (em.hasMoreElements()) {
                    aDriver = (Driver) em.nextElement();
                    System.out.println(aDriver);
                }
            }

            System.out.println("1.3> we tried to use DriverManager.registerDriver");
            // 手工注册mySQL的JDBC驱动程序，也就出现了与mySQL绑定过紧的问题，如果以后需要更换驱动，就需要修改代码。
            // 系统容许出现重复注册同样的jdbc驱动类
            DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            DriverManager.registerDriver(new com.mysql.fabric.jdbc.FabricMySQLDriver());
            DriverManager.registerDriver(new com.mysql.jdbc.Driver());

            System.out.println("---List of all jdbc drivers---");
            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            while (em.hasMoreElements()) {
                aDriver = (Driver) em.nextElement();
                System.out.println(aDriver);
            }

            System.out.println("<1.5> Deregister all JDBC drivers");
            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            while (em.hasMoreElements()) {
                aDriver = (Driver) em.nextElement();
                DriverManager.deregisterDriver(aDriver); // 将已经注册的驱动程序取消注册
            }

            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            if (!em.hasMoreElements()) {
                System.out.println("2.1> Now, there is no JDBC driver");
            }

            System.out.println("2.2> we tried to use Class.forName again");
            try {
                Class.forName(driverString);
            } catch (ClassNotFoundException e) {
                System.out.println("Driver not found");
            }
            try {
                Class.forName("com.mysql.fabric.jdbc.FabricMySQLDriver");
            } catch (ClassNotFoundException e) {
                System.out.println("Driver not found");
            }
            try {
                Class.forName(driverString);
            } catch (ClassNotFoundException e) {
                System.out.println("Driver not found");
            }

            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            if (!em.hasMoreElements()) {
                System.out.println("There is no JDBC drivers");
            } else {
                System.out.println("---List of all jdbc drivers---");
                while (em.hasMoreElements()) {
                    aDriver = (Driver) em.nextElement();
                    System.out.println(aDriver);
                }
            }

            System.out.println("2.3> we tried to use setProperty again");
            System.setProperty("jdbc.drivers", "com.mysql.fabric.jdbc.FabricMySQLDriver");

            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            if (!em.hasMoreElements()) {
                System.out.println("There is no JDBC drivers");
            } else {
                System.out.println("---List of all jdbc drivers---");
                while (em.hasMoreElements()) {
                    aDriver = (Driver) em.nextElement();
                    System.out.println(aDriver);
                }
            }

            System.out.println("2.3> Tried to use DriverManager.registerDriver again");

            DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            DriverManager.registerDriver(new com.mysql.fabric.jdbc.FabricMySQLDriver());
            DriverManager.registerDriver(new com.mysql.jdbc.Driver());

            System.out.println("---List of all jdbc drivers---");
            em = DriverManager.getDrivers(); // 获取已加载JDBC驱动程序的Enumeration
            if (!em.hasMoreElements()) {
                System.out.println("There is no JDBC drivers");
            } else {
                while (em.hasMoreElements()) {
                    aDriver = (Driver) em.nextElement();
                    System.out.println(aDriver);
                }
            }

            System.out.print("3.1> Tried to establish a connection: ");
            connection = DriverManager.getConnection(url, username, password);
            System.out.println(connection);
        } catch (SQLException e) {
            System.out.println("Cannot registered the mysql jdbc driver");
        }

        System.out
                .println("jdbc.drivers property: " + System.getProperty("jdbc.drivers", "nothing"));

    }

}

进程：一个运行的程序通常称为一个进程。
并发进程（concurrent process）：两个或多个可以同时执行的进程称为并发进程。
在多个进程并发执行时，每个进程都有自己的存放程序代码和数据的存储空间，并且每个进程的存储空间对于其他进程都是受保护的，所有这些工作都由操作系统完成。

22.3    线程（thread）：P552
线程：一个程序执行的多个独立任务称为线程。通常将线程称为轻量级进程（lightweight process），因为也管理进程相比，管理线程需要占用较少的系统资源。
线程没有完全独立的存储空间，线程之间共享代码区和存储区。
管理线程的方式也是基于时间切片原则，由JVM和OS协同管理。

22.4    Thread类
继承Thread类实现线程。控制线程用三个方法：start(), run(), finish()
主要执行代码在run()方法中。
注：run()方法结束后，这个线程就运行结束了，不可以再次调用，必须重新创建。原因也可参考图22-2的状态转换图，线程进入TERMINATE状态中，无法再次启动。

22.5    线程的执行与调度
份额（quantum）：每个进程或者线程都可以获得处理器上的一小段时间--称为份额，然后轮转到下一个进程或线程。
份额内时间没有用完时，也可以使用sleep()方法，强制放弃CPU的占用权，将CPU还给OS，从而可以继续分配给下一个进程或线程。
注：sleep()方法传入的时间间隔（以毫秒为单位），可能会抛出InterruptedException异常，必须写在try...catch代码块中。

22.6    Runnable接口
创建一个实现Runnable接口的类，然后将类的实例作为Runnable接口的参数传入Thread对象的构造函数中。
后面的工作主要就是操作Thread的对象，与前面扩展Thread类的方法一样了。
注：此处的Thread对象是独立创建的，前面是对Thread类的继承。

22.7    线程同步：P562
异步行为（asynchronous behaviour）：
    在一般情况下两个或多个并发执行线程的行为并不是协同的，而且无法预知在某个时间段内哪个线程将会占用CPU，这种非协同的行为称为异步行为。
互斥访问（mutual exclusion）：需要将访问缓冲区的程序段看作临界区（critical section）--即在任何时刻只能被一个进程访问的区域，实现临界区的方式称为互斥访问。
忙等待（busy waiting）：被某个线程执行的方法循环中反复执行，直到满足某个条件才能终止。效率太低，可以使用wait()方法将线程挂起，直到被其他线程的消息唤醒。
在Java中创建一个monitor对象（监视器），monitor类的所有方法在任何时刻都只能被一个线程访问。
可以在方法的头部使用synchronized修饰符，由于方法被同步(synchronized)，所以一旦有某个对象调用该方法，那么该方法将被置上一个锁（lock），
其他对象必须在该方法执行完成后才能访问它。
注1：为什么要加锁？是因为你有临界区，对这个临界区加锁才是目的。
因此锁的目的：当前类（即this.静态变量），当前对象（即this.变量），当前对象中创建的对象（即this.对象变量），外部传入到当前对象中的对象。

注2：什么可以加锁？对象，只有对象可以加锁。
在Java中，每一个对象都拥有一个锁标记（monitor），也称为监视器，多线程同时访问某个对象时，线程只有获取了该对象的锁才能访问。
JVM会记录并且监管这个锁，当线程获取锁后计数器由0变1，线程若访问同样锁的其他方法，计数器还会继续增加，从而保证线程完全释放这个锁后才会允许其他线程访问。
所以基本数据类型的变量是不能作为临界区的，也就不能被加锁。

注3：怎么样加锁？使用synchronized对静态方法、方法、对象变量加锁。
static synchronized aStaticMethod(){...}        //        “当前类（即this.静态变量）”加锁
synchronized aMethod(){...}        //        “当前对象（即this.变量）”加锁
synchronized (aObjectVariable){...}        //        “当前对象中创建的对象（即this.对象变量）”或“外部传入到当前对象中的对象”加锁。

22.8    线程状态：P563
状态转换图：图22-2 一个线程的状态转换图
start()启动一个线程-->线程进入ready（就绪）状态。
dispatch()调度一个线程-->线程进入running（运行）状态。
线程运行时间超时、yield()强制一个线程放弃CPU-->线程进入ready（就绪）状态。
sleep()睡眠一个线程-->线程进入sleeping（睡眠）状态-->睡眠时间超时-->线程进入ready（就绪）状态。
wait()-->线程进入waiting（等待）状态-->获得其他线程notify()或notifyAll()方法通知-->线程进入ready（就绪）状态。
由于等待输入或等待外部设备可用-->线程处于blocked（阻塞）状态-->阻塞时间超时或设备正常-->线程进入ready（就绪）状态。
run()方法完成后，线程被终止。

22.10    Timer类：调度线程
在固定时间间隔内生成ActionEvents对象。因此，必须将一个Timer对象关联到一个ActionListener对象。
只要Timer对象生成一个ActionEvent对象，都会执行与Timer对象相关的ActionListener对象的actionPerformed()方法。

自测题：
1.    如何通过时间切片实现并发：P552
时间切片（time-slicing）：处理器只是完成了一个任务的一部分工作，然后完成下一个任务的一部分工作，
因为处理吕每次完成工作的时间都非常短，因此看起来这些任务是并发完成的。

2.    进程与线程的区别：P552
每个进程都有完全独立的存储空间，用于存放程序的代码和数据，并且每个进程的存储空间对于其他进程都是受保护的，所有这些工作都由操作系统完成。
每个线程没有完全独立的存储空间，线程之间共享程序的代码和数据，线程的调度由JVM和操作系统协同完成。

3.    异步线程执行和同步线程执行的区别：P562
异步执行线程：无法预知某个时间段内哪个线程将会占用CPU，也无法估计程序执行的结果。
同步执行线程：确保线程对于临界区是互斥访问的，当某个线程执行同步代码时，其他线程无法再调用同步代码，必须等待前面执行的进程解锁。

4.    临界区和互斥的概念：P562
访问缓冲区的程序段看作临界区（critical section）--即在任何时刻只能被一个进程访问的区域。
实现临界区的方式称为互斥访问（mutual exclusion）。
Jav提供了在多线程程序中实现互斥的机制，即每个对象都有一个monitor（监视器），monitor类的所有方法在任何时刻都只能被一个线程访问。
只需要在方法的头部使用synchronized修饰符，由于方法被同步，所以一旦有某个对象调用该方法，那么这个方法就会被上锁，其他对象如果同时想访问就必须等待。

5.    如何在Java程序中避免忙等待：P562
使用wait()方法将线程的执行挂起，直到它收到另一个进程的消息将它唤醒。就可以避免出现忙等待。

6.    Threads6.java    RunThreads6.java

编程练习：代码附件
3.    CounterVersionFour.java    RunCounterVersion.java    CounterThread.java

19.2    Border接口
8个实现Border接口的标准边框类：
*    BevelBorder
*    SoftBevelBorder
*    LineBorder
*    EtchedBorder
*    TitledBorder
*    MatteBorder
*    CompoundBorder
*    EmptyBorder

19.3    Icon接口

19.5    对话框窗口
*    选项：显示一系列按钮供用户选择一个选项。
*    输入：允许用户通过文本域或列表输入数据。
*    消息：显示一条消息和一个OK按钮。
*    确认：询问用户一个问题，并为答案提供确认与否的按钮。

消息类型：
*    PLAIN_MESSAGE                            不显示任何图标
*    INFORMATION_MESSAGE                显示提示图标
*    ERROR_MESSAGE                            显示错误图标
*    QUESTION_MESSAGE                    显示问题图标
*    WARNING_MESSAGE                    显示警告图标

自测题：
1.    创建下面的对话框窗口：

JOptionPane.showMessageDialog(null, "Have a nice day", "Happy Message", JOptionPane.PLAIN_MESSAGE);
JOptionPane.showInputDialog(null, "Write the words \"I have made a stupid mistake\" below", "Silly Mistake", JOptionPane.ERROR_MESSAGE);
JOptionPane.showConfirmDialog(null, "Are you here?", "Silly Question", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);

2.    屏幕上颜色的创建规则：
三种基本颜色：红、绿、蓝，按不同比例混合这三种基本颜色就可以得到其他颜色。屏幕上颜色就是按照这三种颜色的不同亮度混合得到其他颜色的。

3.    使用CardLayout管理器的场景：
适用于需要将界面分成不同的区域，并且每次只显示一个区域的使用场景。

4.    良好用户界面创建的基本原则：
保持简洁：颜色要少、字体要少、菜单不超过三层。
注意用户群的特征：针对具体的使用者设计使用界面。
考虑有障碍用户的需求。

5.    设计程序界面时，为有障碍人士需要考虑的内容：
视觉障碍：需要颜色对比强烈，注意提供语音提示。
听觉障碍：（不知道，自己没这个感受，也没找到相关资料。）

编程练习：代码附件
1.    BorderTester.java
3.    PasswordFieldTester.java
注：RunTest.java测试该章的所有程序。

2.    使用JMenuBar类、JMenu类和JMenuItem类构建下拉菜单：
创建一个菜单需要有三方面内容：顶端的菜单栏（menu bar）、不同的菜单（menu）以及每个菜单都有各自的菜单项（menu item）列表。
将菜单项添加到菜单中，再将菜单添加到菜单栏中，最后将菜单栏添加到框架中。

3.    模式对话框与非模式对话框的区别：P445
模式对话框处于可见状态时，用户不可以与原框架进行交互，只有先关闭模式对话框后才能与原框架交互。
非模式对话框处于可见状态时，用户仍可以与原框架进行交互，甚至可以直接关闭原框架，非模式对话框也会与原框架一起关闭。

4.    下拉菜单与弹出式菜单的使用场景区别：
下拉菜单适用于全局环境；弹出式菜单适用于特定环境。

5.    弹出式菜单与对话框窗口的区别：P442
不希望原框架或窗体的一部分总是用于交互就可使用对话框窗口。

6.    多个单选按钮如何一起工作？P445
创建一个ButtonGroup对象，将单选按钮一个个加入到该组中，就可以一起工作了。

7.    File类的getName方法与getPath方法的区别：P453
getName只提供了文件的名称，getPath提供了文件的完整路径和名称。

8.    如何判断JComboBox对象中的选中条目：
getSelectedItem()函数就可返回被选中的条目内容。

9.    调用Notepad.exe的代码：

try {
    Runtime.getRuntime().exec("C:\\Windows\\notepad.exe");
} catch (IOException ioe) {
    System.out.println(ioe);
}

编程练习：代码附件
1.    都实现了，没啥想修改的。
2.    DiaglogModalDemo.java    RunDiaglogModalDemo.java
3.    图形界面的就先不做了。
4.    SliderRectangleDemo.java    RunSliderRectangleDemo.java
5.    DrawFigure.java RunDrawFigure.java
注：基本的几个交互组件都已经在DrawFigure中使用了，不再做6题了，图形界面太花时间。

17.2 List接口和ArrayList类
*    ArrayList类
*    LinkedList类

17.2.1    泛型（generics）：允许设定存在在特定聚焦类对象中的对象类型。可以将一个或多个类型作为参数发送到一个类（或接口）中，亦被称为参数化类型。
优点：允许编译检查类型；不必进行对象类型转换；避免产生ClassCastException异常。

17.2.2    使用接口类型代替实现类型作为函数的形参
允许将来修改实现的方式而不必修改形参中对象的类型。

17.2.3    List接口的方法
操作：增加（add）❶将元素插在列表的末尾；❷将元素插入到列表中指定的位置。
注：使用索引插入参数到列表中时，必须保证索引是当前列表中的有效位置
修改（set）、删除（delete）
列表：显示（toString）、总数（size）、是否空（isEmpty）
元素：位置（indexOf）返回指定对象在列表中第一次出现时的索引。
获取（get）、存在（contains）

17.3    增强的for循环：数组、List接口、Set接口
不能用于修改或删除原始集合中的元素，因为编译可以通过，但是有可能导致程序结果不可预测。

17.4    Set接口和HashSet类
*    HashSet类
*    TreeSet类

17.4.1    Set接口的方法
操作：增加和修改（add）、删除（remove）
列表：显示（toString）、总数（size）、是否空（isEmpty）
元素：获取（get）、存在（contains）

17.4.3    Iterator接口：用于修改和删除Set中的元素
使用Set对象中提供的Iterator对象。

17.5    Map接口和HashMap类
*    HashMap类
*    TreeMap类

Map接口的方法：
操作：增加和修改（put）、删除（remove）
元素：关键字存在（containsKey）、值存在（containsValue）、值获取（get）

17.6    JCF中使用自定义类
方法重写：toString();    equals();    hashCode()

自测题：
1. 三种接口的区别：
*    List列表：元素为单个对象，元素在列表中是有序、可重复
*    Set集合：元素为单个对象，元素在集合中无序、不可重复
*    Map映射：元素为成对对象（第一个对象是关键字，第二个对象是值），元素在映射中无序，关键字不可重复

2.    Map<String, Student> javaStudents = new HashMap<String, Student>();
a)    允许将来修改实现的方式而不必修改形参中对象的类型。

b)    可以将一个或多个类型作为参数发送到一个类（或接口）中，亦被称为参数化类型。
优点：允许编译检查类型；不必进行对象类型转换；避免产生ClassCastException异常。

c)    javaStudents.put("U0012345","Fadi");
javaStudents定义的是Student类型，不能接收String类型的数据。

3.    StockItem类
a)   

public String toString(){
    return "("+stockNumber+","+name+","+price+","+totalStock+")\n";
}

b)

public boolean equals(Object objIn){
    StockItem st = (StockItem) objIn;
    return stockNumber.equals(st.stockNumber);
｝

c)

public int hashCode(){
    return stockNumber.hashCode();
}

4.
a)

String tmpString;
    boolean first=true;
    if (regNums.size()==0){
        tmpString="{}";
    } else {
        StringBuilder sb = new StringBuilder();
        for (String item: regNums){
            if (first)    {
                sb.append("{"+item);
                first = false;
            } else {
                sb.append(","+item);
            }
        }
        sb.append("}");
        System.out.println(sb);

Iterator<String> elements = regNums.iterator();
    while(elements.hasNext()){
        String item = elements.next();
        if (item.charAt(item.length()-1)=='S'
            elements.remove();
    }

编程练习：代码附件
1.    NameStack.java    NameStackException.java    NameStackTest.java
a)    因为需要可变大小的存储空间，而存储的对象必须是有序的，但是是可以重复的。

2.    CarRegister.java    CarRegisterException.java        CarRegisterTest.java
a)    因为需要可变大小的存储空间，而存储的对象可以是无序的，但是必须惟一。

3.    Book.java        Library.java    LibraryTest.java

4.    Bank.java        BankAccount.java        BankTest.java
a)    HashMap类适合代替数组实现Bank类。因为其可以满足成对对象集合的需要，还可以确定关键字。

1.Eclipse中如何配置JDK的Documents和Sources？

“Windows”—> “Preferences”—> “Java”—> “Installed JREs”

选中需要配置的JRE，点 “Edit”，选中 “JRE system libraries”中需要配置的JAR文件。

也可以点中其中一个，用 “Ctrl+A”全选。

* 在Eclipse中按F1看API的帮助：

点 “Javadoc Location…”—> “Javadoc in archive”—> “External File”，

在 “Archive path:”中配置下载的压缩文件，

在 “Path within archive”中输入 “docs/api”，

然后点 “Validate…”验证一下，最后点 “OK”。

* 在Eclipse中看JDK的源代码：

点 “Source Attachment…”—> “External Location”，

在 “Path:”中输入源代码压缩文件所在的目录，最后点 “OK”。

16.2    创建二维数组
索引从0开始，创建成表格，第一个索引是行索引，第二个索引是列索引。
length属性：第一个索引的长度。

16.3    初始化二维数组：数值用逗号分隔，行用大括号分隔。

16.4    不规则数组（ragged array）：可变列数的二维数组。
如果只声明但不初始化不规则二维数组，必须声明行数（第一索引），可以不声明列数（第二索引）。
问：不规则数组只能是二维吗？
答：不规则数组可以是多维，并且都是必须声明第一索引就可以了。

自测题：
1. 考虑下列数组声明语句，该数组用于存储学生成绩的集合

char [][] grades=new char[4][20];

a)    该数组有几个维度？
2个

b)    grades.length的值是多少？
4

c)    grades[0].length的值是多少？
20

d)    第一组第一个学生的成绩为B

grades[0][0]='B';

2.    声明合适的数组
a)    进球数：20个球队，38场比赛

int scores[20][38];

b)    座位：70行座位，每行20个座位
boolean seats[70][20];

3.    记录火车晚点情况
a)    一年中第几周，每周中第几天晚点次数

int late[52][7];

b)

int daysNum=0;
for (int i=0;i<52;i++)
    for (int j=0;j<7;j++)
        if (late[i][j]==2)
            daysNum++;

b)    不规则二维数组triangle

int [][] triangle = new int[4][];
for (int i=0;i<4;i++)
    triangle[i]=new int[i+1];

c)    triangle中的最大值

int biggestNum;
biggestNum=triangle[0][0];
for (int i=1;i<4;i++)
    for (int j=0;j<triangle[i].length;j++)
        if (biggestNum < triangle[i][j])
            biggestNum=triangle[i][j];

编程练习：代码附件
1.    VarNoughtsAndCrosses.java        RunVarNoughtsAndCrosses.java
2.    CheckTrain.java        CheckTrainTest.java    InvalidDateException.java
3.    TimeTable.java        TimeTableException.java    TimeTableTest.java   
    TimeTableGUI.java    RunTimeTableGUI.java        做界面太消耗时间了，暂时不做了。

2. 已检查异常和未检查异常的区别是什么？P359
在编译器允许程序被编译通过前，要求程序员必须编写代码，告诉编译器如何处理由特定指令产生的已检查异常。
但是编译器对可能产生的未检查异常并不认为存在潜在的错误可能，也就不会要求程序员必须编写代码处理，只是希望程序员在编写代码时就尽量避免出现这类异常。

已检查异常：FileNotFoundException, IOException, Exception
未检查异常：NegativeArraySizeException, NumberFormatException, ArrayIndexOutOfBoundsException, RuntimeException

3.
a)    抛出异常：P357 每种导致异常的事件类型都对应Java中一个预定义的异常类。当出现某个事件时，Java运行环境就会判断出现异常的类型，
并且生成一个该异常类的对象。这个过程称为抛出(throwing)异常。

b)    声明异常：P361 是指为给定的方法做一个标记，含义是该方法可能会生成一个异常类的对象。

c)    捕捉异常：P364 在某个位置可以控制异常对象，而不是仅仅抛出它们。在Java中，这个过程称为捕捉异常(catching an exception)。

4.    finally语句的作用是什么？P367
无论try程序块中发生任何情况，都希望在程序终止运行前执行一些特别的指令，处理一些清理工作，因此就需要在try...catch程序块的最后部分声明finally程序块。

5.
a)    不会编译错误
b)    Integer.parseInt()和arrayIn[posIn]会抛出异常
c)    输入字母，导致NumberFormatException；输入超过数组边界的数会导致ArrayIndexOutOfBoundsException。

6.    什么情况下需要定义自己的异常类？P378，P380
从构造函数中报告错误的唯一方法是使用异常。但是抛出异常通用异常对象方法使程序无法通过名称知道问题的原因，
还需要借助于getMessage方法来补充信息；并且用于处理特定异常对象的catch语句却将捕捉所有被抛出的异常，
因为所有的异常都是从通用异常类(Exception)派生的。为了希望使用与处理构造函数异常不同的方式来处理其他异常，
因此就得创建自己的异常类。

编程练习：代码附件
1.    ExceptionQ5.java

2.   
a)    ScannerTester.java
b)    EasyScannerPlus.java
c)    EasyScannerPlusTester.java

3.    Hostel.java,    ObjectList.java,    Payment.java,    PaymentList.java,    Tenant.java,    TenantList.java,    NegativeSizeException.java

自测题：
1.    在类的开发过程中，程序包的作用是什么？P321
程序包是为了方便定位和部署类，还可以避免将来类之间出现名称冲突。

2.    哪些import语句合法，哪些非法？

import java.*;                  // 书上说错，代码中承认正确。因为java是个包，只是一个没有任何类的包。
import java.swing.*;            // 错。java下没有swing这个包。
import java.awt.JButton;        // 错。java.awt包下没有JButton类。
import javax.swing.JButton;     // 对。
import javaa.text.*.*;          // 错。不能有两个*
import javax.swing.*;           // 对。

3.    package作用域的含义。P323
对类所在程序包中的其他类可见。

4.
a)    三种方法如下：
(1)    import javax.swing.*;
(2)    import javax.swing.JButton;
(3)    private javax.swing.JButton myButton;
b)

package gameApp;
import javax.swing.JButton;
class GameController
{
    private JButton myButton;
    // more code here
}

5.    所有程序包到javaBook目录下
a)    set classpath=c:\jCreator\myProjects\javaBook
b)    java -cp c:jCreator\myProjects\javaBook

编程练习：代码附件
1. package hostelApp;
注：已经使用包了，就不再修改，只给出处理方法。

2. RunHostelFromPackage.java

3.    LotteryNumber.java

2.    动态（运行时）绑定和静态（编译时）绑定的区别。P335
编译时绑定(compile-time binding)或静态绑定(static binding)技术：
当一个类的代码被编译后，该类的每个方法的代码都会随之编译；编译器将确保该类的对象接收一个调用其方法的消息时，
程序都会跳转到该方法的代码的存储位置--该方法的指令将会被执行，之后程序将返回最初的位置。

运行时绑定(run-time binding)或动态绑定(dynamic binding)技术：
每次创建一个新的对象时，必须记录其方法存储位置的信息；这样对于调用哪个方法的决定可以推迟到运行时决定。

3.
a)    解释Java中接口和适配器的区别。
接口：(P336)是一个类的所有方法都声明为抽象方法。因此实现接口时必须为该接口的所有方法编码。
适配器：(adapter,P348)是一个特殊的类，实现了接口的所有方法，扮演类与接口之间的中介角色，继承适配器类就不必为所有的方法编码。

b)

public interface SomeInterface{
    public void method1();
    public int method2();
}

public SomeAdapter extends SomeInterface{
    public void method1(){    }
    pupblic int method2(){    }
}

4.    解释内部类的作用，描述内部类的使用方法。P349
在Java中一个类只允许继承一个超类，不能继承多个超类（多继承，multiple inheritance）。为了继承业务类，又能够使用适配器类，可以借助内部类来实现。
即在其他类的内部创建一个类，这个内部类继承适配器类。这个内部类不能为程序中其他类服务，从而实现更好地封装。

5.    第7章的Oblong类的toString方法。

public String toString(){
    return "Length:"+length+",\t"+"Height:"+height;
}

2.
a)    Checkable.java
b)    BankAccount.java   
c)    RunAccount.java       
d)    Oblong.java        OblongTester.java
注：length和heigth属性本身就定义为double，为何还要整数呢？所以我只考虑了非负的问题。

3.    DrawRectangle.java            DrawRectangleWithAdapter.java
    RunDrawRectangle.java        RanDrawRectangleWithAdapter.java

4.    SomeGraphicsClass.java    // 这个类为了给第5题服务，部分代码修改了，有些专属部分放在子类中定义。
    Question4.java
   
5.    Question5.java

编程练习：代码附件
Hostel.java
1.    正确运行
2.    Runhostel.java
3.    searchButton

注：不太明白什么时候描述关系，可能用来描述的还是业务上的关系。

2.    为什么开发一个通用的ObjectList类。
该系统需要开发两种列表，PaymentList和TenantList，为了避免重复开发代码，因此开发了一个通用的ObjectList类，
然后通过继承方法分别为PaymentList和TenantList添加特定的属性和方法。

3.    在UML类图中如何记录类的属性？
类属性的语法：
[可见性]属性名[：类型][=初始值][{属性字符串}]
（1）可见性：类中属性的可见性主要包括公有（Public）、私有（Private）和受保护（Protected）。
在UML中，用“+”表达公有类型，用“-”表达私有类型，而用“#”表达受保护类型。UML的类中不存在默认的可见性，
如果没有显示任何一种符号，就表示没有定义该属性的可见性。
（2）属性名：每个属性都必须有一个名字以区别于类中的其他属性，是类的一个特性。属性名由描述所属类
的特性的名词或名词短语组成。按照UML的约定，单字属性名小写。如果属性名包含多个单词，这些单词要合并，
且除了第一个单词外其余单词的首字母要大写。
（3）类型：说明属性的数据类型。在类的图标里，可以指定每个属性值的类型。可能的类型包括字符串
（string）、浮点型（float）、整型（int）和布尔型（boolean），以及其他的枚举类型。指明类型时，需要在
属性值后面加上类型名，中间用冒号隔开。还可以为属性指定一个默认值。
（4）初始值：为了保护系统的完整性，防止漏掉取值或被非法的值破坏系统的完整性，可以设定属性的初始值。
（5）属性字符串：属性字符串用来指定关于属性的其他信息，例如，某个属性应该是永久的。任何希望添加
在属性定义字符串值但又没有合适地方可以加入的规则，都可以放在属性字符串里。

4.    如何改进本章案例研究中开发的应用程序。
（1）使用图形化用户界面。下章会完成。
（2）其他可以改的地方太多了，就不扩展了。

编程练习：代码附件
1.    PaymentTester.java
2.    PaymentTester.java
3.    TenantTester.java
4.    TenantListTester.java
5.    TenantListTester.java
6.    ...

Swing: 基于AWT类构建。
几乎所有的组件都用Java编写，而且所有代码都是Swing程序包的一部分。用Java语言编写的组件称为轻量级(Light Weight)组件。
组件名称都以J开头，如JFrame、JButton、JLabel等。

Swing程序包和AWT程序包都是Java基础类(Java Foundation Class, JFC)中的一部分。

补充说明：首先轻量级与重量级是一个相对的概念，主要是对应用框架使用方便性和所提供服务特性等方面做比较的。
轻量级组件都是纯Java代码开发的，具有良好的平台移植性，不依赖于操作系统的支持，在所有的平台上表现一样，不直接使用操作系统的资源，
当然操作系统的资源依然是要占用的，只是系统资源的管理都由组件完成，使用组件的程序员不直接与操作系统的资源打交道。
重量级组件则每个类都会与操作系统中的一个对等资源相对应。

10.4 Java中的事件处理机制(event-handling)
事件处理器(event-handler)

自测题：
1。轻量级组件与重量级组件的不同。
依赖于本地操作系统的组件被称为重量级组件，因为它们都会大量使用系统资源。
全部使用Java语言编写的组件称为轻量级组件，它们透过AWT使用系统资源，不会直接管理系统资源。

2。布局管理器的作用

3。FlowLayout管理器与BorderLayout管理器的不同

4。
a)    JFrame组件的布局策略

b)    JPanel组件的布局策略

5。一个名为SomeClass的类具有两个按钮组件，这两个按钮组件被按下时将会采取特定的动作。
a)    必要的import语句。
import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

b)    正确的头部语句。
public class SomeClass extends JFrame implements ActionListener

c)    创建按钮需要的Swing组件。
JButton

d)    对按钮监听鼠标单击事件。
button1.addActionListener(this);

e)    哪个方法可以决定鼠标单击按钮时采取行动。
public void actionPerformed(ActionEvent e)

注： 实现可以参看PushMe.java

编程练习：代码附件
1.    PushMe.java    RunPushMe.java
2.    ChangingFacesGUI.java   
这个我用的是Swing Designer完成的界面设计+手工修改了部分代码，
优点：比原始版本简洁
缺点：使用了anoynomous class，本书到这里还没有讲解；还用了enum类型，也是要到书的后面才讲，这样做就是为了更好的对比学习
3.    MetricConverterGUI.java
实现了摄氏温度与华氏温度的转换
最后加了两个Panel是为了对齐前面的Panel
4.    ReactorTesterGUI.java
也是采用Swing Designer完成的界面设计，还增加了MessageBox的使用。
 
补充1：MessageBox需要一个父组件，而ReactorTesterGUI并没有在构造函数中实例化，所以不能使用。
而能使用的是contentPane，这个是在构造函数中实例化了，并且在使用之前已经声明了。
父组件是为也确定MessageBox显示的位置，结果是MessageBox会显示在父组件的中间位置。
 
补充2：因为ReactorTesterGUI在构造函数中是无法实例化的，所以生成的组件并没有直接放在frame的panel中，而是放在contentPane中。
contentPane是在ReactorTesterGUI的类中声明了，再在构造函数中用setContentPane(contentPane)来替换JFrame自己的rootPane。

9.3 可维护性
系统维护(maintaining)是指根据需求的变化更新现有系统的过程

9.3.1    封装的重要性
连锁反应：对系统某一部分的改变可能会对系统的其余部分产生影响，导致系统错误。
面向对象的封装原则保证了面向蝗程序易于维护，因为封装原则减弱了连锁反应的影响：
每个对象都应该在对象内部包含工作的全部细节；所有的数据都应该隐藏在对象内部；保证对象的任何改变都不会影响到系统的其余部分。

9.3.2    文档
在开发面向对象程序的时候，设计文档应该包含以下内容：
*    完整的类图
*    清晰的方法定义（参数和返回类型，必要时包含伪代码）

代码内文档应当包含以下信息：
*    用以描述代码含义的注释信息
*    有意义的数据名称
*    用常量替换固定的数字
*    一致清晰的缩排格式

9.3.3    JavaDoc
常用标签：@author, @version, @param, @return

9.4        可靠性
编译时错误(compile-time error)：没有按照语法规则编写合法的程序。
运行时错误(run-time error)：程序没有完成指定的工作。可能是需求不符，可能是逻辑错误，或者两者兼而有之。
测试错误：从单元测试开始，然后进行集成测试。

9.4.1    单元测试(unit testing，测试独立的类)
不要在原始类中添加main方法进行测试，而是单独构造一个包含main方法的类称为原始类的驱动器(driver)，
这个驱动器类只是完成对特定类的操作，不会干扰的类。
如果要进行单元测试的类依赖于其他的类，而被依赖的类当前无法获得，那么可以开发一个哑元类(dummy class)用于替换无法获得的类。
哑元类是为了完成测试而开发的模拟真实类的类。

9.4.2    集成测试(integrating testing，测试组成应用的所有的类)
在完成程序中每个类的独立测试后，需要将它们组合，进行综合测试，目的是保证类之间的接口可以正常地工作。
为了进行接口测试需要对所有类进行重编译。防止类间的接口不一致。

9.4.3    黑盒测试(black box testing)
把测试组件看作不透明的盒子，即忽略组件的代码细节，构造测试的输入数据时可以分成多个等价组。

9.4.4    白盒测试(white box testing)
把测试组件看作透明的盒子，构造测试集，尽可能覆盖组件所有可能的执行路径。

9.4.5    测试日志
测试日志是记录系统开发过程中进行测试的文档。

9.5        健壮性
一个程序意外地终止运行被称为崩溃(crash)。
将组件推向极限的测试方法称为压力测试(stress testing)。
当违反规则时程序会报告异常(exception)，报告异常的过程称为抛出异常(throwing exception)。

9.6        可用性(usability)
程序的可用性是指应用程序的使用者与程序交互过程的容易度。

9.6.1    文本格式化
转义符：\n, \t, \", \', \\

9.6.2    图形用户界面
是 友好的，易于用户操作的。

自测题：
1。解释什么是继承？
继承是指在类之间共享属性和方法。继承关系是一种层次关系，也被称为a-kind-of关系。

2。在UML类图中如何描述继承关系？
用空心的三角形表示继承关系，三角形的尖指的是基类。

3。在Java中，使用哪个关键字声明一个类是另一个类的子类？
class 子类 extends 基类，用extends关键字代表继承关系。

4。区分方法重写和方法重载的不同。
多态性的实现：方法重载和方法重写。
方法重载指同一类中可以存在具有相同名称的不同方法，通过它们的参数列表加以区分。
方法重写指超类中的方法，可以在子类中重写。
不同的方法的相互区分：在方法重载中通过不同的参数列表相互区分，在方法重写中通过隶属的对象的不同相互区分。

5。解释什么是类型转换，并描述Java中类型转换是如何实现的。
强制类型转换(typecast)：强制一个数据从一种数据类型转换为另一种数据类型。
通过在待转换的数据前加一对含有新类型名称的括号实现。

6。解释abstract和final修饰符分别应用于类和方法时的作用。
abstract class表示这个类为抽象类，不能创建对象，只能作为其他类的基类。
abstract method表示这个方法是抽象方法，没有实现，子类如果要实例化，必须重写这个方法。
final class表示这个类为最终类，不能被继承。
final method表示这个方法是最终的方法，子类不能重写。

编程练习：代码附件
1.    QualityQ2.java
2.    Reactor.java
3.    EscapeSequence.java
4.    FindCost3.java
b)    说实话，这么简单的输出，真不知道还需要怎样改善信息的布局。       

8.4    方法重写(method overriding)
多态性的实现：方法重载和方法重写。
方法重载指同一类中可以存在具有相同名称的不同方法，通过它们的参数列表加以区分。
方法重写指超类中的方法，可以在子类中重写。

不同的方法：在方法重载中通过不同的参数列表相互区分，在方法重写中通过隶属的对象的不同相互区分。

8.5    abstract
抽象类(abstract class)：不可以创建其对象，仅能作为创建其他类的基类。
抽象方法(abstract method)：强制所有的子类必须实现该方法。
注：如果子类声明成abstract class，那么从超类继承来的abstract method也可以不实现。

8.6 final
(final class)：该类不能被继承。
(final method)：该方法不能被重写。
注：(final variable)：就是常量，与面向对象无关。

8.8    包装类和autoboxing
对于每个基本类型，Java都有一个对应的类，这个类将数据类型包装其中，称为包装类。

自测题：
1。解释什么是继承？
继承是指在类之间共享属性和方法。继承关系是一种层次关系，也被称为a-kind-of关系。

2。在UML类图中如何描述继承关系？
用空心的三角形表示继承关系，三角形的尖指的是基类。

3。在Java中，使用哪个关键字声明一个类是另一个类的子类？
class 子类 extends 基类，用extends关键字代表继承关系。

4。区分方法重写和方法重载的不同。
多态性的实现：方法重载和方法重写。
方法重载指同一类中可以存在具有相同名称的不同方法，通过它们的参数列表加以区分。
方法重写指超类中的方法，可以在子类中重写。
不同的方法的相互区分：在方法重载中通过不同的参数列表相互区分，在方法重写中通过隶属的对象的不同相互区分。

5。解释什么是类型转换，并描述Java中类型转换是如何实现的。
强制类型转换(typecast)：强制一个数据从一种数据类型转换为另一种数据类型。
通过在待转换的数据前加一对含有新类型名称的括号实现。

6。解释abstract和final修饰符分别应用于类和方法时的作用。
abstract class表示这个类为抽象类，不能创建对象，只能作为其他类的基类。
abstract method表示这个方法是抽象方法，没有实现，子类如果要实例化，必须重写这个方法。
final class表示这个类为最终类，不能被继承。
final method表示这个方法是最终的方法，子类不能重写。

编程练习：代码附件
1.    ExtendedOblong.java    ExtendedOblongTester.java
2.    Vehicle.java        SecondHandVehicle.java       

属性的权限：
*    public:        属性或方法可以从外部被访问；
*    private:    属性或方法不可以被其他类的方法访问，只能在类的内部被访问，从而实现数据封装。

7.3 static关键字
声明为static的属性为类的属性。对该属性的任何改变都是对类的对象的改变。
声明为static的方法为类的方法。可以不将类实例化为对象时就可以访问。

7.6 传递对象参数
对象可以作为参数传递，实际上是把对象的引用传递给方法，从而可以通过引用修改对象的值。

7.7 聚集类
包含许多相同类型的数据项时称为聚集(collection)类。
当一个对象本身又包含其他对象时，称为聚合关系(aggregation)。聚合关系通常指部分与整体之间的关系，在UML中用空心菱形表示。
组成(composition)是一种更强的聚合关系。通常指整体实际上依赖于部分，在UML中用实心菱形表示。

自测题：
1. UML图中，各部分表示的内容？
答：A是类名；B是属性名称和属性类型；C是方法名称、参数类型和返回值类型。

2。解释public和private在访问属性和方法上的区别。
答：public属性和方法可以从类的外部访问；private属性和方法只能在类的内部访问。

3。static的作用是什么？
答：static属性表示为类的属性，可以直接使用类名访问，对所有的对象都是共有的。
static方法表示为类的方法，可以不实例化类为对象时就可以访问。

4。代码输出结果
答：
20
100

编程练习：代码附件
1.    Student.java StudentTester.java
2.    StockItem.java StockItemTester.java
3.    Bank.java BankAccount.java BankProgram.java
4.    StudentList.java StudentListTester.java
    注：StudentList的UML图中remove(int)和getItem(int)的参数类型不该是int型，搜索的是学生的学号，应该是string。
5.    EasyScanner.java

自测题：
1。如何理解面向对象程序开发的含义？P119
答：面向对象开发技术也可以称为快速应用程序开发技术，因为它允许程序设计人员在分析和设计过程中平稳地过渡。
此外，由于封装(encapsulation)和信息隐藏(information-hiding)技术，面向对象技术允许构建更安全的系统。

2。封装的含义是什么？P123
答：在面向对象方法中，一个类中的方法通常避免直接访问其他类中的数据，这样不容易对数据造成破坏。这一重要原则被称为封装和信息隐藏。

3。区分类和对象。P121
答：在面向对象方法中，方法及其操作的数据都聚合在一个单元中。这种更高层的组织单元被称为对象。
而类是创建对象的模板，对象是由类生成的。

4。构造函数的作用是什么？P123
构造函数(constructor)永远与类同名。当创建一个新对象时，这个特殊的方法总会被调用；该方法的作用是在计算机的存储器中保留足够的空间存储需要的对象，
当然还可以完成更多的功能，例如：初始化变量、申请系统资源等。构造函数可以被重载，因为可以创建需要的构造函数。

5。如何从其他类的方法中调用一个类的方法？P126
首先，需要创建对象，这个过程通常称为实例化(instantiation)过程，因为这也创建了类的一个实例。
其次，当初次创建引用时通常赋空值(null)；空值表示没有分配存储空间。需要将实例化的对象的地址赋给引用，才能正确调用对象的方法。

6。对象数组与基本数据类型数组有何区别？P136
基本数据类型数组一旦创建就会随之创建存储过程，而对象数组创建时并没有在存储器中创建对象数组的存储空间，而是创建了该对象数组的引用 ，
并且没有将具体的对象赋值给引用时，引用默认值为null。

编程练习：代码附件
1.    Olong.java    BankAccount.java均在Chap7
2.    StringComp.java
3.    StringComp.java
4.    BankTester.java

1。答：P92
存储固定个数相同数据类型的一组元素。

2。答：P92
所有存储在一个特定数组里的元素必须是同一类型，但是并没有限制是哪一类型。甚至还可以存储对象。

3。答：P104
当满足以下几种情况才能应用增强的for循环：
* 需要访问整个数据（不是数组的一部分）；
* 需要读取数组中的元素，而不是个性它们；
* 不需要使用数组完成其他处理过程。

4。答：
a) someArray.length的值是5；
b) someArray[2]的值是1
c) 如果访问someArray[6]，程序会报错，超出数组的索引边界；

d)
int[] someArray=new int[5];
someArray[0]=2;
someArray[1]=5;
someArray[2]=1;
someArray[3]=9;
someArray[4]=11;

e)
for (int i=0;i<5;i++)
{someArray[i]=someArray[i]*2;}

f)因为需要修改数组中的值，增加for循环不能实现修改数组的需求。

5。答：
a)
    private static int[] getExamMarks()
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("Please input the student number: ");
        int studentNumber=sc.nextInt();
        int[] students=new int[studentNumber];
        for (int i=0;i<studentNumber;i++){
            System.out.println("Plase input "+(i+1)+" student mark: ");
            students[i]=sc.nextInt();
        }
        return students;
    }
   
b)
    private static void increaseMarks(int[] studentsIn) {
        for (int i = 0; i < studentsIn.length; i++) {
            studentsIn[i] = studentsIn[i] + 5;
        }
    }
   
c)
    private static boolean allHavePassed(int[] studentsIn){
        boolean result=true;
        for (int item:studentsIn)
        {
            result=result&&(item>40);
        }
        return result;
    }

编程练习：代码附件
1. TemperatureReadings3.java
2. Lottery.java
3. ExchangeRate.java
4. ExchangeRate.java
5. SomeUsefulArrayMethods.java