/*面试题
 * 一个字符串有N个从'a~z'用byte[N]表示，计划如何节省空间去保存这个字符串？
 */
public class StringTest {
 public static void main(String[] args) {
  String str = "XAAABBCCCFFGGTTTKKabccccddddeeefffggzzzeeseeeseaa";
  byte[] buf= str.getBytes();//题意
  //创建至少足够的二维存储器,元素第一索引放字符的asii,元素第二索引放字符的数目
  byte[][] nbuf = new byte[buf.length][2];
  int count = 0;//相间除重复之后的字母数目
  int flag = 0;//标志,0表示不重复,1表示重复
  for(int i=0;i<buf.length;i++)
  {
   if(i != buf.length-1 && buf[i] == buf[i+1])//非最后一个并有重复时
    flag = 1;
   else
    flag = 0;
   
   if(i== 0)//第一个直接接收
   {
    nbuf[0][0] = buf[i];
    nbuf[0][1] = 1;
   }
   if(flag == 0)//不重复
   {
    nbuf[count++][0] = buf[i];
    nbuf[count][1] = 1;
   }
   else//重复
   {
    nbuf[count][0] = buf[i];
    nbuf[count][1] ++;
   }
  }
  //存储和显示  
  StringBuffer sb = new StringBuffer();
  for(int i=0;i<count;i++)
  {
   sb.append(nbuf[i][1]);
   sb.append((char)nbuf[i][0]);
  }
  System.out.print(sb.toString());
 }
}
运行结果:

1X3A2B3C2F2G3T2K1a1b4c4d3e3f2g3z2e1s3e1s1e2a

　　由上面的分析可以看出，问题的根源就在于对数据库连接资源的低效管理。我们知道，对于共享资源，有一个很著名的设计模式：资源池(Resource Pool)。该模式正是为了解决资源的频繁分配?释放所造成的问题。为解决上述问题，可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量?使用情况，为系统开发?测试及性能调整提供依据。

　　2、服务器自带的连接池

　　JDBC的API中没有提供连接池的方法。一些大型的WEB应用服务器如BEA的WebLogic和IBM的WebSphere等提供了连接池的机制，但是必须有其第三方的专用类方法支持连接池的用法。

　　连接池关键问题分析

　　1、并发问题

　　为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题。这个问题相对比较好解决，因为Java语言自身提供了对并发管理的支持，使用synchronized关键字即可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字，如：

　　public synchronized Connection getConnection()

　　2、多数据库服务器和多用户

　　对于大型的企业级应用，常常需要同时连接不同的数据库(如连接Oracle和Sybase)。如何连接不同的数据库呢?我们采用的策略是：设计一个符合单例模式的连接池管理类，在连接池管理类的唯一实例被创建时读取一个资源文件，其中资源文件中存放着多个数据库的url地址()?用户名()?密码()等信息。如tx.url=172.21.15.123：5000/tx_it，tx.user=yang，tx.password=yang321。根据资源文件提供的信息，创建多个连接池类的实例，每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字，通过不同的名字来管理不同的连接池。

　　对于同一个数据库有多个用户使用不同的名称和密码访问的情况，也可以通过资源文件处理，即在资源文件中设置多个具有相同url地址，但具有不同用户名和密码的数据库连接信息。

　　3、事务处理

　　我们知道，事务具有原子性，此时要求对数据库的操作符合“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全做，要么全不做。

　　在Java语言中，Connection类本身提供了对事务的支持，可以通过设置Connection的AutoCommit属性为false,然后显式的调用commit或rollback方法来实现。但要高效的进行Connection复用，就必须提供相应的事务支持机制。可采用每一个事务独占一个连接来实现，这种方法可以大大降低事务管理的复杂性。

　　4、连接池的分配与释放

　　连接池的分配与释放，对系统的性能有很大的影响。合理的分配与释放，可以提高连接的复用度，从而降低建立新连接的开销，同时还可以加快用户的访问速度。

　　对于连接的管理可使用空闲池。即把已经创建但尚未分配出去的连接按创建时间存放到一个空闲池中。每当用户请求一个连接时，系统首先检查空闲池内有没有空闲连接。如果有就把建立时间最长(通过容器的顺序存放实现)的那个连接分配给他(实际是先做连接是否有效的判断，如果可用就分配给用户，如不可用就把这个连接从空闲池删掉，重新检测空闲池是否还有连接);如果没有则检查当前所开连接池是否达到连接池所允许的最大连接数(maxConn),如果没有达到，就新建一个连接，如果已经达到，就等待一定的时间(timeout)。如果在等待的时间内有连接被释放出来就可以把这个连接分配给等待的用户，如果等待时间超过预定时间timeout,则返回空值(null)。系统对已经分配出去正在使用的连接只做计数，当使用完后再返还给空闲池。对于空闲连接的状态，可开辟专门的线程定时检测，这样会花费一定的系统开销，但可以保证较快的响应速度。也可采取不开辟专门线程，只是在分配前检测的方法。

　　5、连接池的配置与维护

　　连接池中到底应该放置多少连接，才能使系统的性能最佳?系统可采取设置最小连接数(minConn)和最大连接数(maxConn)来控制连接池中的连接。最小连接数是系统启动时连接池所创建的连接数。如果创建过多，则系统启动就慢，但创建后系统的响应速度会很快;如果创建过少，则系统启动的很快，响应起来却慢。这样，可以在开发时，设置较小的最小连接数，开发起来会快，而在系统实际使用时设置较大的，因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目，具体设置多少，要看系统的访问量，可通过反复测试，找到最佳点。

　　如何确保连接池中的最小连接数呢?有动态和静态两种策略。动态即每隔一定时间就对连接池进行检测，如果发现连接数量小于最小连接数，则补充相应数量的新连接,以保证连接池的正常运转。静态是发现空闲连接不够时再去检查。

　　连接池的实现

　　1、连接池模型

　　本文讨论的连接池包括一个连接池类(DBConnectionPool)和一个连接池管理类(DBConnetionPoolManager)。连接池类是对某一数据库所有连接的“缓冲池”，主要实现以下功能：①从连接池获取或创建可用连接;②使用完毕之后，把连接返还给连接池;③在系统关闭前，断开所有连接并释放连接占用的系统资源;④还能够处理无效连接(原来登记为可用的连接，由于某种原因不再可用，如超时，通讯问题)，并能够限制连接池中的连接总数不低于某个预定值和不超过某个预定值。

　　连接池管理类是连接池类的外覆类(wrapper),符合单例模式，即系统中只能有一个连接池管理类的实例。其主要用于对多个连接池对象的管理，具有以下功能：①装载并注册特定数据库的JDBC驱动程序;②根据属性文件给定的信息，创建连接池对象;③为方便管理多个连接池对象，为每一个连接池对象取一个名字，实现连接池名字与其实例之间的映射;④跟踪客户使用连接情况，以便需要是关闭连接释放资源。连接池管理类的引入主要是为了方便对多个连接池的使用和管理，如系统需要连接不同的数据库，或连接相同的数据库但由于安全性问题，需要不同的用户使用不同的名称和密码。

　　2、连接池实现

　　下面给出连接池类和连接池管理类的主要属性及所要实现的基本接口：

　　public class DBConnectionPool implements TimerListener{

　　private int checkedOut;//已被分配出去的连接数

　　private ArrayList freeConnections=new ArrayList();

　　//容器，空闲池，根据//创建时间顺序存放已创建但尚未分配出去的连接

　　private int minConn;//连接池里连接的最小数量

　　private int maxConn;//连接池里允许存在的最大连接数

　　private String name;//为这个连接池取个名字，方便管理

　　private String password;//连接数据库时需要的密码

　　private String url;//所要创建连接的数据库的地址

　　private String user;//连接数据库时需要的用户名

　　public Timer timer;//定时器

　　public DBConnectionPool(String name,String URL,String user,

　　String password,int maxConn)//公开的构造函数

　　public synchronized void freeConnection(Connection con)

　　//使用完毕之后，把连接返还给空闲池

　　public synchronized Connection getConnection(long timeout)

　　//得到一个连接，timeout是等待时间

　　public synchronized void release()

　　//断开所有连接，释放占用的系统资源

　　private Connection newConnection()

　　//新建一个数据库连接

　　public synchronized void TimerEvent()

　　//定时器事件处理函数

　　}

　　public class DBConnectionManager {

　　static private DBConnectionManager instance;

　　//连接池管理类的唯一实例

　　static private int clients;//客户数量

　　private ArrayList drivers=new ArrayList();

　　//容器，存放数据库驱动程序

　　private HashMap pools = new HashMap();

　　//以name/value的形式存取连接池对象的名字及连接池对象

　　static synchronized public DBConnectionManager getInstance()

　　/**如果唯一的实例instance已经创建，直接返回这个实例;否则，调用私有构造函数，

　　创建连接池管理类的唯一实例*/

　　private DBConnectionManager()

　　//私有构造函数,在其中调用初始化函数init()

　　public void freeConnection(String name,Connection con)

　　//释放一个连接，name是一个连接池对象的名字

　　public Connection getConnection(String name)

　　//从名字为name的连接池对象中得到一个连接

　　public Connection getConnection(String name,long time)

　　//从名字为name的连接池对象中取得一个连接，time是等待时间

　　public synchronized void release()//释放所有资源

　　private void createPools(Properties props)

　　//根据属性文件提供的信息，创建一个或多个连接池

　　private void init()//初始化连接池管理类的唯一实例，由私有构造函数调用

　　private void loadDrivers(Properties props)//装载数据库驱动程序

　　}

　　3、连接池使用

　　上面所实现的连接池在程序开发时如何应用到系统中呢?下面以Servlet为例说明连接池的使用。

　　Servlet的生命周期是：在开始建立servlet时，调用其初始化(init)方法。之后每个用户请求都导致一个调用前面建立的实例的service方法的线程。最后，当服务器决定卸载一个servlet时，它首先调用该servlet的destroy方法。

　　根据servlet的特点，我们可以在初始化函数中生成连接池管理类的唯一实例(其中包括创建一个或多个连接池)。如：

　　public void init() throws ServletException

　　{

　　connMgr=DBConnectionManager.getInstance();

　　}

　　然后就可以在service方法中通过连接池名称使用连接池，执行数据库操作。最后在destroy方法中释放占用的系统资源，如：

　　public void destroy(){

　　connMgr.release();

　　super.destroy();

　　}

　　结束语

　　在使用JDBC进行与数据库有关的应用开发中，数据库连接的管理是一个难点。很多时候，连接的混乱管理所造成的系统资源开销过大成为制约大型企业级应用效率的瓶颈。对于众多用户访问的Web应用，采用数据库连接技术的系统在效率和稳定性上比采用传统的其他方式的系统要好很多。本文阐述了使用JDBC访问数据库的技术?讨论了基于连接池技术的数据库连接管理的关键问题并给出了一个实现模型。文章所给出的是连接池管理程序的一种基本模式，为提高系统的整体性能，在此基础上还可以进行很多有意义的扩展。

    另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，这个对象的创建并不是通过ThreadLocal.set()来实现的，set()并不会做什么对象的拷贝，而是每个线程之前已经创建好的对象。通 过ThreadLocal.set()将这个新创建的对象的引用以当前线程为key，保存TheadLocal的一个map中，执行 ThreadLocal.get()时，各线程从map中取出以当前线程为key的对象，因此取出来的是各自自己线程中的对象。

下面来看看ThreadLocal的实现原理（jdk1.5源码）

1. public class ThreadLocal<T> {  
2.     /**
3.       * ThreadLocals rely on per-thread hash maps attached to each thread
4.       * (Thread.threadLocals and inheritableThreadLocals).   The ThreadLocal
5.       * objects act as keys, searched via threadLocalHashCode.   This is a
6.       * custom hash code (useful only within ThreadLocalMaps) that eliminates
7.       * collisions in the common case where consecutively constructed
8.       * ThreadLocals are used by the same threads, while remaining well-behaved
9.       * in less common cases.
10.       */  
11.     private final int threadLocalHashCode = nextHashCode();  
12.   
13.     /**
14.       * The next hash code to be given out. Accessed only by like-named method.
15.       */  
16.     private static int nextHashCode = 0;  
17.   
18.     /**
19.       * The difference between successively generated hash codes - turns
20.       * implicit sequential thread-local IDs into near-optimally spread
21.       * multiplicative hash values for power-of-two-sized tables.
22.       */  
23.     private static final int HASH_INCREMENT = 0x61c88647;  
24.   
25.     /**
26.       * Compute the next hash code. The static synchronization used here
27.       * should not be a performance bottleneck. When ThreadLocals are
28.       * generated in different threads at a fast enough rate to regularly
29.       * contend on this lock, memory contention is by far a more serious
30.       * problem than lock contention.
31.       */  
32.     private static synchronized int nextHashCode() {  
33.         int h = nextHashCode;  
34.          nextHashCode = h + HASH_INCREMENT;  
35.         return h;  
36.      }  
37.   
38.     /**
39.       * Creates a thread local variable.
40.       */  
41.     public ThreadLocal() {  
42.      }  
43.   
44.     /**
45.       * Returns the value in the current thread's copy of this thread-local
46.       * variable.   Creates and initializes the copy if this is the first time
47.       * the thread has called this method.
48.       *
49.       * @return the current thread's value of this thread-local
50.       */  
51.     public T get() {  
52.          Thread t = Thread.currentThread();  
53.          ThreadLocalMap map = getMap(t);  
54.         if (map != null)  
55.             return (T)map.get(this);  
56.   
57.         // Maps are constructed lazily.   if the map for this thread  
58.         // doesn't exist, create it, with this ThreadLocal and its  
59.         // initial value as its only entry.  
60.          T value = initialValue();  
61.          createMap(t, value);  
62.         return value;  
63.      }  
64.   
65.     /**
66.       * Sets the current thread's copy of this thread-local variable
67.       * to the specified value.   Many applications will have no need for
68.       * this functionality, relying solely on the {@link #initialValue}
69.       * method to set the values of thread-locals.
70.       *
71.       * @param value the value to be stored in the current threads' copy of
72.       *         this thread-local.
73.       */  
74.     public void set(T value) {  
75.          Thread t = Thread.currentThread();  
76.          ThreadLocalMap map = getMap(t);  
77.         if (map != null)  
78.              map.set(this, value);  
79.         else  
80.              createMap(t, value);  
81.      }  
82.   
83.     /**
84.       * Get the map associated with a ThreadLocal. Overridden in
85.       * InheritableThreadLocal.
86.       *
87.       * @param   t the current thread
88.       * @return the map
89.       */  
90.      ThreadLocalMap getMap(Thread t) {  
91.         return t.threadLocals;  
92.      }  
93.   
94.     /**
95.       * Create the map associated with a ThreadLocal. Overridden in
96.       * InheritableThreadLocal.
97.       *
98.       * @param t the current thread
99.       * @param firstValue value for the initial entry of the map
100.       * @param map the map to store.
101.       */  
102.     void createMap(Thread t, T firstValue) {  
103.          t.threadLocals = new ThreadLocalMap(this, firstValue);  
104.      }  
105.   
106.      .......  
107.   
108.     /**
109.       * ThreadLocalMap is a customized hash map suitable only for
110.       * maintaining thread local values. No operations are exported
111.       * outside of the ThreadLocal class. The class is package private to
112.       * allow declaration of fields in class Thread.   To help deal with
113.       * very large and long-lived usages, the hash table entries use
114.       * WeakReferences for keys. However, since reference queues are not
115.       * used, stale entries are guaranteed to be removed only when
116.       * the table starts running out of space.
117.       */  
118.     static class ThreadLocalMap {  
119.   
120.      ........  
121.   
122.      }
     

                     Collection<--List<--Vector
                           Collection<--List<--ArrayList
                           Collection<--List<--LinkedList
                           Collection<--Set<--HashSet
                           Collection<--Set<--HashSet<--LinkedHashSet
                           Collection<--Set<--SortedSet<--TreeSet

Vector : 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用，它不可能走入Array的限制。性能也就不可能超越Array。所以，在可能的情况下，我们要多运用Array。另外很重要的一点就是Vector“sychronized”的，这个也是Vector和ArrayList的唯一的区别。

ArrayList：同Vector一样是一个基于Array上的链表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector优越一些，但是当运行到多线程环境中时，可需要自己在管理线程的同步问题。

LinkedList：LinkedList不同于前面两种List，它不是基于Array的，所以不受Array性能的限制。它每一个节点（Node）都包含两方面的内容：1.节点本身的数据（data）；2.下一个节点的信息（nextNode）。所以当对LinkedList做添加，删除动作的时候就不用像基于Array的List一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。

List总结：

1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]；

2. 所有的List中可以有相同的元素，例如Vector中可以有 [ tom,koo,too,koo ]；

3. 所有的List中可以有null元素，例如[ tom,null,1 ]；

4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。

HashSet：虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。看看HashSet的add（Object   obj）方法的实现就可以一目了然了。

     public boolean add(Object obj)
     {
         return map.put(obj, PRESENT) == null;
     }

