一般来说，不要在expression1、expression2中使用函数的返回值；
不要将其使用在public函数中检查输入参数，但可以用于private函数中检测输入参数。

使用时，编译时需要用javac -source；执行时需要使用java -ea。

个人的一点理解：使用assert只是为了帮助我们调试程序，因此使用assert所遵循的原则就是“不能因为有了assert的存在而使程序的结构发生任何的改变”，说白了就是“如果把assert部分删除了，程序依然不会有任何的问题，只不过不能帮助我们检查出一些错误来了”，因此使用assert的时候不应该在表达式中使用函数，因为一旦把这句assert语句删除后，程序的结构就改变了，这不符合上述提到的原则！

 附上一篇写得很不错的原文：

深入解析Java的assertion

一、assertion的语法和语义

    J2SE 1.4在语言上提供了一个新特性，就是assertion(断言)功能，它是该版本在Java语言方面最大的革新。在软件开发中，assertion是一种经典的调试、测试方式，本文将深入解析assertion功能的使用以及其设计理念，并给出相关的例子 。

     assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制，如C，C++和Eiffel等，但是支持的形式不尽相同，有的是通过语言本身、有的是通过库函数等。另外，从理论上来说，通过assertion方式可以证明程序的正确性，但是这是一项相当复杂的工作，目前还没有太多的实践意义。

      在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。下面简单介绍一下Java中assertion的实现。

1．1) 语法表示

在语法上，为了支持assertion，Java增加了一个关键字assert。它包括两种表达式，分别如下：

1. assert expression1;
2. assert expression1: expression2;

在两种表达式中，expression1表示一个boolean表达式，expression2表示一个基本类型或者是一个对象(Object) ，基本类型包括boolean,char,double,float,int和long。由于所有类都为Object的子类，因此这个参数可以用于所有对象。

1．2) 语义含义

在运行时，如果关闭了assertion功能，这些语句将不起任何作用。如果打开了assertion功能，那么expression1的值将被计算，如果它的值为false，该语句强抛出一个AssertionError对象。如果assertion语句包括expression2参数，程序将计算出expression2的结果，然后将这个结果作为AssertionError的构造函数的参数，来创建AssertionError对象，并抛出该对象；如果expression1值为true，expression2将不被计算。

一种特殊情况是，如果在计算表达式时，表达式本身抛出Exception，那么assert将停止运行，而抛出这个Exception。

1．3) 一些assertion例子

下面是一些Assert的例子。

1. assert　　0 < value;
2. assert　　0 < value:"value="+value;
3. assert　　ref != null:"ref doesn't equal null";
4. assert　　isBalanced();

1．4) 编译

由于assert是一个新关键字，使用老版本的JDK是无法编译带有assert的源程序。因此，我们必须使用JDK1.4(或者更新)的Java编译器，在使用Javac命令时，我们必须加上-source 1.4作为参数。-source 1.4表示使用JDK 1.4版本的方式来编译源代码，否则编译就不能通过，因为缺省的Javac编译器使用JDK1.3的语法规则。

一个简单的例子如下：

javac      -source   1.4    test.java

1．5) 运行

由于带有assert语句的程序运行时，使用了新的ClassLoader和Class类，因此，这种程序必须在JDK1.4(或者更高版本)的JRE下运行，而不能在老版本的JRE下运行。

由于我们可以选择开启assertion功能，或者不开启，另外我们还可以开启一部分类或包的assertion功能，所以运行选项变得有些复杂。通过这些选项，我们可以过滤所有我们不关心的类，只选择我们关心的类或包来观察。下面介绍两类参数：

1. 参数 -esa 和 -dsa：
   它们含义为开启(关闭)系统类的assertion功能。由于新版本的Java的系统类中，也使了assertion语句，因此如果用户需要观察它们的运行情况，就需要打开系统类的assertion功能 ，我们可使用-esa参数打开，使用 -dsa参数关闭。
   -esa和-dsa的全名为-enablesystemassertions和-disenablesystemassertions，全名和缩写名有同样的功能。
    
2. 参数 -ea和-ea：
   它们含义为开启(关闭)用户类的assertion功能：通过这个参数，用户可以打开某些类或包的assertion功能，同样用户也可以关闭某些类和包的assertion功能。打开assertion功能参数为-ea；如果不带任何参数，表示打开所有用户类；如果带有包名称或者类名称，表示打开这些类或包；如果包名称后面跟有三个点，代表这个包及其子包；如果只有三个点，代表无名包。关闭assertion功能参数为-da，使用方法与-ea类似。
   -ea和-da的全名为-enableassertions和-disenableassertions，全名和缩写名有同样的功能。
   下面表格表示了参数及其含义，并有例子说明如何使用。
   　

   参数	例子	说明
   -ea	java -ea	打开所有用户类的assertion
   -da	java -da	关闭所有用户类的assertion
   -ea:<classname>	java -ea:MyClass1	打开MyClass1的assertion
   -da:<classname>	java -da: MyClass1	关闭MyClass1的assertion
   -ea:<packagename>	java -ea:pkg1	打开pkg1包的assertion
   -da:<packagename>	java -da:pkg1	关闭pkg1包的assertion
   -ea:...	java -ea:...	打开缺省包(无名包)的assertion
   -da:...	java -da:...	关闭缺省包(无名包)的assertion
   -ea:<packagename>...	java -ea:pkg1...	打开pkg1包和其子包的assertion
   -da:<packagename>...	java -da:pkg1...	关闭pkg1包和其子包的assertion
   -esa	java -esa	打开系统类的assertion
   -dsa	java -dsa	关闭系统类的assertion
   综合使用	java -dsa:MyClass1:pkg1	关闭MyClass1和pkg1包的assertion

   
   其中...代表，此包和其子包的含义。例如我们有两个包为pkg1和pkg1.subpkg。那么pkg1...就代表pkg1和pkg1.subpkg两个包。
   另外，Java为了让程序也能够动态开启和关闭某些类和包的assertion功能，Java修该了Class和ClassLoader的实现，增加了几个用于操作assert的API。下面简单说明一下几个API的作用。
   ClassLoader类中的几个相关的API:
   　　setDefaultAssertionStatus:用于开启/关闭assertion功能
   　　setPackageAssertionStatus:用于开启/关闭某些包的assertion功能
   　　setClassAssertionStatus: 用于开启/关闭某些类的assertion功能
   　　clearAssertionStatus：用于关闭assertion功能
   　

二、assertion的设计问题

      首先，我们认为assertion是必要的。因为，如果没有统一的assertion机制，Java程序通常使用if-then-else或者switch-case语句进行assertion检查，而且检查的数据类型也不完全相同。assertion机制让Java程序员用统一的方式处理assertion问题，而不是按自己的方式处理。另外，如果用户使用自己的方式进行检查，那么这些代码在发布以后仍然将起作用，这可能会影响程序的性能。而从语言言层次支持assertion功能，这将把assertion对性能带来的负面影响降到最小。

      Java是通过增强一个关键字assert实现支持assertion，而不是使用一个库函数支持，这说明Java认为assertion对于语言本身来说是非常重要的。实际上，在Java的早期的规范中，Java是能够支持assert的，但是由于一些实现的限制，这些特性从规范中除去了。因此，assert的再次引入应该是恢复了Java对assert的支持。C语言就是通过Assert.h函数库实现断言的支持。

      Java的assertion的开启也和C语言不太一样，我们都知道在C语言中，assertion的开启是在编译时候决定的。当我们使用debug方式编译程序时候，assertion被开启，而使用release方式编译时候，assertion自动被关闭。而Java的assertion却是在运行的时候进行决定的。其实，这两种方式是各有优缺点。如果采用编译时决定方式，开发人员将处理两种类型的目标码，debug版本和release版本，这加大了文档管理的难度，但是提高了代码的运行效率。Java采用运行时决定的方式，这样所有的assertion信息将置于目标代码中，同一目标代码可以选择不同方式运行，增强目标代码的灵活性，但是它将牺牲因为assertion而引起一部分性能损失。Java专家小组认为，所牺牲的性能相当小，因此java采用了运行时决定方式。

      另外，我们注意到AssertionError作为Error的一个子类，而不是RuntimeException。关于这一点，专家组也进行了长期的讨论。Error代表一些异常的错误，通常是不可以恢复的，而RuntimeException强调该错误在运行时才发生的特点。AssertionError通常为非常关键的错误，这些错误往往是不容易恢复的，而且assertion机制也不鼓励程序员对这种错误进行恢复。因此，为了强调assertion的含义，Java专家小组选择了让AssertError为Error的子类。

三、assertion与继承

       在本节，我们将考虑assertion与继承的关系，研究assert是如何定位的。如果开启一个子类的assertion，那么它的父类的assertion是否执行？

       下面的例子将显示如果一个assert语句在父类，而当它的子类调用它时，该assert为false。我们看看在不同的情况下，该assertion是否被处理。

class Base
{
public void baseMethod()
{
assert      false : "Assertion failed:This is base ";// 总是assertion失败
System.out.println("Base Method");
}
}
class Derived
extends Base
{
public void derivedMethod()
{
assert false: "Assertion failed:This is derive";// 总是assertion失败
System.out.println( "Derived Method" );
}
public static void main( String[] args )
{
try
{
Derived derived = new Derived();
derived.baseMethod(  );
derived.derivedMethod();
}
catch( AssertionError ae )
{
System.out.println(ae);
}
}
}

运行命令	含义	结果
Java Derived	不启用assertion	Base Method Derived Method
Java -ea Derived	开启所有assertion	Java.lang.AssertionError:Assertion Failed:This is base
Java -da Derived	关闭所有assertion	Base Method Derived Method
Java -ea:Base Derived	仅打开Base的assertion	Java.lang.AssertionError:Assertion Failed:This is base
Java -ea:Derived Derived	仅打开Derived的assertion	Base Method Java.lang.AssertionError:Assertion Failed:This is derived

       从这个例子我们可以看出，父类的assert语句将只有在父类的assert开启才起作用，如果仅仅开启子类的assert，父类的assert仍然不运行。例如，我们执行java -ea:Derived Derived的时候，Base类的assert语句并不执行。因此，我们可以认为，assert语句不具有继承功能。

四、assertion的使用

       assertion的使用是一个复杂的问题，因为这将涉及到程序的风格，assertion运用的目标，程序的性质等问题。通常来说，assertion用于检查一些关键的值，并且这些值对整个程序，或者局部功能的完成有很大的影响，并且这种错误不容易恢复的。assertion表达式应该短小、易懂，如果需要评估复杂的表达式，应该使用函数计算。以下是一些使用assertion的情况的例子，这些方式可以让java程序的可靠性更高。

1. 检查控制流； 在if-then-else和swith-case语句中，我们可以在不应该发生的控制支流上加上assert false语句。如果这种情况发生了，assert能够检查出来。
   例如：x取值只能使1,2,3，我们的程序可以如下表示
   　

   	switch (x)
       { case 1: …;
       case 2: …;
       case 3: …
       default: assert false:"x value is invalid: "+x;
       }
       

2. 在私有函数计算前，检查输入参数是否有效；对于一私有些函数，要求输入满足一些特定的条件，那么我们可以在函数开始处使用assert进行参数检查。对于公共函数，我们通常不使用assertion检查，因为一般来说，公共函数必须对无效的参数进行检查和处理。而私有函数往往是直接使用的。
   例如：某函数可能要求输入的参数必须不为null。那么我们可以在函数的一开始加上 assert parameter1!=null : "paramerter is null in test method";
3. 在函数计算后，检查函数结果是否有效；对于一些计算函数，函数运行完成后，某些值需要保证一定的性质，因此我们可以通过assert检查该值。
   例如，我们有一个计算绝对值的函数，那么我们就可以在函数的结果处，加上一个语句：
   　

   assert  value>=0:"Value should be bigger than 0:"+value;

   通过这种方式，我们可以对函数计算完的结果进行检查。
4. 检查程序不变量；有些程序中，存在一些不变量，在程序的运行生命周期，这些不变量的值都是不变的。这些不变量可能是一个简单表达式，也可能是一个复杂的表达式。对于一些关键的不变量，我们可以通过assert进行检查。
   例如，在一个财会系统中，公司的支出和收入必须保持一定的平衡关系，因此我们可以编写一个表达式检查这种平衡关系，如下表示。
   　

             private boolean isBalance() {
       ……
       }
       

   在这个系统中，在一些可能影响这种平衡关系的方法的前后，我们都可以加上assert验证：assert isBalance():"balance is destoried";
   　

五、结论

        assertion为开发人员提供了一种灵活地调试和测试机制，它的使用也非常简单、方便。但是，如何规范、系统地使用assertion(特别是在Java语言中)仍然是一个亟待研究的问题。

关于作者 欧阳辰，北京大学计算机系硕士毕业，98年起开始研究基于java的软件开发、测试，参与开发、测试过多个基于Java的应用程序和Web服务项目。联系方式mailto:yeekee@sina.com 周欣，北京大学计算机系在读博士生，主要研究方向：程序理解、逆向工程及软件度量，联系方式 zhouxin@sei.pku.edu.cn。

而我们调用interrupt方法也很有趣，通常这个标志都是未被设置的，一旦调用这个方法，它就会设置这个标志，说白了，这个方法所完成的工作也就仅仅限于设置了一个这样的标志。接下来就能和上一段落中提到的事情相关联了，如果线程当前是阻塞的状态，那么它会利用这个标志啦，然后做“三件事情”，然后这个标志又被清除了；如果线程当前是非阻塞状态，那么该方法的调用也就仅仅是设置一个标志而已，注意设置了这个标记就和没设置这个标记完全不同了，一旦你再想调用sleep等阻塞方法时，它们都会“立刻跳出阻塞状态、抛出异常、清除标记”啦，呵呵。

至此，终于清除了interrupt方法的作用了吧？

式，Eclipse会加上：private static final long serialVersionUID = 1L;
　　其实这个问题倒也不影响程序的运行，但是我看到Problems里面有警告就不舒服，同时也说明我们写的代码还是不规范。不怕，我们有互

联网查查是怎么回事，具体的原因还就是和序列化中的这个serialVersionUID有关。
　　
　　serialVersionUID 用来表明类的不同版本间的兼容性。如果你修改了此类, 要修改此值。否则以前用老版本的类序列化的类恢复时会出错

。
　　
　　在JDK中，可以利用JDK的bin目录下的serialver.exe工具产生这个serialVersionUID，对于Test.class，执行命令：serialver Test。

