public class FlyNoWay implements FlyBehavior{

 public void fly() {
  System.out.println("I can't fly");
 }
}

public class FlyWithWings implements FlyBehavior{

 public void fly() {
  System.out.println("I'm flying!!");
 }
}

public class Quack  implements QuackBehavior{

 public void quack() {
  System.out.println("Quack");
 }
}

public class muteQuack implements QuackBehavior{

 public void quack() {
  System.out.println("<<Silence>>");
 }

}

public class Squeak implements QuackBehavior{

 public void quack() {
  System.out.println("Squeak");
 }
}

• Document Object Model （DOM，文档对象模型），Level 2
• Simple API for XML (SAX), Version 2.0
• JDOM, Jason Hunter 和 Brett McLaughlin 创立的一种简单 Java API
• Java API for XML Processing (JAXP)

使用 DOM、SAX 或 JDOM 处理 XML 文档的内容。

如果使用 DOM 或 SAX，则使用 JAXP 创建解析器。

如果使用 JDOM，则 JDOM 库为您创建解析器。

解析器的类型：

• 验证和非验证解析器
• 支持一种或多种 XML Schema 语言的解析器
• 支持 Document Object Model (DOM) 的解析器
• 支持 Simple API for XML (SAX) 的解析器

XML文件的类型：

（如果您有一个 XML 文档符合 XML 的基本规则，那么它就是一个 结构良好的 文档。如果该文档还满足您的公司所定义的支出帐目文档规则，那么它也是 有效的。 ）

如果 XML 解析器发现 XML 文档不是结构良好的，XML Specification 要求解析器报告一个致命错误。但验证是一个不同的问题。验证解析器 在解析时验证 XML 文档，而 非验证解析器 不验证文档。换句话说，如果一个 XML 文档是结构良好的，那么非验证解析器并不关心文档是否符合 DTD 或模式中定义的规则，甚至不关心该文档是否有这样的规则（原因：验证需要大量工作）

设置：