这个也是为什么在Set中不能像在List中一样有重复的项的根本原因，因为HashMap的key是不能有重复的。

LinkedHashSet：HashSet的一个子类，一个链表。

TreeSet：SortedSet的子类，它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。

Set总结：

1. Set实现的基础是Map（HashMap）；

2.   Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象；

使用Apache Jakarta Commons Collections：

CollectionUtils.addAll()方法的实现很简单，只是循环使用了Collection的add()方法而已。

如果只是想将数组转换成List，可以用JDK中的java.util.Arrays类：

不过Arrays.asList()方法返回的List不能add对象，因为该方法的实现是使用参数引用的数组的大小来new的一个ArrayList。

★ Collection转数组

直接使用Collection的toArray()方法，该方法有两个重载版本：

★ Map转Collection

直接使用Map的values()方法。

★ List和Set转换

第2章.     配置文件

2.1.    日志信息的优先级

2.2.    输出源的使用

2.2.1.  ConsoleAppender

2.2.2.  FileAppender

2.2.3.  DailyRollingAppender

2.2.4.  org.apache.log4j.RollingFileAppender

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.SortedSet;
import java.util.TreeSet;

/**
 *
 * @author semovy@gmail.com
 *  Collection
 *  |        |
 *  List    Set______________________________________________
 *  |__________                      |       |               |
 *  |          |                     |       |               |
 *  ArrayList  LinkedList        HashSet   LinkedHashSet     SortedSet
 *                                                           |
 *                                                           TreeSet
 */
public class CollectionTest {
/* Set容器中的对象是唯一的,所以加入Set容器的对象,必须重新equals()方法.作为唯一性的标识
 * HashSet的排序规则是利用HashTable,所以HashSet容器的对象必须重新定义hashCode()方法
 * 利用hashCode()方法,可以让快速找到容器中的对象,在比较两加入到容器中的对象是否相同时,会比较
 * hashCode()方法返回是否相同,如果相同,则再利用equals()方法比较,如果两者都相同,则被看作相同的对象
 * String 对象的hashCode(),equals已经被重新定义
 */
 public static void main(String[] args)
 {
  //String 对象的hashCode(),equals已经被重新定义
  //结果重复的内容对象被除去,并按按照hashCode()升序排序
  Collection<String> colStr = new HashSet<String>();
  colStr.add("ArrayList");
  colStr.add("LinkedList");
  colStr.add("HashSet");
  colStr.add("LinkedHashSet");
  colStr.add("LinkedSortedSet");
  colStr.add("ArrayList");
  CollectionTest ct = new CollectionTest();
  ct.display(colStr);
  //自定义类Employee.如果没有重新定义hashCode(),equals()方法,则不会除去重复内容的对象,不会自动按hashCode()排序
  Collection<Employee> colEmp = new HashSet<Employee>();
  colEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  colEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  colEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  colEmp.add(new Employee(4,"no.4","joke","note1"));
  colEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(colEmp);
  //LinkedHashSet,既去除了内容重复的对象,又按时插入容器时的顺序,被迭代.
  Collection<Employee> linkedEmp = new LinkedHashSet<Employee>();
  linkedEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  linkedEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  linkedEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  linkedEmp.add(new Employee(4,"no.4","joke","note1"));
  linkedEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(linkedEmp);
  //SortedSet接口,可以去除重复,并有比较器.
  SortedSet<String> ss = new TreeSet<String>();
  ss.add("1");
  ss.add("2");
  ss.add("3");
  ss.add("4");
  ss.add("4");
  ct.display(ss);
  
  //  SortedSet接口,可以去除重复,并有比较器.
  SortedSet<Employee> treeEmp = new TreeSet<Employee>(
    new Comparator<Employee>()//使用Employee泛型,匿名内部类比较器
    {
     
     public int compare(Employee arg0, Employee arg1) {
      
      return arg1.getName().compareTo(arg0.getName());//按照名称比较降序排序
     }
     
    }
    );
  treeEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  treeEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  treeEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  treeEmp.add(new Employee(4,"no.4","joke","note1"));
  treeEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(treeEmp);
  
  //SortedSet接口,可以去除重复,并有比较器.比较器名为comparatorById
  ComparatorById comparatorById = new ComparatorById();
  SortedSet<Employee> treeEmp1 = new TreeSet<Employee>(comparatorById);
  treeEmp1.add(new Employee(1,"no.1","semovy","he is a hero."));
  treeEmp1.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  treeEmp1.add(new Employee(3,"no.3","韦善茂","来自中国"));
  treeEmp1.add(new Employee(4,"no.4","joke","note1"));
  treeEmp1.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(treeEmp1);
  
  System.out.println();
  System.out.println(treeEmp1.last().toString());
  System.out.println(treeEmp1.first().toString());
  
  //用List接口的实现
  //ArrayList.基于数组的实现,添加与删除的效率慢于LinkedList,
  //LinkedList基于双向链表的实现 ,添加与删除的效率快于ArrayList,但迭代遍历的效率不如ArrayList
  List<Employee> empList = new ArrayList<Employee>();
  empList.add(new Employee(1,"no.1","semovy","he is a hero."));
  empList.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  empList.add(new Employee(3,"no.3","韦善茂","来自中国"));
  empList.add(new Employee(4,"no.4","joke","note1"));
  empList.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(empList);
  
  Employee[] arrEmp = empList.toArray(new Employee[0]);
  Arrays.sort(arrEmp, comparatorById);//用Arrays.sort静态方法排序,比较器是comparatorById
  
  ct.display(arrEmp);
  
  LinkedList<Employee> linkedListEmp = new LinkedList<Employee>();
  linkedListEmp.add(new Employee(1,"no.1","semovy","he is a hero."));
  linkedListEmp.add(new Employee(2,"no.2","superman_wshm","from Shenzhen China"));
  linkedListEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  linkedListEmp.add(new Employee(4,"no.4","joke","note1"));
  linkedListEmp.add(new Employee(3,"no.3","韦善茂","来自中国"));
  ct.display(linkedListEmp);
  
  ListIterator<Employee> ll =  linkedListEmp.listIterator();
  while(ll.hasNext())
  {
   Employee em = ll.next();
   System.out.println("index:" + ll.nextIndex());
   if(em.getId() == 3)
    ll.remove();//删除刚跨过的元素
  }
  ct.display(linkedListEmp);
 }

 /**
  * display all the objects in Collection
  * @prama Conllection
  */
 public void display(Collection c)//用for循环集合
 {
  System.out.println();
  for(Object obj : c)
   System.out.println(obj.toString() + " ");
 }
 public void display(Object[] arr)//用for循环数组
 {
  System.out.println();
  for(Object obj : arr)
   System.out.println(obj.toString() + " ");
 }
}
/**
 * 比较器接口Comparator 按id.升序
 */
 class ComparatorById implements Comparator<Employee>
{
 public int compare(Employee e1 ,Employee e2)
 {
  return e1.getId() - e2.getId();//按照id比较升序排序
 }
}

ArrayList
HashSet
LinkedSortedSet
LinkedHashSet
LinkedList

[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

1
2
3
4

[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]
[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]
[ ID: 3 , No.: no.3 , Name: 韦善茂 , Note: 来自中国 ]
index:1
index:2
index:3
index:3
index:4

[ ID: 1 , No.: no.1 , Name: semovy , Note: he is a hero. ]
[ ID: 2 , No.: no.2 , Name: superman_wshm , Note: from Shenzhen China ]
[ ID: 4 , No.: no.4 , Name: joke , Note: note1 ]

Set接口：（共15个函数）
  继承Collection,不允许重复的项，没有添加任何新的方法，只是在添加的函数中依赖元素equals()方法检
  查等同性。
  实现类：
    HashSet:为快速查找而设计的Set,存入的对象必须实现hashCode();
    TreeSet:保持次序的Set ,底层为树结构，使用它可以从Set中提取有序的序列，
    LinkedHashSet:具有HashSet的查询速度，且内部使用链表维护元素的顺序。
   

Map接口：
  首先说明的是与Collection没有任何关系,反映的是一对映射关系的集合，该接口描述了从不重复的键到值
  的映射。我们可以把这个接口方法分成三组操作：改变、查询和提供可选视图。
  改变操作允许您从映射中添加和除去键-值对。键和值都可以为null。但是，您不能把Map作为一个键或值添
  加给自身。
  Object put(Object key, Object value)
  Object remove(Object key)
  void putAll(Map mapping)
  void clear()
  查询操作允许您检查映射内容：
  Object get(Object key)
  boolean containsKey(Object key)
  boolean containsValue(Object value)
  int size()
  boolean isEmpty()
  最后一组方法允许您把键或值的组作为集合来处理。
 public Set keySet()
 public Collection values()
 public Set entrySet()
  因为映射中键的集合必须是唯一的，您用Set支持。因为映射中值的集合可能不唯一，您用Collection支持。
  最后一个方法返回一个实现Map.Entry接口的元素Set。
  实现类：
    TreeMap:基于红黑树的实现，查看键或键值对时，他们能会被排序，TreeMap是唯一一个带subMap()的Map,
     它可以返回一个子树。
    HashMap:是Map基于散列表的实现，插入和查询“键值对”的开销是固定的，可以通过构造起设置容量和负载
            因子(load factor)，以调整容器性能。
    LinkedHashMap：Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现与 HashMap 的不同
     之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭
     代顺序通常就是将键插入到映射中的顺序（插入顺序）。注意，如果在映射中重新插入键，则插
     入顺序不受影响。（如果在调用 m.put(k, v) 前 m.containsKey(k) 返回了 true，则调用时会
     将键 k 重新插入到映射 m 中。）
    这里要解释一下loadfactor，默认为0.75，负载因子是哈希表在其容量自动增加之前可以达到多满的一种
    尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行rehash操作
    （即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
 通常，默认加载因子 (.75)在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，
 但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get和put操作，都反映了这一点）。
 在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash
 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。

总结java.util包里的东东包括一些集合框架方面的，日历，时间方面，及正则表达式，模式匹配等方面的类 

　　1.抽象：
　　抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

　　2.继承：
　　继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

　　3.封装：
　　封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
　　
　　4. 多态性：
　　多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

2、String是最基本的数据类型吗?
　　基本数据类型包括byte、int、char、long、float、double、boolean和short。
    java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

3、int 和 Integer 有什么区别
　　Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类
booleanBoolean
charCharacter
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
　　引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
　　
4、String 和StringBuffer的区别
　　JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。
　　
5、运行时异常与一般异常有何异同？
　　异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

6、说出Servlet的生命周期，并说出Servlet和CGI的区别。
　　Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。

　　与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

7、说出ArrayList,Vector, LinkedList的存储性能和特性
　　ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

8、EJB是基于哪些技术实现的？并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。
    EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。
　　SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。EntityBean被用来代表应用系统中用到的数据。
　　对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。
　　对于客户机，EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。

　　Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态。

9、Collection 和 Collections的区别。 
　　Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
    Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

10、&和&&的区别。 
　　&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。

11、HashMap和Hashtable的区别。 
　　HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。

　　HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
　　HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。 
　　Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
　　最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 
　　Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

12、final, finally, finalize的区别。 
　　final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。

　　finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

13、sleep() 和 wait() 有什么区别? 
　　sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

14、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
　　方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

15、error和exception有什么区别?
　　error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
　　exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

16、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
　　如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

17、abstract class和interface有什么区别?

　　声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

　　接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

18、heap和stack有什么区别。
　　栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。
　　堆是栈的一个组成元素

19、forward 和redirect的区别
　　forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。
　　redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。

2.InfoQ.com Floyd Marinescu 在离开 TSS 后另起炉灶，2006年中最重要推荐。视野不再局限于Java 而是包括Java,.Net, Ruby ,SOA, Agile方法等热门话题。

3.JDJ的电子杂志 在JDJ首页的最底处订阅，文章质量不低于5-7的传统三强。

4.SWik.net   收集了大量OpenSource Project的资源聚合。其中如Spring，Hibernate的更新度非常高，出现什么和Spring有关的blog,article,project都会马上被聚合。

5.IBM DeveloperWorks 传统、稳定的Java文章来源地。

6.JavaWorld 传统、稳定的Java文章来源地。

7.OnJava   传统、稳定的Java文章来源地。

8.Artima.com 类似于TSS而略逊，其中Spotlight 文章值得关注，而Java News是聚合了所有其他Java站点的大聚合。

9.JavaLobby   站内的Announcements 是大大小小Java   Project的发布声明区，Trips and Tricks 有很多的Tips。

10. No Fluff Just Stuff 的Blogs 聚合 一直缺一个所有优秀Java Blogger的rss总聚合，NFJS这里勉强算一个。

                                       OLTP                                                              OLAP
用户                               操作人员,低层管理人员                               决策人员,高级管理人员
功能                              日常操作处理                                                 分析决策
DB 设计                        面向应用                                                        面向主题
数据                               当前的, 最新的细节的, 二维的分立的         历史的, 聚集的, 多维的集成的, 统一的
存取                              读/写数十条记录                                           读上百万条记录
工作单位                       简单的事务                                                     复杂的查询
用户数                         上千个                                                             上百个
DB 大小                       100MB-GB                                                      100GB-TB

二. Java中的类反射：
反射就是把Java类中的各种成分映射成相应的java类.
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。

1．检测类：

1.1 reflection的工作机制

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
   try {
    Class c = Class.forName(args[0]);
    Method m[] = c.getDeclaredMethods();
    for (int i = 0; i < m.length; i++)
    System.out.println(m[i].toString());
   }
   catch (Throwable e) {
    System.err.println(e);
   }
}
}

按如下语句执行：

java DumpMethods java.util.Stack

它的结果输出为：

public java.lang.Object java.util.Stack.push(java.lang.Object)

public synchronized java.lang.Object java.util.Stack.pop()

public synchronized java.lang.Object java.util.Stack.peek()

public boolean java.util.Stack.empty()

public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

1.2 Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数：

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

1.3开始使用 Reflection：

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

2．处理对象：

如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤:

a.创建一个Class对象
b.通过getField 创建一个Field对象
c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：
import java.lang.reflect.*;
import java.awt.*;

class SampleGet {  
public static void main(String[] args) {
   Rectangle r = new Rectangle(100, 325);
   printHeight(r);  
}

static void printHeight(Rectangle r) {
   Field heightField;
   Integer heightValue;
   Class c = r.getClass();
   try {
    heightField = c.getField("height");
    heightValue = (Integer) heightField.get(r);
    System.out.println("Height: " + heightValue.toString());
   } catch (NoSuchFieldException e) {
    System.out.println(e);
   } catch (SecurityException e) {
    System.out.println(e);
   } catch (IllegalAccessException e) {
    System.out.println(e);
   }
}
}

顾名思义，反射 (reflection) 机制就像是在吴承恩所写的西游记中所提及的「照妖镜」，可以让类别或对象 (object) 在执行时期「现出原形」。我们可以利用反射机制来深入了解某类(class) 的构造函数 (constructor)、方法 (method)、字段 (field)，甚至可以改变字段的值、呼叫方法、建立新的对象。有了反射机制，程序员即使对所想使用的类别所知不多，也能照样写程序。反射机制能够用来呼叫方法，这正是反射机制能够取代函数指针的原因。

以 Java 来说，java.lang.reflect.Method (以下简称 Method) 类别是用来表示某类别的某方法。我们可以透过 java.lang.Class (以下简称 Class) 类别的许多方法来取得 Method 对象。Method 类别提供 invoke() 方法，透过 invoke()，此 Method 对象所表示的方法可以被呼叫，所有的参数则是被组织成一个数组，以方便传入 invoke()。

举个例子，下面是一个名为 Invoke 的程序，它会将命令列的 Java 类别名称和要呼叫的方法名称作为参数。为了简单起见，我假定此方法是静态的，且没有参数：

import java.lang.reflect.*;
class Invoke {        
public static void main(String[] args ) {               
   try {                       
    Class c = Class.forName( args[0] );                       
    Method m = c.getMethod( args[1], new Class [] { } );                       
    Object ret = m.invoke( null, null );                       
    System.out.println(args[0] + "." + args[1] +"() = " + ret );               
   } catch ( ClassNotFoundException ex ) {                       
    System.out.println("找不到此类别");               
   } catch (NoSuchMethodException ex ) {                       
    System.out.println("此方法不存在");               
   } catch (IllegalAccessException ex ) {                       
    System.out.println("没有权限调用此方法");               
   } catch (InvocationTargetException ex ) {                       
    System.out.println("调用此方法时发生下列例外:\n" + ex.getTargetException() );               
   }        
}
}
我们可以执行 Invoke 来取得系统的时间：

java Invoke java.lang.System CurrentTimeMillis执行的结果如下所示：