　　为了在反序列化时，确保类版本的兼容性，最好在每个要序列化的类中加入private static final long serialVersionUID这个属性，具

体数值自己定义。这样，即使某个类在与之对应的对象已经序列化出去后做了修改，该对象依然可以被正确反序列化。否则，如果不显式定义

该属性，这个属性值将由JVM根据类的相关信息计算，而修改后的类的计算结果与修改前的类的计算结果往往不同，从而造成对象的反序列化因

为类版本不兼容而失败。

　　不显式定义这个属性值的另一个坏处是，不利于程序在不同的JVM之间的移植。因为不同的编译器实现该属性值的计算策略可能不同，从而

造成虽然类没有改变，但是因为JVM不同，出现因类版本不兼容而无法正确反序列化的现象出现。

　　
serialVersionUID作用：
序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。

你可以随便写一个，在Eclipse中它替你生成一个，有两种生成方式：
一个是默认的1L，比如：private static final long serialVersionUID = 1L;
一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：private static final long serialVersionUID = -

8940196742313994740L;之类的。

当你一个类实现了Serializable接口，如果没有定义serialVersionUID，Eclipse会提供这个提示功能告诉你去定义之。
在Eclipse中点击类中warning的图标一下，Eclipse就会自动给定两种生成的方式，如上面所述。如果不想定义它，在Eclipse的设置中也可以

把它关掉的，设置如下：
Window ==> Preferences ==> Java ==> Compiler ==> Error/Warnings ==> Potential programming problems
将Serializable class without serialVersionUID的warning改成ignore即可。

如果你没有考虑到兼容性问题时，就把它关掉，不过有这个功能是好的，这个serialVersionUID为了让该类别Serializable向后兼容。

如果你的类Serialized存到硬盘上面后，可是后来你却更改了类别的field(增加或减少或改名)，当你Deserialize时，就会出现Exception的，

这样就会造成不兼容性的问题。

但当serialVersionUID相同时，它就会将不一样的field以type的预设值Deserialize，这个可以避开不兼容性的问题。

　　1） private
　　类中限定为private的成员，只能被这个类本身访问。
　　如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。

　　2） default
　　类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。

　　3） protected
　　类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。

　　4） public
　　类中限定为public的成员，可以被所有的类访问。

　　表3-1列出了这些限定词的作用范围。

【表3-1】　java中类的限定词的作用范围比较
  =============================================================
||              同一个类  同一个包的类 不同包的子类  不同包非子类    ||
|| private     *                                                                                              ||
|| default     *                   *                                                                         ||
|| protected *                   *                              *                                        ||
|| public      *                   *                              *                        *              ||
  =============================================================
说明：上面这个表，看起来很简单，而且也很容易记忆，但是却蕴含着极为丰富的信息，可以从不同的角度来理解上面的这个表。
比如在同一个类里面时，四个关键词都相当于是public，可以不在乎限定词是什么；在同一个包里面时，除了private限定词外，所有的限定词的作用都完全等同于public。我们经常会思考这样一个问题：一个类的属性和方法是否对外可见？这个问题描述中提到的“可见”二字，当环境为“非子类”时，说白了就是我们能否通过实例化这个类后，用一个对象把这个类的这些字段或者方法给“点”出来，即“某对象.某属性（或某方法）”。因为通常我们都是在不同包的环境下操作的，比如我们会import很多系统的包中的类，诸如“import java.awt.*;”这样的语句，因此我们使用这些包中的类时，它们对我们的可见也就仅仅局限在使用“public”限定词修饰的属性或方法上了，因此大家往往会误以为只有public的东西才能点出来，实则不然，当我们在同一个包中的非子类中也可以把除了private修饰的东西之外的所有属性和方法给“点”出来。其实对于“点”这个运算，可以分两个角度去理解，既然能用到“点”操作，那就代表了我们使用的环境应该是“非子类”，非子类又可以分为“包内”和“非包内”，对于“包内”，只要不是private修饰的东西都能点出来；对于“非包内”则只能是public的东西才能点出来；；；如果是在“子类”中操作时，大家可以思考一下，我们还用“点”操作吗？显然不用了，因为在子类中，父类中定义的东西只要可见的话都可以被你拿过来用，因此根本就用不到点操作，当然这里也要分“包内”和“非包内”。对于default限定词，我们不能显示的使用它来定义属性或方法，只要我们在定义属性或方法的前面什么限定词都不加，就默认的使用了default限定词。

final变量是在整个类被创建时候被赋值，之后就不能改变了。
对于final变量，如果在声明的时候和构造的时候均不进行赋值，编译出错。

对于利用构造方法对final变量进行赋值的时候，此时在构造之前系统设置的默认值被覆盖。

常量（这里的常量指的是实例常量：即成员变量）赋值：
①在初始化的时候通过显式声明赋值。final int x=3；
②在构造的时候赋值。
class A{
 final int x;
 public A(){
 x=4;
 }
}

2. final方法不能被改写; 
利用final定义方法：这样的方法为一个不可覆盖的方法。
下面这样就会编译出错：
class A{
 public static void max(){
  System.out.println("A:max()");
 }
}
class B extends A{
 public void max(){
 }
}
为了保证方法的一致性（即不被改变），可将方法用final定义。
如果在父类中有final定义的方法，那么在子类中保证调用的是同一个父类方法。
如果一个方法前有修饰词private或static，则系统会自动在前面加上final。即private和static方法默认均为final方法。

注：类的修饰符仅限于abstract、final、public。Final和abstract永远不会同时出现。

3. final类不能被继承; 
final修饰类的时候，此类不可被继承，即final类没有子类。这样可以用final保证用户调用时动作的一致性，可以防止子类覆盖情况的发生。
String 类就是final类 ，目的是提供效率保证安全。

import java.applet.*;
import java.net.*;

public class InetAddDemo extends Applet{
 public void test(){
  try{
   InetAddress add=InetAddress.getLocalHost();
   System.out.println(add.getHostAddress());
   System.out.println(add.getHostName());
   System.out.println(InetAddress.getLocalHost());
   System.out.println(add.hashCode());
   byte [] b= add.getAddress();
   
   /*ByteArrayInputStream bais=new ByteArrayInputStream(b);
   InputStreamReader isr=new InputStreamReader(bais);
   BufferedReader br=new BufferedReader(isr);
   char [] ch=new char[b.length];
   br.read(ch);
   System.out.println(ch);
   这段代码依然不能够打印出我们期望的结果*/
   
   String s = "12345abcd";
   byte b2[] = s.getBytes();
   System.out.println(b2.toString());
   
   String s1="d我3a你2";
   byte [] s2=s1.getBytes();
   String s3=new String (s2);
   System.out.println(s3);
   String tt=new String(b);
   System.out.println(tt);
   System.out.println(Bytes2String(b));
   System.out.println(add.toString());
  }catch(Exception e){
   System.out.println(e.getMessage());
  }
 }
 
 public void init(){
  test();
 }
 
 public String Bytes2String(byte [] b){
  String str="";
  for(int i=0;i<b.length;i++){
   int t=(b[i]<<24)>>>24;
   str+=Integer.toString(t)+".";
  }
  str=str.substring(0, str.length()-1);
  return str;
 }
}

/*说明：
（1）java中定义变量并不需要赋予初始值，系统自动为其赋0值或null，但是这仅限于在类中定义的属于类的类变量，
而对于在类函数中定义的临时变量，则必须要赋初始值，否则会出错的！
（2）位运算赋默认的两端都是int型变量，而且返回值也是int型的。如果在位运算符的两端有一个变量为long型，则返回值也为long型。
（3）对于byte类型，比较特殊，首先它是整型，而且只有一个字节长度，而且是有符号的，这里需要特别说明的是
java中不会区分无符号和有符号，既然byte是一个字节的有符号数，那它的表示范围就是-128~127，但是我们经常会把byte作为
单字节的容器，比如在文件读写时，或作为缓冲区时都是使用byte这种类型，如果要把byte转化为字符时就会有问题，
比如：例如下面一个例子:

 import java.io.UnsupportedEncodingException;

 public class test{
  public static void main(String g[]) {
   String s = "12345abcd";
   byte b[] = s.getBytes();
   String t = b.toString();

   System.out.println(t);

  }
 }
 输出字符串的结果和字符串s不一样了.
 这是因为对于byte[]类型，它也是Object的子类，但是数组这种特殊的子类并没有特别的实现自己的toString()方法，因此我们调用
 "b.toString()"后，实际上还是调用了Object父类里的toString方法<函数体内的具体代码是：
 getClass().getName() + "@" + Integer.toHexString(hashCode())>，该方法只是返回了该类的Name+@+hashCode而已！
 有意思的是，对于数组类，类名字是在"["后紧跟数组的类型，比如这里返回的就是"[B"，呵呵，挺有趣吧？

 经过以下方式转码就可以正确转换了:

 public class test{
  public static void main(String g[]) {
   String s = "12345abcd";
   byte b[] = s.getBytes();
   try {
    String t = new String(b);
    System.out.print(t);
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
 }
因此如果只是单纯的使用它来作为一个中转的用途，那就无所谓了，但是一旦涉及到和字符的转化时就会有问题，
这里就暂且使用上述提到的方法，即重新构造一个String对象，但是构造String对象有着如下的从byte[]
转化为String类型的潜规则：
如果byte里存储的数据范围是0~127时，也就是字节的首位为0时，就会将byte[]数组中的一个字节拿出来转化为一个
两个字节的char类型，并把这个字符放到String中，如果范围为-128~-1时，也就是首位为1时，就会自动的把
btye[]中下一个字节也拿出来，让这两个字节组合成一个两字节的char类型，然后存放到String中。从这里
也可以看出一个潜规则，汉字表示成两字节的二进制时，第一个字节肯定是负值。
因此对于今天做的这个程序来说，想要把保存在byte[]中的IP地址数值直接拿出来，需要人为的把byte中存储的
有符号数转化为无符号数据，用简单的位操作就可以实现了。
（4）还需要说明的一点是，java中没有运算符重载，对于String类所谓的+号可以连接字符串，其实只是在编译器里面做了点手脚，
并不是真正意义上的运算符重载。
（5）最后，还要说明的是，要熟练的掌握String和各种数值类型之间的转化方法：
举int型和String类型转化的例子吧：
int b --> String str：
<1>str=""+b;
<2>str=Integer.toString(b);//从int出发，利用Integer包装类实现
<3>str=String.valueOf(b);//从str出发，利用String类实现
String str --> int b;
b=Integer.parseInt(str);
b=Integer.parseInt(str, int radix);
最后，再对Integer.parseInt方法作一点说明，str字符串只能为三种形式之一，即"[0-9]*"、"-[0-9]*"
和"\u002D[0-9]*"两种形式之一，其中负号'-'的ASCii码就是\u002D，因此这两种形式是等价的，除此之外
的形式均非法，这里为了写得简洁，使用了正则表达式的写法[0-9]*表示任意长度数字序列。
*/

import java.io.IOException;
import java.net.*;

public class UDPServer implements Runnable{

 /**
  * @param args
  */
 
 public UDPServer(){
  new Thread(this).start();
  try{
   DatagramSocket dgs=new DatagramSocket(8765);
   byte [] buf=new byte[1024];
   DatagramPacket dgp=new DatagramPacket(buf,buf.length);
   
   for(int i=0;i<3;i++){
    dgs.receive(dgp);
    System.out.println("The server has received the datagram!");
    dgs.send(dgp);
   }
  }catch(IOException ioe){
   ioe.printStackTrace();
  }
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  new UDPServer();
 }

 public void run() {
  // TODO Auto-generated method stub
  new UDPClient();
 }

}
/*
说明：
这里要对UDP方式作一个简要的说明，构成UDP通信机制的主要是两个类，即DatagramSocket和DatagramPacket，
主要包括发送和接收两个方面的内容，对于发送方来说，需要：
（1）建立一个DatagramSocket对象，注意建立的时候不需要指定端口，因为发送方关注的是发送成功，而不在乎是从本机的哪个端口发送出去的，
而发送的具体事宜则是由DatagramPacket来完成的，包括对目的地址的指定。
（2）建立一个DatagramPacket对象，注意要制定目的地址和对应的端口A。
（3）调用DatagramSocket对象的send函数发送，send函数的参数就是刚建立的DatagramPacket对象。
对于接收方来讲，需要：
（1）建立一个DatagramSocket对象，注意要指定端口，因为作为接收方，不在乎接收的东西是从哪里来的，而只是在本机的一个指定端口进行
接收就ok了，但需要注意这里的端口要与发送方投递的端口A一致。
（2）建立一个DatagramPacket对象，注意不必指定地址和端口，因为这是被动的接收，而在接收过程中，该DatagramPacket对象
扮演的角色仅仅是一个信息的承载者，也就是把从端口来的信息封存到它里面。
（3）调用DatagramSocket对象的receive函数接收，receive函数的参数就是刚建立的DatagramPacket对象。

最后，还有一点需要说明，就是在刚刚指出的接受模式来说，比如说本例中，虽然未给DatagramPacket对象指定地址和端口，但是
依然可以调用send函数进行发送，这是为什么呢？因为它先调用了receive函数，通过调用该函数，可以在接收过程中保存了信息的来源，
也就是地址和端口，因此下次再用send发送时，就仍然往这个地址和端口发送数据，因此可以发送成功。
*/

对于轻量级组件，都是继承于Container类的，“轻量级”部件需要一个处在容器体系上的“重量级”部件提供进行绘画的场所。当这个“重量级”的“祖宗”被告知要绘制自身的窗体时，它必须把这个绘画的请求转化为对其所有子孙的绘画请求。这是由java.awt.Container的paint()方法处理的，该方法调用包容于其内的所有可见的、并且与绘画区相交的轻量级部件的paint()方法。因此对于所有覆盖了paint()方法的Container子类（“轻量级”或“重量级”，Container的子类不一定都是轻量级组件哦，呵呵）都需要在函数的最后调用父类的paint方法，即super.paint(g)。

最后，对于AWT绘制，给出以下准则：
a.对于大多数程序，所有的客户区绘画代码应该被放置在部件的paint()方法中。
b.通过调用repaint()方法，程序可以触发一个将来执行的paint()调用，不能直接调用paint()方法。
c.对于界面复杂的部件，应该触发带参数的repaint()方法，使用参数定义实际需要更新的区域；而不带参数调用会导致整个部件被重画。
d.因为对repaint()的调用会首先导致update()的调用，默认地会促成paint()的调用，所以重量级部件应该覆盖update()方法以实现增量绘制，如果需要的话(轻量级部件不支持增量绘制) 。
e.覆盖了paint()方法的java.awt.Container子类应当在paint()方法中调用super.paint()以保证子部件能被绘制。
f.界面复杂的部件应该灵活地使用裁剪区来把绘画范围缩小到只包括与裁剪区相交的范围。