1首先请访问 Apache XML Project (http://xml.apache.org/xerces2-j/) 上的 Xerces XML 解析器主页。您也可以直接去 下载页面 (http://xml.apache.org/xerces2-j/download.cgi)。

2解压从 Apache 下载的文件。根据解析器版本的不同，这样将会创建名为 xerces-2_5_0 或者类似名称的目录。所需要的 JAR 文件（xercesImpl.jar 和 xml-apis.jar）应该出现在 Xerces 根目录下。

3访问 JDOM 项目站点 并下载最新版本的 JDOM (http://jdom.org/)。

4解压从 JDOM 下载的文件，这样将建立名为 jdom-b9 或者类似名称的目录。所需要的 JAR 文件（jdom.jar）应该在 build 目录中。

5最后请下载本教程的示例压缩文件 ，并解压该文件。

6把当前目录 (.)、xercesImpl.jar、xml-apis.jar 和 jdom.jar 添加到 CLASSPATH 变量中。

使用解析器：

1创建一个解析器对象

2使解析器指向您的 XML 文档

3处理结果


SAX：
Simple API for XML (SAX) API 是处理 XML 文档内容的一种替代方法。它的设计目标是更少的内存占用，但是把更多的工作交给了程序员。SAX 和 DOM 是互补的，有各自的适用环境。
 

SAX 和 DOM 都过于复杂，

和 DOM 类似，JDOM 也提供一个对象树表示 XML 文档，但是这些对象工作的方式对 Java 程序员更直观。要记住，JDOM 在背后包含使用普通 SAX 或 DOM 解析器的适配器；JDOM 对所有主要的（和几个次要的） Java XML 解析器都提供了适配器，因此不必担心您的 Java XML 解析器是否支持 JDOM。JDOM 在幕后使用一个解析器不需要您的干涉。

DOM

DOM 是处理 XML 文档结构的一种接口。作为一个 W3C 项目，DOM 的设计目标是提供一组对象和方法，使程序员的工作更轻松。

当使用 DOM 解析器解析一个 XML 文档时，您得到一个层次化的数据结构（DOM 树），它表示解析器在 XML 文档中发现的所有内容。然后您可以使用 DOM 函数操纵这棵树。您可以搜索树中的内容、移动分支、增加新的分支或者删除树的一部分。

DOM 解析器返回一个树状结构，这个 DOM 树包含一些 Node。从 Java 语言的角度看，Node 是一个接口。Node 是 DOM 的基本数据类型，DOM 树中的所有事物都是这种或那种类型的 Node。

DOM Level 1 还定义了 Node 接口的几种子接口：

• Element：表示源文档中的一个 XML 元素。
• Attr：表示 XML 元素的一个属性。
• Text：一个元素的内容。这意味着带有文本的元素包含文本节点孩子，元素的文本 不是 元素本身的一个属性。
• Document：表示整个 XML 文档。解析的每个 XML 文档中有且只有一个 Document 对象。给定一个 Document 对象就可以找到 DOM 树的根，从这个根可以使用 DOM 函数读和操纵树。

注意：“元素”和“标签”这两个词有不同的含义。元素 是指起始元素、结束元素以及两者之间的一切内容，包括属性、文本、注释以及子元素。标签 是一对<尖括号>和两者之间的内容，包括元素名和所有属性。比如 <p class="blue"> 是一个标签，</p> 也是；而 <p class="blue">The quick brown fox</p> 是一个元素。

DOM 经常要用到以下方法：

• Document.getDocumentElement()：返回 DOM 树的根。（该函数是 Document 接口的一个方法，没有定义其他的 Node 子类型。）
• Node.getFirstChild() 和 Node.getLastChild()：返回给定 Node 的第一个和最后一个孩子。
• Node.getNextSibling() 和 Node.getPreviousSibling()：返回给定 Node 的下一个和上一个兄弟。
• Element.getAttribute(String attrName)：对于给定的 Element，返回名为 attrName 的属性的值。如果需要 "id" 属性的值，可以使用 Element.getAttribute("id")。如果该属性不存在，该方法返回一个空字符串 ("")。

第 1 步：扫描命令行

public static void main(String argv[])
{
if (argv.length == 0 ||
(argv.length == 1 && argv[0].equals("-help")))
{
System.out.println("\nUsage:  java DomOne uri");
System.out.println("   where uri is the URI of the XML " +
"document you want to print.");
System.out.println("   Sample:  java DomOne sonnet.xml");
System.out.println("\nParses an XML document, then writes " +
"the DOM tree to the console.");
System.exit(1);
}
DomOne d1 = new DomOne();
d1.parseAndPrint(argv[0]);
}

第 2 步：创建一个解析器对象

下面的代码说明了先创建一个工厂对象，然后工厂对象创建解析器：

public void parseAndPrint(String uri)
{
Document doc = null;
try
{
DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
. . .

  第 3 步：解析 XML 文件

doc = db.parse(uri);

  第 4 步：打印 DOM 树的内容
 

  if (doc != null)
printDomTree(doc);
. . .
}
public void printDomTree(Node node)
{
int type = node.getNodeType();
switch (type)
{
// print the document element
case Node.DOCUMENT_NODE:
{
System.out.println("<?xml version=\"1.0\" ?>");
printDomTree(((Document)node).getDocumentElement());
break;
}

    case Node.ELEMENT_NODE:
{
System.out.print("<");
System.out.print(node.getNodeName());
NamedNodeMap attrs = node.getAttributes();
for (int i = 0; i < attrs.getLength(); i++)
printDomTree(attrs.item(i));
System.out.print(">");
if (node.hasChildNodes())
{
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++)
printDomTree(children.item(i));
}
System.out.print("</");
System.out.print(node.getNodeName());
System.out.print('>');
break;
}

    case Node.ATTRIBUTE_NODE:
{
System.out.print(" " + node.getNodeName() + "=\"" +
((Attr)node).getValue() + "\"");
break;
}
case Node.TEXT_NODE:
{
System.out.print(node.getNodeValue());
break;
}

尽管这里只是打印 DOM 树的内容，但多数围绕着 DOM 建立的 XML 应用程序都使用这种四个步骤的模式，第四步是递归处理例程。

运行 DomOne

在您解压示例文件的目录下键入：

javac DomOne.java

（记住 Java 语言是区分大小写的。）如果没有任何错误，键入：

java DomOne sonnet.xml

解析并显示文件 sonnet.xml。

如果一切都和预期的一样，您应该看到类似这样的内容：

C:\xml-prog-java>java DomOne sonnet.xml
<?xml version="1.0" ?>
<sonnet type="Shakespearean">
<author>
<lastName>Shakespeare</lastName>
<firstName>William</firstName>
<nationality>British</nationality>
<yearOfBirth>1564</yearOfBirth>
<yearOfDeath>1616</yearOfDeath>
</author>
<title>Sonnet 130</title>
<lines>
<line>My mistress' eyes are nothing like the sun,</line>
<line>Coral is far more red than her lips red.</line>
<line>If snow be white, why then her breasts are dun,</line>
<line>If hairs be wires, black wires grow on her head.</line>
. . .
</lines>

待续
摘自IBM在线学习

整个体系架构非常清晰，按照我们的要求实现了全部功能，而且相当稳定。但是打开具体的代码一看，拖沓冗长，水平不咋样。我们自己的一些程序员就有怪话了，说他们水平真低。但是！印度人能够把软件整体把握得很好，能够完成软件，并得到相当好的设计文档。

而中国人在那里琢磨数据结构、算法，界面人员就还没编码就想着是Outlook式的还是Visual Studio式的界面。到最后就成为Code高手，对某
些特定的开发工具精通，但是就是不能保证能够把一个软件稳当、完整的开发出来。

举个简单的例子：

软件中需要一个列表，用来表示我们处理的事务。该类表在业务繁忙的时候将变得很大。中国人就用双向链表，抱着《数据结构》书在那里写
链表的类。印度人开了一个大数组，然后就开始干。为什么印度人不用链表，他们说：

1.你们给出的设备（小型机），最少具备512M内存，浪费一些没有什么。

2.数组方式访问方便、效率高。

看出了一拿到东西就吭哧吭哧作Code，和好好进行软件分析的不同了吗？正好前几天我有几个同事从印度回来和我们交流，那家公司是CMM4级
公司。我感受的几点：

1.流程重于项目

2.QC（就是QA）独立于研发部门，专门检查研发部门的开发流程是不是按照既定流程走。如果QC觉得流程不对，他会直接上报高层，项目肯定就此停止。

3.所谓的项目经理（PC）一般也是从编码人员升上来的，并不是所谓的不懂技术，一般都至少有四年以上的经验

4.PC主要就是制定开发计划，负责协调，填写各种表格。

5.所有的东西（包括草稿）都有文档。

6.详细文档要求达到只有这个文档就可以编码的程度，一般写文档时间占60%，编码时间极少

7.有各种详细的review（同行评审），项目组内的，项目组之间的，客户的……

8.计划很详细，的确能达到小时级，但是实际情况还是误差比较大，所以他们也有加班。

先学习UML和Rose以及RUP，不要总是要找着证据。在中国的软件开发水平下，很难给你一个好的例子，OK？中国人总是要看到一个东西有了试
验田，而且稻子长得好，才换稻种。要知道在国外上述的软件开发模式的应用，大可以看看 Rational网页上的story。Just do it！一句话，中国的软件开发水平低得很。赶不上印度人，印度的软件公司可以让高中生编代码，它的软件工程水平可想而知。

当然，你如果是个很牛的程序员。估计够呛，因为中国的气氛中，很牛的程序员都很难接受软件工程的。你可以测试一下自己，看看自己适不适合现在学习软件工程

1.你是不是不能忍受一个编程序不如你的人做你的项目经理？
2.你是不是觉得你的老板对客户吹牛皮、夸大自己而感到不舒服？
3.你是不是一个拿到一个需求脑袋里第一念头就是如何实现的人？
4.你是不是很崇拜Stallman，Linus，很讨厌Microsoft？
5.你是不是曾经在深夜编码的时候，突然感觉到一种乏味，对Code的生涯感到一种无趣？我们现在处于深深的自卑当中，感到中国的软件工程水平的低下已经是牵涉到民族劣根性的问题了。

1.他们的软件教育水平：我们招聘印度人，给应聘者出了一份与国内差不多的试卷，有基础概念和编程题目。等到他们完成后，我们这些中国
的自认高手惊呆了！他们的编程题目简直象是抄袭的？？程序结构，注释，变量命名就不说了吧，全部都是极其类似！

反观中国的牛人、高手，每个人有自己的一套。到了新的岗位，先把前任的程序贬损一通，然后自己再开发更多的问题的代码来代替。我的公
司统计，一个软件中有4个以上CSocket版本，每个人都觉得别人做得差，自己再搞一套。中国人，就是这个样子，还会辩解说“我们这样有创造
性”。其实软件发展，早就走过了求伯君那个编码英雄的年代，程序员已经是个坐办公室的蓝领了。你具备拧好一个螺丝钉的能力就可以了，Code
是最低级的事情了。

2.他们许多公司的项目经理根本就不懂技术。中国的项目经理如果不能在技术上压服下属，那么下属将与他搞鬼，越是高手越喜欢搞鬼，根本不知道作软件的终极目的是从别人兜里掏钱，而在内部搞不团结。技术高手都会纠集一些对他技术上崇拜的菜鸟，与管理层作对。

而印度的软件经理根本就不懂正在做的东西，许多甚至直接就是MBA，或者是领域专家（工业设计、地理专家等），而不是编码的专家。但是却
能够领导大群素质良好的程序员把工作做好，没有内部不团结的情况。许多印度的程序员加入一个公司很长时间，都不知道自己整天编的代码是干
什么用的。给他们的任务可能就是一个函数的声明以及该函数要实现的功能。我们呢？

3.他们的编程人员的流动率达到 30%！他们的编程人员流动率（包括内部项目之间的流动）高达 30%，可以想见他们的文档水平如何。他们的
产品不依赖任何一个人，谁都可以立即辞职，产品的开发还是会正常进行。而中国，是老板怕总工。技术骨干拥兵自重，抗拒管理。任何制定好的计
划，都有可能被技术人员推翻或者跟你消极怠工。

4.他们的开发计划能够做到小时级别。如果一个印度公司的项目经理没有上班，那么他的下属将可能不知道作什么。他们的计划一般都定到天，
每个基层开发人员每天的工作量就是 8小时。而我们能够给出月度计划的公司就很少，而给出的月度计划要么不可能实现，要么就可能被取消。开发人员被初略的给个任务，他在月初，可以慢慢琢磨是做成什么样子，然后上上网，聊聊天。到了月中和月末，就开始熬夜编码。

看到每年，从各大高校不尽牛人滚滚来，我们是不得不要召人，同时又是不抱希望。我公司现在有意以后将核心软件开发外包给印度公司，中
国人？做做界面吧，中国人做界面会极尽奇技淫巧，搞得花里胡哨的。BTW，大家不要误会我有什么种族歧视。但是我们现在就是对自己歧视，自卑得很。中科院那么多研究院，连个能用的操作系统
都搞不定。

北大开发一些东西，比如什么青鸟CASE，就是给一帮人评职称的。杨芙清院士整天搞来搞去，搞出了什么东西？B大，T大的人最难管理，牛得看不见人。中国的程序员骂微软，追 Linux是全世界最狠的，可是我们除了汉化Linux，做了什么东西出来。CDE 是瑞典人写的，Linus是芬兰的，GNome是墨西哥人写的。哎，我们曾经是多么的瞧不起印度人......

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=2048678

• Servlet
• JavaBean(tm) 组件
• 语法

请求和响应

当一个用户在浏览器中输入 URL时，一个请求被创建并送到服务器上。依据请求的类型，服务器的响应可能是存放在服务器上的静态 HTML 页面，或者是从多方汇集的动态内容。

静态和动态响应

JSP 页面被一次编译为 servlet 并被载入到内存。如果 JSP 页面有了新版本，应用服务器将编译新的版本然后载入对应的新 servlet。

为什么要使用JSP呢？
首先，Java 编程语言具有 "Write Once, Run Anywhere(tm)"(书写一次，任意运行) 的特性。

  

罗嗦的注释一般比较难维护，通常不及一个小的、编写良好的方法那么好地表达意图，并且很快就会过期。根本不要过分依赖注释。

8：使方法是 public 的，变量是 protected 的，直到您有一个很好的理由限制访问。如果您对代码中您设想其他人不应该访问的东西限制访问，您就是在设想自己无所不知。这在大多数时候是一个危险的假设。不要以“这段代码不应该被调用”、或者“没有人会用这段代码”为理由气绝将代码设为public。

教学目的： 掌握哈希表的概念作用及意义，哈希表的构造方法

教学重点： 哈希表的构造方法

教学难点： 哈希表的构造方法

授课内容：

一、哈希表的概念及作用

一般的线性表，树中，记录在结构中的相对位置是随机的，即和记录的关键字之间不存在确定的关系，因此，在结构中查找记录时需进行一系列和关键字的比较。这一类查找方法建立在“比较“的基础上，查找的效率依赖于查找过程中所进行的比较次数。

理想的情况是能直接找到需要的记录，因此必须在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使每个关键字和结构中一个唯一的存储位置相对应。

哈希表最常见的例子是以学生学号为关键字的成绩表，１号学生的记录位置在第一条，１０号学生的记录位置在第１０条...

如果我们以学生姓名为关键字，如何建立查找表，使得根据姓名可以直接找到相应记录呢？

a	b	c	d	e	f	g	h	i	j	k	l	m	n	o	p	q	r	s	t	u	v	w	x	y	z
1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26

	刘丽	刘宏英	吴军	吴小艳	李秋梅	陈伟	...
姓名中各字拼音首字母	ll	lhy	wj	wxy	lqm	cw	...
用所有首字母编号值相加求和	24	46	33	72	42	26	...
最小值可能为3 最大值可能为78 可放75个学生

用上述得到的数值作为对应记录在表中的位置，得到下表：

		成绩一	成绩二...
3	...
...	...
24	刘丽	82	95
25	...
26	陈伟
...	...
33	吴军
...	...
42	李秋梅
...	...
46	刘宏英
...	...
72	吴小艳
...	...
78	...

上面这张表即哈希表。

如果将来要查李秋梅的成绩，可以用上述方法求出该记录所在位置：

李秋梅:lqm 12+17+13=42 取表中第42条记录即可。

问题：如果两个同学分别叫 刘丽 刘兰 该如何处理这两条记录？

这个问题是哈希表不可避免的，即冲突现象：对不同的关键字可能得到同一哈希地址。

二、哈希表的构造方法

１、直接定址法

例如：有一个从1到100岁的人口数字统计表，其中，年龄作为关键字，哈希函数取关键字自身。

地址	01	02	...	25	26	27	...	100
年龄	1	2	...	25	26	27	...	...
人数	3000	2000	...	1050	...	...	...	...
...

２、数字分析法

有学生的生日数据如下：

年.月.日

75.10.03
75.11.23
76.03.02
76.07.12
75.04.21
76.02.15
...

经分析,第一位，第二位，第三位重复的可能性大，取这三位造成冲突的机会增加，所以尽量不取前三位，取后三位比较好。

３、平方取中法

取关键字平方后的中间几位为哈希地址。

４、折叠法

将关键字分割成位数相同的几部分（最后一部分的位数可以不同），然后取这几部分的叠加和（舍去进位）作为哈希地址，这方法称为折叠法。

例如：每一种西文图书都有一个国际标准图书编号，它是一个10位的十进制数字，若要以它作关键字建立一个哈希表，当馆藏书种类不到10,000时，可采用此法构造一个四位数的哈希函数。如果一本书的编号为0-442-20586-4,则：

	5864		5864
	4220		0224
+)	04	+)	04
	-----------		-----------
	10088		6092
	H(key)=0088		H(key)=6092
	(a)移位叠加		(b)间界叠加

５、除留余数法

取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址。

H(key)=key MOD p (p<=m)

６、随机数法

选择一个随机函数，取关键字的随机函数值为它的哈希地址，即

H(key)=random(key) ,其中random为随机函数。通常用于关键字长度不等时采用此法。

三、总结

哈希表的优缺点

四、作业

 

预习如何处理冲突及哈希表的查找。

 http://www.bc-cn.net/Article/kfyy/sjjg/200411/261.html

教学目的： 掌握哈希表处理冲突的方法及哈希表的查找算法

教学重点： 哈希表处理冲突的方法

教学难点： 开放定址法

授课内容：

一、复习上次课内容

什么是哈希表？如何构造哈希表？

提出问题：如何处理冲突？

二、处理冲突的方法

		成绩一	成绩二...
3	...
...	...
24	刘丽	82	95
25	...
26	陈伟
...	...
33	吴军
...	...
42	李秋梅
...	...
46	刘宏英
...	...
72	吴小艳
...	...
78	...

如果两个同学分别叫 刘丽 刘兰，当加入刘兰时，地址24发生了冲突，我们可以以某种规律使用其它的存储位置，如果选择的一个其它位置仍有冲突，则再选下一个，直到找到没有冲突的位置。选择其它位置的方法有：

１、开放定址法

Hi=(H(key)+di) MOD m i=1,2,...,k(k<=m-1)

其中m为表长，di为增量序列

如果di值可能为1,2,3,...m-1，称线性探测再散列。

如果di取值可能为1,-1,2,-2,4,-4,9,-9,16,-16,...k*k,-k*k(k<=m/2)

称二次探测再散列。

如果di取值可能为伪随机数列。称伪随机探测再散列。

例：在长度为11的哈希表中已填有关键字分别为17,60,29的记录，现有第四个记录，其关键字为38，由哈希函数得到地址为5，若用线性探测再散列，如下：

0	1	2	3	4	5	6	7	8	9	10
					60	17	29

(a)插入前

0	1	2	3	4	5	6	7	8	9	10
					60	17	29	38

(b)线性探测再散列

0	1	2	3	4	5	6	7	8	9	10
					60	17	29

(c)二次探测再散列

0	1	2	3	4	5	6	7	8	9	10
			38		60	17	29

(d)伪随机探测再散列

伪随机数列为9,5,3,8,1...

２、再哈希法

当发生冲突时，使用第二个、第三个、哈希函数计算地址，直到无冲突时。缺点：计算时间增加。

３、链地址法

将所有关键字为同义词的记录存储在同一线性链表中。

４、建立一个公共溢出区

假设哈希函数的值域为[0,m-1],则设向量HashTable[0..m-1]为基本表，另外设立存储空间向量OverTable[0..v]用以存储发生冲突的记录。

三、哈希表的查找

//开放定址哈希表的存储结构

int hashsize[]={997,...};

typedef struct{

ElemType *elem;

int count;

int sizeindex;

}HashTable;

#define SUCCESS 1

#define UNSUCCESS 0

#define DUPLICATE -1

Status SearchHash(HashTable H,KeyType K,int &p,int &c){

p=Hash(K);

while(H.elem[p].key!=NULLKEY && !EQ(K,H.elem[p].key))

collision(p,++c);

if(EQ(K,H.elem[p].key)

return SUCCESS;

else return UNSUCCESS;

}

Status InsertHash(HashTable &H,EleType e){

c=0;

if(SearchHash(H,e.key,p,c))

return DUPLICATE;

else if(c<hashsize[H.sizeindex]/2){

H.elem[p]=e; ++H.count; return OK;

}

else RecreateHashTable(H);

}

四、总结

处理冲突的要求是什么？

      类图(Class diagram)由许多（静态）说明性的模型元素（例如类、包和它们之间的关系，这些元素和它们的内容互相连接）组成。类图可以组织在（并且属于）包中，仅显示特定包中的相关内容。

      类图(Class diagram)是最常用的UML图，显示出类、接口以及它们之间的静态结构和关系；它用于描述系统的结构化设计。

      类图(Class diagram)最基本的元素是类或者接口。

类图通常包含如下的内容

      类
      接口
      协作
      关系

      同其他的图一样，类图也可以包含注解和限制。

      类图中也可以包含包和子系统，这两者用来将元素分组。有时后你也可以将类的实例放到类图中。

      注：组件图和分布图和类图类似，虽然他们不包含类而是分别包含组件和节点。

一：run()和start()
示例1：
public class ThreadTest extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
new ThreadTest().start();
new ThreadTest().start();
}
}
这是个简单的多线程程序。run()和start()是大家都很熟悉的两个方法。把希望并行处理的
代码都放在run()中；stat()用于自动调用run()，这是JAVA 的内在机制规定的。并且run()
的访问控制符必须是public，返回值必须是void（这种说法不准确，run()没有返回值），run()
不带参数。
这些规定想必大家都早已知道了，但你是否清楚为什么run 方法必须声明成这样的形式？这涉
及到JAVA 的方法覆盖和重载的规定。这些内容很重要，请读者参考相关资料。

二：关键字synchronized
有了synchronized 关键字，多线程程序的运行结果将变得可以控制。synchronized 关键
字用于保护共享数据。请大家注意"共享数据"，你一定要分清哪些数据是共享数据，JAVA 是面向
对象的程序设计语言，所以初学者在编写多线程程序时，容易分不清哪些数据是共享数据。请看下
面的例子：
示例2：
public class ThreadTest implements Runnable
{ public synchronized void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
Runnable r1 = new ThreadTest();
Runnable r2 = new ThreadTest();
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
在这个程序中，run()被加上了synchronized 关键字。在main 方法中创建了两个线程。你
可能会认为此程序的运行结果一定为：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。但你
错了！这个程序中synchronized 关键字保护的不是共享数据（其实在这个程序中synchronized
关键字没有起到任何作用，此程序的运行结果是不可预先确定的）。这个程序中的t1,t2 是两个   对象（r1,r2）的线程。JAVA
是面向对象的程序设计语言，不同的对象的数据是不同的，r1,r2 有
各自的run()方法，而synchronized 使同一个对象的多个线程，在某个时刻只有其中的一个线程
可以访问这个对象的synchronized 数据。每个对象都有一个"锁标志"，当这个对象的一个线程
访问这个对象的某个synchronized 数据时，这个对象的所有被synchronized 修饰的数据将被
上锁（因为"锁标志"被当前线程拿走了），只有当前线程访问完它要访问的synchronized 数据
时，当前线程才会释放"锁标志"，这样同一个对象的其它线程才有机会访问synchronized 数据。
示例3：
public class ThreadTest implements Runnable
{
public synchronized void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start(); t2.start();
}
}
如果你运行1000 次这个程序，它的输出结果也一定每次都是：0 1 2 3 4 5 6 7 8 9 0 1
2 3 4 5 6 7 8 9。因为这里的synchronized 保护的是共享数据。t1,t2 是同一个对象（r）
的两个线程，当其中的一个线程（例如：t1）开始执行run()方法时，由于run()受synchronized
保护，所以同一个对象的其他线程（t2）无法访问synchronized 方法（run 方法）。只有当t1
执行完后t2 才有机会执行。
示例4：
public class ThreadTest implements Runnable
{
public void run()
{
synchronized(this)
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
这个程序与示例3 的运行结果一样。在可能的情况下，应该把保护范围缩到最小，可以用示例
4 的形式，this 代表"这个对象"。没有必要把整个run()保护起来，run()中的代码只有一个for 循环，所以只要保护for 循环就可以了。
示例5：
public class ThreadTest implements Runnable
{
public void run()
{
for(int k=0;k<5;k++)
{
System.out.println(Thread.currentThread().getName()
+ " : for loop : " + k); }
synchronized(this)
{
for(int k=0;k<5;k++)
{
System.out.println(Thread.currentThread().getName()
+ " : synchronized for loop : " + k);
}
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.start();
t2.start();
}
}
运行结果：
t1_name : for loop : 0
t1_name : for loop : 1
t1_name : for loop : 2
t2_name : for loop : 0
t1_name : for loop : 3
t2_name : for loop : 1
t1_name : for loop : 4
t2_name : for loop : 2
t1_name : synchronized for loop : 0
t2_name : for loop : 3
t1_name : synchronized for loop : 1
t2_name : for loop : 4
t1_name : synchronized for loop : 2
t1_name : synchronized for loop : 3
t1_name : synchronized for loop : 4
t2_name : synchronized for loop : 0
t2_name : synchronized for loop : 1
t2_name : synchronized for loop : 2
t2_name : synchronized for loop : 3
t2_name : synchronized for loop : 4
第一个for 循环没有受synchronized 保护。对于第一个for 循环，t1,t2 可以同时访问。
运行结果表明t1 执行到了k=2 时，t2 开始执行了。t1 首先执行完了第一个for 循环，此时t2
还没有执行完第一个for 循环（t2 刚执行到k=2）。t1 开始执行第二个for 循环，当t1 的第二
个for 循环执行到k=1 时，t2 的第一个for 循环执行完了。t2 想开始执行第二个for 循环，但
由于t1 首先执行了第二个for 循环，这个对象的锁标志自然在t1 手中（synchronized 方法的
执行权也就落到了t1 手中），在t1 没执行完第二个for 循环的时候，它是不会释放锁标志的。所
以t2 必须等到t1 执行完第二个for 循环后，它才可以执行第二个for 循环。

三：sleep()
示例6：
public class ThreadTest implements Runnable
{
public void run()
{
for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{}
}
System.out.print(" " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
}
}
sleep 方法会使当前的线程暂停执行一定时间（给其它线程运行机会）。读者可以运行示例6，
看看结果就明白了。sleep 方法会抛出异常，必须提供捕获代码。
示例7：
public class ThreadTest implements Runnable
{
public void run()
{ for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{}
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
t1 被设置了最高的优先级，t2 被设置了最低的优先级。t1 不执行完，t2 就没有机会执行。
但由于t1 在执行的中途休息了5 秒中，这使得t2 就有机会执行了。读者可以运行这个程序试试看。
示例8：
public class ThreadTest implements Runnable
{
public synchronized void run()
{
for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{} }
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.start();
t2.start();
}
}
请读者首先运行示例8 程序，从运行结果上看：一个线程在sleep 的时候，并不会释放这个对
象的锁标志。

四：join()
示例9：
public class ThreadTest implements Runnable
{
public static int a = 0;
public void run()
{
for(int k=0;k<5;k++)
{
a = a + 1;
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
System.out.println(a);
}
}
请问程序的输出结果是5 吗？答案是：有可能。其实你很难遇到输出5 的时候，通常情况下都
不是5。这里不讲解为什么输出结果不是5，我要讲的是：怎样才能让输出结果为5！其实很简单，
join()方法提供了这种功能。join()方法，它能够使调用该方法的线程在此之前执行完毕。
把示例9 的main()方法该成如下这样： public static void main(String[] args) throws Exception
{
Runnable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
t.join();
System.out.println(a);
}
这时，输出结果肯定是5！join()方法会抛出异常，应该提供捕获代码。或留给JDK 捕获。
示例10：
public class ThreadTest implements Runnable
{
public void run()
{
for(int k=0;k<10;k++)
{
System.out.print(" " + k);
}
}
public static void main(String[] args) throws Exception
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t1.join();
t2.start();
}
}
运行这个程序，看看结果是否与示例3 一样？

五：yield()
yield()方法与sleep()方法相似，只是它不能由用户指定线程暂停多长时间。按照SUN 的
说法：sleep
方法可以使低优先级的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会。而yield()方法只能使同优先级的线程有执行的机会。
示例11：
public class ThreadTest implements Runnable
{
public void run()
{ for(int k=0;k<10;k++)
{
if(k == 5 && Thread.currentThread().getName().equals("t1"))
{
Thread.yield();
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1");
Thread t2 = new Thread(r,"t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
输出结果：
t1 : 0
t1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t2 : 0
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
多次运行这个程序，输出也是一样。这说明：yield()方法不会使不同优先级的线程有执行的
机会。

六：wait(),notify(),notifyAll()
首先说明：wait(),notify(),notifyAll()这些方法由java.lang.Object 类提供，而上面
讲到的方法都是由java.lang.Thread 类提供（Thread 类实现了Runnable 接口）。
wait(),notify(),notifyAll()这三个方法用于协调多个线程对共享数据的存取，所以必
须在synchronized 语句块内使用这三个方法。先看下面了例子：
示例12：
public class ThreadTest implements Runnable
{
public static int shareVar = 0;
public synchronized void run()
{
if(shareVar == 0)
{
for(int i=0;i<10;i++)
{
shareVar++ ;
if(shareVar == 5)
{
try
{
this.wait();
}
catch(Exception e)
{}
}
}
}
if(shareVar != 0)
{
System.out.print(Thread.currentThread().getName());
System.out.println(" shareVar = " + shareVar);
this.notify();
}
}
public static void main(String[] args)
{
Runnable r = new ThreadTest();
Thread t1 = new Thread(r,"t1"); Thread t2 = new Thread(r,"t2");
t1.start();
t2.start();
}
}
运行结果：
t2 shareVar = 5
t1 shareVar = 10
t1线程最先执行。由于初始状态下shareVar 为0，t1 将使shareVar 连续加1，当shareVar
的值为5 时，t1 调用wait()方法，t1 将处于休息状态，同时释放锁标志。这时t2 得到了锁标志
开始执行，shareVar 的值已经变为5，所以t2 直接输出shareVar 的值，然后再调用notify()
方法唤醒t1。t1 接着上次休息前的进度继续执行，把shareVar 的值一直加到10，由于此刻
shareVar 的值不为0，所以t1 将输出此刻shareVar 的值，然后再调用notify()方法，由于
此刻已经没有等待锁标志的线程，所以此调用语句不起任何作用。
这个程序简单的示范了wait(),notify()的用法，读者还需要在实践中继续摸索。

七：关于线程的补充
编写一个具有多线程能力的程序可以继承Thread 类，也可以实现Runnable 接口。在这两个
方法中如何选择呢？从面向对象的角度考虑，作者建议你实现Runnable 接口。有时你也必须实现
Runnable 接口，例如当你编写具有多线程能力的小应用程序的时候。
线程的调度：
一个Thread 对象在它的生命周期中会处于各种不同的状态，上图形象地说明了这点。wa in
调用start()方法使线程处于可运行状态，这意味着它可以由JVM 调度并执行。这并不意味
着线程就会立即运行。
实际上，程序中的多个线程并不是同时执行的。除非线程正在真正的多CPU 计算机系统上执行，
否则线程使用单CPU 必须轮流执行。但是，由于这发生的很快，我们常常认为这些线程是同时执行
的。
JAVA 运行时系统的计划调度程序是抢占性的。如果计划调度程序正在运行一个线程并且来了另
一个优先级更高的线程，那么当前正在执行的线程就被暂时终止而让更高优先级的线程执行。
JAVA 计划调度程序不会为与当前线程具有同样优先级的另一个线程去抢占当前的线程。但是，
尽管计划调度程序本身没有时间片（即它没有给相同优先级的线程以执行用的时间片），但以
Thread 类为基础的线程的系统实现可能会支持时间片分配。这依赖具体的*作系统，Windows 与
UNIX 在这个问题上的支持不会完全一样。
由于你不能肯定小应用程序将运行在什么*作系统上，因此你不应该编写出依赖时间片分配的
程序。就是说，应该使用yield 方法以允许相同优先级的线程有机会执行而不是希望每一个线程都自动得到一段CPU 时间片。
Thread 类提供给你与系统无关的处理线程的机制。但是，线程的实际实现取决于JAVA 运行
所在的*作系统。因此，线程化的程序确实是利用了支持线程的*作系统。
当创建线程时，可以赋予它优先级。它的优先级越高，它就越能影响运行系统。JAVA 运行系统
使用一个负责在所有执行JAVA 程序内运行所有存在的计划调度程序。该计划调度程序实际上使用
一个固定优先级的算法来保证每个程序中的最高优先级的线程得到CPU――允许最高优先级的线程
在其它线程之前执行。
对于在一个程序中有几个相同优先级的线程等待执行的情况，该计划调度程序循环地选择它们，
当进行下一次选择时选择前面没有执行的线程，具有相同优先级的所有的线程都受到平等的对待。
较低优先级的线程在较高优先级的线程已经死亡或者进入不可执行状态之后才能执行。
继续讨论wait(),notify(),notifyAll()：
当线程执行了对一个特定对象的wait()调用时，那个线程被放到与那个对象相关的等待池中。
此外，调用wait()的线程自动释放对象的锁标志。
可以调用不同的wait()：wait() 或wait(long timeout)
对一个特定对象执行notify()调用时，将从对象的等待池中移走一个任意的线程，并放到锁
标志等待池中，那里的线程一直在等待，直到可以获得对象的锁标志。notifyAll()方法将从对象
等待池中移走所有等待那个对象的线程并放到锁标志等待池中。只有锁标志等待池中的线程能获取
对象的锁标志，锁标志允许线程从上次因调用wait()而中断的地方开始继续运行。
在许多实现了wait()/notify()机制的系统中，醒来的线程必定是那个等待时间最长的线程。
然而，在Java 技术中，并不保证这点。
注意，不管是否有线程在等待，都可以调用notify()。如果对一个对象调用notify()方法，
而在这个对象的锁标志等待池中并没有线程，那么notify()调用将不起任何作用。
在JAVA 中，多线程是一个神奇的主题。之所以说它"神奇"，是因为多线程程序的运行结果不
可预测，但我们又可以通过某些方法控制多线程程序的执行。要想灵活使用多线程，读者还需要大
量实践。
另外，从JDK 1.2 开始，SUN 就不建议使用resume(),stop(),suspend()了。

转http://vegetable318.bokee.com

UML图与应用代码例子:

[具体表现]
依赖关系表现在局部变量，方法的参数，以及对静态方法的调用

[现实例子]
比如说你要去拧螺丝，你是不是要借助(也就是依赖)螺丝刀(Screwdriver)来帮助你完成拧螺丝(screw)的工作

[UML表现](图1.2)

图1.2 Person类与Screwdriver类的依赖关系

[代码表现]

1. public class Person{   
2.     /** 拧螺丝 */  
3.     public void screw(Screwdriver screwdriver){   
4.         screwdriver.screw();   
5.     }   
6. }  

3.关联(Association)
对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。

[具体表现]
关联关系是使用实例变量来实现

[现实例子]
比如客户和订单，每个订单对应特定的客户，每个客户对应一些特定的订单；再例如公司和员工，每个公司对应一些特定的员工，每个员工对应一特定的公司

[UML图] (图1.3)

图1.3 公司和员工的关联关系

[代码表现]