java.lang.System.currentTimeMillis() = 1049551169474我们的第一步就是用名称去寻找指定的 Class。我们用类别名称 (命令列的第一个参数) 去呼叫 forName() 方法，然后用方法名称 (命令列的第二个参数) 去取得方法。getMethod() 方法有两个参数：第一个是方法名称 (命令列的第二个参数)，第二个是 Class 对象的数组，这个阵例指明了方法的 signature (任何方法都可能会被多载，所以必须指定 signature 来分辨。) 因为我们的简单程序只呼叫没有参数的方法，我们建立一个 Class 对象的匿名空数组。如果我们想要呼叫有参数的方法，我们可以传递一个类别数组，数组的内容是各个类别的型态，依顺序排列。

一旦我们有了 Method 对象，就呼叫它的 invoke() 方法，这会造成我们的目标方法被调用，并且将结果以 Object 对象传回。如果要对此对象做其它额外的事，你必须将它转型为更精确的型态。

invoke() 方法的第一个参数就是我们想要呼叫目标方法的对象，如果该方法是静态的，就没有对象，所以我们把第一个参数设为 null，这就是我们范例中的情形。第二个参数是要传给目标方法作为参数的对象数组，它们的型态要符合呼叫 getMethod() 方法中所指定的型态。因为我们呼叫的方法没有参数，所以我们传递 null 作为 invoke() 的第二个参数。

import   java.lang.reflect.Constructor;
import   java.lang.reflect.Field;
import   java.lang.reflect.Method;
import   java.lang.reflect.Modifier;
import   java.util.HashMap;

public    class   TestRef    {
      public    static    void   main(String[] args)   throws   Exception   {
         TestRef testRef   =    new   TestRef();
         Class clazz   =   TestRef. class ;
         System.out.println( " getPackage() =   "    +   clazz.getPackage().getName());
         //   getModifiers()的返回值可以包含类的种类信息。比如是否为public,abstract,static
         int   mod   =   clazz.getModifiers();
         System.out.println( " Modifier.isAbstract(mod) =   " + Modifier.isAbstract(mod));
         System.out.println( " getName() =   " + clazz.getName());
         System.out.println( " getSuperclass() =   " + clazz.getSuperclass().getName());
         System.out.println( " getInterfaces() =   " + clazz.getInterfaces()); // 实现了哪些Interface
         System.out.println( " clazz.getDeclaredClasses() =   " + clazz.getDeclaredClasses()); // 包含哪些内部类
         System.out.println( " getDeclaringClass() =   " + clazz.getDeclaringClass());
         // 如果clazz是inner class 那么返回其outer class
         
         System.out.println( " ---------- " );
         Constructor[] constructor   =   clazz.getDeclaredConstructors(); // 返回一组构造函数 Constructor[]
            if   (constructor   !=    null )   {
              for   ( int   i   =    0 ; i   <   constructor.length; i ++ )    {
                 System.out.println(constructor[i].getName());
             }
         }
        
         System.out.println( " ---------- " );
         Method[] method   =   clazz.getDeclaredMethods();   //   Method[]
            if   (method   !=    null )   {
              for   ( int   i   =    0 ; i   <   method.length; i ++ )    {
                 System.out.println(method[i].getName());
             }
         }
        
         System.out.println( " ---------- " );
         Field[] field   =   clazz.getDeclaredFields();   //   Field[]
            if   (field   !=    null )   {
              for   ( int   i   =    0 ; i   <   field.length; i ++ )    {
                 System.out.println(field[i].getName());
                 System.out.println(field[i].getType().getName());
                 System.out.println(field[i].get(testRef));
             }
         }
        
         //   动态生成instance(无参数)
         Class clz   =   Class.forName( " reflection.TestRef " );
         Object obj   =   clz.newInstance();
         System.out.println(((TestRef)obj).getStr());
        
         //   动态生成instance(有参数)
          Class[] params   =    new   Class[]   {String. class ,   int . class ,   double . class } ;
         Constructor construct   =   clz.getConstructor(params);
         //   JDK1.5的情况下可以直接用{"haha",999,100.01}作为参数         
          Object obj2   =   construct.newInstance(new Object[]{"haha",new Integer( 999 ),   new   Double( 100.01 )} );
         System.out.println(((TestRef)obj2).getStr());
        
         //   动态调用method(public method)
          Class[] params2   =    new   Class[]   {String. class } ;
         Method methods   =   clz.getMethod( " setStr " , params2);
         methods.invoke(testRef,   new   Object[]   { " invoke method " } );
         System.out.println(testRef.getStr());
        
         //   动态改变field内容(public field)
         Field fields   =   clz.getField( " str " );
         fields.set(testRef,   " set field's value " );
         System.out.println(testRef.getStr());
        
     }

      public   TestRef()   {
         System.out.println( " --- complete TestRef() --- " );
     }
    
     public   TestRef(String str,   int   i,   double   d)   {
          this .str   =   str;
          this .i   =   i;
          this .d   =   d;
         System.out.println( " --- complete TestRef(String str, int i, double d) --- " );
     }
    
     public   String str   =    " I'm a string " ;

     int   i   =    1 ;

     double   d   =    3.14 ;

     HashMap map   =    new   HashMap();

      public    double   getD()    {
          return   d;
     }

       public    void   setD( double   d)    {
          this .d   =   d;
     }

       public    int   getI()    {
          return   i;
     }

       public    void   setI( int   i)    {
          this .i   =   i;
     }

       public   HashMap getMap()    {
          return   map;
     }

       public    void   setMap(HashMap map)    {
          this .map   =   map;
     }

       public   String getStr()    {
          return   str;
     }

       public    void   setStr(String str)    {
          this .str   =   str;
     }
}

三. 代理(Proxy)
1.
我们直接从代码入手吧，我们可以使用一个动态代理类(Proxy)，通过拦截一个对象的行为并添加我们需要的功能来完成。Java中的java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口为我们实现动态代理类提供了一个方案，但是该方案针对的对象要实现某些接口；如果针对的目的是类的话，cglib为我们提供了另外一个实现方案。等下会说明两者的区别。
一、接口的实现方案：
1）首先编写我们的业务接口（StudentInfoService.java）：
public interface StudentInfoService{
void findInfo(String studentName);
}
      及其实现类（StudentInfoServiceImpl.java）：
public class StudentInfoServiceImpl implements StudentInfoService{
public void findInfo(String name){
   System.out.println("你目前输入的名字是:"+name);
}
}
2）现在我们需要一个日志功能，在findInfo行为之前执行并记录其行为，那么我们就首先要拦截该行为。在实际执行的过程中用一个代理类来替我们完成。Java中为我们提供了实现动态代理类的方案：

1'处理拦截目的的类（MyHandler.java）
import org.apache.log4j.Logger;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;

public class MyHandler implements InvocationHandler{
private Object proxyObj;
private static Logger log=Logger.getLogger(MyHandler.class);

public Object bind(Object obj){
   this.proxyObj=obj;
   return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
}

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
   Object result=null;
   try{
    //请在这里插入代码，在方法前调用
    log.info("调用log日志方法"+method.getName());
    result=method.invoke(proxyObj,args); //原方法
    //请在这里插入代码，方法后调用
   }catch(Exception e){
    e.printStackTrace();
   }
   return result;
}
}
2'我们实现一个工厂，为了方便我们使用该拦截类(AOPFactory.java)：
public class AOPFactory{
private static Object getClassInstance(String clzName){
   Object obj=null;
   try{
    Class cls=Class.forName(clzName);
    obj=(Object)cls.newInstance();
   }catch(ClassNotFoundException cnfe){
    System.out.println("ClassNotFoundException:"+cnfe.getMessage());
   }catch(Exception e){
    e.printStackTrace();
   }
   return obj;
}

public static Object getAOPProxyedObject(String clzName){
   Object proxy=null;
   MyHandler handler=new MyHandler();
   Object obj=getClassInstance(clzName);
   if(obj!=null) {
    proxy=handler.bind(obj);
   }else{
    System.out.println("Can't get the proxyobj");
    //throw
   }
   return proxy;
}
}

3)基本的拦截与其工厂我们都实现了，现在测试（ClientTest.java）：
public class ClientTest{
public static void main(String[] args){
   StudentInfoService studentInfo=(StudentInfoService)AOPFactory.getAOPProxyedObject("StudentInfoServiceImpl");
   studentInfo.findInfo("阿飞");
}
}
输出结果（看你的log4j设置）：
[INFO]调用log日志方法findInfo
你目前输入的名字是:阿飞
      这样我们需要的效果就出来了，业务处理自己在进行，但是我们实现了日志功能

2.再看一个例子:
　　假设系统由一系列的BusinessObject所完成业务逻辑功能，系统要求在每一次业务逻辑处理时要做日志记录。这里我们略去具体的业务逻辑代码。

public interface BusinessInterface {
　public void processBusiness();
}

public class BusinessObject implements BusinessInterface {
　private Logger logger = Logger.getLogger(this.getClass().getName());
　public void processBusiness(){
　　try {
　　　logger.info("start to processing...");
　　　//business logic here.
　　　System.out.println(“here is business logic”);
　　　logger.info("end processing...");
　　} catch (Exception e){
　　　logger.info("exception happends...");
　　　//exception handling
　　}
　}
}

　　这里处理商业逻辑的代码和日志记录代码混合在一起，这给日后的维护带来一定的困难，并且也会造成大量的代码重复。完全相同的log代码将出现在系统的每一个BusinessObject中。

按照AOP的思想，我们应该把日志记录代码分离出来。要将这些代码分离就涉及到一个问题，我们必须知道商业逻辑代码何时被调用，这样我们好插入日志记录代码。一般来说要截获一个方法，我们可以采用回调方法或者动态代理。动态代理一般要更加灵活一些，目前多数的AOP Framework也大都采用了动态代理来实现。这里我们也采用动态代理作为例子。
JDK1.2以后提供了动态代理的支持，程序员通过实现java.lang.reflect.InvocationHandler接口提供一个执行处理器，然后通过java.lang.reflect.Proxy得到一个代理对象，通过这个代理对象来执行商业方法,在商业方法被调用的同时，执行处理器会被自动调用。

　　有了JDK的这种支持，我们所要做的仅仅是提供一个日志处理器。

public class LogHandler implements InvocationHandler {

　private Logger logger ＝ Logger.getLogger(this.getClass().getName());
　　private Object delegate;
　　public LogHandler(Object delegate){
　　　this.delegate = delegate;
　　}

　public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
　　Object o = null;
　　try {
　　　logger.info("method stats..." ＋ method);
　　　o = method.invoke(delegate,args);
　　　logger.info("method ends..." + method);
　　} catch (Exception e){
　　　logger.info("Exception happends...");
　　　//excetpion handling.
　　}
　　return o;
　}
}

　　现在我们可以把BusinessObject里面的所有日志处理代码全部去掉了。

public class BusinessObject implements BusinessInterface {

　private Logger logger = Logger.getLogger(this.getClass().getName());
　public void processBusiness(){
　　//business processing
　　System.out.println(“here is business logic”);
　}
}

　　客户端调用商业方法的代码如下：

BusinessInterface businessImp = new BusinessObject();

InvocationHandler handler = new LogHandler(businessImp);

BusinessInterface proxy = (BusinessInterface) Proxy.newProxyInstance(
　businessImp.getClass().getClassLoader(),
　businessImp.getClass().getInterfaces(),
　handler);

proxy.processBusiness();

　　程序输出如下：

INFO: method stats...
here is business logic
INFO: method ends...

　　至此我们的第一次小尝试算是完成了。可以看到，采用AOP之后，日志记录和业务逻辑代码完全分开了，以后要改变日志记录的话只需要修改日志记录处理器就行了，而业务对象本身（BusinessObject）无需做任何修改。并且这个日志记录不会造成重复代码了，所有的商业处理对象都可以重用这个日志处理器。

在JAVA API中的java.net包中提供了URLEncoder和URLDecoder两个类,供我们方便实现URL编码和解码.下面来看几个小例子:
1.对于空格也可以直接使用其十六进制编码方式,即用%20表示,而不是转换成+号,按照上面说的第三条,很显然%20是可以解码成空格的.如下两个URL字符串的效果是一样的:
http://www.baidu.com/search.html?name=a+b&password=123
http://www.baidu.com/search.html?name=a%20b&password=123
2.如果确信URL串中的特殊字符不会引起歧义,也可以不对它们进行编码,例如:
http://www.baidu.com/search.html?name=中国&password=123
http://www.baidu.com/search.html?name=%D6%D0%B9%FA&password=123
上面的两个URL字符串,不管是否对其进行URL编码,结果都是一样的,注意:虽然规定了除数字和英文字符不对其URL编码,但这并不等于必须对其URL编码,只有在有可能引起歧义或冲突时才是必需的.看下面的例子:
如果要传递的name是"中+国",如果不对其进行URL编码,服务器就会认为传过来的是"中 国"."中&国"如果不进行URL编码就传给服务器变成了
http://www.baidu.com/search.html?name=中&国&password=123
我们知道,&这个字符在URL中是有特殊含义的.所以这个查询字符串的服务器端就被分成三段来解释.这样就不可能达到预期的结果.所以对这样的字符就必须进行URL编码.

                                         建立连接，发送请求信息         
                         -------------------------------------------------------------------------->
         客户机                                                                              服务器
                         <--------------------------------------------------------------------------
                                         关闭连接，回送响应消息

每次连接只处理一个请求，即使是对同一个网站的每一个页面的访问，浏览器和WEB服务器都要建立一次单独的连接。

2.HTTP/1.1的会话方式：

                                         建立连接，第1个请求信息         
                         -------------------------------------------------------------------------->
                                                   ............
                                         发送第N请求信息         
                         -------------------------------------------------------------------------->
         客户机                 回送第1次响应                                      服务器
                         <--------------------------------------------------------------------------                                        
                                                 ..............
                                         回应第n次响应
                         <--------------------------------------------------------------------------
                                         发送关闭连接请求         
                         -------------------------------------------------------------------------->          
                                         关闭连接              
                         <--------------------------------------------------------------------------
                                        

HTTP/1.1支持持久连接，在一个TCP连接上可以传送多个HTTP请求和响应，减少了建立和关闭连接的消耗和延迟。一个包含有许多图象的网页文件的多个请求和响应可以在一个连接中传输，但每个单独的网页文件的请求和响应仍然需要使用各自的连接，还允许客户端不用等待上一次请求结果返回就可以发送下一个请求。

HTTP消息的格式：
一个完整的请求消息包括：一个请求行、若干消息头、以及实体内容。
一个完整的响应消息包括：一个状态行、若干消息头、以及实体内容。
这在前面已经有过简单的介绍。下面对这几个部分再做个详细的解说：
1.请求行：包括三个部分，即请求方式、资源路径、以及使用的HTTP协议版本。语法如下：请求方式 资源路径 HTTP版本号<CRLF>,其中<CRLF>表示回车和换行这两个字符的组合。HTTP请求方式包括POST、GET、HEAD、OPTIONS、DELETE、TRACE和PUT几种。常用的是前两种。
2.状态行：包括HTTP协议的版本号、一个状态码、以及对状态码进行描述的文本信息。
语法如下：HTTP版本号 状态码 原因叙述<CRLF>

使用GET和POST传递参数：
在URL地址后面可以附加一些参数，每个参数都由参数名和参数值组成，中间用＝分隔，各个参数用&分隔，URL地址和整个参数之间用？分隔，如下所示：
http://www.it315.org/servlet/ParamsServlet?param1=aaa&param2=bbb
使用GET传递参数的数据量是有限的，一般限制在1KB以下。使用POST比GET要大的多。是没有限制的。但是必须设置Content=Type消息头为‘application/x-www-form-urlencoded’和设置Content-Length消息头为实体内容的长度。

响应状态码：
200：表示一切正常，返回的是正常请求结果。
404：表示服务器上不存在客户机上所请求的资源，这个状态码在浏览网页时最常见的。

通用信息头：
Cache-Control：此字段用于通知客户机和服务器之间的代理服务器如何使用已缓存的页面。
Connection：用于指定处理完本次请求/响应后，客户端和服务器是否还要继续保持连接。
Date：用于表示HTTP消息产生的当前时间。
Transfer-Encoding：用于指定实体内容的传输编码方式。

请求头：
Accept：用于指定客户端程序能够处理的MIME类型。有多个时用逗号隔开。
Accept-Charset：指出客户端程序可以使用的字符集。有多个时用逗号隔开。
Accept-Encoding：指定客户机能够进行解码的数据编码方式。有多个时用逗号隔开。
Accept-Language：指定客户机期望服务器返回哪个国家语言的文档。有多个时用逗号隔开。
Host：指定资源所在的主机名和端口号。

响应头：
Accept-Range：用于说明当前WEB服务器是否接受Range请求和Range请求中指定的数据的单位。
Location：用于通知客户机应该到哪个新的地址去获取文档。由于当前响应并没有直接返回内容给客户机，所以使用Location头的HTTP消息不应该有实体内容，由此可见，在消息头中不能同时出现Location和Contect-Type这两个头自段。