==============================================================================
Swing绘画的处理过程
 Swing处理"repaint"请求的方式与AWT有稍微地不同，虽然对于应用开发人员来讲其本质是相同的 -- 同样是触发paint()。Swing这么做是为了支持它的RepaintManager API (后面介绍)，就象改善绘画性能一样。在Swing里的绘画可以走两条路，如下所述：

(A) 绘画需求首先产生于一个重量级祖先(通常是JFrame、JDialog、JWindow或者JApplet)：
1。事件分派线程调用其祖先的paint()
2。Container.paint()的默认实现会递归地调用任何轻量级子孙的paint()方法。
3。当到达第一个Swing部件时，JComponent.paint()的默认执行做下面的步骤：
 i.如果部件的双缓冲属性为true并且部件的RepaintManager上的双缓冲已经激活，将把Graphics对象转换为一个合适的屏外Graphics。
 ii.调用paintComponent()(如果使用双缓冲就把屏外Graphics传递进去)。
 iii.调用paintBorder()(如果使用双缓冲就把屏外Graphics传递进去)。
 iv.调用paintChildren()(如果使用双缓冲就把屏外Graphics传递进去)，该方法使用裁剪并且遮光和optimizedDrawingEnabled等属性来严密地判定要递归地调用哪些子孙的paint()。
 v.如果部件的双缓冲属性为true并且在部件的RepaintManager上的双缓冲已经激活，使用最初的屏幕Graphics对象把屏外映像拷贝到部件上。

 注意：JComponent.paint()步骤#1和#5在对paint()的递归调用中被忽略了(这里的JComponent指的是在paintChildren()函数中判断出的需要递归调用的组件，在步骤#4中介绍了)，因为所有在swing窗体层次中的轻量级部件将共享同一个用于双缓冲的屏外映像。

(B) 绘画需求从一个javax.swing.JCponent扩展类的repaint()调用上产生：
1。JComponent.repaint()注册一个针对部件的RepaintManager的异步的重画需求，该操作使用invokeLater()把一个Runnable加入事件队列以便稍后执行在事件分派线程上的需求。
 
2。该Runnable在事件分派线程上执行并且导致部件的RepaintManager调用该部件上paintImmediately()，该方法执行下列步骤：

 i.使用裁剪框以及遮光和optimizedDrawingEnabled属性确定“根”部件，绘画一定从这个部件开始(处理透明以及潜在的重迭部件)。
 ii.如果根部件的双缓冲属性为true，并且根部件的RepaintManager上的双缓冲已激活，将转换Graphics对象到适当的屏外Graphics。
 iii.调用根部件(该部件执行上述(A)中的JComponent.paint()步骤#2-4)上的paint()，导致根部件之下的、与裁剪框相交的所有部件被绘制。
 iv.如果根部件的doubleBuffered属性为true并且根部件的RepaintManager上的双缓冲已经激活，使用原始的Graphics把屏外映像拷贝到部件。

 注意：如果在重画没有完成之前，又有发生多起对部件或者任何一个其祖先的repaint()调用，所有这些调用会被折迭到一个单一的调用，即回到最上层（这里的层指的是那种Hierarchy，而不是展现给我们的最上面的那个图或者按钮）的SWing部件的paintImmediately()，调用它的repaint()。例如，如果一个JTabbedPane包含了一个JTable并且在其包容层次中的现有的重画需求完成之前两次发布对repaint()的调用，其结果将变成对该JTabbedPane部件的paintImmediately()方法的单一调用，会触发两个部件的paint()的执行。
 
这意味着对于Swing部件来说，update()不再被调用。

虽然repaint()方法导致了对paintImmediately()的调用，它不考虑"回调"绘图，并且客户端的绘画代码也不会放置到paintImmediately()方法里面。实际上，除非有特殊的原因，根本不需要超载paintImmediately()方法。

===================================================================================
Swing绘画准则
Swing开发人员在写绘画代码时应该理解下面的准则：
1。对于Swing部件，不管是系统－触发还是程序－触发的请求，总会调用paint()方法；而update()不再被Swing部件调用。
 
2。程序可以通过repaint()触发一个异步的paint()调用，但是不能直接调用paint()。
 
3。对于复杂的界面，应该调用带参数的repaint()，这样可以仅仅更新由该参数定义的区域；而不要调用无参数的repaint()，导致整个部件重画。
 
4。Swing中实现paint()的3个要素是调用3个分离的回调方法：
 paintComponent()
 paintBorder()
 paintChildren()
 Swing部件的子类，如果想执行自己的绘画代码，应该把自己的绘画代码放在paintComponent()方法的范围之内。(不要放在paint()里面)。
 
5。Swing引进了两个属性来最大化的改善绘画的性能︰
 opaque: 部件是否要重画它所占据范围中的所有像素位？
 optimizedDrawingEnabled: 是否有这个部件的子孙与之交迭？
 
6。如果Swing部件的(遮光)opaque属性设置为true，那就表示它要负责绘制它所占据的范围内的所有像素位(包括在paintComponent()中清除它自己的背景)，否则会造成屏幕垃圾。
7。如果一个部件的遮光性(opaque)和optimizedDrawingEnabled属性有一个被设置为false，将导致在每个绘画操作中要执行更多的处理，因此我们推荐的明智的方法是同时使用透明并且交迭部件。
8。使用UI代理(包括JPanel)的Swing部件的扩展类的典型作法是在它们自己的paintComponent()的实现中调用super.paintComponent()。因为UI代理可以负责清除一个遮光部件的背景，不过这一操作需要根据规则#5中的设定来决定。
9。Swing通过JComponent的doubleBuffered属性支持内置的双缓冲，所有的Swing部件该属性默认值是true，然而把Swing容器的遮光设置为true有一个整体的构思，把该容器上的所有轻量级子孙的属性打开，不管它们各自的设定。
10。强烈建议为所有的Swing部件使用双缓冲。
11。界面复杂的部件应该灵活地运用剪切框来，只对那些与剪切框相交的区域进行绘画操作，从而减少工作量。

P.S.英文出处：http://java.sun.com/products/jfc/tsc/articles/painting/index.html

构造方法摘要
JTree()           返回带有示例模型的 JTree。
JTree(Hashtable<?,?> value)           返回从 Hashtable 创建的 JTree，它不显示根。
JTree(Object[] value)           返回 JTree，指定数组的每个元素作为不被显示的新根节点的子节点。
JTree(TreeModel newModel)           返回 JTree 的一个实例，它显示根节点 - 使用指定的数据模型创建树。
JTree(TreeNode root)           返回 JTree，指定的 TreeNode 作为其根，它显示根节点。
JTree(TreeNode root, boolean asksAllowsChildren)           返回 JTree，指定的 TreeNode 作为其根，它用指定的方式显示根节点，并确定节点是否为叶节点。
JTree(Vector<?> value)           返回 JTree，指定 Vector 的每个元素作为不被显示的新根节点的子节点。

常用方法：
1。得到模型：
getModel()或(DefaultTreeModel)getModel()
2。得到根：
getModel().getRoot()或(DefaultMutableTreeNode)getModel().getRoot()
3。根据node得到path：
TreePath visiblePath = new TreePath(((DefaultTreeModel)getModel()).getPathToRoot(node))
4。根据Path展开到该节点：
makeVisible(visiblePath)
5。根据path设定该节点选定
tree.setSelectionPath(visiblePath)
6。滚动到可见位置：
scrollRowToVisible(int row)
7。展开树<从根展开或从某一个节点展开>
关于JTree的展开
   // If expand is true, expands all nodes in the tree.
   // Otherwise, collapses all nodes in the tree.
 public static void expandAll(JTree tree, boolean expand) {
  TreeNode root = (TreeNode) tree.getModel().getRoot();

  // Traverse tree from root
  expandAll(tree, new TreePath(root), expand);
 }

 private static void expandAll(JTree tree, TreePath parent, boolean expand) {
  // Traverse children
  TreeNode node = (TreeNode) parent.getLastPathComponent();
  if (node.getChildCount() >= 0) {
   for (Enumeration e = node.children(); e.hasMoreElements();) {
    TreeNode n = (TreeNode) e.nextElement();
    TreePath path = parent.pathByAddingChild(n);
    expandAll(tree, path, expand);
   }
  }

  // Expansion or collapse must be done bottom-up
  if (expand) {
   tree.expandPath(parent);
  } else {
   tree.collapsePath(parent);
  }
 }
8。遍历树的所有节点<从根遍历或从某一个节点遍历>
public static void visitAllNodes(JTree tree) {
  TreeNode root = (TreeNode) tree.getModel().getRoot();
  visitAllNodes(tree,root);
 }

 public static void visitAllNodes(JTree tree,TreeNode node) {
  // node is visited exactly once
  //you can do your things about this node,such as:
  tree.makeVisible(new TreePath(
    ((DefaultTreeModel)tree.getModel()).getPathToRoot(node)));

  if (node.getChildCount() >= 0) {
   for (Enumeration e = node.children(); e.hasMoreElements();) {
    TreeNode n = (TreeNode) e.nextElement();
    visitAllNodes(tree,n);
   }
  }
 }
9。遍历树已经展开的节点<从根遍历或从某一个节点遍历>
// Traverse all expanded nodes in tree
 public static void visitAllExpandedNodes(JTree tree) {
  TreeNode root = (TreeNode) tree.getModel().getRoot();
  visitAllExpandedNodes(tree, new TreePath(root));
 }

 public static void visitAllExpandedNodes(JTree tree, TreePath parent) {
  // Return if node is not expanded
  if (!tree.isVisible(parent)) {
   return;
  }

  // node is visible and is visited exactly once
  TreeNode node = (TreeNode) parent.getLastPathComponent();
  //you can do your things about this node,such as:
  System.out.println(node.toString());

  // Visit all children
  if (node.getChildCount() >= 0) {
   for (Enumeration e = node.children(); e.hasMoreElements();) {
    TreeNode n = (TreeNode) e.nextElement();
    TreePath path = parent.pathByAddingChild(n);
    visitAllExpandedNodes(tree, path);
   }
  }
 }

一个较为完整的练习：
import java.awt.Dimension;
import java.awt.Color;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Enumeration;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.BoxLayout;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;

public class JTreeDemo {

 public static void expandAll(JTree tree, boolean expand) {
  TreeNode root = (TreeNode) tree.getModel().getRoot();

  // Traverse tree from root
  expandAll(tree, new TreePath(root), expand);
 }

 private static void expandAll(JTree tree, TreePath parent, boolean expand) {
  // Traverse children
  TreeNode node = (TreeNode) parent.getLastPathComponent();
  if (node.getChildCount() >= 0) {
   for (Enumeration e = node.children(); e.hasMoreElements();) {
    TreeNode n = (TreeNode) e.nextElement();
    TreePath path = parent.pathByAddingChild(n);
    expandAll(tree, path, expand);
   }
  }

  // Expansion or collapse must be done bottom-up
  if (expand) {
   tree.expandPath(parent);
  } else {
   tree.collapsePath(parent);
  }
 }

 
 public static void visitAllNodes(JTree tree) {
  TreeNode root = (TreeNode) tree.getModel().getRoot();
  visitAllNodes(tree,root);
 }

 public static void visitAllNodes(JTree tree,TreeNode node) {
  // node is visited exactly once
  //you can do your things about this node,such as:
  tree.makeVisible(new TreePath(
    ((DefaultTreeModel)tree.getModel()).getPathToRoot(node)));

  if (node.getChildCount() >= 0) {
   for (Enumeration e = node.children(); e.hasMoreElements();) {
    TreeNode n = (TreeNode) e.nextElement();
    visitAllNodes(tree,n);
   }
  }
 }

 // Traverse all expanded nodes in tree
 public static void visitAllExpandedNodes(JTree tree) {
  TreeNode root = (TreeNode) tree.getModel().getRoot();
  visitAllExpandedNodes(tree, new TreePath(root));
 }

 public static void visitAllExpandedNodes(JTree tree, TreePath parent) {
  // Return if node is not expanded
  if (!tree.isVisible(parent)) {
   return;
  }

  // node is visible and is visited exactly once
  TreeNode node = (TreeNode) parent.getLastPathComponent();
  //you can do your things about this node,such as:
  System.out.println(node.toString());

  // Visit all children
  if (node.getChildCount() >= 0) {
   for (Enumeration e = node.children(); e.hasMoreElements();) {
    TreeNode n = (TreeNode) e.nextElement();
    TreePath path = parent.pathByAddingChild(n);
    visitAllExpandedNodes(tree, path);
   }
  }
 }
 public static JTree tr;
 public static void main(String[] args) {

  // 构造函数：JTree()
  JTree example1 = new JTree();
  tr=example1;
  example1.setBackground(Color.lightGray);
  example1.addMouseListener(new MouseAdapter(){
   public void mouseClicked(MouseEvent me){
    try{
     visitAllNodes(tr);
     Thread.sleep(2000);
     System.out.println(tr.getPathForRow(1).toString());
     expandAll(tr,tr.getPathForRow(1),false);
     Thread.sleep(2000);
     visitAllExpandedNodes(tr);
    }catch(InterruptedException e){
     e.printStackTrace();
    }
   }
  });

  // 构造函数：JTree(Object[] value)
  Object[] letters = { " a ", " b ", " c ", " d ", " e " };
  JTree example2 = new JTree(letters);

  // 构造函数：JTree(TreeNode root)(TreeNode空)
  // 用空结点创建树
  DefaultMutableTreeNode node1 = new DefaultMutableTreeNode(); // 定义树结点
  JTree example3 = new JTree(node1); // 用此树结点做参数调用 JTree的构造函数创建含有一个根结点的树

  // 构造函数：JTree(TreeNode root)(同上,只是TreeNode非空)
  // 用一个根结点创建树
  DefaultMutableTreeNode node2 = new DefaultMutableTreeNode(" Color ");
  JTree example4 = new JTree(node2); // 结点不可以颜色,默认为白面黑字
  example4.setBackground(Color.lightGray);

  // 构造函数：JTree(TreeNode root, boolean
  // asksAllowsChildren)(同上,只是TreeNode又有不同)
  // 使用DefaultMutableTreeNode类先用一个根结点创建树，设置为可添加孩子结点,再添加孩子结点
  DefaultMutableTreeNode color = new DefaultMutableTreeNode(" Color ",
    true);
  DefaultMutableTreeNode gray = new DefaultMutableTreeNode(" Gray ");
  color.add(gray);
  color.add(new DefaultMutableTreeNode(" Red "));
  gray.add(new DefaultMutableTreeNode(" Lightgray "));
  gray.add(new DefaultMutableTreeNode(" Darkgray "));
  color.add(new DefaultMutableTreeNode(" Green "));
  JTree example5 = new JTree(color);

  // 构造函数：JTree(TreeNode root)(同上,只是TreeNode非空)
  // 通过逐个添加结点创建树
  DefaultMutableTreeNode biology = new DefaultMutableTreeNode(" Biology ");
  DefaultMutableTreeNode animal = new DefaultMutableTreeNode(" Animal ");
  DefaultMutableTreeNode mammal = new DefaultMutableTreeNode(" Mammal ");
  DefaultMutableTreeNode horse = new DefaultMutableTreeNode(" Horse ");
  mammal.add(horse);
  animal.add(mammal);
  biology.add(animal);
  JTree example6 = new JTree(biology);
  horse.isLeaf();
  horse.isRoot();

  // 构造函数:JTree(TreeModel newModel)
  // 用DefaultMutableTreeNodel类定义一个结点再用这个结点做参数定义一个用DefaultTreeMode
  // 创建一个树的模型,再用JTree的构造函数创建一个树

  DefaultMutableTreeNode root = new DefaultMutableTreeNode(" Root1 ");
  DefaultMutableTreeNode child1 = new DefaultMutableTreeNode(" Child1 ");
  DefaultMutableTreeNode child11 = new DefaultMutableTreeNode(" Child11 ");
  DefaultMutableTreeNode child111 = new DefaultMutableTreeNode(
    " Child111 ");
  root.add(child1);
  child1.add(child11);
  child11.add(child111);

  DefaultTreeModel model = new DefaultTreeModel(root);

  JTree example7 = new JTree(model);

  JPanel panel = new JPanel();
  panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS));
  panel.setPreferredSize(new Dimension(700, 400));
  panel.add(new JScrollPane(example1)); // JTree必须放在JScrollPane上
  panel.add(new JScrollPane(example2));
  panel.add(new JScrollPane(example3));
  panel.add(new JScrollPane(example4));
  panel.add(new JScrollPane(example5));
  panel.add(new JScrollPane(example6));
  panel.add(new JScrollPane(example7));

  JFrame frame = new JFrame(" JTreeDemo ");
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  frame.setContentPane(panel);
  frame.pack();
  frame.setVisible(true);
 }
}

另外一个例子，在该例子中笔者使用基于本机目录构建的模型来构建树：

/**
 * 查API时发现1.4FileSystemView这个东东多了一些功能,
 * 无聊地写了这个文件目录树
 *
 * 声明：使用j2sdk1.4
 * 建议:实现自己的File类，以过滤掉一般文件，只剩下目录
 * 缺点：gui慢得要死,swing的通病?(my pc==256ddr,thunderbird900,xp)
 */

import java.awt.Component;
import java.io.*;
import javax.swing.*;
import javax.swing.event.TreeModelListener;
import javax.swing.filechooser.FileSystemView;
import javax.swing.tree.*;

public class Test {

 /**
  * javax.swing.filechooser.FileSystemView在这个程序里很重要，
  * 用法参考j2sdk1.4 API文档
  * 切记，1.4 not 1.3!!!!!!!!
  */
 private static FileSystemView fileView;
 int a=BB;
 static int BB=34;

 /**
  *在这里使用了Singleton模式
  * 不过似乎没什么破用
  */
 static FileSystemView getFileView() {
  if (fileView == null)
   fileView = FileSystemView.getFileSystemView();
  return fileView;
 }
  
 public static void main(String[] args) throws Exception {
  //如果加入下面这句,会乱码.i wonder why
  UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());

  //initial frame
  JFrame frame = new JFrame();
  frame.setSize(400, 300);
  //关闭窗口时退出程序
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  //initial tree with customer TreeModel
  
  JTree tree = new JTree(new CustomTreeModel());

  //set customer TreeCellRenderer
  tree.setCellRenderer(new CustomTreeCellRenderer());
  frame.getContentPane().add(new JScrollPane(tree));
  frame.setVisible(true);
 }
}

class CustomTreeModel implements TreeModel {
 private FileSystemView fileView;

 public CustomTreeModel() {
  fileView = Test.getFileView();
 }

 //返回根节点
 public Object getRoot() {
  return fileView.getRoots()[0];
 }

 //返回父节点parent的第index个子节点,index以0开始
 public Object getChild(Object _parent, int index) {
  File parent = (File) _parent;
  return parent.listFiles()[index];
 }

 //返回父节点parent下,子节点child的位置,与上面的方法正好相反
 public int getIndexOfChild(Object parent, Object child) {
  File[] files = ((File) parent).listFiles();
  for (int i = 0; i < files.length; i++) {
   if (files[i].equals(child))
    return i;
  }
  return -1;
 }

 //返回父节点parent的子节点数
 public int getChildCount(Object parent) {
  File[] files = ((File) parent).listFiles();
  /**
   *maybe driver not ready,ie cdrom
   *then files is null
   */
  if (files == null)
   return -1;

  return files.length;
 }

 //是否叶节点
 public boolean isLeaf(Object node) {
  return ((File) node).isFile();
 }

 public void valueForPathChanged(TreePath path, Object newValue) {
 }

 /**
  *下面的方法要实现,则要涉及比较复杂的事件处理
  *如果有兴趣,
  *可以简单的使用javax.swing.EventListenerList来实现
  */
 public void addTreeModelListener(TreeModelListener l) {
 }

 public void removeTreeModelListener(TreeModelListener l) {
 }

}

/**
 * 如果没有安装自己的CellRenderer
 * JTree默认的CellRenderer就是JLabel
 * 它只是简单的setText(node.toString)
 * CustomeTreeCellRenderer也只是简单取回
 * windows默认的文件图标和文件名,装到JLabel上去
 */

class CustomTreeCellRenderer extends DefaultTreeCellRenderer {
 /**
  *
  */
 private static final long serialVersionUID = 3892593039200536416L;
 private FileSystemView fileView;

 public CustomTreeCellRenderer() {
  fileView = Test.getFileView();
 }

 public Component getTreeCellRendererComponent(JTree tree, Object value,
   boolean selected, boolean expanded, boolean leaf, int row,
   boolean hasFocus) {
  super.getTreeCellRendererComponent(tree, value, selected, expanded,
    leaf, row, hasFocus);
  File file = (File) value;
  setIcon(fileView.getSystemIcon(file));
  setText(fileView.getSystemDisplayName(file));
  return this;
 }
}

JDBC是一个通用的底层的、支持基本SQL功能的Java API。它提供了两部分与数据库独立的API，即JDBC API和JDBC Driver API。

Java程序通过JDBC API访问JDBC Driver Manager，JDBC Driver Manager再通过JDBC Driver API 访问不同的JDBC驱动程序，从而实现对不同数据库的访问。说白了就是底层是数据库，上层是用户的访问请求，中间层包括各个数据库的各自的驱动程序、用户调用的API函数，只不过这里的API有两个子层，中间加入了一个JDBC Driver Manager来进行管理。整个链是这样的：DB--〉DB Driver--〉JDBC Driver API--〉JDBC Driver Manager--〉JDBC API--〉用户

JDBC URL结构：

jdbc:<子协议>:<子名称>

例如：

jdbc:odbc:test

Tips:

(1)

如果通过网络来访问数据库，则将网络地址的放在子名称部分，格式为：//hostname:port/sub protocol

例如：

jdbc:dbnet://ant:356/fred

(2)

对于odbc子协议，比较特殊，可以在子名称后面接任意多个属性值的特征。因此odbc子协议的完整语法为：

jdbc:odbc:<数据源名称>[;<属性名>=<属性值>;......]

例如：

jdbc:odbc:mydb;UID=bacoo;PWD=bacoo

所有与数据库有关的对象和方法都在 java.sql 包中，因此在使用 JDBC 的程序中必须加入 "import java.sql.* "。 JDBC 要连接 ODBC 数据库，您必须首先加载 JDBC-ODBC 桥驱动程序

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

该语句加载驱动程序，并创建该类的一个实例。然后，要连接一个特定的数据库，您必须创建 Connect 类的一个实例，并使用 URL 语法连接数据库。

String url = "jdbc:odbc:Grocery prices";

Connection con = DriverManager.getConnection(url);

请注意，您使用的数据库名是您在 ODBC 设置面板中输入的“数据源”名称。

URL 语法可能因数据库类型的不同而变化极大。

jdbc:subprotocol:subname

第一组字符代表连接协议，并且始终是 jdbc。还可能有一个子协议，在此处，子协议被指定为 odbc。它规定了一类数据库的连通性机制。如果您要连接其它机器上的数据库服务器，可能也要指定该机器和一个子目录：

jdbc:bark//doggie/elliott

最后，您可能要指定用户名和口令，作为连接字符串的一部分：

jdbc:bark//doggie/elliot;UID=GoodDog;PWD=woof

*******************************************************************************************

*******************************************************************************************

上面给出了连接数据库的一种方法，其实还有另外一种方法，如下：

System.setProperty("jdbc.drivers","sun.jdbc.odbc.JdbcOdbcDriver");

String url = "jdbc:odbc:Grocery prices";

Connection con=DriverManager.getConnection(url);

说明：

我们可以用System.getProperty("jdbc.drivers")对设定的System属性值进行查询。其实，对于System属性，系统认可的属性如下：

java.version            Java Runtime Environment version
java.vendor            Java Runtime Environment vendor
java.vendor.url            Java vendor URL
java.home            Java installation directory
java.vm.specification.version                    Java Virtual Machine specification version
java.vm.specification.vendor                    Java Virtual Machine specification vendor
java.vm.specification.name                    Java Virtual Machine specification name
java.vm.version            Java Virtual Machine implementation version
java.vm.vendor            Java Virtual Machine implementation vendor
java.vm.name            Java Virtual Machine implementation name
java.specification.version                Java Runtime Environment specification version
java.specification.vendor             Java Runtime Environment specification vendor
java.specification.name        Java Runtime Environment specification name
java.class.version                        Java class format version number
java.class.path                  Java class path
java.library.path                        List of paths to search when loading libraries
java.io.tmpdir                Default temp file path
java.compiler            Name of JIT compiler to use
java.ext.dirs            Path of extension directory or directories
os.name                Operating system name
os.arch                Operating system architecture
os.version            Operating system version
file.separator            File separator ("/" on UNIX)
path.separator            Path separator (":" on UNIX)
line.separator            Line separator ("\n" on UNIX)
user.name            User's account name
user.home            User's home directory
user.dir                            User's current working directory

大家可以看到其中并没有jdbc.drivers这一个属性，但是System的属性可以随意的由我们来添加，比如我们用setProperty设定了一个名为“bacoo”的属性，并指定该属性值为“test”的话，那么当我们用getProperty时就可以检索到属性bacoo的值为test。这里之所以要加入“jdbc.drivers”这个属性值，是因为DriverManager这个类默认的会在初始化时去System中搜索这一属性的值，在这个属性值中我们可以将多个需要加载的驱动用冒号“:”隔开，又由于DriverManager是一个静态类（其实在定义一个类时，不允许用static修饰，只允许public、final、abstract三个修饰符，这里说其是静态类指的是该类的所有方法和属性<其实该类也没有属性，连构造函数都没有>均是静态的），因此在调用DriverManager.getConnection(url)时，DriverManager需要先初始化，就会加载驱动了。

访问数据库

一旦连接到数据库，就可以请求表名以及表列的名称和内容等信息，而且您可以运行 SQL 语句来查询数据库或者添加或修改其内容。可用来从数据库中获取信息的对象有：

DatabaseMetaData

有关整个数据库的信息：表名、表的索引、数据库产品的名称和版本、数据库支持的操作。

DatabaseMetaData dbmd;

dbmd=con.getMetaData();

下面重点介绍一下DatabaseMetaDat中的两个重要函数getTables和getColumns：

ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types)

仅返回与目录、模式、表名称和（表）类型标准匹配的表描述。

catalog：要在其中查找表名的目录名。对于 JDBC-ODBC 数据库以及许多其他数据库而言，可将其设置为 null。这些数据库的目录项实际上是它在文件系统中的绝对路径名称。

schemaPattern：要包括的数据库“方案”。许多数据库不支持方案，而对另一些数据库而言，它代表数据库所有者的用户名。一般将它设置为 null。

tableNamePattern：一个掩码，用来描述您要检索的表的名称。如果您希望检索所有表名，则将其设为通配符 %。请注意，SQL 中的通配符是 % 符号，而不是一般 PC 用户的 * 符号。

types[]：这是描述您要检索的表的类型的 String 数组。数据库中通常包括许多用于内部处理的表，而对作为用户的您没什么价值。如果它是空值，则您会得到所有这些表。如果您将其设为包含字符串“TABLES”的单元素数组，您将仅获得对用户有用的表格。

例子：

String [] types=new String[1];
types[0]="TABLE";

rs=dbmd.getTables(null, null, "%", types);

Java Doc中说该函数返回的表描述信息都包括以下10种信息，TABLE_CAT、TABLE_SCHEM、TABLE_NAME、TABLE_TYPE、REMARKS、TYPE_CAT、TYPE_SCHEM、TYPE_NAME、SELF_REFERENCING_COL_NAME、REF_GENERATION，但是在实际测试时，返回的结果中只有TABLE_CAT、TABLE_SCHEM、TABLE_NAME、TABLE_TYPE、REMARKS这5项。顺便要说一声的是，变量types可以取的值有："TABLE"、"VIEW"、"SYSTEM TABLE"、"GLOBAL TEMPORARY"、"LOCAL TEMPORARY"、"ALIAS" 和 "SYNONYM"，通常只取TABLE。

*************************************************************************************************************************************************************************************************

ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)

仅返回与目录、模式、表和列名称标准匹配的列描述。