实体头：
Allow：用于指定客户机请求的资源所支持的请求方法。
Content-Encoding：用于指定实体内容的压缩编码方式。
Content-Language：用于指定返回的网页文档的国家语言类型。
Content-Length：用于指定实体内容的长度。
Content-Location：用于指定响应消息中所封装的实体内容的实际位置路径。
Content-Type：用于指定实体内容的MIME类型。客户机通过检查服务器响应消息的此字段中的MIME类型就能知道实体内容的数据格式和知道以何种方式来进行处理了。<Tomcat>安装目录下的conf目录下的web.xml文件里面就定义了很多的类型。
Last-Modified：用于指定文档的最后修改时间。

扩展头：
Refresh：此字段告诉浏览器隔多长时间刷新。

２．path环境变量的作用

指定操作系统查找命令的路径
操作系统依次查找path指定的路径，并以最先找到符合的为准

３．classpath环境变量的作用

指定操作系统查找类的路径
操作系统只在classth指定的路径查找该类
不会查找当前目录
set classpath=E:\Programming\Java　设置classpath的值
注意：
(１)= 号前后都不能有空格
(２)路径包含的目录名中不可以出现空格
(３)目录名不能包含中文字符
set classpath=E:\Programming\Java;
set classpath=E:\Programming\Java;.　(注意后面有个分号和点)
操作系统同时也在当前目录下查找

4.1 Java的类

　　4.1.1 类的声明

　　Java是一种很典型的面向对象的程序设计语言。在面向对象的语言中，世界被看成独立的对象集合，相互间通过消息来通信。因而这种语言以数据对象为中心，而不以处理对象的代码为中心。Java中的类将数据和有关的操作封装在一起，描述一组具有相同类型的对象，作为构筑程序的基本单位。
　　类声明定义的格式为：
　　[类修饰符] class类名 [extends　父类名][implements　接口名]
其中类修饰符用于指明类的性质，可缺省。接下来的关键字class指示定义的类的名称，类名最好是唯一的。“extends 父类名”通过指出所定义的类的父类名称来表明类间的继承关系，当缺省时意味着所定义类为Object类的子类。“implements 接口名”用来指出定义的类实现的接口名称。一个类可以同时实现多个接口。类体则包括一系列数据变量和成员方法的定义声明。下面是一些略去类体的类定义例子：
　　public class WelcomeApp
　　public class Welcome extends java.applet.Applet
　　public Car extends Automobile implements Runable
其中前两个类是我们在上一章的示例中定义的。第三个类是小汽车类Car，它的父类是交通工具类Automobile，它还实现了接口Runnable。
　　类修饰符是用以指明类的性质的关键字。基本的类修饰符有三个：
　　public，abstract和final
　　■public
　　如果一个类被声明为public，那么与它不在同一个包中的类也可以通过引用它所在的包来使用这个类；否则这个类就只能被同一个包中的类使用。
　　■abstract
　　如果一个类被声明为abstract，那么它是一个抽象的类，不能被实例化生成自己的对象，通常只是定义了它的子类共有的一些变量和方法供继承使用。被声明为abstract的抽象类往往包含有被声明为abstract的抽象方法，这些方法由它的非抽象子类完成实现细节。
　　■final
　　如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为abstract的，又被声明为final的。
　　继承是面向对象程序设计中一个强有力的工具，它允许在已存在的类的基础上创建新的类。新创建的类称为其基础类的子类，基础类称为其子类的父类。子类的对象除了具有新定义的属性和方法外，还自动具有其父类定义的部分或全部属性方法。这样程序员可以在子类中重用父类中已定义好的变量和方法，只需对子类中不同于父类或新添加的部分重新定义，这样就节省了大量的时间、空间和精力。Java在类声明中使用
　　extends 父类名
的方式定义继承关系。如果不明显地写出继承的父类名，则缺省地认为所声明的类是Java的Object类的一个子类。Object类是Java中所有的类的祖先类。我们可以把这种类继承关系想象为一棵倒置的类家族树，Object类就是这棵树的根。

　　4.1.2 类的组成

　　我们已经知道类是代表对象的，而每一个对象总有特定的状态和行为，在类中分别用变量数据和在数据上可进行的操作表示这些状态和行为。因此类的组成成分是变量和方法。变量和方法的声明格式如下：
　　[变量修饰符]　数据类型　变量名[=初值]　;
　　[方法修饰符]　返回值类型　方法名(参数表)
其中修饰符用来指明变量和方法的特性。变量可一次定义一个或多个，定义时可以给出初值。例如：
　　public int a,b=12;
　　protected String s="Hot Java";
定义方法时一定要给出返回值类型和参数表。当没有返回值时，返回值类型记为void。参数表的形式为：
　　参数类型 参数值{，参数类型 参数值}
各参数间以逗号分隔。下面是一些简单的例子：
　　public static void main(String args[])
　　public void paint(Graphics g)
　　public int area(int length,int width){return length * width;}
其中前两个是我们在第三章已经见过的方法声明，这里略去了具体语句组成的方法体。第三个则是一个计算长方形面积的简单方法，接受整数类型的长度和宽度参数并返回它们的乘积作为结果。
　　变量和方法修饰符是用来指明特性的关键字，主要有以下几种：
　　■public
　　一个类中被声明为public的变量和方法是“公开”的，意味着只要能使用这个类，就可以直接存取这个变量的数据，或直接使用这个方法。
　　■protected
　　一个类中被声明为protected的变量和方法是“受限”的，意味着它们仅能被与该类处于同一个包的类及该类的子类所直接存取和使用。
　　■private
　　被声明为private的变量和方法是“私有”的，除了声明它们的类外，不能被任何其它的类直接存取和使用。
　　当变量或方法前不加以上三种修饰符时，被认为取friendly状态，即它们只能被同一个包中的类直接存取和使用。但不存在friendly关键字。
　　■static
　　被声明为static的变量和方法是属于类而不是属于对象的。不管这个类产生了多少个对象，它们都共享这个类变量或类方法。我们可以在不创建类实例对象时直接使用类变量和类方法。一般来说，在Java中，引用一个特定的变量或方法的形式是：
　　对象名.变量名
　　对象名.方法名
例如：
　　int a=rectangle.length;
　　g.drawString("Welcome to Java World!");
即变量和方法是受限于对象的，但声明为static的变量或方法受限于类，使用形式是
　　类名.变量名
　　类名.方法名
例如：
　　System.out.println("Welcome to Java World!");
　　String s=String.valueOf(123);
这里我们并没有创建System类或String类的对象，而直接调用System类的类变量out和String类的类方法valueOf。其中valueOf方法将整形参数转换为String类对象。被声明为static的类方法在使用时有两点要特别注意：
　　(1)类方法的方法体中只能使用类中其它同样是static的变量或方法；
　　(2)类方法不能被子类修改或重新定义。
　　■final
　　将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
　　■abstract
　　这个修饰符仅适用于方法。被声明为abstract的方法不需要实际的方法体，只要提供方法原型接口，即给出方法的名称、返回值类型和参数表，格式如下：
　　abstract　返回值类型　方法名(参数表)；
定义了abstract抽象方法的类必须被声明为abstract的抽象类。

　　4.1.3 构造方法和finalizer

　　Java中有两个特殊的方法：用于创建对象的构造方法(constructor)和用于撤销对象的方法finalizer，相当于C++中的构造函数和析构函数。构造方法是生成对象时编译器自动调用的方法，用以给出对象中变量的初值。构造方法必须与类同名，而且绝对不允许有返回值，甚至不允许以void来标记无返回值。一个类的构造方法可以有多个，以不同的参数表区分不同的情形，这是Java多态性的一个体现。下面是一个简单的例子。
　　例4.1 Rectangle类的构造方法。
　　class Rectangle{
　　　protected int width;/*类Rectangle的两个整型变量*/
　　　protected int height;/*分代表长方形的长和宽*/
　　　/*下面是类Rectangle的三个构造方法*/
　　　/*第一个构造方法，无参数，缺省地给出长和宽*/
　　　　Rectangle()
　　　/*第二个构造方法，给出长、宽参数*/
　　　　Rectangle(int w,int h)
　　　/*第三个构造方法，给出另一个Rectangle作参数*/
　　　　Rectangle(Rectangle r)
　　　　{width=r.width();
　　　　　height=r.height();
　　　　}
　　　/*下面是类Rectangle的另外两个方法，分别为取长和宽的值*/
　　　　public int width()
　　　　　{return width;}
　　　　public int height()
　　　　　{return height;}
　　}
　　class Test{
　　　Rectangle r1=new Rectangle();/*调用第一个构造方法*/
　　　Rectangle r2=new Rectangle(12,20);/*调用第二个构造方法*/
　　　Rectangle r3=new Rectangle(r1);/*调用第三个构造方法*/
　　}
　　在这个例子中Rectangle有三个构造方法，它们的名字相同，参数不同因而采用的调用形式也不同。第一个构造方法不需要任何参数，调用时系统自动地给出统一的固定的长方形的宽和高(这里我们设定为20和30)。第二个构造方法需要两个整形参数，根据用户给出的长方形的宽和高创建长方形对象。第三个构造方法需要一个长方形参数，创建出与这个长方形具有同样的宽和高的长方形对象。在Rectangle类中，width和height都是protected的，不宜直接存取。为了使用方便，我们定义出width()和height()方法来获得一个特定长方形的宽和高，再将取得的数值传递给新创建的对象。像这样在一类中有两个或两个以上同名方法的现象叫Overloading，是多态的一种表现。这样同名方法应该有且必须有不同的参数表，调用时编译系统就是根据参数的匹配情况，包括个数和类型，来决定实际使用哪一个方法的。如果两同名方法的参数表也相同，会造成混淆，编译时将得到出错信息：
　　Duplicate method declaration
　　(重复的方法声明)
　　为了实际创建出对象，我们要使用new。系统执行遇到new，才根据new后面跟随的构造方法名和参数表，选择合适的构造方式，分配内存，创建对象并初始化。一个类若没有显示地定义构造方法，使用new时将调用它的父类的构造方法，这种上溯可一直到达Object类，而Object类的构造方法是语言预先定义好的。
　　相对于构造方法，在对象被撤销时调用的方法是finalizer。对所有的类，它的原始定义形式都是一样的：
　　void finalize();
没有返回值，而且没有任何参数。一般来说，由于Java的内存管理是由系统自动完成，通常不需要我们重写这个方法，而让它自然而然地从父类(最终也就是从Object类)继承。只有当某些资源需要自动归还时，才需要将这一方法重写。

　　4.1.4 重写(Overriding)和重载(Overloading)

　　方法的重写Overriding和重载Overloading是Java多态性的不同表现。前者是父类与子类之间多态性的一种表现，后者是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。这在例4.1中已经可以看到。下面再给出两个简单的例子，分别显示Overriding和Overloading。
　　例4.2 Overriding的例示
　　class Father{
　　　void speak(){
　　　　System.out.println("I am Father!");//父类定义的speak方法
　　　}
　　}
　　class Son extends Father{
　　　void speak(){
　　　　System.out.println("I am Son!");//子类重写的speak方法
　　　}
　　}
　　public class Check{
　　　public static void main(String args[]){
　　　　Son x=new Son();
　　　　x.speak();//调用子类的speak方法
　　　}
　　}
　　//output of class Check!
　　I am Son!
　　从这个例子我们可以看到，类Son中的speak()方法重写了其父类Father中一模一样的方法，而它的对象x调用speak()方法的结果是与Son中定义致的。
　　例4.3　Overloading例示。
　　class Father{
　　　void speak(){　　//无参的speak方法
　　　　System.out.println("I am Father.");
　　　}
　　　void speak (String s){　　//有参的speak方法
　　　　System.out.println("I like"+s+".");
　　　}
　　}
　　public class Check{
　　　public static void main(String args[]){
　　　　Father x=new Father();
　　　　x.speak();//调用无参的speak方法
　　　　x.speak("music");//调用有参的speak方法
　　　}
　　}
　　//out put of class Check
　　I am Father
　　I like music.
　　这个例子中类的Father定义了两个speak方法，在类Check中又两次调用，一次无参，一次有参，打印出两行不同的字符串。注意Java在打印字符串时，字符串间的连接用符号“+”来完成。

　　Overriding是父类与子类之间多态性的一种表现；Overloading是一个类中多态性的一种表现。

　　4.1.5 几个特殊的变量：null，this和super

　　Java中有三个特殊的变量：null,this和super，这三个变量是所有的类都可以使用的，用来指示一些特定的对象。
　　null相当于“空”，可以用来代指任何对象，但没有实例。如
　　　　Rectangle r=null;
创建了一个Rectangle的变量r，但并没有一个Rectangle的实例对象由r来代表。r就如同一个可放置Rectangle的盒子，只是这个盒子现在是空的。
　　this用以指代一个对象自身。它的作用主要是将自己这个对象作为参数，传送给别的对象中的方法。它的使用形式是这样的：
　　class Painter{
　　　　...
　　　　void drawing(Father y){
　　　　...
　　　　}
　　}
　　class Father{
　　　　...
　　　　void draw(Painter x)
　　　　{...
　　　　　x.drawing(this);/*将自身传递给x的drawing方法*/
　　　　　　...
　　　　}
　　}
　　class Test{
　　　...
　　　Father f=new Father();
　　　Painter p=new Painter();
　　　f.draw(p);
　　　...
　　}
例中调用Father类的draw方法时，使用语句
　　f.draw(p);
又Father类中定义draw方法时以this为参数调用了类Painter的drawing方法：
　　x.drawing(this);
因而实际上调用了Painter类对象p的drawing方法，而将Father类对象f作为参数传递给drawing方法.
　　super用来取用父类中的方法和变量数据。它的用法如在下面的例子中所示。
　　例4.4在类中使用super的例示。
　　/* Check.java */
　　class Father{
　　　void speak(){
　　　　System.out.println("I am Father.");
　　　}
　　　void speak(String s){
　　　　System.out.println("I like "+s+".");
　　　}
　　}
　　class Son extends Father{
　　　void speak(){
　　　　System.out.println("My father says.");
　　　　super.speak();//相当于调用Father类的speak()方法
　　　　super.speak("hunting");
　　　　　//相当于调用Father类的speak(String s)方法
　　　}
　　}
　　class Check{
　　　public static void main(String args[]){
　　　　Son s=new Son();
　　　　s.speak();
　　　}
　　}
　　//Check.java的执行结果：
　　My father says:
　　I am Fater.
　　I like hunting.
　　在这个例子中，类Son的speak()方法语句
　　super.speak();
　　super.speak("hunting");
实际调用了Son的父类Father中的speak()和speak(String s)方法，以实现执行结果后两行的输出。使用父类的变量形式也很类似。
　　super.变量名
　　super和this的另一个重要用途是用在构造方法中。当一个类中不止一个构造方法时，可以用this在一个构造方法中调用中一个构造方法。若想调用父类的构造函数，则直接使用super。例如我们可心如下定义例4.1中类Rectangle的子类ColorRectangle:
　　public class ColorRectaqngle extends Rectangle{
　　　int color;
　　　ColorRectangle(int w,int h,int c){
　　　　super(w,h);
　　　　color=c;
　　　}
　　　...
　　}
　　与父类Rectangle相比，类ColorRectangle增加了color成员变量代表长方形的颜色。在它的构造方法中，用语句
　　　　super(w,h);
调用了类Rectangle的构造方法
　　　　Rectangle(int w,int h);
设定长方形的长和宽，然后就只需设定长方形的颜色：
　　　　color=c;
这样大大提高了代码的重用性。

4.2 Java的包

　　在Java中，包的概念和目的都与其它语言的函数库非常类似，所不同的只是其中封装的是一组类。为了开发和重用的方便，我们可以将写好的程序类整理成一个个程序包。Java自身提供了21个预先设定好的包，下面列出其中主要的几个，其余读者参看Java的API：
　　java.lang　　　　提供基本数据类型及操作
　　java.util　　　　提供高级数据类型及操作
　　java.io　　　　　提供输入/输出流控制
　　java.awt　　　　　提供图形窗口界面控制
　　java.awt.event　　提供窗口事件处理
　　java.net　　　　　提供支持Internet协议的功能
　　java.applet　　　提供实现浏览器环境中Applet的有关类和方法
　　java.sql　　　　　提供与数据库连接的接口
　　java.rmi　　　　　提供远程连接与载入的支持
　　java.security　　提供安全性方面的有关支持
　　我们可以引用这些包，也可以创建自己的包。

　　4.2.1 包的声明

　　为了声明一个包，首先必须建立一个相应的目录结构，子目录名与包名一致。然后在需要放入该包的类文件开头声明包，形式为：
　　package 包名；
这样这个类文件中定义的所有类都被装入到你所希望的包中。例如
　　package Family;
　　class Father{
　　　...//类Father装入包Family
　　}
　　class Son{
　　　...//类Son装入包Family
　　}
　　class Daughter{
　　　...　　//类Daughter装入包Family
　　}
不同的程序文件内的类也可以同属于一个包，只要在这些程序文件前都加上同一个包的说明即可。譬如：
　　//文件 Cat.java
　　package Animals;
　　class Cat{/*将类Cat放入包Animals中*;
　　...
　　}
　　//文件Dog.java
　　package Animals;
　　class Dog{　　/*将类Dog放入包Animals中*/
　　...
　　}