通常在得到有关指定表（比如我们这里指定了表名为FoodPrice）的列的描述信息的结果集（rs）之后，我们重点关心的是COLUMN_NAME、DATA_TYPE（数据类型占用的字节数，比如整型就是4）、TYPE_NAME（INTEGER、CURRENCY之类的类型名称），当然最关心的肯定是COLUMN_NAME了。下面把结果集中所有可以得到的信息列给出如下：

TABLE_CAT、TABLE_SCHEM、TABLE_NAME、COLUMN_NAME、DATA_TYPE、TYPE_NAME、COLUMN_SIZE、BUFFER_LENGTH、DECIMAL_DIGITS、NUM_PREC_RADIX、NULLABLE、REMARKS、COLUMN_DEF、SQL_DATA_TYPE、SQL_DATETIME_SUB、CHAR_OCTET_LENGTH、ORDINAL_POSITION、IS_NULLABLE、ORDINAL。

例子：

rs=dbmd.getColumns(null, null, "FoodPrice", null);

因此我们通常用

while(rs.next()){
                System.out.print(rs.getString("COLUMN_NAME")+"\t");
}来得到该表中所有的列名称。其实这就是一个从结果集中检索的结果。

ResultSet

关于某个表的信息或一个查询的结果。您必须逐行访问数据行，但是您可以任何顺序访问列。

对于数据库中表的描述信息的结果集可以这样得到：rs=dbmd.getTables(null, null, "%", null);

对于某张表中的列的描述信息的结果集可以这样得到：rs=dbmd.getColumns(null, null, "FoodPrice", null);

对于要从表中检索具体的符合要求的结果集（而不仅仅是一些描述信息了）就必须使用如下的方法：

Statement st=con.createStatement();

String query="SELECT FoodName FROM FOOD;";//注意字符串中要包含“;”！
rs=st.executeQuery(query);

ResultSetMetaData

有关 ResultSet 中列的名称和类型的信息。

ResultSetMetaData rsmd;

rsmd = rs.getMetaData();

numCols = rsmd.getColumnCount();

// 打印列名
for (i = 1; i <= numCols; i++)

System.out.print(rsmd.getColumnName(i) + "     ");

System.out.println();

最后，给出一些零散的知识：

（1）对于数据库的连接、访问等等操作都需要放在try和catch块中进行，都有可能抛出SQLException异常，使用该异常类需要import java.sql.*;

（2）前面提到的DatabaseMetaDat、ResultSet、ResultSetMetaData均是接口，而不是类，在下面的例子中，通过跟踪调试，可以发现在程序运行过程中产生的都是基于JdbcOdbc驱动的类，即JdbcOdbcResultSet等类，把这些类（它们都实现了相应的接口）实例化后赋值给ResultSet接口，如ResultSet rs=dbmd.getColumns(null, null, "FoodPrice", null);因此，我们们不难推断出对于其他类型的数据库驱动，均是这样一个原理，同时也理解了为什么Java中有许多接口，而并没有与这些接口对应的实现了它们的类，再一次验证了接口就是一种标准，一种规范。

给出一个完整的例子：

package com.bacoo.www;

import java.sql.*;
public class JdbcOdbcTest {

    ResultSet rs;
    ResultSetMetaData rsmd;
    DatabaseMetaData dbmd;
    Connection con;
    int numCols,i;
    public JdbcOdbcTest(){
        System.setProperty("jdbc.drivers","sun.jdbc.odbc.JdbcOdbcDriver");
        String url="jdbc:odbc:Groceries";
        String query="SELECT DISTINCTROW FoodName FROM Food " +
                "WHERE (FoodName like 'C%');";
        try{
            //Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            con=DriverManager.getConnection(url);
            dbmd=con.getMetaData();
            System.out.println("Connected to:"+dbmd.getURL());
            System.out.println("Driver "+ dbmd.getDriverName());
            String [] types=new String[1];
            types[0]="TABLE";
            rs=dbmd.getTables(null, null, "%", null);
            dumpResults("--Tables--");
            rs.close();
        }catch(Exception e){
            System.out.println(e);
        }
        System.out.println("--Column Names--");
        try{
            rs=dbmd.getColumns(null, null, "FoodPrice", null);
            while(rs.next()){
                System.out.print(rs.getString("COLUMN_NAME")+" ");
            }
            System.out.println();
            rs.close();
        }catch(Exception e){
            System.out.println(e);
        }
        try{
            Statement st=con.createStatement();
            rs=st.executeQuery("SELECT FoodName FROM FOOD;");
        }catch(Exception e){
            System.out.println("query exception");
        }       
        dumpResults("--contents of FoodName column--");
        try{
            Statement st=con.createStatement();
            rs=st.executeQuery(query);
        }catch(Exception e){
            System.out.println("query exception");
        }
        dumpResults("--Results of Query--");
    }

    private void dumpResults(String head) {
        // 这是打印列标头和每列的内容的
        // 通用方法
        System.out.println(head);
        try {
            // 从元数据中获取列数
            rsmd = rs.getMetaData();
            numCols = rsmd.getColumnCount();
            // 打印列名
            for (i = 1; i <= numCols; i++)
                System.out.print(rsmd.getColumnName(i) + "、");
            System.out.println();
            // 打印列内容
            while (rs.next()) {
                for (i = 1; i <= numCols; i++)
                    System.out.print(rs.getString(i) + "\t");
                System.out.println();
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new JdbcOdbcTest();
        System.out.println(System.getProperty("jdbc.drivers"));
    }

}

运行的结果是：

Connected to:jdbc:odbc:Groceries
Driver JDBC-ODBC Bridge (odbcjt32.dll)
--Tables--
TABLE_CAT、TABLE_SCHEM、TABLE_NAME、TABLE_TYPE、REMARKS、
C:\Documents and Settings\Administrator\桌面\db1    null    MSysAccessObjects    SYSTEM TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    MSysAccessXML    SYSTEM TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    MSysACEs    SYSTEM TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    MSysObjects    SYSTEM TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    MSysQueries    SYSTEM TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    MSysRelationships    SYSTEM TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    Food    TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    FoodPrice    TABLE    null   
C:\Documents and Settings\Administrator\桌面\db1    null    Stores    TABLE    null   
--Column Names--
FSKey StoreKey FoodKey Price
--contents of FoodName column--
FoodName、
Apples   
Oranges   
Hamburger   
Butter   
Milk   
Coca Cola   
Green beans   
--Results of Query--
FoodName、
Coca Cola   
sun.jdbc.odbc.JdbcOdbcDriver

当然使用该例子，必须要先建立一个数据源。

其实，不光是JTabbedPane有这种问题，任何一个组件都不能在同一个容器（或面板）中被加载两次，不论以何种方式。

将抽象与其实现解耦，使它们都可以独立地变化。

大致意思是说：将一组实现与另一组使用他们的对象分离。这里的实现指的是抽象类及其

派生类用来实现自己的对象（而不是抽象类的派生类，这些派生类被称为具体类）。下面

是《Design Patterns Explained》书中的例子。其结构图如下：
  

下面是它的实现：

abstract　class Shape{

    protected Drawing myDrawing;

    abstract　public　void draw();

    Shape(Drawing drawing){

        myDrawing=drawing;

    }

    protected　void drawLine(){

        myDrawing.drawLine();

    }

    protected　void drawCircle(){

        myDrawing.drawCircle();

    }

}

class Rectangle extends Shape{

    public Rectangle(Drawing darw){

        super(darw);

    }

    public　void draw(){

        drawLine();

        drawLine();

        drawLine();

        drawLine();

    }

}

 class Circle extends Shape{

    public Circle(Drawing draw){

        super(draw);

    }

    publicvoid draw(){

        myDrawing.drawCircle();

    }

}

abstract　class Drawing{

    abstract　public　void drawLine();

    abstract　public　void drawCircle();

}

class V1Drawing extends Drawing{

    public　void drawLine(){

        DP1.draw_a_line();

    }

    public　void drawCircle(){

        DP1.draw_a_circle();

    }

}

class V2Drawing extends Drawing{

    public　void drawLine(){

        DP2.drawLine();

    }

    public　void drawCircle(){

        DP2.drawCircle();

    }

}

class DP1{

    public　static　void draw_a_line(){

        System.out.println("使用DP1的draw_a_line()画线");

    }

    public　static　void draw_a_circle(){

        System.out.println("使用DP1的draw_a_circle()画圆");

    }

}

class DP2{

    public　static　void drawLine(){

        System.out.println("使用DP2的drawLine()画线");

    }

    public　static　void drawCircle(){

        System.out.println("使用DP2的drawCircle()画圆");

    }

}

 public　class BridgeClient {

    public　static　void main(String[] args) {

        Drawing draw1=new V1Drawing();

        Drawing draw2=new V2Drawing();

        Shape shape1=new Rectangle(draw1);

        shape1.draw();

        Shape shape2=new Circle(draw2);

        shape2.draw();

    }

}

输出结果如下：

使用DP1的draw_a_line()画线

使用DP1的draw_a_line()画线

使用DP1的draw_a_line()画线

使用DP1的draw_a_line()画线

使用DP2的drawCircle()画圆

在这个例子中Shape对象实际上是一个Retangle或Circle对象，但Client并不知道到底是那个，因为它们看起来都一样。Drawing实际上是一个V1Drawing或V2Drawing,但Shape对象并知道到底是哪个，因为它们看起来都一样。DP1或DP2使用它的Drawing对象知道是哪一个。Shape是事物的抽象，Drawing是实现或者操作事物方法的抽象。他们两个都可以独立地变化。正如例子中所说那样，我们可以输出一个矩形可以使用V1Drawing也可以使用V2Drawing来完成，输出一个圆形也是一样都有两种方法。Bridge模式遵循了设计模式中两条基本策略：找出变化并封装之和优先使用对象聚集，而不是类继承。

    小结：Bridge模式是一种抽象与其实现相分离的模式。它主要应用于：当事物是一组变化量，和对这些事物的操作方法(实现)也是一组变化量的情况，也就是说它们都是多变的。

单态定义:
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。

还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。

另外方面，Singleton也能够被无状态化。提供工具性质的功能，

Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。

如何使用?
一般Singleton模式通常有几种形式:

public class Singleton { 　　private Singleton(){} 　　//在自己内部定义自己一个实例，是不是很奇怪？ 　　//注意这是private 只供内部调用 　　private static Singleton instance = new Singleton(); 　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　 　　public static Singleton getInstance() { 　　　　return instance; 　　 　　 } }

第二种形式:

public class Singleton { 　　private static Singleton instance = null; 　　public static synchronized Singleton getInstance() { 　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　 　　//使用时生成实例，提高了效率！ 　　if (instance==null) 　　　　instance＝new Singleton(); 　　return instance; 　　} }

使用Singleton.getInstance()可以访问单态类。

上面第二中形式是lazy initialization，也就是说第一次调用时初始Singleton，以后就不用再生成了。

注意到lazy initialization形式中的synchronized，这个synchronized很重要，如果没有synchronized，那么使用getInstance()是有可能得到多个Singleton实例。关于lazy initialization的Singleton有很多涉及double-checked locking (DCL)的讨论，有兴趣者进一步研究。

一般认为第一种形式要更加安全些。

使用Singleton注意事项：
有时在某些情况下，使用Singleton并不能达到Singleton的目的，如有多个Singleton对象同时被不同的类装入器装载；在EJB这样的分布式系统中使用也要注意这种情况，因为EJB是跨服务器，跨JVM的。

我们以SUN公司的宠物店源码(Pet Store 1.3.1)的ServiceLocator为例稍微分析一下：

在Pet Store中ServiceLocator有两种，一个是EJB目录下；一个是WEB目录下，我们检查这两个ServiceLocator会发现内容差不多，都是提供EJB的查询定位服务，可是为什么要分开呢？仔细研究对这两种ServiceLocator才发现区别：在WEB中的ServiceLocator的采取Singleton模式，ServiceLocator属于资源定位，理所当然应该使用Singleton模式。但是在EJB中，Singleton模式已经失去作用，所以ServiceLocator才分成两种，一种面向WEB服务的，一种是面向EJB服务的。

Singleton模式看起来简单，使用方法也很方便，但是真正用好，是非常不容易，需要对Java的类 线程 内存等概念有相当的了解。

总之：如果你的应用基于容器，那么Singleton模式少用或者不用，可以使用相关替代技术。

进一步深入可参考：

Double-checked locking and the Singleton pattern

When is a singleton not a singleton?

设计模式如何在具体项目中应用见《Java实用系统开发指南》

Singleton模式的要点：
1、某个类只能有一个实例
2、必须自行创建这个实例
3、必须向整个系统提供这个实例

Singleton模式的实现方法
1、饿汉式singleton
public class EagerSingleton
{
private static final EagerSingleton m_instance = new Eagersingleton();
private Eagersingleton(){}

public static EagerSingleton getInstance()
{
return m_instance;
}

}

2、懒汉式singleton
public class LazySingleton
{
private static LazySingleton m_instance = null;
private LazySingleton(){};
synchronized public static LazySingleton getInstance()
{
if( m_instance == null )
{
m_instance = new LazySingleton();
}
return m_instance;
}
}

3、登记式singleton
import java.util.HashMap;
public class RegSingleton
{
static private HashMap m_registry = new HashMap();
static
{
RegSingleton x = new regSingleton();
m_registry.put(x.getClass().getName(), x);
}
protect RegSingleton(){}
static public RegSingleton getInstance(String name)
{
if(name == null )
{
name = "RegSingleton";
}
if(m_registry.get(name ) == null )
{
m_registry.put(name, Class.forName(name).newInstance();
}
catch(Exception e)
{
System.out.println("Error happened.");
}
return (RegSingleton)(m_registry.get(name));
}
}

三种Singleton模式的比较

饿汉式 类被加载时就被实例化。
懒汉式 类加载时，不被实例化，在第一次引用时实例化。

饿汉式、懒汉式都不能被继承
而登记式可以被继承。

　　下面的内容只是API的规范,没有什么太高深的意义,但我之所以最先把它列在这儿,是因为这些规范在事实中并不是真正能保证得到实现。

1。自反性：对于任何引用类型, o.equals(o) == true成立。
2。对称性：如果 o.equals(o1) == true 成立,那么o1.equals(o)==true也一定要成立。
3。传递性：如果 o.equals(o1) == true 成立且  o1.equals(o2) == true 成立,那么o.equals(o2) == true 也成立。
4。一致性：如果第一次调用o.equals(o1) == true成立再o和o1没有改变的情况下以后的任何次调用都成立。
5。o.equals(null) == true 任何时间都不成立。
　　以上几条规则并不是最完整的表述,详细的请参见API文档。
    但是在hashCode()函数的协定中，要求“如果根据 equals(Object) 方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。”，因此我个人认为equals方法还应该加上这第6条规定：
6。如果 o.equals(o1) == true 成立,那么必须有o.hashCode==o1.hashCode()。

　　对于Object类,它提供了一个最最严密的实现,那就是只有是同一对象是,equals方法才返回true,也就是人们常说的引用比较而不是值比较。这个实现严密得已经没有什么实际的意义,所以在具体子类(相对于Object来说)中,如果我们要进行对象的值比较,就必须实现自己的equals方法。

　　先来看一下以下这段引自于JDK中的程序:
（说明：attribute在FieldPosition中有这样的定义：private Format.Field attribute;）
    public boolean equals(Object obj)
    {
        if (obj == null) return false;
        if (!(obj instanceof FieldPosition))
            return false;
        FieldPosition other = (FieldPosition) obj;
        if (attribute == null) {
            if (other.attribute != null) {
                return false;
            }
        }
        else if (!attribute.equals(other.attribute)) {
            return false;
        }
        return (beginIndex == other.beginIndex
            && endIndex == other.endIndex
            && field == other.field);
    }
　　这是JDK中java.text.FieldPosition的标准实现,似乎没有什么可说的. 我相信大多数或绝大多数程序员认为,这是正确的合法的equals实现.毕竟它是JDK的API实现啊. 还是让我们以事实来说话吧:

package debug;
import java.text.*;
public class Test {
  public static void main(String[] args) {
    FieldPosition fp = new FieldPosition(10);
    FieldPosition fp1 = new MyTest(10);
    System.out.println(fp.equals(fp1));
    System.out.println(fp1.equals(fp));
  }
}
class MyTest extends FieldPosition{
  int x = 10;
  public MyTest(int x){
    super(x);
    this.x = x;
  }
  public boolean equals(Object o){
    if(o==null) return false;
    if(!(o instanceof MyTest )) return false;
    return ((MyTest)o).x == this.x;
  }
}
　　 运行一下看看会打印出什么:

System.out.println(fp.equals(fp1));打印true
System.out.println(fp1.equals(fp));打印flase　　
　　两个对象,出现了不对称的equals算法.问题出在哪里(脑筋急转弯：当然出在JDK实现的固有BUG，看来JDK中的东西未必就完全都是最最最正确的，我们要敢于怀疑它！)?

　　我相信有太多的程序员在实现equals方法时都用过instanceof运行符来进行短路优化的，实事求是地说很长一段时间我也这么用过。太多的教程，文档都给了我们这样的误导。而有些稍有了解的程序员可能知道这样的优化可能有些不对但找不出问题的关键。另外一种极端是知道这个技术缺陷的骨灰级专家就提议不要这样应用。

　　我们知道，"通常"要对两个对象进行比较，那么它们"应该"是同一类型。所以首先利用nstanceof运行符进行短路优化（“短路”《Short-circuiting》，而短路的最大好处就是能够优化性能。所谓的短路就是当第一个被运算的表达式的结果已经能够决定运算的最终结果时，就不会再去计算其他的表达式，因此可以避免掉额外且不必要的运算操作，尤其是当所略过的是复杂或含有过程调用的表达式时，短路的性能提升幅度更为明显。比如我们在if中同时用&&判断多个条件的时候，遇到第一个false的时候就不会再计算后面的表达式是否为true了），如果被比较的对象不和当前对象是同一类型则不用比较返回false,但事实上，"子类是父类的一个实例"，所以如果 子类 instanceof 父类，始终返回true,这时肯定不会发生短路优化，下面的比较有可能出现多种情况，一种是父类不能造型成子类而抛出异常（比如子类.equals(父类)后，在equals内部会进行试图将父类向下造型成子类的操作），另一种是父类的private 成员没有被子类继承而不能进行比较，还有就是形成上面这种不对称比较。可能会出现太多的情况。

　　那么，是不是就不能用 instanceof运行符来进行优化？答案是否定的，JDK中仍然有很多实现是正确的，如果一个class是final的，明知它不可能有子类，为什么不用instanceof来优化呢？（可见对于不涉及子类的问题时，用instanceof进行短路优化还是很可行的）

　　为了维护SUN的开发小组的声誉，我不说明哪个类中，但有一个小组成员在用这个方法优化时在后加加上了加上了这样的注释：

if (this == obj)             // quick check（也就是短路优化）
         return true;
      if (!(obj instanceof XXXXClass))  // (1) same object?
         return false;　　可能是有些疑问，但不知道如何做（不知道为什么没有打电话给我......）

　　那么对于非final类，如何进行类型的quick check呢？

if(obj.getClass() != XXXClass.class) return false;
　　用被比较对象的class对象和当前对象的class比较，看起来是没有问题，但是，如果这个类的子类没有重新实现equals方法，那么当子类.equals(子类)比较时，也就是要使用“if(obj.getClass() != XXXClass.class) return false;”来进行比较了，显然obj.getClass()《这个是字类》 肯定不等于XXXCalss.class《这个是父类》,从这里就直接返回得到false的结果了，因此子类中定义的equals实际上根本没发挥出应有的效力来，所以if(obj.getClass() != this.getClass()) return false;才是正确的比较。 呵呵，看到了没？我们首先否定了instanceof，接下来又否定了“obj.getClass() != XXXClass.class”这种错误的比较做法，最后才给出了正确的比较方法。
另外一个quick check是if(this==obj) return true;而且这个短路优化应该放在“obj.getClass() != XXXClass.class”优化的前面。

　　是否equals方法一定比较的两个对象就一定是要同一类型？上面我用了"通常"，这也是绝大多数程序员的愿望，但是有些特殊的情况，我们可以进行不同类型的比较，这并不违反规范。但这种特殊情况是非常罕见的，一个不恰当的例子是，Integer类的equals可以和Sort做比较，比较它们的value是不是同一数学值。（事实上JDK的API中并没有这样做，所以我才说是不恰当的例子）。在完成quick check以后，我们就要真正实现你认为的“相等”。对于如果实现对象相等，没有太高的要求，比如你自己实现的“人”类，你可以认为只要name相同即认为它们是相等的，其它的sex,ago都可以不考虑。这是不完全实现，但是如果是完全实现，即要求所有的属性都是相同的，那么如何实现equals方法？

class Human{
private String name;
private int ago;
private String sex;
  ....................
  public boolean equals(Object obj){
  quick check.......
  Human other = (Human)ojb;
  return this.name.equals(other.name)
   && this.ago == ohter.ago
   && this.sex.equals(other.sex);
}
}
　　 这是一个完全实现，但是，有时equals实现是在父类中实现的，而且要求被子类继承后，父类的equals能正确的工作，这时父类中的equals并不事实知道子类到底扩展了哪些属性，所以用上面的方法无法使equals得到完全实现。

　　一个好的方法是利用反射来对equals进行完全实现： 给出一个完整的在父类中定义的equals方法（只是比较字段）的实现：
public boolean equals(Object obj){
  if(obj == this)
      return true;
  if(obj.getClass() != this.getClass())
      return false;
  Class c = this.getClass();
  Filed[] fds = c.getDeclaredFields();
  for(Filed f:fds){
   if(!f.get(this).equals(f.get(obj)))
    return false;
  }
  return true;
}
　　为了说明的方便，上明的实现省略了异常，这样的实现放在父类中，可以保证你的子类的equals可以按你的愿望正确地工作。当然这里只是考虑了基于字段相等的比较，如何还涉及到基于方法等其他方面的相等比较，则应该扩展上面的代码，反射出更多的东西（比如方法）来加以比较判断。

　　关于equals方法的最后一点是：如果你要是自己重写（正确说应该是履盖）了equals方法，那同时就一定要重写hashCode()，否则.............

　　我们还是看一下这个例子：

public final class PhoneNumber {
    private final int areaCode;
    private final int exchange;
    private final int extension;
    public PhoneNumber(int areaCode, int exchange, int extension) {
        rangeCheck(areaCode, 999, "area code");
        rangeCheck(exchange, 99999999, "exchange");
        rangeCheck(extension, 9999, "extension");
        this.areaCode = areaCode;
        this.exchange = exchange;
        this.extension = extension;
    }
    private static void rangeCheck(int arg, int max, String name) {
        if(arg < 0 || arg > max)
            throw new IllegalArgumentException(name + ": " + arg);
    }
    public boolean equals(Object o) {
        if(o == this)
            return true;
        if(!(o instanceof PhoneNumber))
            return false;
        PhoneNumber pn = (PhoneNumber)o;
        return pn.extension == extension && pn.exchange == exchange && pn.areaCode == areaCode;
    }
}
　　注意这个类是final的，所以这个equals实现没有什么问题。

　　我们来测试一下:

    public static void main(String[] args) {
        Map hm = new HashMap();
        PhoneNumber pn = new PhoneNumber(123, 38942, 230);
        hm.put(pn, "I love you");
        PhoneNumber pn1 = new PhoneNumber(123, 38942, 230);
        System.out.println(pn);
        System.out.println("pn.equals(pn1) is " + pn.equals(pn1));
        System.out.println(hm.get(pn1));
        System.out.println(hm.get(pn));
    }
　　既然pn.equals(pn1),那么我put(pn,"I love you");后，get(pn1)这什么是null呢？

　　答案是因为pn和pn1的hashCode不一样，而hashMap就是以hashCode为主键的。

　　所以根据规范要求（在文章最开始部分提到的标准equals方法需要满足的6条性质），如果两个对象进行equals比较时如果返回true,那么它们的hashcode要求返回相等的值。

此外，在写hashCode函数时，需要注意：
随便你怎么写，只要保证A.equals(B)一定可以推出A.hashCode()==B.hashCode()就行；当然，应该尽量使得A.equals(B)==false的时候，使得A.hashCode()尽量不等于B.hashCode()，绝对不会相等是不可能的，但是要尽量降低概率。

比如：
public int hashCode() {
        int result;
        result = getName().hashCode();
        result = 29 * result + getBirthday().hashCode();
        return result;
    }
其时就是需要你根据自己的类给出特有的一种算法，能够满足通过该算法得到的这个整数值（也就是hashCode）能够区别该类的各个实例。

1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory

工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。（这一定比美军在伊拉克用的翻译机好卖）

建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。

工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）

原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。

5、SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事)

单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。

结构型模式

6、ADAPTER—在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)

适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

7、BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了

桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。

8、COMPOSITE—Mary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧，去商店，你自己挑。”“这件T恤挺漂亮，买，这条裙子好看，买，这个包也不错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。”“……”，MM都会用Composite模式了，你会了没有？

合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。

9、DECORATOR—Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒子装起来……，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗？

装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。

10、FACADE—我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样照出来的照片才专业，但MM可不懂这些，教了半天也不会。幸好相机有Facade设计模式，把相机调整到自动档，只要对准目标按快门就行了，一切由相机自动调整，这样MM也可以用这个相机给我拍张照片了。

    门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。

11、FLYWEIGHT—每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一些常用的句子存在手机里，要用的时候，直接拿出来，在前面加上MM的名字就可以发送了，再不用一个字一个字敲了。共享的句子就是Flyweight，MM的名字就是提取出来的外部特征，根据上下文情况使用。

    享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。

12、PROXY—跟MM在网上聊天，一开头总是“hi,你好”,“你从哪儿来呀？”“你多大了？”“身高多少呀？”这些话，真烦人，写个程序做为我的Proxy吧，凡是接收到这些话都设置好了自动的回答，接收到其他的话时再通知我回答，怎么样，酷吧。

    代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。

行为模式

13、CHAIN OF RESPONSIBLEITY—晚上去上英语课，为了好开溜坐到了最后一排，哇，前面坐了好几个漂亮的MM哎，找张纸条，写上“Hi,可以做我的女朋友吗？如果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的MM把纸条传给老师了，听说是个老处女呀，快跑!

   责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接

    起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。

14、COMMAND—俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们俩之间传送信息，她对我有什么指示，就写一张纸条让她弟弟带给我。这不，她弟弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说：“我同时给我姐姐三个男朋友送COMMAND，就数你最小气，才请我吃面。”，:-(

    命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。

15、INTERPRETER—俺有一个《泡MM真经》，上面有各种泡MM的攻略，比如说去吃西餐的步骤、去看电影的方法等等，跟MM约会时，只要做一个Interpreter，照着上面的脚本执行就可以了。

    解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。

16、ITERATOR—我爱上了Mary，不顾一切的向她求婚。

          Mary：“想要我跟你结婚，得答应我的条件”

          我：“什么条件我都答应，你说吧”

          Mary：“我看上了那个一克拉的钻石”

          我：“我买，我买，还有吗？”

          Mary：“我看上了湖边的那栋别墅”

          我：“我买，我买，还有吗？”

          Mary：“你的小弟弟必须要有50cm长”

          我脑袋嗡的一声，坐在椅子上，一咬牙：“我剪，我剪，还有吗？”

          ……

    迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。

17、MEDIATOR—四个MM打麻将，相互之间谁应该给谁多少钱算不清楚了，幸亏当时我在旁边，按照各自的筹码数算钱，赚了钱的从我这里拿，赔了钱的也付给我，一切就OK啦，俺得到了四个MM的电话。

    调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

18、MEMENTO—同时跟几个MM聊天时，一定要记清楚刚才跟MM说了些什么话，不然MM发现了会不高兴的哦，幸亏我有个备忘录，刚才与哪个MM说了什么话我都拷贝一份放到备忘录里面保存，这样可以随时察看以前的记录啦。

    备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。

19、OBSERVER—想知道咱们公司最新MM情报吗？加入公司的MM情报邮件组就行了，tom负责搜集情报，他发现的新情报不用一个一个通知我们，直接发布给邮件组，我们作为订阅者（观察者）就可以及时收到情报啦

    观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

20、STATE—跟MM交往时，一定要注意她的状态哦，在不同的状态时她的行为会有不同，比如你约她今天晚上去看电影，对你没兴趣的MM就会说“有事情啦”，对你不讨厌但还没喜欢上的MM就会说“好啊，不过可以带上我同事么？”，已经喜欢上你的MM就会说“几点钟？看完电影再去泡吧怎么样？”，当然你看电影过程中表现良好的话，也可以把MM的状态从不讨厌不喜欢变成喜欢哦。

    状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子类。

21、STRATEGY—跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到MM的芳心，我的追MM锦囊中有好多Strategy哦。

    策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

22、TEMPLATE METHOD——看过《如何说服女生上床》这部经典文章吗？女生从认识到上床的不变的步骤分为巧遇、打破僵局、展开追求、接吻、前戏、动手、爱抚、进去八大步骤(Template method)，但每个步骤针对不同的情况，都有不一样的做法，这就要看你随机应变啦(具体实现)；

    模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。

23、VISITOR—情人节到了，要给每个MM送一束鲜花和一张卡片，可是每个MM送的花都要针对她个人的特点，每张卡片也要根据个人的特点来挑，我一个人哪搞得清楚，还是找花店老板和礼品店老板做一下Visitor，让花店老板根据MM的特点选一束花，让礼品店老板也根据每个人特点选一张卡，这样就轻松多了；

    访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。访问者模式使得增加新的操作变的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。 

《java与模式》笔记(zz)

虽然自认为自己对设计模式已经很了解了,但是从来没有系统的看过设计模式相关的书,最近在公司发现一本<java与模式>,正好系统的看一下,下面是这几天记的笔记.(并不是系统的讲解书中的内容)
一  综述:
1、不要使用接口定义常量
2、自己少用标志接口
3、不要继承具体类
4、类层次的中间节点应该是接口或者抽象类，叶子是具体类
5、子类应当扩展父类的责任，而不是覆写父类的责任
6、面向接口编程
7、不要滥用继承，组合优先于继承

java中设计不当的类：calendar:作为接口，含有与具体的历法（罗马历法）相关的常量，不能扩展到中国的阴历历法（不符合开闭原则）
                    properies类：滥用继承，继承至hashtable，应当使用聚合

8、笛比特法则：只与自己的直接朋友通信，不与陌生人通信（1）狭义笛比特法则：只与朋友通讯，通过自己的朋友传递间接的调用（2）结合依赖倒转原则修改：不必通过朋友传递间接的调用，通过陌生人的抽象接口调用陌生人的行为（依旧不能与具体的陌生人发生通信）
9、尽量降低类中成员的访问权限，不要设计退化类（类似c中struct）。
        java中的point2D以及Dinmension2D类有这种设计缺陷（不过这种情况问题不大）
10、如果多个具体的产品类没有共同的商业逻辑，就可以把它们抽象到一个接口中，如果有共同的商业逻辑，就把共同的部分抽象到抽象类中，共同的部分尽量向类继承层次的上层移动，以达到复用的目的
二   工厂模式
1、简单工厂模式：参与角色：工厂/抽象产品类/具体产品类

   缺点：添加新产品的时候，虽然产品相关代码符合开闭原则，但对工厂类本身并不符合，需要修改其中的产生产品方法或者添加新的产生方法（工厂里实现的不同造成的修改不同）来支持新的产品类
   退化方式：省略掉工厂角色，抽象产品类担任具体产品类的工厂角色：提供静态的getInstance方法，比如java类库中的DateFormat类，（本人认为这样很不符合开闭原则，父类中出现与具体子类相关的代码，不方便扩展，添加新产品的时候，修改的时候缺点与原简单工厂的工厂角色类似）

2、工厂方法模式：参与角色：抽象工厂类/具体工厂类/抽象产品类/具体产品类
     消除了简单工厂的缺点

3、抽象工厂模式：简单工厂模式与工厂方法模式的结合

4、单例模式：饿汉和懒汉两种，前者将本身对象作为静态私有属性事先生成，后者推迟到调用的时候，后者需要考虑多线程的时候，前面需要加线程安全关键字（注意），java中还是前者为优。
   不要滥用单例，只有系统要求只有一个类的实例的时候才调用
   有的单例可能有状态属性，这就为多例模式提供了可能
   含有私有属性的类作成单例的时候尤其要注意：一是私有属性的线程安全，确实需要的时候可以加线程安全关键字，比如系统中的log类，二是确认这些属性是不是可以所有线程共享的，类似普通类的static
三   各种具体模式（1）
1、建造模式：参与角色4个：指导者、抽象建造对象、具体建造对象、产品
      一个复杂的产品有很多的零部件，就可以使用具体的建造对象来一一构造
2、原始模式：深拷贝、浅拷贝
3、适配器模式：将adaptee类适配成目标接口
4、合成模式：参与角色：composite接口、树枝节点类、树叶节点类
      分成透明式和安全式两种，各有优缺点
      (1)前者将管理子对象的方法放到接口中，这样树型结构中的所有对象都是透明的，都可以统一调用，但是叶节点并没有管理子对象的能力，因此透明但不安全
      (2)后者将管理子对象的方法下放到树枝节点类中，这样安全但不透明
5、装饰模式：继承已有类的接口，提供和已有类相同的方法，并对已有类的功能提供扩展（通过组合已有对象，调用已有对象方法的时候加入新的代码）
      (1)透明的装饰模式（纯粹的装饰模式）：装饰类、被装饰类继承于同一接口，而且装饰类只实现接口的方法，不提供额外方法的实现，调用该类的时候使用接口声明调用（实例化当然还是自己的构造函数），即该类的所有方法都是透明的
      (2)半透明的装饰模式（退化的装饰模式）：装饰类、被装饰类继承于同一接口，装饰类不仅实现接口的方法，还提供额外方法的实现，这样要调用它独特的方法的时候就必须使用它本身来调用，退化到一半装饰模式、一半适配器模式。

用法：javac <选项> <源文件>
可能的选项包括：
-g 生成所有调试信息
-g:none 生成无调试信息
-g:{lines,vars,source} 生成只有部分调试信息
-O 优化；可能妨碍调试或者增大类文件
-nowarn 生成无警告
-verbose 输出关于编译器正在做的信息
-deprecation 输出使用了不鼓励使用的API的源程序位置
-classpath <路径> 指定用户类文件的位置
-sourcepath <路径> 指定输入源文件的位置
-bootclasspath <路径> 覆盖自举类文件的位置
-extdirs <目录(多个)> 覆盖安装的扩展类的位置
-d <目录> 指定输出类文件的位置
-encoding <编码> 指定源文件中所用的字符集编码
-target <版本> 生成指定虚拟机版本的类文件
-help Print a synopsis of standard options

appletviewer.exe

用法：appletviewer <options> url
其中，<options> 包括：
-debug 在 Java 调试器中启动 applet 小程序查看器
-encoding <encoding> 指定由 HTML 文件使用的字符编码
-J<runtime flag> 向 Java 解释器传递参数
-J 选项不是标准选项，如有更改，不另行通知。

jar.exe

用法：jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...
选项：
-c 创建新的存档
-t 列出存档内容的列表
-x 展开存档中的命名的（或所有的〕文件
-u 更新已存在的存档
-v 生成详细输出到标准输出上
-f 指定存档文件名
-m 包含来自标明文件的标明信息
-0 只存储方式；未用ZIP压缩格式
-M 不产生所有项的清单（manifest〕文件
-i 为指定的jar文件产生索引信息
-C 改变到指定的目录，并且包含下列文件：
如果一个文件名是一个目录，它将被递归处理。
清单（manifest〕文件名和存档文件名都需要被指定，按'm' 和 'f'标志指定的相同顺序。
示例1：将两个class文件存档到一个名为 'classes.jar' 的存档文件中：
jar cvf classes.jar Foo.class Bar.class
示例2：用一个存在的清单（manifest）文件 'mymanifest' 将 foo/ 目录下的所有
文件存档到一个名为 'classes.jar' 的存档文件中：
jar cvfm classes.jar mymanifest -C foo/ .

javadoc.exe

用法：javadoc [options] [packagenames] [sourcefiles] [classnames] [@files]
-overview <file> 读取 HTML 格式的概述文档
-public 仅显示 public 类和成员
-protected 显示 protected/public 类和成员（缺省）
-package 显示 package/protected/public 类和成员
-private 显示所有类和成员
-help 显示命令行选项
-doclet <class> 通过候选 doclet 生成输出
-docletpath <path> 指定 doclet 类文件的查找位置
-sourcepath <pathlist> 指定源文件的查找位置
-classpath <pathlist> 指定用户类文件的查找位置
-exclude <pkglist> Specify a list of packages to exclude
-subpackages <subpkglist> Specify subpackages to recursively load
-breakiterator Compute 1st sentence with BreakIterator
-bootclasspath <pathlist> 覆盖自举类加载器所加载的类文件的位置
-source <release> Provide source compatibility with specified release
-extdirs <dirlist> 覆盖已安装的扩展的位置
-verbose 有关 Javadoc 所做工作的输出信息
-locale <name> 所用的 Locale，例如 en_US 或 en_US_WIN
-encoding <name> 源文件编码名称
-J<flag> 将 <flag> 直接传给运行时系统
由标准 doclet 提供：
-d <directory> 输出文件的目标目录
-use 创建类和包的用法页
-version 包含 @version 段
-author 包含 @author 段
-docfilessubdirs Recursively copy doc-file subdirectories
-splitindex 将索引分为每个字母对应一个文件
-windowtitle <text> 文档的浏览器窗口标题
-doctitle <html-code> 包含包索引页（首页）的标题
-header <html-code> 包含每一页的页眉文本
-footer <html-code> 包含每一页的页脚文本
-bottom <html-code> 包含每一页的页底文本
-link <url> Create links to javadoc output at <url>
-linkoffline <url> <url2> Link to docs at <url> using package list at <url2>
-excludedocfilessubdir <name1>:.. Exclude any doc-files subdirectories with given name.
-group <name> <p1>:<p2>.. Group specified packages together in overview page
-nocomment Supress description and tags, generate only declarations.
-nodeprecated 不包含 @deprecated 信息
-noqualifier <name1>:<name2>:... Exclude the list of qualifiers from the output.
-nosince Do not include @since information
-nodeprecatedlist 不生成不鼓励使用的列表
-notree 不生成类层次
-noindex 不生成索引
-nohelp 不生成帮助链接
-nonavbar 不生成导航栏
-quiet Do not display status messages to screen
-serialwarn Generate warning about @serial tag
-tag <name>:<locations>:<header> Specify single argument custom tags
-taglet The fully qualified name of Taglet to register
-tagletpath The path to Taglets
-charset <charset> Charset for cross-platform viewing of generated documentation.
-helpfile <file> 包含帮助链接功能链接到目标的文件
-linksource Generate source in HTML
-stylesheetfile <path> 改变所生成文档的样式的文件
-docencoding <name> 输出编码名称

javah.exe

用法：javah [options] <classes>
其中 [options] 包括：
-help 打印该帮助信息
-classpath <path> 类的加载路径
-bootclasspath <path> 自举类的加载路径
-d <dir> 输出目录
-o <file> 输出文件（仅能使用 -d 或 -o 之一）
-jni 生成 JNI 风格的头文件（缺省）
-old 生成 JDK1.0 风格的头文件
-stubs 生成 stubs 文件
-version 打印版本信息
-verbose 输出有关本命令所做工作的信息
-force 始终写输出文件
指定 <classes> 时必须使用全名（例如 java.lang.Object）。

javaw.exe

HtmlConverter.exe
用法：HtmlConverter [-option1 value1 [-option2 value2 [...]]] [-simulate] [filespecs]
其中，选项包括：
-source: 获取源文件的路径。 缺省值： <userdir>
-dest: 写入已转换文件的路径。 缺省值： <userdir>
-backup: 写备份文件的路径。 缺省值： <dirname>_BAK
-f: 强制覆写备份文件。
-subdirs: 应处理子目录中的文件。
-template: 模板文件的路径。 如果不确定，请使用缺省值。
-log: 写日志的路径。 如果没有提供，则不会写入任何日志。
-progress: 转换时显示进度。 缺省值： true
-simulate: 在没有进行转换时显示特定于转换的信息。
-latest: 使用最新的 JRE 支持发行版 mimetype。
-gui: 显示转换程序的图形用户界面。
filespecs: 用空格分开的文件说明列表。 缺省值： "*.html *.htm" （需要引号）

orbd.exe

用法：orbd <选项>
其中，<选项> 包括：
-port 启动 ORBD 的激活端口，缺省值为 1049 (可选)
-defaultdb ORBD 文件的目录，缺省值为 "./orb.db" (可选)
-serverid ORBD 的服务器标识符，缺省值为 1 (可选)
-ORBInitialPort 初始端口（必需）
-ORBInitialHost 初始主机名称（必需）

policytool.exe

用法：policytool [选项]
[-file <file>] 规则文件位置

rmic.exe

用法：rmic <选项> <类名>
其中 <选项> 包括：
-keep 不删除中间生成的源文件
-keepgenerated （同 "-keep")
-v1.1 为 1.1 stub 协议版本创建 stubs/skeleton
-vcompat （缺省）创建与 1.1 和
1.2 stub 协议版本兼容的 stubs/skeleton
-v1.2 仅为 1.2 stub 协议版本创建 stubs
-iiop 为 IIOP 创建 stubs。当使用该选项时，<选项>还应包括：
-always 总创建 stubs （即使在它们同时出现时〕
-alwaysgenerate (同 "-always")
-nolocalstubs 不创建为同一进程优化的 stubs
-idl 创建 IDL。当使用该选项时，<选项>还应包括：
-noValueMethods 不生成值类型的方法
-always 总创建 IDL （即使在它们同时出现时〕
-alwaysgenerate (同 "-always")
-g 一般调试信息
-depend 以递归方式重编译过期的文件
-nowarn 不警告
-nowrite 不将编译过的类写入到文件系统
-verbose 输出有关编译器所做工作的信息
-classpath <path> 指定输入源和类文件的查找位置
-sourcepath <path> 指定用户源文件的查找位置
-bootclasspath <path> 覆盖自举类文件的位置
-extdirs <path> 覆盖安装扩展类的位置
-d <directory> 指定所生成类文件的放置位置
-J<runtime flag> 将参数传给 java 解释程序

rmid.exe

用法：rmid <option>
其中，<option> 包括:
-port <option> 指定供 rmid 使用的端口
-log <directory> 指定 rmid 将日志写入的目录
-stop 停止当前的 rmid 调用（对指定端口）
-C<runtime 标记> 向每个子进程传递参数（激活组）
-J<runtime 标记> 向 java 解释程序传递参数

rmiregistry.exe

用法： rmiregistry <选项> <端口>
其中，<选项> 包括：
-J<runtime 标记> 将参数传递到 java 解释程序

serialver.exe

用法：serialver [-classpath classpath] [-show] [classname...]

servertool.exe

欢迎使用 Java IDL 服务器工具
请在提示处输入命令
servertool > help
可用命令：
register - 注册一个可激活的服务器
unregister - 取消服务器注册
getserverid - 返回应用程序名称的服务器标识符
list - 列举所有已注册服务器
listappnames - 列举当前定义的应用程序名称
listactive - 列举当前活动的服务器
locate - 将已注册服务器定位在特定类型的端口
locateperorb - 为已注册服务器的特定对象请求代理程序定位端口。
orblist - 对象请求代理程序 (orb) 名称及其映射列表
shutdown - 关闭一个已注册服务器
startup - 启动一个已注册服务器
help - 取得帮助
quit - 退出此工具

rmic

功能说明：
rmic 为远程对象生成 stub 和 skeleton。
语法：
rmic [ options ] package-qualified-class-name(s)
补充说明：
rmic 编译器根据编译后的 Java 类（含有远程对象实现）名，为远程对象生成 stub 和 skeleton（远程对象是指实现 java.rmi.Remote 接口的对象）。在 rmic 命令中所给的类必须是经 javac 命令成功编译且是完全包限定的类。
命令选项
-classpath[路径] 指定 rmic 用于查询类的路径。如果设置了该选项，它将覆盖缺省值或 CLASSPATH 环境变量。目录用冒号分隔。
-d[目录] 指定类层次的根目录。此选项可用来指定 stub 和 skeleton 文件的目标目录。
-depend 使编译器考虑重新编译从其它类引用的类。 一般来说，它只重新编译从源代码引用的遗漏或过期的类。
-g 允许生成调试表格。调试表格含有行号和局部变量的有关信息，即 Java 调试工具所使用的信息。缺省情况下，只生成行号。
-J 与 -D 选项联用，它将紧跟其后的选项（ -J 与 -D 之间无空格）传给 java 解释器。
-keepgenerated 为 stub 和 skeleton 文件保留所生成的 .java 源文件，并将这些源文件写到与 .class 文件相同的目录中，如果要指定目录，则使用 -d 选项。
-nowarn 关闭警告。如果使用该选项，则编译器不输出任何警告信息。
-show 显示 rmic 编译器的 GUI（图形用户界面）。输入一个或多个包限定类名（以空格分隔），并按回车键或“显示”按钮，创建 stub 和 skeleton。
-vcompat （缺省值）创建与 JDK 1.1 和 1.2 stub 协议版本都兼容的 stub 和 skeleton。
-verbose 使编译器和链接器输出关于正在编译哪些类和正在加载哪些类文件的信息。
-v1.1 创建 JDK 1.1 stub 协议版本的 stub 和 skeleton。
-v1.2 只创建 JDK 1.2 stub 协议版本的 stub。

rmid

功能说明：
rmid 启动激活系统守护进程，以便能够在 Java 虚拟机上注册和激活对象。
语法：
rmid [-port port] [-log dir]
补充说明：
rmid 工具启动激活系统守护进程。必须先启动激活系统守护进程，才能向激活系统注册可被激活的对象或在 Java 虚拟机上激活可被激活的对象。
命令选项
-C<某些命令行选项> 指定一个选项，在创建每个 rmid 的子守护进程（激活组）时，该选项以命令行参数的形式传给该子守护进程。
-log[目录] 指定目录的名称，激活系统守护进程在该目录中写入其数据库及相关信息。缺省状态下，将在执行 rmid 命令的目录中创建一个 log 目录。
-port[端口] 指定 rmid 的注册服务程序所使用的端口。激活系统守护进程将 ActivationSystem 与该注册服务程序中的名称java.rmi.activation.ActivationSystem 捆绑在一起。
-stop 停止 -port 选项所指定端口上的当前 rmid 调用。若未指定端口，则将停止在端口 1098 上运行的 rmid。

rmiregistry

功能说明：
rmiregistry 命令可在当前主机的指定端口上启动远程对象注册服务程序。
语法：
rmiregistry [port]
补充说明：
rmiregistry 命令在当前主机的指定 port 上创建并启动远程对象注册服务程序。如果省略 port，则注册服务程序将在 1099 端口上启动。rmiregistry 命令不产生任何输出而且一般在后台运行。远程对象注册服务程序是自举命名服务。主机上的 RMI 服务器将利用它将远程对象绑定到名字上。客户机即可查询远程对象并进行远程方法调用。注册服务程序一般用于定位应用程序需调用其方法的第一个远程对象。该对象反过来对各应用程序提供相应的支持，用于查找其它对象。java.rmi.registry.LocateRegistry 类的方法可用于在某台主机或主机和端口上获取注册服务程序操作。java.rmi.Naming 类的基于 URL 的方法将对注册服务程序进行操作，并可用于查询远程对象、将简单（字符串）名称绑定到远程对象、将新名称重新绑定到远程对象（覆盖旧绑定）、取消远程对象的绑定以及列出绑定在注册服务程序上的 URL。

serialver

功能说明：
serialver 命令返回 serialVersionUID。
语法：
serialver [ 命令选项 ]
补充说明：
serialver 以适于复制到演变类的形式返回一个或多个类的 serialVersionUID。不带参数调用时，它输出用法行。
命令选项
-show 显示一个简单的用户界面。输入完整的类名并按回车键或“显示”按钮可显示 serialVersionUID。

jarsigner

功能说明：
为 Java 归档 (JAR) 文件产生签名，并校验已签名的 JAR 文件的签名。
语法：
jarsigner [ 命令选项 ] jar-file alias
jarsigner -verify [ 命令选项 ] jar-file
补充说明：
jarsigner 工具用于两个目的：
1:为 Java 归档 (JAR) 文件签名
2:校验已签名的 JAR 文件的签名和完整性
命令选项
-keystore[url] 指定密钥仓库的 URL。缺省值是用户的宿主目录中的 .keystore 文件，它由系统属性“user.home”决定。
-storetype[storetype] 指定要被实例化的密钥仓库类型。默认的密钥仓库类型是安全属性文件中 "keystore.type" 属性值所指定的那个类型，由 java.security.KeyStore 中的静态方法 getDefaultType 返回。
-storepass[password] 指定访问密钥仓库所需的口令。这仅在签名（不是校验）JAR 文件时需要。在这种情况下，如果命令行中没有提供 -storepass 选项，用户将被提示输入口令。
-keypass[password] 指定用于保护密钥仓库项（由命令行中指定的别名标出）的私钥的口令。使用 jarsigner 为 JAR 文件签名时需要该口令。如果命令行中没有提供口令，且所需的口令与密钥仓库的口令不同，则将提示用户输入它。
-sigfile[file] 指定用于生成 .SF 和 .DSA 文件的基本文件名。
-signedjar[file] 指定用于已签名的 JAR 文件的名称。
-verify 如果它出现在命令行中，则指定的 JAR 文件将被校验，而不是签名。如果校验成功，将显示“jar verified”。如果试图校验未签名的 JAR 文件，或校验被不支持的算法（例如未安装 RSA 提供者时使用的 RSA）签名的 JAR 文件，则将有如下显示： "jar is unsigned. (signatures missing or not parsable)" 。
-certs 如果它与 -verify 和 -verbose 选项一起出现在命令行中，则输出将包括 JAR 文件的每个签名人的证书信息。
-verbose 如果它出现在命令行中，则代表“verbose”模式，它使 jarsigner 在 JAR 签名或校验过程中输出额外信息。
-internalsf 过去，JAR 文件被签名时产生的 .DSA（签名块）文件包含一个同时产生的 .SF 文件（签名文件）的完整编码副本。这种做法已被更改。为了减小输出 JAR 文件的整个大小，缺省情况下 .DSA 文件不再包含 .SF 文件的副本。但是如果 -internalsf 出现在命令行中，将采用旧的做法。该选项主要在测试时有用；实际上不应使用它，因为这样将消除有用的优化。
-sectionsonly 如果它出现在命令行中，则 JAR 文件被签名时生成的 .SF 文件（签名文件）将不包括含有整个清单文件的散列的头。它仅包含 与 JAR 中每个单独的源文件相关的信息和散列。该选项主要在测试时有用；实际上不应使用它，因为这样将消除有用的优化。
-J[javaoption] 将指定的 javaoption 串直接传递到 Java 解释器。(（jarsigner 实际上是解释器的一个 “wrapper”）。该选项不应含有任何空格。它有助于调整执行环境或内存使用。要获得可用的解释器选项的清单，可在命令行键入 java -h 或 java -X。

keytool

功能说明：
管理由私钥和认证相关公钥的 X.509 证书链组成的密钥仓库（数据库）。还管理来自可信任实体的证书。
语法：
keytool [ 命令 ]
补充说明：
keytool 是个密钥和证书管理工具。它使用户能够管理自己的公钥/私钥对及相关证书，用于（通过数字签名）自我认证（用户向别的用户/服务认证自己）或数据完整性以及认证服务。它还允许用户储存他们的通信对等者的公钥（以证书形式）。

native2ascii

功能说明：
将含有本地编码字符（既非 Latin1 又非 Unicode 字符）的文件转换为 Unicode 编码字符的文件。
语法：
native2ascii [options] [inputfile [outputfile]]
补充说明：
Java 编译器和其它 Java 工具只能处理含有 Latin-1 和/或 Unicode 编码（udddd 记号）字符的文件。native2ascii 将含有其它字符编码的文件转换成含 Latin-1 和/或 Unicode 编码字符的文件。若省略 outputfile，则使用标准输出设备输出。此外，如果也省略 inputfile，则使用标准输入设备输入。
命令选项
-reverse 执行相反的操作：将含 Latin-1 和/或 Unicode 编码字符的文件转换成含本地编码字符的文件。
-encoding[encoding_name] 指定转换过程使用的编码名称。缺省的编码从系统属性 file.encoding 中得到。

appletviewer

功能说明：
Java applet 浏览器。appletviewer 命令可在脱离万维网浏览器环境的情况下运行 applet。
语法：
appletviewer [ threads flag ] [ 命令选项 ] urls ...
补充说明：
appletviewer 命令连接到 url 所指向的文档或资源上，并在其自身的窗口中显示文档引用的每个 applet。注意：如果 url 所指向的文档不引用任何带有 OBJECT、EMBED 或 APPLET 标记的 applet，那么 appletviewer 就不做任何事情。
命令选项
-debug 在 Java 调试器 jdb 中启动 appletviewer，使您可以调试文档中的 applet。
-encoding[编码名称] 指定输入 HTML 文件的编码名称。
-J[javaoption] 将 javaoption 字符串作为单个参数传给运行 appletviewer 的 Java 解释器。参数不能含有空格。由多重参数组成的字符串，其中的每个参数都必须以前缀 -J 开头，该前缀以后将被除去。这在调整编译器的执行环境或内存使用时将很有用。

extcheck

功能说明：
extcheck 检测目标 jar 文件与当前安装方式扩展 jar 文件间的版本冲突。
语法：
extcheck [ -verbose ] targetfile.jar
补充说明：
extcheck 实用程序检查指定 Jar 文件的标题和版本与 JDK TM 软件中所安装的扩展是否有冲突。在安装某个扩展前，可以用该实用程序查看是否已安装了该扩展的相同版本或更高的版本。
extcheck 实用程序将 targetfile.jar 文件清单的 specification-title 和 specification-version 头与当前安装在扩展目录下所有 Jar 文件的相对应的头进行比较（缺省扩展目录为 jre/lib/ext）。extcheck 实用程序比较版本号的方式与 java.lang.Package.isCompatibleWith 方法相同。若未检测到冲突，则返回代码为 0。如果扩展目录中任何一个 jar 文件的清单有相同的 specification-title 和相同的或更新的 specification-version 号，则返回非零错误代码。如果 targetfile.jar 的清单中没有 specification-title 或 specification-version 属性，则同样返回非零错误代码。
命令选项
-verbose 对扩展目录中的 Jar 文件进行检查时，列出文件。此外，还报告目标 jar 文件的清单属性及所有冲突的 jar 文件。

jar

功能说明：
Java归档工具
语法：
jar [ 命令选项 ] [manifest] destination input-file [input-files]
补充说明：
jar工具是个java应用程序，可将多个文件合并为单个JAR归档文件。jar是个多用途的存档及压缩工具，它基于ZIP和ZLIB压缩格式。然而，设计jar的主要目的是便于将java applet或应用程序打包成单个归档文件。将applet或应用程序的组件(.class 文件、图像和声音)合并成单个归档文件时，可以用java代理(如浏览器)在一次HTTP事务处理过程中对它们进行下载，而不是对每个组件都要求一个新连接。这大大缩短了下载时间。jar还能压缩文件，从而进一步提高了下载速度。此外，它允许applet的作者对文件中的各个项进行签名，因而可认证其来源。jar工具的语法基本上与tar命令的语法相同。
命令选项
-c 在标准输出上创建新归档或空归档。
-t 在标准输出上列出内容表。
-x[file] 从标准输入提取所有文件，或只提取指定的文件。如果省略了file，则提取所有文件；否则只提取指定文件。
-f 第二个参数指定要处理的jar文件。在-c(创建)情形中，第二个参数指的是要创建的jar文件的名称(不是在标准输出上)。在-t(表(或-x(抽取)这两种情形中，第二个参数指定要列出或抽取的jar文件。
-v 在标准错误输出设备上生成长格式的输出结果。
-m 包括指定的现有清单文件中的清单信息。用法举例：“jar cmf myManifestFile myJarFile *.class”
-0 只储存，不进行 ZIP 压缩。
-M 不创建项目的清单文件。
-u 通过添加文件或更改清单来更新现有的 JAR 文件。例如：“jar -uf foo.jar foo.class”将文件 foo.class 添加到现有的JAR文件foo.jar中，而“jar umf manifest foo.jar”则用manifest中的信息更新foo.jar的清单。
-C 在执行 jar 命令期间更改目录。例如：“jar -uf foo.jar -C classes *”将classes目录内的所有文件加到foo.jar中，但不添加类目录本身。
程序示例
1:将当前目录下所有CLASS文件打包成新的JAR文件：
jar cf file.jar *.class
2:显示一个JAR文件中的文件列表
jar tf file.jar
3:将当前目录下的所有文件增加到一个已经存在的JAR文件中
jar cvf file.jar *

javadoc

功能说明
Java API文档生成器从Java源文件生成API文档HTML页。
语法：
javadoc [ 命令选项 ] [ 包名 ] [ 源文件名 ] [ @files ]
其中[ 包名 ]为用空格分隔的一系列包的名字，包名不允许使用通配符，如（*）。[ 源文件名 ]为用空格分