　　4.2.2 包的使用

　　在Java中，为了装载使用已编译好的包，通常可使用以下三种方法：
　　(1) 在要引用的类名前带上包名作为修饰符。如：
　　Animals.Cat cat=new Animals.Cat();
其中Animals是包名，Cat是包中的类，cat是类的对象。
　　(2)在文件开头使用import引用包中的类。如：
　　import Animals.Cat;
　　class Check{
　　　Cat cat=new Cat();
　　}
同样Animals是包名，Cat是包中的类，cat是创建的Cat类对象。
　　(3)在文件前使用import引用整个包。如：
　　import Animals.*;
　　class Check{
　　　Cat cat=new Cat();
　　　Dog dog=new Dog();
　　　...
　　}
Animals整个包被引入，Cat和Dog为包中的类，cat和dog为对应类的对象。
　　在使用包时，可以用点“.” 表示出包所在的层次结构，如我们经常使用的
　　import java.io.*;
　　import java.applet.*;
实际是引入了/java/io/或/java/applet/这样的目录结构下的所有内容。需要指出的是，java.lang这个包无需显式地引用，它总是被编译器自动调入的。使用包时还要特别注意系统classpath路径的设置情况，它需要将包名对应目录的父目录包含在classpath路径中，否则编译时会出错，提示用户编译器找不到指定的类。

4.3 一个邮件类(Mails)的例子

　　下面我们给出一个较大的例子，让读者在实例中进一步熟悉Java的类和包。
　　这里所有的类都放在包ch4package中，先定义出一个虚基类Mails，然后派生出它的两个子类Parcel(包裹)和Remittance(汇款)。Show类用于实际执行，允许用户创建自己的邮件，然后显示出所有的邮件信息。为了方便地存取邮件，还定义了类ShowMails。接下来我们逐一介绍这经些类。
　　例4.5 类Mails程序文件。
　　1：package ch4package;
　　2: public abstract class Mails{
　　3: 　protected String fromAddress;
　　4: 　protected String toAddress;
　　5: 　public abstract void showMe();
　　6: }
　　类Mails是一个虚类，不能产生自己的实例对象，而只是描述了邮件最基本的特性。类文件的开头首先用
　　　　package cha4package;
表明Mails类是放于ch4package这个包里的。然后程序第二行为Mails的类声明。
　　　　public abstract class Mails
　　用修饰符abstract指出这是个虚类。第三至第四行Mails类中定义了两个变量：
　　　　protected String fromAddress;
　　　　protected String toAddress;
fromAddress和toAddress ,分别代表邮件的寄出地址和送往地址，都是protected类型的，这样cha4package包外的类不能直接引用，保证了信息的隐藏。第五行Mails类定义了方法
showMe()，用于显示一个邮件自身的有在信息：
　　　　public abstract voi showMe();
声明时以abstract修饰，意味着这是一个抽象方法，只给出原型，具体实现要由Mails类的非虚子类通过Overriding完成。
　　接下来是Mails的两个非虚子类。
　　例4.6　类Parcel和类Remittance程序文件。
　　//Parcel.java
　　1: package ch4package;
　　2: 　public class Parcel extends Mails{//邮件类的子类Parcel类
　　3: 　　protected int weight;
　　4: 　　Parcel(String address1,String address2,int w){//构造方法
　　5: 　　fromAddress=address1;
　　6: 　　toAddress=address2;
　　7: 　　weight=w;
　　8: 　}
　　9: 　public void showMe(){
　　10:　　System.out.print("Parcel:");
　　11:　　System.out.println("\tFrom:"+fromAddress+"\tTo:"+toAddress);
　　12:　　System.out.println("\tWeigth:"+weight+"g");}
　　13:　}
　　//Remittance.java
　　1: package ch4package;
　　2: 　public class Remittance extends Mails{//邮件类的子类Remittance
　　3: 　　protected int money;
　　4: 　　Remittance(String address1,String address2,int m){//构造方法
　　5: 　　fromAddress=address1;
　　6: 　　toAddress=address2;
　　7: 　　money=m;
　　8: 　}
　　9: 　public void showMe(){//显示邮件信息
　　10:　　System.out.println("Remittance:");
　　11:　　System.out.println("\tFrom:"+fromAddress+"\tTo:"+toAddress);
　　12:　　System.out.println("\tMoney:"+money+" Yuan");
　　13:　}
　　14:}

这里是邮件的两个子类：包裹Parcel和汇款Remittance。以类Parcel为例详细说明。首先在程序开头写出：
　　package ch4package;
　　一方面将类Parcel装入包ch4package，另一方面方便类Parcel使用包ch4package中的其它类，如已定义的Mails类。接下来类Parcel声明时用
　　extends Mails
表明自己是Mails的一个子类。在第三行Parcel声明了一个weight变量，用来代表包裹的重量。加上从父类Mails继承下来的变量fromAddress和toAddress，类Parcel一共有三个成员变量：
　　寄出地址　fromAddress，寄达地址toAddress和重量weight
　　相对应的，它的构造方法Parcel也必须有三个参数，分别传递给三个成员变量。构造方法的定义如第四行至第八行所示。由于Parcel类不是虚类，所以必须在其中重写完成它的父类Mails中声明的抽象方法showMe。Parcel的showMe()方法仅仅是将自己的邮件类型和三个变量的信息在屏幕上显示出来。
　　类Remittance与Parcel非常相似，只是它定义的变量为money，用来代表汇款的金额。它也必须具体完成方法showMe。
　　下面我们看到的是用于存取邮件的类ShowMails。
　　例4.7 类ShowMails程序文件。
　　1: package ch4package;
　　2: import java.lang.*;
　　3: public class ShowMails{
　　4: 　protected Mails showList[];//邮件数组序列
　　5: 　protected static final int maxMails=50;//最大邮件个数
　　6: 　protected int numMails;//当前邮件个数
　　7: 　ShowMails(){
　　8: 　　showList=new Mails[maxMails];
　　9: 　　numMails=0;
　　10:　}
　　11:　public void putMails(Mails mail){
　　12:　　if(numMails<maxMails){
　　13:　　　showList[numMails]=mail;//加入邮件
　　14:　　　numMails++;//修改计数
　　15:　　}
　　16:　}
　　17:　public Mails getMails(int index){//获取邮件
　　18:　　if((0<=index)&&(index<numMails)) return showList[index];
　　19:　　else return null;
　　20:　}
　　21:　public void showAll(){//展示邮件
　　22:　　if(numMails>0)
　　23:　　　for (int i=0;i<numMails;i++){
　　24:　　　　System.out.print("Mail NO"+(i+1)+":");//邮件序号
　　25:　　　　showList[i].showMe();//邮件具体信息
　　26:　　　}
　　27:　　else
　　28:　　　System.out.println("No mails.");
　　29:　}
　　30:　public int mailnum(){
　　31:　　return numMails;
　　32:　}
　　33:}
　　程序第四行至第六行类ShowMails定义了三个成员变量：
　　　　showList[],maxMails和numMails
　　变量showList[]是类Mails的一个数组。但由于Mails本身是个虚类，因而showList[]的元素不可能是Mails的对象，它实际上是用来存放Mails的两个子类Parcel和Remittance的对象的。一般说来，一个被声明为类A的的变量，总可以被赋值为任何类A的子类的实例对象。这与父子类之间的类型转换的原则是一致的：父类到子类的转换可以隐式地自动进行，而子类到父类的转换则需要显式地加以说明。
　　变量maxMails用来指出showList[]中最多可容 纳的邮件数，它对ShowMails的所有对象都应是固定且一致的。因此它被声明为tatatic和final的，为所有对象共享且不可更改。变量numMails则用来作为showList[]中实际邮件个数的计数。
　　对应ShowMails的三个成员变量，我们在ShowMails()构造方法中只需做两件事：实际创建类mails的数组showList[]，然后将邮件计数numMails置零。
　　第11行开始的方法putMails和第17行开始的方法getMails分别完成对showList[]中邮件的存取。第30行的mailnum方法则返回当时的邮件计数值。putMails方法接受一个邮件类参数，并把它加入到当前邮件序列的末尾。getMails方法接受一个整型参数作为邮件序号，根据该序号找出当前邮件序列中对应邮件返回。当给定的邮件号index不在有效范围时，以据该序号找出当前邮件序列中对应邮件返回。当给定的邮件号index不在有效范围时，以
　　　　return null;(19行)
返回一个定值。这一句看上去并没有完成什么实质性的工作，但如果省略则编译时会出错。因为getMails方法的返回值已声明为Mails类，这就要求在任何情况下都返回一个符合这一要求的值。而空变量null可与任何类型匹配，恰好能适合这样的要求。
　　第21行的方法showAll显示showList[]中所有邮件的信息。每一邮件首先显示自己的邮件号。因为showList[]数组的下标从0开始，为了符合人们的日常习惯，将每一个下标加1后再作为邮件号输出。各个邮件的显示是调用邮件的showMe()方法来实现的。因为showMe()方法已经在虚类Mails中定义了，所以不管showList[]中的实际元素是Parcel还是Remittance，编译器总能顺利地连接调用相应的代码。Java面向对象特性中的动态绑定(Dynamic Binding)，保证了无需在编译前确定地知道showList[]每一个数组元素的类型，就能成功地实现这样的链接。
　　最后给出的类是实际执行的Shos类。
　　例4.8 类Show程序文件
　　1: package ch4package;
　　2: import java.io.*;
　　3:
　　4: public class Show{
　　5:　public static ShowMails board=new ShowMails();//邮件库变量
　　6:　　public static void main(String args[])throws IOException{
　　7: 　　　boolean finished=false;
　　8:　　　BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
　　9:　　　while(!finished){//添加邮件
　　10:　　　　System.out.print("\nDo you want to add mails(Y/N)?");
　　11:　　　　System.out.flush();
　　12:　　　　char ch=in.readLine().charAt(0);
　　13:　　　　if('Y'==Character.toUpperCase(ch)){//输入地址
　　14:　　　　System.out.println("Address information:");
　　15:　　　　System.out.print("\tFrom:");
　　16:　　　　System.out.flush();
　　17:　　　　String address1=in.readLine();
　　18:　　　　System.out.print("\tTo:");
　　19:　　　　System.out.flush();
　　20:　　　　String address2=in.readLine();
　　　　　　//选择邮件各类(包裹或汇款)
　　21:　　　　System.out.print("Choose the mail type:1-Parcel 2-Remittance ");
　　22:　　　　System.out.flush();
　　23:　　　　ch=in.readLine().charAt(0);
　　24:　　　　if('1'==ch){//输入包裹重量
　　25:　　　　　System.out.print("Parce\tWeight:");
　　26:　　　　　System.out.flush();
　　27:　　　　　int w=getInt();
　　28:　　　　　Parcel pa=new Parcel(address1,address2,w);
　　29:　　　　　board.putMails(pa);
　　30:　　　　}
　　31:　　　　if('2'==ch){//输入汇款金额
　　32:　　　　　System.out.print("Remittance\tMoney:");
　　33:　　　　　System.out.flush();
　　34:　　　　　int m=getInt();
　　35:　　　　　Remittance re=
　　　　　　　　　　new Remittance(address1,address2,m);
　　36:　　　　　board.putMails(re);
　　37:　　　　}
　　38:　　　}
　　39:　　　else finished=true;
　　40:　　}
　　41:　　System.out.println(" ");
　　42:　　board.showAll();//输出所有邮件信息
　　43:　}
　　　//键盘输入获取整数
　　44:　public static int getInt() throws IOException{
　　45:　　BufferedReader in= new BufferedReader
　　　　　　　(new InputStreamReader(System.in));
　　46:　　String st=in.readLine();
　　47:　　Integer i=new Integer(st);
　　48:　　return i.intValue();
　　49:　}
　　50:}
　　由于涉及交互，类Show中用到了许多输入输出语句，我们在程序第2行用
　　　　import java.io.*;
引入Java的IO包。这个包封装了大量有关输入输出的方法，具体内容将在第七章中详细介绍。这里我们只需要弄清楚所用到的输入/出语句的功能。
　　在输入/出中，总有可能产生输入输出错误，Java反这引起错误都归入IOException(IO异常)因为我们不打算在程序中加入对这些异常的处理，所以需要在每个方法的参数表后用关键字throws“扔出”这些异常，如第6行
　　　　public static void main(String args[])throws IOException
这样异常发生时，将自动中止程序运行并进行标准处理。请参看第五章的内容。
　　程序的输入来源是一个BufferedReader类的对象in，它的声明在第８行：
　　BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
因而具有BufferedReader中定义的所有输入功能。
　　in.readLine()
是读入一行输入，并返回一字符串。而
　　charAt(i)
是String类的一个方法，取得指定字符串的第i个元素作为字符型返回。这两上方法边用，则可取得想要的输入。而在输入前用
　　System.out.flush();
将缓冲清空，以保证输入的正确性。
　　System.out.print
　　System.out.println
都是输出语句，不同的只是后者在输出结束后自动换行。类System和getInt()中用到的类都是Interger(注意不是int!)都在Java的lang名中定义，我们将在第六章详细介绍。
　　在了解以上的基本输入输出后，这个程序就变得较等了。为了方便起见，我们不失一般性的将Show类的所有成员都定义为static的，这样，类Show就不同志需要特别定义的构造方法了。在第５行声明的变量board是ShowMails类的对象，用来建立邮件库：
　　public static ShowMails board=new ShowMails();
第44行开始的getInt方法用来从键盘输入获得一个整数。第6行开始的main方法则是程序的主体。它实现的功能是不断询问是否要加入新邮件，肯定回答时要求选择邮件类型并输入相应信息。据此创建邮件子类对象并加入board中，直至得到不定回答退出。最后显示此时已有的邮件信息。邮件的加入和显示都通过简单的
　　　　board.pubMails()
　　　　board.showAll()
调用ShowMails的方法来实现的，简洁明了而层次清晰。这就是面向对象进行数据封装和重用的优点所在。要执行类Show，我们需要将例4.5～例4.8的文件依次输入、编译。最后用解释器java执行类Show。下面给出的是Show的运行结果，其中加下划线“_”的是键盘输入。
　　例4.9　类Show运行结果。
　　D:\java01>java ch4package.Show

　　Do you want to add mails(Y/N)?n　//询问有是否添加邮件

　　No mails.　　　　　　　　　　　　　//显示没有邮件

　　D:\java01>java ch4package.Show

　　Do you want to add mails(Y/N)?y//询问有是否添加邮件
　　Address information:　　　　　　//要求输入地址信息
　　From:NanJing
　　To:BeiJing
　　Choose the mail type:1-Parcel 2-Remittance 1//要求选择邮件类型
　　Parce Weight:100//要求输入包裹重量

　　Do you want to add mails(Y/N)?y
　　Address information:
　　From:ShangHai
　　To:TianJing
　　Choose the mail type:1-Parcel 2-Remittance 2
　　Remittance Money:400//要求输入汇款金额

　　Do you want to add mails(Y/N)?n

　　Mail NO1:Parcel://输出所有邮件信息
　　　　 From:NanJing To:BeiJing
　　Weigth:2g
　　Mail NO2:Remittance:
　　From:ShangHai To:TianJing
　　Money:400 Yuan

　　D:\java01

4.4 Java的接口

　　4.4.1 引进接口的目的

　　Java的接口也是面向对象的一个重要机制。它的引进是为了实现多继承，同时免除C++中的多继承那样的复杂性。前面讲过，抽象类中包含一个或多个抽象方法，该抽象类的子类必须实现这些抽象方法。接口类似于抽象类，只是接口中的所有方法都是抽象的。这些方法由实现这一接口的不同类具体完成。在使用中，接口类的变量可用来代表任何实现了该接口的类的对象。这就相当于把类根据其实现的功能来分别代表，而不必顾虑它所在的类继承层次。这样可以最大限度地利用动态绑定，隐藏实现细节。接口还可以用来实现不同类之间的常量共享。
　　为了说明接口的作用，我们不妨假设有一系列的图形类，其中一部分在图形中加入了文字，成为可编辑的，它们应当支持最普遍的编辑功能：
　　cut，copy，paste和changeFont
将这些方法的原型统一组合在一个EditShape接口中，就可以保证方法名的规范统一和使用的方便。我们画出这个假想的类和接口的继承关系图，可以更直观地了解。

　　　　　　　　　　　　　　　　　　　　Object
　　　　　　　　　　　　　　　　　　　　　↓
　　　　　　　　　　　　　　　　　　　　Shape
　　　　　　　　┌────────────┼─────────────┐
　　　　　　　　↓　　　　　　　　　　　　↓　　　　　　　　　　　　　↓
　　　　　　　Circle 　　　　　　　　　Rectangle 　　　　　　　　　Triangle
　　　　　　　↙　↘　　　　　　　　　　↙　↘　　　　　　　　　　　　↙　↘
　　PaintCircle TextCircle PaintRectangle TextRectangle PaintTriangle TextTrangle
　　　　　　　　　　　↑　　　　　　　　　　　↑　　　　　　　　　　　　　　　↑
　　　　　　　　　　　└───────────┼───────────────┘
　　　　　　　　　　　　　　　　　　　　　　EditShape
　　　　　　　　图4.1　Shape 和 EditShape

　　以图中类Circle的两个子类为例。类PaintCircle未实现EditShape接口，不支持上述编辑功能。而类TextCircle既是Cricle的子类，又实现了EditShape接口，因而不但具有Circle类的图形牲，又支持EditShape定义的编辑功能。而在TextCircle，TextRectangle和TextTriangle中，支持这些编辑功能的方法是同名同参的(与EditShape的定义一致)，这又提供了使用上的方便。

　　4.4.2 接口的声明和使用

　　Java的接口类似于抽象类，因而它的声明也和抽象类类似，只定义了类中方法的原型，而没有直接定义方法的内容。它的声明格式为：
　　[接口修饰符] interface　接口名 [extends 父类名]
　　　　
　　接口修饰符可以是public或abstract，其中abstract缺省时也有效。public的含义与类修饰符是一致的。要注意的是一个编译单元，即一个.java文件中最多只能有一个public的类或接口，当存在public的类或接口时，编译单必须与这个类或接口同名。
　　被声明的变量总是被视为static和final的，因而必须在声明时给定初值。被声明的方法总是abstract的，abstarct缺省也有效。与抽象类一样，接口不需要构造方法。接口的继承与为是一样的，当然一个接口的父类也必须是接口。下面是一个接口的例子：
　　interface EditShape{
　　　void cut();
　　　void copy();
　　　void paste();
　　　void changeFont();
　　}
在使用时，为了将某个接口实现，必须使用关键字implements。格式是这样的：
　　[类修饰符] class 类名 [extends 父类名] [implements 接口名表]
其中，接口名表可包括多个接口名称，各接口间用逗号分隔。“实现(implements)“了一个接口的非抽象类必须写出实现接口中定义的方法的具体代码，同时可以读取使用接口中定义的任何变量。
　　例4.10　接口的实现
　　class TextCircle extends Circle implements EditShape
　　{...
　　　void cut()　　　　　
　　　void copy()　　　　
　　　void paste()　　　　
　　　void changeFont　　　
　　　...
　　}

　　4.4.3 多继承

　　在Java中，类之间只允许单继承，但我们可以把一个类实现的接口类也看作这个类的父类。类从它实现的接口那里“继承”了变量和方法，尽管这些变量是静态常量，这些方法是未实现的原型。如果一个类实现的接口类不止一个，那么所有这些接口类都被视为它的“父类”。这样，实现了一个或多个接口的类就相当于是从两个(加上该类原有意义上的父类)或两个以上的类派生出来的。Java的多继承正是建立在这种意义之上。通过接口的继承，相当于只选择了一部分需要的特征汇集在接口中由不同的类共享并继承下去，而不必通过父子类间的继承关系将所有的方法和变量全部传递给子类。所以我们又可以把Java的这种多继承称为“有选择的多继承”。这种多继承与一般的多继承相比，更为精简，复杂度也随之大大降低。
　　在多继承时，一个子类可能会从它的不同父类那里继承到同名的不同变量或方法，这往往会引起两义性问题，即不知道子类中这样的变量或方法究竟是继承了哪一个父类的版本，在Java中，为了防止出现这样的两义性问题，规定不允许一个子类继承的父类和实现的接口类中定义同名的不同变量，否则编译该子类时将出错，无法通过。而对于方法，由于接口类中定义的总是abstract的方法原型，而没有实际代码，所以不会出现类似的两义性问题。相反，常会存在这样的情况：当接口类中要求实现的方法子类没有实现，而子类的父类中定义有同名方法时，编译器将子类从父继承的该方法视为对接口的的实现。这样的继承和实现都被认为是合法的。

4.5 实现了接口的邮件类例子

　　这一节我们将4.3节邮件类的例子加以改进和扩展，加入有关接口的内容，以说明接口和多继承的概念。
　　首先定义一个名为MailPost的接口，其中没有定义变量，而是给出两个有关邮寄方法原型。
　　calPrice()计算邮费并以浮点数形式返回；
　　post()完成邮寄。
　　例4.11 接口MailPost。
　　//MailPost.java
　　package ch4package;
　　public interface MailPost{
　　　public float claPrice();
　　　public void post();
　　}
　　接下来在包裹Parcel和汇款Remittance的基础上分别派生出可邮寄的包裹和汇款：PostParcel和PostRemit两个子类。
　　例4.12　子类PostParcel和PostRemit。
　　---------------------------------
　　//PostParcel.java
package ch4package;
import java.lang.*;

public class PostParcel extends Parcel implements MailPost{
protected int postage;
protected boolean postable;
protected boolean posted;
PostParcel(Ttring address1,String address2,int w,intp){
//构造方法
super(address1,address2,w);
postage=p;
postable=false;
posted=false;
}
public float calPrice(){//计算邮资
return((float)0.05*weight);
}
public void post(){//邮寄包裹
float price=calPrice();
postable=(price<=postage);
posted=true;
}
public void showMe(){//显示邮件信息
float price=calPrice();
System.out.println("Postable Parcel:");
System.out.println("\tFrom:")+fromAddress+\tTo"
+toAddress);
System.out.println("\tWeigth:)+weigth+"g\tPostage:"
+postage+"Yuan");
if(posted){
if(postable)System.out.println("\tIt has been
posted !");
else{
System.out.println("\tIt needs more postage:");
System.out.println("\tThe current postage
is:"+postage+"Yuan");
System.out.println("\t\tThe price is:"+price+"Yuan");
}
}
}
}
//PostRemit.java
package ch4package;
import java.lang.*;

public class PostRemit exteds Remittance implements MailPost{
protected int postage;
portected boolean postable;
protected boolean posted;
PostRemit(String address1,String address2,int m,int p){
//构造方法
super(address1,address2,m);
postage=p;
postable=false;
posted=false;
}
public float calPrice(){//计算邮资
float price=cealPrice();
postable=(price<=postage);
posted=true;
}
public void showMe(){//显示邮件信息
float price=calPrice();
System.out.println("Postable Remit:");
System.out.println("\tFrom:"+fromAddress+"\tTo:"
+toAddress);
System.out.println("\tMoney:"+money+"Yuan"+"\tPostage:"
+postage+"Yuan");
if(posted){
if(postable)System.out.println("\tIt has been
posted!");
else{
System.out.println("\tIt needs more postage:");
System.out.println("\t\tThe current postage is:"
+postage+"Yuan");
System.out.println("\t\tThe price is:"
+price+"Yuan");
}
}
}
}

　　---------------------------------
　　这两个类都实现了接口MailPost。由于两个类非常相似，我们仍然重点讲解其中一个：类PostParce。
　　PostParcel仍是包ch4package中的一员，它是类Parcel的子类(extends Parcel)，又实现了接口MailPost(implements MailPost)：
　　　　public class PostParcel extends Parcel implements MailPost
　　在Parcel的基础上，它新增加了三个变量：
　　　　postage，posted，postable
其中整型的postage用来记录邮寄人提供的邮资，布尔型的posted和postable分别用来记录是否被尝试邮寄过以及邮寄是束成功。在PostParcel的构造方法中，第9行语句
　　　　super(address1,address2,w);
调用了它的父类Parcel的构造方法，设定它从Parcel中继承的变量寄出地址、寄达地址和重量的初值。这就是我们在前面提到过的super变量在构造方法中的用途：调用父类的相应构造方法。这样做的一个好处是可以重用父类的代码，然后PostParcel就只需设定邮资，并将posted和postable初值都置为false。
　　PostParcel和PostRemit都实现了接口MailPost，国而在它们的定义中，都必须给出方法calPrice()和post()的具体实现。在PostParcel中，为了简单起见，邮费只是根据重量每克收到0.05元，而不考虑寄达的距离，如语句第15行：
　　　　return ((float)0.05*weight);
在post()方法中，将计算所得邮资与瑞有邮费加以比较，若邮费已够将postable设为true，包裹可邮寄；否则postable为false，包裹不可邮寄。无论postable取值如何，都已试图邮寄，所以将posted置为true。处理过程见第18行至20行。
　　最后一个方法是showMe()。在这里，PostParcel重写(Overriding)了它的父类Parcel中的同名方法。当包裹尚未被试图邮寄过，则在基本信息后附加有关的邮寄信息，若未邮寄成功，给出所需最费提示。
　　PostRemit类的基本构成与PostParcel是一致的，读者可以自己试着读懂它的源文件。
　　在包ch4package中，类Mails，Parcel，Remittance以及ShowMails都无需改动，只有最后的可执行类Show需要相应的修改。它的源程序如下。
　　例4.13 可执行类Show程序文件。
　　-------------------------
//Show.java

　　1: package ch4package;
import java.lang.*;
　　2: import java.io.*;
　　3:
　　4: public class Show{
　　5:　public static ShowMails board=new ShowMails();
　　6:　　public static void main(String args[])throws IOException{
　　7: 　　　boolean finished=false;
　　8:　　　BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
　　9:　　　while(!finished){//添加邮件
　　10:　　　　System.out.print("\nDo you want to add mails(Y/N)?");
　　11:　　　　System.out.flush();
　　12:　　　　char ch=in.readLine().charAt(0);
　　13:　　　　if('Y'==Character.toUpperCase(ch)){
　　14:　　　　System.out.println("Address information:");
　　15:　　　　System.out.print("\tFrom:");//输入地址信息
　　16:　　　　System.out.flush();
　　17:　　　　String address1=in.readLine();
　　18:　　　　System.out.print("\tTo:");
　　19:　　　　System.out.flush();
　　20:　　　　String address2=in.readLine();
　　　　　　//选择邮件种类
　　21:　　　　System.out.print("Choose the mail type:1-Parcel
2-Remittance ");
　　22:　　　　System.out.flush();
　　23:　　　　ch=in.readLine().charAt(0);
　　24:　　　　if('1'==ch){//输入包裹重量
　　25:　　　　　System.out.print("Parcel\tWeight:");
　　26:　　　　　System.out.flush();
　　27:　　　　　int w=getInt();
//是否寄出邮件
System.out.print("Do you want to post it(Y/N?");
System.out.flush();
ch=in.readLine().charAt(0);
if('Y'==Character.toUpperCase(ch)){//输入邮资
System.out.println("You want to post in,then
input your postage:");
System.out.flush();
int p=getInt();
//可邮寄包裹
PostParcel pa=new
PostParcel(address1,address2,w,p);
board.putMails(pa);
}
//不可邮寄包裹
else{Parcel pa=new Parcel(address1,address2,w);
board.putMails(pa);}
}
if('2'==ch){
System.out.print("Remittance\tMoney:");
System.out.flush();
int m=getInt();
System.out.print("Do you want to post it(Y/N)?");
System.out.flush():
ch=in.readLine().charAt(0);
if('Y'==Character.toUpperCase(ch)){
System.out.println("You want to post it,then input
postage:");
System.out.flush();
int p=getInt();
//可邮寄汇款
PostRemit re=new PostRemit(address1,address2,m,p);
board.putMails(re);
}
//不可邮寄汇款
else{Remittance re=new Remittance(address1,address2,m);
board.putMails(re);}
}
}
else finished=true;
}
System.out.println("");
board.showAll();//显示邮件信息
post();
}
public static int getInt() throws IEOxception{
BufferedReader in=new BufferedReader
(new InputStreamReader(System.in));
String st=in.readLine();
Integer i=new Integer(st);
return i.intValue();
}
private static void post()throws ClassCastException,IOException{
int n\board.mailnum();
if(n!=0){
System.out.println("You have "+n+" mails");
boolean end=false;
//检查邮寄情况
while(!end){
System.out.print("\nInput the mail NO you want to check the
result(输0退出):");
System.out.flush();
int i=getInt();
if(i!=0){
try{
Mails obj=board.getMails(i-1);
post((MailPost)obj);
obj.showMe();
}catch(ClassCastException ex){
System.out.println("Mail is not postable!");}
}
else end=true;
}
}
}
private static void post(MailPost obj){
obj.calPrice();
obj.post();
}
}
　　-------------------------
　　与第三节例4.8中类的Show相比，改动后的Show的main方法增加了询问是否要将邮件设为可邮寄类型的功能以及相应的处理段，并调用Post()方法邮寄邮件并给出邮寄情况说明。类Show定义了两个post方法来实惠邮寄。这两个方法虽同名，但参数不同，完成的功能也大相径庭。
　　第72行至92行的第一个post方法没有参数。它首先给出现有邮件数量，然后根据输入的邮件号通过ShowMails的getMails方法取得邮件，再调用第二个post方法实际将邮件寄出；当输入的邮件号为零时结束。在调用第二个post方法时，需要将邮件显式转换为接口类MailPost:
　　83:Mails obj=bord.getMails(i-1);
　　84:post((MailPost)obj);
因为PostParcel和PostRemit都实现了接口MailPost，都支持这样的转换，就可以通过种形式从功能上将它们统一起来。如果该邮件所属的类没有实现接口MailPost ,如类Parcel或类Remittance，这样的类型转换就不能实现，将引发类型转换异常(ClassCastException)，不再转去调用post方法，而由catch结构给出“邮件无法被邮寄”的报错信息：
　　86:}catch(ClassCastException ex){
　　87:　System.out.println("Mail is not postable!");}
其中的try-catch结构是Java中异常处理的典型结构。
　　第二个post方法带一个MailPost接口类的参数，它实际调用接口定义的方法calPrice和post将邮件寄出。
　　下面我们来看一个Show的执行实例，其中带下划线“_”的部分为执行的键盘输入。
　　例4.14　Show的执行结果。
　　--------------------
　　--------------------
　　当启动Show的运行后，首先依照提示创建三个邮件对象，其中第一个是不可邮寄包裹后两个分别是可邮寄的包裹和汇款。停止添加邮件后顺序显示现有邮件信息，包括邮件号、邮件类别、地址信息、重量／金额以及已付邮资，并提示现有邮件总数。此时我们可依次检查邮件是否可寄出：
　　输入邮件号“１”，由于此包裹不是可邮寄包裹类，给出报告：邮件不可寄出；
　　输入邮件号“２”，该邮件是可邮寄包裹，且通过邮资计算已付足，给出报告：邮件可寄出；
　　输入邮件号“３”，该邮件是可邮寄汇款，但欠缺邮资，给出报告：邮件需补足邮资，然后列出应交邮费与实交邮费比较。
　　最后输入数字“０”，结束本次执行。
　　这样我们就完成了对第三节中邮件类的扩充和改进，最终得到的包ch4package中所有类和接口的层次继承关系，如图4.2所示。读者可以对照这个图理清它们的继承和实现关系。
　　　　　　　　　　　　　Object
　　　　　　　　┌─────┼─────┐
　　　　　　　　↓　　　　　↓　　　　　↓
　　　　　　　Mails　　ShowMails　　show
　　　　┌───┴───┐
　　　　↓　　　　　　　↓
　　　Parcel　　　　Remittance
　　　　↓　　　　　　　↓
　　PostParcel　　PostRemit
　　　　　　↖　　↗
　　　　　　MailPost
　　　　图4.2 包ch4package的类和接口层次

Class 的命名
Class 的名字必須由大寫字母開頭而其他字母都小寫的單詞組成

Class 變數的命名
變數的名字必須用一個小寫字母開頭。後面的單詞用大寫字母開頭。

Static Final 變數的命名
Static Final 變數的名字應該都大寫，並且指出完整含義。

參數的命名
參數的名字必須和變數的命名規範一致。

陣列的命名
陣列應該總是用下面的方式來命名：
byte[] buffer;    
而不是：
byte buffer[];
    
方法的參數
使用有意義的參數命名，如果可能的話，使用和要賦?的欄位一樣的名字：
1234
 SetCounter(int size)
{ 
this.size = size;
}

Java 文件樣式
所有的 Java(*.java) 文件都必須遵守如下的樣式規則
版權資訊
版權資訊必須在 java 文件的開頭，比如：

/** * Copyright R 2000 XXX Co. Ltd. * All right reserved. */    
其他不需要出現在 javadoc 的資訊也可以包含在這?。

Package/Imports
package 行要在 import 行之前，import 中標準的包名要在本地的包名之前，而且按照字母順序排列。如果 import 行中包含了同一個包中的不同子目?，則應該用 * 來處理。
123
 package hotlava.net.stats;
import java.io.*;
import java.util.Observable;import hotlava.util.Application; 

 
  
這兒java.io.* 使用來代替InputStream and OutputStream 的。
Class
接下來的是類的注釋，一般是用來解釋類的。
1
 /** * A class representing a set of packet and byte counters * It is observable to allow it to be watched, but only * reports changes when the current set is complete */ 

 
  
接下來是類定義，包含了在不同的行的 extends 和 implements
1
 public class CounterSet   extends Observable implements Cloneable 

 
  
Class Fields

接下來是類的成員變數：
123
 
/** * Packet counters */
protected int[] packets;

public 的成員變數必須生成文?（JavaDoc）。proceted、private和 package 定義的成員變數如果名字含義明確的話，可以沒有注釋。

存取方法
接下來是類變數的存取的方法。它只是簡單的用來將類的變數賦?獲取?的話，可以簡單的寫在一行上。
12345678910111213
 
/** * Get the counters * @return an array containing the statistical data.  This array has been * freshly allocated and can be modified by the caller. */public int[] getPackets() {
return copyArray(packets, offset);
}
public int[] getBytes() {
return copyArray(bytes, offset);
}
public int[] getPackets() {
 return packets;
}
public void setPackets(int[] packets) {
this.packets = packets;
 }

其他的方法不要寫在一行上

構造函數
接下來是構造函數，它應該用遞增的方式寫（比如：參數多的寫在後面）。
訪問類型 ("public", "private" 等.) 和 任何 "static", "final" 或 "synchronized" 應該在一行中，並且方法和參數?寫一行，這樣可以使方法和參數更易讀。
1234
 public CounterSet
(int size){ 
this.size = size;
}

克隆方法
如果這個類是可以被克隆的，那?下一?就是 clone 方法：
12345678910111213
 
public Object clone()
{ 
try {  
 CounterSet obj = (CounterSet)super.clone();  
 obj.packets = (int[])packets.clone();  
 obj.size = size;   
return obj; 
}
catch(CloneNotSupportedException e) {   
throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage()); 
}
}

類方法
下面開始寫類的方法：
12345678
 /** * Set the packet counters * (such as when restoring from a database) */
protected finalvoid setArray(int[] r1, int[] r2, int[] r3, int[] r4)  throws IllegalArgumentException
{ 
//  // Ensure the arrays are of equal size  //
 if (r1.length != r2.length || r1.length != r3.length || r1.length != r4.length)
  throw new IllegalArgumentException("Arrays must be of the same size");  System.arraycopy(r1, 0, r3, 0, r1.length); 
 System.arraycopy(r2, 0, r4, 0, r1.length);
}

toString 方法
無論如何，?一個類都應該定義 toString 方法：
12345678910
 public String toString()
{ 
String retval = "CounterSet: ";  
 for (int i = 0; i < data.length(); i++) {    
   retval += data.bytes.toString();
      retval += data.packets.toString();
   }   
return retval; 
}
}

main 方法
如果main(String[]) 方法已經定義了, 那?它應該寫在類的底部.
代碼編寫格式

代碼樣式
代碼應該用 unix 的格式，而不是 windows 的（比如：回車變成回車+換行）

文?化
必須用 javadoc 來爲類生成文?。不僅因爲它是標準，這也是被各種 java 編譯器都認可的方法。使用 @author 標記是不被推薦的，因爲代碼不應該是被個人擁有的。

縮進
縮進應該是?行2個空格. 不要在原始?案中保存Tab字元. 在使用不同的源代碼管理工具時Tab字元將因爲用?設置的不同而擴展爲不同的寬度.
如果?使用 UltrEdit 作爲?的 Java 源代碼編輯器的話，?可以通過如下操作來禁止保存Tab字元, 方法是通過 UltrEdit中先設定 Tab 使用的長度室2個空格，然後用 Format|Tabs to Spaces 功能表將 Tab 轉換爲空格。

頁寬
頁寬應該設置爲80字元. 源代碼一般不會超過這個寬度, 並導致無法完整顯示, 但這一設置也可以靈活調整. 在任何情況下, 超長的語句應該在一個逗號或者一個操作符後折行. 一條語句折行後, 應該比原來的語句再縮進2個字元.

{} 對
{} 中的語句應該單獨作爲一行. 例如, 下面的第1行是錯誤的, 第2行是正確的:
12
 if (i>0) { i ++ };
// 錯誤, { 和 } 在同一行

1234
  if (i>0) {
 i ++
 };
 // 正確, { 單獨作爲一行 } 語句永遠單獨作爲一行.

如果 } 語句應該縮進到與其相對應的 { 那一行相對齊的位置。

括弧
左括弧和後一個字元之間不應該出現空格, 同樣, 右括弧和前一個字元之間也不應該出現空格. 下面的例子?明括弧和空格的錯誤及正確使用:
12
 CallProc( AParameter ); // 錯誤
CallProc(AParameter); // 正確

不要在語句中使用無意義的括弧. 括弧只應該爲達到某種目的而出現在源代碼中。下面的例子?明錯誤和正確的用法:
12
 if ((I) = 42) { // 錯誤 - 括弧毫無意義
if (I == 42) or (J == 42) then // 正確 - 的確需要括弧

程式編寫規範
exit()
exit 除了在 main 中可以被調用外，其他的地方不應該調用。因爲這樣做不給任何代碼代碼機會來截獲退出。一個類似後臺服務地程式不應該因爲某一個庫模組決定了要退出就退出。

異常
申明的錯誤應該抛出一個RuntimeException或者派生的異常。
頂層的main()函數應該截獲所有的異常，並且列印（或者記?在日誌中）在螢幕上。

??收集
JAVA使用成熟的後臺??收集技術來代替引用計數。但是這樣會導致一個問題：?必須在使用完物件的實例以後進行清場工作。比如一個prel的程式師可能這?寫：
1234
   ...  {
    FileOutputStream fos = new FileOutputStream(projectFile);
    project.save(fos, "IDE Project File");
   }  ...

除非輸出流一出作用域就關閉，非引用計數的程式語言，比如JAVA，是不能自動完成變數的清場工作的。
必須象下面一樣寫：
  FileOutputStream fos = new FileOutputStream(projectFile);
  project.save(fos, "IDE Project File");
  fos.close();
Clone
下面是一種有用的方法：
1234567891011
   implements Cloneable  public    Object clone()    { 
    try {
       ThisClass obj = (ThisClass)super.clone();
        obj.field1 = (int[])field1.clone();
        obj.field2 = field2;
        return obj;
     }
catch(CloneNotSupportedException e) {
        throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage());
      }
 }

final 類
?對不要因爲性能的原因將類定義爲 final 的（除非程式的框架要求）
如果一個類還沒有準備好被繼承，最好在類文?中注明，而不要將?定義爲 final 的。這是因爲沒有人可以保證會不會由於什?原因需要繼承?。

訪問類的成員變數
大部分的類成員變數應該定義爲 protected 的來防止繼承類使用他們。
注意，要用"int[] packets"，而不是"int packets[]"，後一種永遠也不要用。
1234567
 
public void setPackets(int[] packets) {
this.packets = packets;
}
 CounterSet(int size){
this.size = size;
}

 

文件构成	文件路径	模块位置	文件应当属于他所在的模块（serivce,dao…… ）目录。	●
		机能位置	文件属于他所对应的机能目录。	●
命名规则	包名	包名	首字母小写，名词方式或者编号方式命名	●
	类名	类名	首字母大写，单词第一个字母大写。	●
	常量	常量	定义为静态（static），定义为终结（final）			●
		常量名	常量名全部使用大写，单词间使用（_）分割			●
	方法名	无返回值方法名	首字母小写，机能方式命名。			●
		其他类型方法名	首字母小写	●
		Boolean型方法名	is+形容词，can+动词，has+名词/动词过去式			●
	变量名	Boolean型变量名	is+形容词，can+动词，has+名词/动词过去式			●
		其他类型变量名	首字母小写	●
	英文	拼写正确	英语单词拼写正确	●
	对称性	命名单词对称	add/remove insert/delete insert/delete start/stop begin/end ……			●
	循环用变量	循环用变量命名	根据使用次序按照i j k l m n 依次使用	●
	临时变量	临时变量命名	使用该变量类型每个单词的首字母小写命名，如（ServeletContext sc;） 使用该变量类型名，将该名称首字母小写，如（Array array; 或者 Array arr;）	●
	方法参数	方法参数命名	定义方式参照变量名定义。参数名能够表示该参数的含义。	●
	内部变量	内部变量命名	用于保存公开变量（publci String getXXX()）的内部变量，使用XXX作为变量名命名（但首字母要小写）
编程样式	注释	注释方式	单行注释使用"//"+空格+注释内容。多行注释使用/*...*/。	●
	缩进方式	缩进方式	使用1个tab进行缩进处理	●
	括号方式	类	起始括号位于类定义行末尾，结束括号单独一行，与类定义对齐。	●
		方法	起始括号位于方法定义行末尾，结束括号单独一行，与方法定义对齐。	●
		程序分支	起始括号位于分支定义行末尾，结束括号单独一行，与分支定义对齐。	●
	行的长度	行的长度	每行程序的长度不得超过80个字符。	●
	private	使用范围	除去公开方法或者属性外，应当全部定义为private。	●
	protected	使用范围	共通类/方法以外，没有特殊要求，不得使用protected定义。	●
	public	使用范围	允许外部访问和修改的方法/变量。	●
	if/while	"="符号的使用	在if/while语句的判断式内，不能使用"="符号。	●
		"< > <= >="的使用	在同一个判断式中的多个部分内，不允许同时出现"<"和">"（判断方向必须一致）	●
	循环处理	循环处理嵌套	循环处理不允许嵌套3层以上。	●
	循环变量	循环变量	不允许多个循环代码使用同一个变量作为循环参数。	●
	文件注释	注释方式	使用多行注释	●
		改版履历	式样变更的改版履历，内容有（时间，式样版本，对应者）			●
	类注释	注释方式	使用多行注释	●
		机能说明	对机能进行简单说明。	●
		创建者	记录创建者（@author）	●
	方法注释	注释方式	使用多行注释	●
		机能说明	对机能进行简单说明。		●
		参数说明	对参数和返回值进行简单说明。		●
	变量注释	注释方式	使用单行注释	●
其他	判断式	判断式	使用"< > = && ||"等判断式组成多次组合判断时，使用括号标明判断式执行次序。	●

弗雷德里克·布鲁克斯（Frederick P. Brooks）博士在他那篇著名的《没有银弹——软件工程中的根本和次要问题》一文中，将软件项目比作可怕的人狼（werewolves），并大胆地预言十年内不会找到特别有效的银弹。该论文发表的时间是1986年，如今整整20年过去了，尽管不时有人惊呼找到了神奇的银弹，但是冷静的人们很快发现那只是美好的愿望。

如果说软件工业中与人狼的战斗还在持续，那么在这些战役中一定会有程序员的身影，笔者也是其中的一个。我的编程生涯是从使用汇编语言编写DOS下的TSR程序开始的。今天DOS操作系统已经成为历史，在那个年代最值得炫耀的TSR技术也早已经过时了。十几年中，OWL、VFW、VDX、ISAPI、Active Movie等技术也被时间淘汰……然而，在这漫长的时间当中，我最看重的是软件调试技术。它是十几年中我学到的最有用、一直受用、而且日久弥新的一项技术。  其实就是: "软件工程"与"软件工艺"之间门派之争的问题

从软件工程的角度来讲，软件调试是软件工程的一个重要部分，软件调试过程出现在软件工程的各个阶段。从最初的可行性分析、原型验证、到开发和测试阶段、再到发布后的维护与支持，都有软件调试过程的参与。通常认为，一个完整的软件调试过程由以下几个步骤组成：
● 重现故障，通常是在用于调试的系统上重复导致故障的步骤，使要解决的问题出现在被调试的系统中。
● 定位根源，即综合利用各种调试工具，使用各种调试手段寻找导致软件故障的根源（root cause）。通常测试人员报告和描述的是软件界面或工作行为中所表现出的异常，或者是与软件需求和功能规约不符的地方，泛指软件缺欠（defect）或者故障（failure）。而这些表面的缺欠总是由于一或多个内在因素所导致的。这些内因要么是代码的行为错误，要么是不行为错误（该作而未作）。
● 探索和实现解决方案，即根据寻找到的故障根源、和资源情况、紧迫程度等要求设计和实现解决方案。
● 验证方案，在目标环境中测试方案的有效性，又称为回归（regress）测试。如果问题已经解决，那么就可以关闭问题。如果没有解决则回到第3步调整和修改解决方案。
这些步骤中，定位根源常常是最困难也是最关键的步骤，它是软件调试过程的核心和灵魂。如果没有找到故障根源，那么解决方案便很是隔靴搔痒，或者头痛医脚，白白浪费了时间。
对软件调试的另一种更通俗的解释是指使用调试工具求解各种软件问题的过程,例如跟踪软件的执行过程,探索软件本身或者与其配套的其它软件或者硬件系统的工作原理等,这些过程的目的有可能是为了去除软件缺欠,也可能不是。

在了解了软件调试技术的基本概念以后，下面我们来看一下支撑软件调试技术的几种基本机制。
● 断点:即当被调试程序执行到某一空间或时间点时将其中断到调试器中。根据中断条件分为如下几种:
○   代码断点:当程序执行到指定内存地址的代码时中断到调试器。
○   数据断点:当程序访问指定内存地址的数据时中断到调试器。
○   I/O断点:当程序访问指定I/O地址的端口时中断到调试器。
根据断点的设置方法,断点又分为软件断点和硬件断点。软件断点通常是通过向指定的代码位置插入专用的断点指令来实现的,比如IA32 CPU的INT 3指令（机器码为0xCC）就是断点指令。硬件断点通常是通过设置CPU的调试寄存器来设置的。IA32 CPU定义了8个调试寄存器,DR0~DR7,可以最多同时设置4个硬件断点(对于一个调试会话)。通过调试寄存器可以设置以上三种断点中的任一种,但是通过断点指令只可以设置代码断点。

● 单步跟踪:即让应用程序按照某单位一步步执行。根据单位，又分几种:
○   每次执行一条汇编指令，称为汇编语言一级的单步跟踪。设置IA32 CPU标志寄存器的TF（Trap Flag，即陷阱标志位）位，便可以让CPU每执行完一条指令便产生一个调试异常（INT 1），中断到调试器。
○   每次执行源代码（比汇编语言更高级的程序语言,如C/C++）的一条语句，又称为源代码级的单步跟踪。通常高级语言的单步跟踪是通过反复设置CPU的陷阱标志位来实现的,如果当前源代码行还没有执行完,那么调试器重新设置陷阱标志并让程序继续执行,直到该语句结束（EIP指向另一语句）才中断给用户。
○   每次执行一个程序分支，又称为分支到分支单步跟踪。设置IA32 CPU的DbgCtl MSR寄存器的BTF(Branch Trap Flag)标志后，便可以启用分支到分支单步跟踪。
○   每次执行一个任务（线程），即当一个任务（线程）被调度执行时中断到调试器。IA32架构所定义的任务状态段（TSS）中的T标志为实现这一功能提供了硬件一级的支持，但是很多调试器还有提供这项功能。

● 栈回溯（stack backtrace）:即通过记录在栈中的函数返回地址显示（追溯）函数调用过程。在将返回地址翻译成函数名时需要有调试符号（debug symbol）的支持。大多数编译器都支持在编译时生成调试符号。微软的调试符号服务器（http://msdl.microsoft.com/download/symbols）提供了大多数Windows系统文件的调试符号，是调试和学习Windows操作系统的宝贵资源。
● 调试信息输出（debug output/print）:即将程序运行的位置、变量状态等信息输出到调试器、窗口、文件或者其它可以观察到的地方。这种方法的优点是简单方便、不依赖于调试器，但也有明显的缺点，如效率低，安全性差，通常不可以动态开启，且难以管理等。在Windows操作系统中，驱动程序可以使用DbgPrint/DbgPrintEx来输出调试信息，应用程序可以调用OutputDebugString API。
● 日志（log）:将程序运行的状态信息写入到特定的文件或者数据库中。Windows操作系统提供了记录、观察和管理（删除和备份）日志的功能。Windows Vista新引入了名为Common Log File System（CLFS.SYS）的内核模块，用于进一步加强日志功能。
● 事件追踪（event trace）:通常用来监视频繁的复杂的软件过程，满足普通日志机制难以胜任的需求。比如监视大信息量的文件操作、网络通信等。ETW（Event Trace for Windows）是Windows操作系统内建的事件追踪机制，Windows内核本身和很多Windows下的软件工具（如Bootvis，TCP/IP View）都使用了该机制。

在以上机制中，断点和单步跟踪通常必须在有调试器参与的情况下才能使用。调试器（software debugger）是综合提供各种调试功能的软件工具。除了处理断点、单步跟踪、模块映射等调试事件外，调试器通常还提供如下功能:
● 观察和编辑被调试程序的内存和数据，如全局变量、局部变量、以及程序的栈和堆等重要数据结构。
● 观察和反汇编被调试程序的代码。
● 显示线程栈中的函数调用信息。
● 管理调试符号。
● 控制进程和线程，例如将被调试程序中断到调试器中，和恢复其执行等。
根据调试器所调试目标程序的工作模式，可以把调试器分为用户态调试器和内核态调试器，前者用于调试用户态下的各种程序（应用程序、系统服务、或者用户态的DLL模块），后者用于调试工作在内核模式的程序，如驱动程序和操作系统的内核部分。WinDbg是微软开发的一个免费调试器，它既可以用作用户态调试器，也可以用作内核态调试器，是调试Windows操作系统下的各种软件的一个强有力工具。我几乎每天都使用WinDbg，它是我的计算机中使用频率最高的软件之一。

最后，简要地描述一下软件调试技术的几个特征。
系统性——很多看似简单的调试机制都是依靠系统内的多个部件协同工作而完成的。以软件断点为例，CPU提供了指令支持和硬件级的异常机制，操作系统将异常以调试事件的形式分发给调试器，调试器响应调试事件并与用户交互。如果在做源代码级的调试，那么调试器又需要编译器所产生的调试符号来帮忙。
全局性——对于一个软件项目，应该在项目的设计和架构阶段就制定出全局的调试支持机制，并贯彻实施。比如，所有模块都应该使用统一的方法来输出调试信息、记录日志、报告错误，并公开统一的接口用做单元测试和故障诊断。这样不仅可以避免重复工作，而且增加了软件的可调适性（debuggability），有利于保证产品的质量和进度。
困难性——《C语言编程》一书的作者Brian Kernighan曾经说过，“调试天生就比编写代码难上一倍，如果你写出了最聪明的代码，那么你的智商就不足以调试这个代码。”因为，要调试一个程序，就必须深刻理解它的工作原理，不仅要知道how和表层的东西，还要知道why和深层次的内幕。另外，调试需要锲而不舍的探索精神和坚韧的耐力，这也让很多人望而却步。
综上所述，软件调试技术是与软件开发密不可分的一门技术，其初衷是为了定位和去除软件故障，但因为调试技术所具有的对软件的强大控制力和观察力，其应用早已延伸到了很多其它领域，比如逆向工程、计算机安全等等。
 

1 大前提：软件活动包含根本任务和次要任务

布鲁克斯指出：所有软件活动包括：

根本任务——打造构成抽象软件实体的复杂概念结构；

次要任务——使用编程语言表达这些抽象实体，并在时间和空间内将它们映射成机器语言。

2 小前提：现有解决方案致力于解决次要任务

考察和评估几乎现有所有的软件工程解决方案，布鲁克斯指出：现有所有方案全都在致力于解决软件工程中的次要问题。

3 结论：没有银弹

无论这些方案多么完善，都不可能在根本上解决问题，即使将全部次要任务的时间缩减到零，也不会带来生产率数量级上的提高。

应用孤岛问题：管理软件如何实施、应用的问题

由于基础架构的先天不足，现有的信息系统，无论是独立的工具软件还是集成的解决方案，大多是孤岛型的应用，或者是业务功能模块的简单累加。这些孤岛系统，相互之间是孤立封闭的

IT黑洞问题：管理软件如何设计、开发和维护的问题

现有信息系统的建设，是在底层的技术平台上直接构建业务系统，并且也只能采用面向技术的、业务无关的“原始”编程工具来开发管理系统 。这种低层次的软件开发模式，使信息系统的开发、维护和扩展困难重重，导致IT黑洞现象的普遍发生

三：线程的四种状态
1. 新状态：线程已被创建但尚未执行（start() 尚未被调用）。
2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。
3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。
4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。

四：线程的优先级
线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。
你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。

五：线程的同步
由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问
由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如
public synchronized void accessVal(int newVal);
synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方
法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。
在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。
synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法 run() 声明为 synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中，将其声明为 synchronized ，并在主方法中调用来解决这一问题，但是 Java 为我们提供了更好的解决办法，那就是 synchronized 块。
2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：
synchronized(syncObject) {
//允许访问控制的代码
}
synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject （如前所述，可以是类实例或类）的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。
六：线程的阻塞
为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。
阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞，下面让我们逐一分析。
1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。
典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume() 使其恢复。
3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。
4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式，一种允许 指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。
初看起来它们与 suspend() 和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的所有方法，阻塞时都不会释放占用的锁（如果占用了的话），而这一对方法则相反。
上述的核心区别导致了一系列的细节上的区别。
首先，前面叙述的所有方法都隶属于 Thread 类，但是这一对却直接隶属于 Object 类，也就是说，所有对象都拥有这一对方法。初看起来这十分不可思议，但是实际上却是很自然的，因为这一对方法阻塞时要释放占用的锁，而锁是任何对象都具有的，调用任意对象的 wait() 方法导致线程阻塞，并且该对象上的锁被释放。而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。
其次，前面叙述的所有方法都可在任何位置调用，但是这一对方法却必须在 synchronized 方法或块中调用，理由也很简单，只有在synchronized 方法或块中当前线程才占有锁，才有锁可以释放。同样的道理，调用这一对方法的对象上的锁必须为当前线程所拥有，这样才有锁可以释放。因此，这一对方法调用必须放置在这样的 synchronized 方法或块中，该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件，则程序虽然仍能编译，但在运行时会出现IllegalMonitorStateException 异常。
wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用，将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性：synchronized方法或块提供了类似于操作系统原语的功能，它们的执行不会受到多线程机制的干扰，而这一对方法则相当于 block 和wakeup 原语（这一对方法均声明为 synchronized）。它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法（如信号量算法），并用于解决各种复杂的线程间通信问题。
关于 wait() 和 notify() 方法最后再说明两点：
第一：调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题。
第二：除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。
谈到阻塞，就不能不谈一谈死锁，略一分析就能发现，suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是，Java 并不在语言级别上支持死锁的避免，我们在编程中必须小心地避免死锁。
以上我们对 Java 中实现线程阻塞的各种方法作了一番分析，我们重点分析了 wait() 和 notify() 方法，因为它们的功能最强大，使用也最灵活，但是这也导致了它们的效率较低，较容易出错。实际使用中我们应该灵活使用各种方法，以便更好地达到我们的目的。

七：守护线程
守护线程是一类特殊的线程，它和普通线程的区别在于它并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使仍然有守护线程在运行，应用程序也将终止，反之，只要有一个非守护线程在运行，应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。
可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程，也可以调用方法 setDaemon() 来将一个线程设为守护线程。

八：线程组
线程组是一个 Java 特有的概念，在 Java 中，线程组是类ThreadGroup 的对象，每个线程都隶属于唯一一个线程组，这个线程组在线程创建时指定并在线程的整个生命期内都不能更改。你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组，若没有指定，则线程缺省地隶属于名为 system 的系统线程组。
在 Java 中，除了预建的系统线程组外，所有线程组都必须显式创建。
在 Java 中，除系统线程组外的每个线程组又隶属于另一个线程组，你可以在创建线程组时指定其所隶属的线程组，若没有指定，则缺省地隶属于系统线程组。这样，所有线程组组成了一棵以系统线程组为根的树。
Java 允许我们对一个线程组中的所有线程同时进行操作，比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级，也可以启动或阻塞其中的所有线程。
Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程，对不同组的线程进行不同的处理，还可以通过线程组的分层结构来支持不对等安全措施的采用。Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。

九：总结
在这一讲中，我们一起学习了 Java 多线程编程的方方面面，包括创建线程，以及对多个线程进行调度、管理。我们深刻认识到了多线程编程的复杂性，以及线程切换开销带来的多线程程序的低效性，这也促使我们认真地思考一个问题：我们是否需要多线程？何时需要多线程？
多线程的核心在于多个代码块并发执行，本质特点在于各代码块之间的代码是乱序执行的。我们的程序是否需要多线程，就是要看这是否也是它的内在特点。
假如我们的程序根本不要求多个代码块并发执行，那自然不需要使用多线程；假如我们的程序虽然要求多个代码块并发执行，但是却不要求乱序，则我们完全可以用一个循环来简单高效地实现，也不需要使用多线程；只有当它完全符合多线程的特点时，多线程机制对线程间通信和线程管理的强大支持才能有用武之地，这时使用多线程才是值得的

　　GB2312：GB2312码是中华人民共和国国家汉字信息交换用编码，全称《信息交换用汉字编码字符集－基本集》。主要用于给每一个中文字符指定相应的数字，也就是进行编码。一个中文字符用两个字节的数字来表示，为了和ASCII码有所区别，将中文字符每一个字节的最高位置都用1来表示。

　　GBK：为了对更多的字符进行编码，国家又发布了新的编码系统GBK(GBK的K是“扩展”的汉语拼音第一个字母)。在新的编码系统里，除了完全兼容GB2312 外，还对繁体中文、一些不常用的汉字和许多符号进行了编码。

　　ISO-8859-1：是西方国家所使用的字符编码集，是一种单字节的字符集 ，而英文实际上只用了其中数字小于128的部分。

　　Unicode：这是一种通用的字符集，对所有语言的文字进行了统一编码，对每一个字符都用2个字节来表示，对于英文字符采取前面加“0”字节的策略实现等长兼容。如 “a” 的ASCII码为0x61，UNICODE就为0x00，0x61。

　　UTF-8：Eight-bit UCS Transformation Format，(UCS，Universal Character Set，通用字符集，UCS 是所有其他字符集标准的一个超集)。一个7位的ASCII码值，对应的UTF码是一个字节。如果字符是0x0000，或在0x0080与0x007f之间，对应的UTF码是两个字节，如果字符在0x0800与0xffff之间，对应的UTF码是三个字节。

　　我们运行java程序时，JVM有自己所支持的编码种类，用以下代码可以看到：

Map m = Charset.availableCharsets();
   Set names = m.keySet();
   Iterator it = names.iterator();
   while (it.hasNext())
   {
    System.out.println(it.next());
   }

　　 然后可以通过以下代码看到我们目前JVM所使用的编码：

Properties pps = System.getProperties();
   pps.list(System.out);

　　具体来说什么是编码，什么是解码？
　　在InputStreamReader JDK有这样描述：It reads bytes and decodes them into characters using a specified charset.(用指定的字符集将字节数组解码成字符串)。
　　相反OutputStreamWriter 描述：Characters written to it are encoded into bytes using a specified charset.(用指定的字符集将字符串编码成字节数组)。

　　理解这个以后一切好办了啦！

　　我们的OS一般是GBK编码的（凡是从磁盘上读取文件可以看成是用OS的字符集编码方式来对操作对象进行解码处理--从标准输入设备读取数据的时候是依赖OS的字符集）。而我们将从磁盘上文件经过处理得到我们想要的字符串等其它对象的时候，这一过程是用JVM的默认的字符集编码方式来处理的！由于不同的字符集编码方式有着不同的原理(前面所述)，这样当编码与解码不一致的时候，自然而然就出现了可爱的乱码。

　　比如如下，将我们JVM字符集改成iso-8859-1这样在就与我们的OS不同：
　　当输入中文时自然就输出的是乱码了。

pps.put( " file.encoding " , " ISO-8859-1 " );
   int data;
   byte [] buf = new byte [ 100 ];
   int i = 0 ;
   while ((data = System.in.read()) != ' q ' )
   {
    buf[i] = ( byte )data;
    i ++ ;
   }
   String str = new String(buf, 0 ,i);
   System.out.println(str);

　
　　这时我们可以用string的一个构造方法：
　　String(byt[] bytes, String charsetName)
　　Constructs a new String by decoding the specified array of bytes using the specified charset.(用指定的字符集对字节数组进行解码)。
　　其中用到了string 的getBytes方法：
　　getBytes(String charsetName)
　　Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte array.(用指定的字符集进行编码，将结果存放到一字节数组里面)重新构造一个string：

String strGBK = new String(str.getBytes( " ISO-8859-1 " ), " GBK " );

　　这样又可以重新得到我们想要的汉字了。

　　我们这例子中是GBK(OS)来编码的，然后采用iso-8859-1(JVM)来解码得到一个新string(此string是乱码)，然后将此string用iso-8859-1重新编码，并且用指定的GBK来解码。得到一个新string(也就是strGBK)，这个string就不再是乱码了。

　　但如果我们一开始就采用GBK解码得到的字符串，然后用ISO-8859-1编码，能否再解码回去得到我们的中文字符呢？显示不可以啦，因为用ISO-8859-1的编码的时候采用是一种单字节的字符集来对其编码，这样就丢失了一个字节(对中文来说)！所以这样是得不到中文字符的！

        国际化（Internationalization）是设计一个适用于多种语言和地区的应用程序的过程。适用于多种语言和地区的含义是当使用不同语言及处于不同的地区的用户在使用这个应用程序时，应用程序必须使用他们能看懂的语言和符合他们文化习惯来显示信息。国际化有时候被简称为i18n，因为有18个字母在国际化的英文单词的字母i和n之间。

        一个国际化的程序通常具有以下特征：

• 有一个附加的本地化数据（localized  data）及拥有在全世界各个地区执行的能力。
• 文本的元素，比如状态信息或GUI截面的lables，不是直接写（hardcoded）在程序中，而是被存储在本地化的数据中，并且能被程序正确的动态的使用。
• 支持新的语言时，不需要修改程序，不需要重新编译。
• 文化差异的数据，比如日期和货币，必须根据拥护的语言和习惯显示不同的格式。
• 可以被迅速的本地化。

        本地化（Localization）是指通过增加本地描述的构件（locale-specific components ）和文字翻译工作来使应用程序适应于不同的语言和地区的过程。本地化有时候被简称为l10n，应为有10个字母在本地化的英文单词的字母l和n之间。通常本地化最耗时的工作应该是文字翻译。本地化工作者们要根据地区的具体需求来为日期、数字和通货等数据建立新的格式。其他类型的数据，象声音，图象等，也需要根据具体需要来决定是否本地化。

         下面通过一个简单的例子来说明如何给一个程序提供国际化的特性。这个例子在不同的语言环境下显示不同的文本信息。

一个简单的例子

        先看下面的一段代码：
    public class NotI18N {
                static public void main(String[] args) {
                 System.out.println("Hello.");
                 System.out.println("How are you?");
                 System.out.println("Goodbye.");
             }
         }
    如果你决定在上面的程序中给德国和法国的不同用户显示同样的信息。但是你的程序员却不是个语言专家，他不懂德语和法语。所以你需要翻译人员把它翻译成德语和法语，但是你的翻译人员不懂程序，所以你可以把这些信息存到一个文本或其他格式的文件中供翻译人员使用。那么，程序必须能显示不同语言的信息，并且你并不知道你希望为这个程序提供的下一个语言支持是什么，或许是日语或许是别的什么语言。
    下面的代码是一个国际化的代码的例子：
         import java.util.*;

         public class I18NSample {
             static public void main(String[] args) {
                 String language;

    从上面的代码我们可以看出，在实现了国际化的代码中，并没有将需要显示的信息直接hardcode在代码中，而是存在一个文件中供程序使用。程序根据不同的语言和国家（Local）来取得文件中不同信息显示。我们试着按一下的步骤一步一步分析这段代码如何实现了国际化：

    1、建立properties文件----本地化数据

     properties文件用来存储程序和环境相关的信息。必须以.properties的后缀结尾，properties文件是纯文本格式的。在上面的例子中，一共有4个properties文件。分别定义了不同语言和国家的打招呼、再见和问候时使用的语言。properties文件使用名值对（key-value）的形式，如下所示：
     greetings = Bonjour.
     farewell = Au revoir.
     inquiry = Comment allez-vous?
     properties文件的名字很重要，它的形式是basename_LL_CC.properties.LL表示语言代码，CC表示国家代码。语言代码和国家代码是Local类初始化的参数，basename是创建ResourceBundle对象的参数。

      2、创建Local对象----不同语言和国家的标识

        java.util.Local是JDK提供的标准API。这个类用来标识国家和语言。
        我们可以创建一个local对象：
                 aLocale = new Locale("en","US");
        这个对象标志了一个地方，这个地方是美国，并且这里的语言是英语。
        这下面2个对象又表示什么呢？
                 caLocale = new Locale("fr","CA");
                  frLocale = new Locale("fr","FR");
        caLocale对象标志的是加拿大并且那里使用了法语，而frLocal标志的是法国而那里的语言是法语。
        注意：Local对象只是一个标识类，创建了这个类的对象并不表示你的程序已经实现了国际化。这个类是给那些需要实现国际化的类使用的，它用来标识我们即将实现国际化的Local信息。

         3、创建ResourceBundle对象----本例中实现国际化的主要角色

         java.util.ResourceBundle是JDK提供的标准API。它实际上是个抽象类，同时它提供了创建它的子类的静态工厂方法。在例子程序中我们实际上使用的是ResourceBundle的子类PropertyResourceBundle的对象。通过它，我们可以根据Local对象来读取不同的properties文件，从而取得不同的信息。
        如果local = new Locale("en","US");则读取了MessagesBundle_en_US.properties文件。
         在例子中，用如下语句创建这个对象：
message = ResourceBundle.getBundle("MessagesBundle",  currentLocale);