对象序列化主要是为了支持两种主要的特性，一是Java远程方法调用(RMI)，另外一个是序列化Java Beans。

1.        实现了Serializable接口的对象的序列化

要序列化一个对象，首先要创建OutputStream对象，然后将其封装在一个ObjectOutputStream对象内。此时，调用writeObject()方法将对象序列化并发送给OutputStream。在反序列化时，需要将一个InputStream封装在ObjectInputStream内，然后调用readObject()，得到的结果是一个Object对象，需要进行转型得到最后所需的对象。需要注意的是，在对一个Serializable对象进行反序列化的过程中，没有调用任何构造器，包括缺省的构造器，整个对象都是通过从InputStream中取得数据恢复过来的。对象序列化是面向字节的，因此采用InputStream和OutputStream层次结构。

2.        实现了Externalizable接口的对象的序列化

Externalizable接口继承了Serializable接口，同时添加了writeExternal()和readExternal()，它们在序列化和反序列化过程中会被自动调用。出于安全的考虑，可以将需要序列化的对象在上述方法中显式处理，否则不用在上述两个方法内考虑。注意，对于实现了Serializable接口的对象，对象完全以它存储的二进制位为基础来构造，不调用构造器。而对于一个Externalizable对象，所有普通的缺省构造器都会被调用，然后调用readExternal()。

3.        transient关键字

在某些情况下，有些特定的子对象不希望Java序列化机制自动保存与恢复，即使对象中的这些信息是private的，经过序列化处理，就可以通过读取文件或者拦截网络传输的方式来访问到它。实现了Externalizable接口的对象的writeExternal()方法可以对需要的对象进行显式的序列化，但是如果我们操作的是一个实现了Serializable接口的对象，就只能用transient关键字逐个字段的关闭序列化，只需要在字段定义前加上该关键字即可。

4.        实现了Serializable接口的同时，提供两个方法

private void writeObject(ObjectOutputStream stream) throws IOException

private void readObject(ObjectInputStream stream)

throws IOException, ClassNotFoundException

这种方法使用起来比较混乱，仅仅提供了这样的一种功能，绝大多数情况下，使用前面三种方法就能满足需求。

作者：Flyingis

    文件加锁是JDK1.4引入的一种机制，它允许我们同步访问某个作为共享资源的文件。竞争同一文件的两个线程可能在不同的Java虚拟机上，或者一个是Java线程，另一个是操作系统中的某个本地线程。文件锁对其他的操作系统进程是可见的，因为Java的文件加锁直接映射到了本地操作系统的加锁工具。

通过对FileChannel调用tryLock()或lock()，就可以获得整个文件的FileLock。特殊的是，SocketChannel/DatagramChannel/ServerSocketChannel不需要加锁，因为它们是从单进程实体继承而来，我们通常不在两个进程之间共享网络的socket。

tryLock()是非阻塞式的，它设法获取锁，但如果不能获得，例如因为其他一些进程已经持有相同的锁，而且不共享时，它将直接从方法调用返回。

lock()是阻塞式的，它要阻塞进程直到锁可以获得，或调用lock()的线程中断，或调用lock()的通道关闭。

对独占锁和共享锁的支持必须由底层的操作系统提供。锁的类型可以通过FileLock.isShared()进行查询。另外，我们不能获取缓冲器上的锁，只能是通道上的。

文件加锁的实际应用之一：文件映射通常应用于大型的文件，我们可能需要对巨大的文件进行部分加锁，以便其他的进程可以修改文件中未被加锁的部分，数据库就是如此，使得多用户可以访问到未加锁的部分数据。其他的应用还知之甚少。

    在基于Java的各种开发中，字符编码是常见的问题之一，在最基本的Java I/O中也存在这种问题。新的Java I/O通过通道和缓冲器来读写数据，缓冲器容纳的是普通的字节，为了把它们转换成字符，我们要么在输入的时候对其进行编码，要么在从缓冲器输出时对它们进行解码。

import java.io.*;

import java.nio.*;

import java.nio.channels.*;

import java.nio.charset.*;

public class ByteToCharacter {

  private static final int SIZE = 1024;

  public static void main(String[] args) throws Exception {

FileChannel fc = new FileOutputStream(“Output.txt”).getChannel();

ByteBuffer buffer = ByteBuffer.allocate(SIZE);

/**

* 在输入的时候进行编码方式一

*/

fc.write(ByteBuffer.wrap(“Good holiday!”.getBytes(“UTF-16BE”)));  // UTF-16BE可以更换为其他编码方式

fc.close();

fc = new FileInputStream(“Output.txt”).getChannel();

fc.read(buffer);

buffer.flip();  //准备从缓冲区读取已经写入的数据

System.out.println(buffer.asCharBuffer());

/**

* 在输入的时候进行编码方式二

* 通过asCharBuffer()方法直接以char形式将字符写入

*/

fc = new FileOutputStream(“Output.txt”).getChannel();

buffer.clear();

buffer.asCharBuffer.put(“Good holiday has passed!”);

fc.write(buffer);

fc.close();

fc = new FileInputStream(“Output.txt”).getChannel();

buffer.clear();

fc.read(buffer);

buffer.flip();

System.out.println(buffer.asCharBuffer());

/**

* 从缓冲器输出时进行编码

*/

fc = new FileOutputStream(“Output.txt”).getChannel();

fc.write(ByteBuffer.wrap(“Once again!”.getBytes()));

fc.close();

fc = new FileInputStream(“Output.txt”).getChannel();

buffer.clear();

fc.read(buffer);

buffer.flip();

String encode = System.getProperty(“file.encoding”);  // 平台缺省字符集，更加通用的方法，跨平台特性的体现之一

System.out.println(Charset.forName(encode).decode(buffer));

}

}

    在上述代码中，如果不对从缓冲器写入的数据进行正确编码，那么当再次通过缓冲器读取这些数据时，将不能显示任何所需要的数据。

    JDK中的java.nio.charset.Charset类提供了把数据编码成多种不同类型的字符集的工具，满足在各种应用中的编码需求。

Java的I/O使用“流”这个抽象的概念，它屏蔽了实际的I/O设备中处理数据的细节。在实际的应用中，我们很少使用单一的类来创建流对象，而是通过多个对象来提供所需要的I/O功能。Java从1.0到1.1到1.4多I/O类库作了多次重大修改，具体的可以参考相关的书籍或Sun官方网站。这里是从模式的角度来分析Java的I/O类库的设计。

Strategy设计模式

将会发生变化的代码封装在单独的类(Strategy对象)中，供其他保持不变的类使用，实现某种算法或应用，这是Strategy设计模式的一般思想。在Java I/O中，一个典型的应用是File类，它可以代表一个特定文件的名称，也可以代表一个目录下一组文件的名称。当我们要查询显示一个目录下特定文件类型的所有文件对象信息时，就需要将这个目录下的文件过滤，找到所需要的对象。

import java.io.*;

import java.util.*;

import java.util.regex.*;

 

public class AlphabeticComparator implements Comparator {

public int compare(Object o1, Object o2) {

  String s1 = (String)o1;

  String s2 = (String)o2;

  return s1.toLowerCase().compareTo(s2.toLowerCase());  //比较时不考虑大小写

}

}

 

public class FruitList {

  public static FilenameFilter filter(final String regex) {

return new FilenameFilter() {

  private Pattern pattern = Pattern.compile(regex);

  public boolean accept(File dir, String name) {

    return pattern.matcher(new File(name).getName()).matches();

}

};

}

public static void main(String[] args) {

  File path = new File(“.”);

  String[] list;

  if (args.length == 0)

    list = path.list();  //搜索出该目录下所有类型的文件

else

  list = path.list(filter(args[0]));  //搜索出该目录下指定类型的文件

Arrays.sort(list, new AlphabeticComparator());

for (int i = 0; i < list.length; i++)

  System.out.println(list[i]);

}

}在上述代码中，有两个地方使用了Strategy设计模式，一个是AlphabeticComparator类，用来在忽略字符串大小写的情况下提供排序的规则，另一个就是FilenameFilter接口，使用了匿名内部类的设计，然后将其中实现的accept()规则提供给File类的list方法使用。这里是用来判断正则表达式regex是否和文件名匹配，当运行程序在命令操作符中输入“E.*\.java”时，搜索到的是该目录下所有.java文件。

File类除了上述用法外，还可以创建或删除目录，查看文件的信息，包括文件大小、最后修改日期，读写状态等，具体的可以参考JDK文档。

Decorator设计模式

在http://www.j2eesp.com上有对Decorator设计模式的定义：动态给一个对象添加一些额外的职责，就像在墙上刷油漆。使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。Decorator模式规定所有封装于初始对象内部的对象具有相同的接口，这使得该模式的应用具有透明性。

在Java I/O设计中，Decorator模式主要体现在filter类的设计上，抽象类filter是所有Decorator模式类的基类。但是Decorator模式同样存在缺点：在编写程序时，它在给开发人员提供了灵活性的同时，增加了代码的复杂性，造成了Java I/O类操作不便，因为很多I/O设计中都需要应用Decorator模式，增加一些类来完成该设计。

例如在Java 1.0中，FilterInputStream从InputStream中读取数据，FilterOutPutStream向OutputStream中写入数据，在Java 1.1中，相应的有FilterReader和FilterWriter(抽象类，没有子类)用于Decorator模式设计。举个简单的例子：

import java.io.*;

public class DecoratorDemo {

  public static void main(String[] args) {

BufferedReader in = new BufferedReader(new FileReader(“FruitList.java”));

String s = new String();

while ((s = in.readLine()) != null)

  System.out.println(s);

in.close();

}

}

    BufferedReader和FileReader完成了Decorate模式设计，这两个类可以更换为其他具有相同功用的类(在Thinking in Java中称为“修饰器”类)来组合完成特定的任务，正如上文所述，这给开发者提供了多种组合方式，同时也相对的增加了复杂度。

    最后，祝blogjava所有成员和Java、开源爱好者元旦快乐！幸福安康！

Flyingis 2005-12-30 21:47 发表评论

]]>

1.Map的功能方法

Map(interface): 维护label和value的关联性，使得可以通过label查找value。

HashMap: Map基于散列表的实现，取代了Hashtable。插入和查询label/value的开销是固定的，并且可以通过构造器设置容量和负载因子，以调整容器的性能。

LinkedHashMap: 在HashMap的基础上做了一些改进，在迭代遍历它时，取得label/value的顺序是其插入的次序，或者是最近最少使用(LRU)的次序，速度上比HashMap要慢一点，但在迭代访问时速度会更快，主要原因是它使用了链表维护内部次序。

TreeMap: 查看label或label/value时，元素会被排序，其次序由Comparable或Comparator决定，因此查询所得到的结果是经过排序的。另外，它是唯一带有subMap()方法的Map具体类，即返回一个子树。它也是SortedMap接口的唯一实现，subMap()方法也是从该接口继承的。

WeakHashMap: Weak Key映射，允许释放映射所指向的对象。当映射之外没有引用指向某个label时，此label可以被垃圾收集器回收。

IdentityHashMap: 使用==代替equals()对label进行比较的散列映射。

2.hashCode()

         当使用标准库中的类Integer作为HashMap的label时，程序能够正常运行，但是使用自己创建的类作为HashMap的label时，通常犯一个错误。

         在HashMap中通过label查找value时，实际上是计算label对象地址的散列码来确定value的。一般情况下，我们是使用基类Object的方法hashCode()来生成散列码，它默认是使用对象的地址来计算的，因此由第一个对象new Apple(5)和第二个对象new Apple(5)生成的散列码是不同的，不能完成正确的查找。通常，我们可以编写自己的hashCode()方法来覆盖基类的原始方法，但与此同时，我们必须同时实现equals()方法来判断当前的label是否与表中存在的label相同。正确的equals()方法满足五个条件：

(1)     自反性。对于任意的x，x.equals(x)一定返回true。

(2)     对称性。对于任意的x和y，如果y.equals(x)返回true，则x.equals(y)也返回true。

(3)     传递性。对于任意的x、y、z，如果有x.equals(y)返回true，y.equals(z)返回true，则x.equals(z)一定返回true。

(4)     一致性。对于任意的x和y，如果对象中用于等价比较的信息没有改变，那么无论调用x.equals(y)多少次，返回的结果应该保持一致，要么一直是true，要么一直是false。

(5)     对任何不是null的x，x.equals(null)一定返回false。

equals()比较的是对象的地址，如果要使用自己的类作为HashMap的label，必须同时重载hashCode()和equals()方法。

使用散列的目的：想要使用一个对象来查找另一个对象。使用TreeSet或TreeMap也能实现此目的。另外，还可以自己实现一个Map，此时，必须提供Map.entrySet()方法来生成Map.Entry对象的Set。

使用散列的价值：速度，散列使得查询可以快速进行。散列将label保存载数组中方便快速查询，因为存储一组元素最快的数据结构是数组，用它来表示label的信息(后面有信息的描述)，而不是label本身。通过label对象计算得到一个数字，作为数组的下标，这个数字就是散列码(即前面所述的信息)。该散列码具体是通过定义在基类Object中，可能由程序员自定义的类覆盖的hashCode()方法，即散列函数生成。为了解决数组容量带来的限制，可以使不同的label生成相同的下标，保存在一个链表list中，每一个链表就是数组的一个元素。查询label时就可以通过对list中的信息进行查找，当散列函数比较好，数组的每个位置中的list长度较短，则可以快速查找到数组元素list中的某个位置，提高了整体速度。

散列表中的slot通常称为bucket，为了使散列分步均匀，bucket的值一般取质数。但事实证明，质数实际上并不是散列bucket的理想容量，近来Java散列实现都使用2的幂，具体如何验证以后再续。

3.HashMap的性能因子

容量(capacity): 散列表中bucket的数量。

初始化容量(initial capacity): 创建散列表时bucket的数量。可以在构造方法中指定HashMap和HashSet的初始化容量。

尺寸(size): 散列表中记录的数量。(数组的元素个数，非list中元素总和)

负载因子(load factor): 尺寸/容量。负载因子为0，表示空的散列表，0.5表示半满的散列表。轻负载的散列表具有冲突少，适宜插入与查询的特点，但是使用迭代器遍历会比较慢。较高的负载会减少所需空间大小。当负载达到指定值时，容器会自动成倍地增加容量，并将原有的对象重新分配，存入新的bucket中，这个过程称为“重散列”。

4.重写hashCode()的关键

(1)     对同一个对象调用hashCode()都应该生成同样的值。

(2)     hashCode()方法不要依赖于对象中易变的数据，当数据发生变化时，hashCode()就会生成一个不同的散列码，即产生了一个不同的label。

(3)     hashCode()不应依赖于具有唯一性的对象信息，例如对象地址。

(4)     散列码应该更关心速度，而不是唯一性，因为散列码不必是唯一的。

(5)     好的hashCode()应该产生分步均匀的散列码。在Effective Java(Addison-Wesley 2001)中，Joshua Bloch给hashCode()给出了设计指导，可以参考。

Map----一组成对的“键值对”对象，即其元素是成对的对象，最典型的应用就是数据字典，并且还有其它广泛的应用。另外，Map可以返回其所有键组成的Set和其所有值组成的Collection，或其键值对组成的Set，并且还可以像数组一样扩展多维Map，只要让Map中键值对的每个“值”是一个Map即可。

1.迭代器

       迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

       Java中的Iterator功能比较简单，并且只能单向移动：

(1)    使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。

(2)    使用next()获得序列中的下一个元素。

(3)    使用hasNext()检查序列中是否还有元素。

(4)    使用remove()将迭代器新返回的元素删除。

Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

2.List的功能方法

List(interface): 次序是List最重要的特点；它确保维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(只推荐LinkedList使用)。一个List可以生成ListIterator，使用它可以从两个方向遍历List，也可以从List中间插入和删除元素。

ArrayList: 由数组实现的List。它允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList，而不是用来插入和删除元素，因为这比LinkedList开销要大很多。

LinkedList: 对顺序访问进行了优化，向List中间插入与删除得开销不大，随机访问则相对较慢(可用ArrayList代替)。它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()，这些方法(没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

3.Set的功能方法

Set(interface): 存入Set的每个元素必须是唯一的，因为Set不保存重复元素。加入Set的Object必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。

HashSet: 为快速查找而设计的Set。存入HashSet的对象必须定义hashCode()。

TreeSet: 保持次序的Set，底层为树结构。使用它可以从Set中提取有序的序列。

LinkedHashSet: 具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。

       HashSet采用散列函数对元素进行排序，这是专门为快速查询而设计的；TreeSet采用红黑树的数据结构进行排序元素；LinkedHashSet内部使用散列以加快查询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，Set需要维护元素的存储顺序，因此要实现Comparable接口并定义compareTo()方法。

其它相关内容：
Java容器分析--数组
Java容器分析--Map

Fruit f;

Apple a = (Apple)f;

当出现下列情况时，就会引发ClassCastException异常：

1.        Fruit和Apple类不兼容。当应用程序代码尝试将某一对象转换为某一子类时，如果该对象并非该子类的实例，JVM就会抛出ClassCastException异常。

2.        Fruit和Apple类兼容，但加载时使用了不同的ClassLoader。这是这种异常发生最常见的原因。在这里，需要了解一下什么是ClassLoader？

ClassLoader

         ClassLoader是允许JVM查找和加载类的一种Java类。JVM有内置的ClassLoader。不过，应用程序可以定义自定义的ClassLoader。应用程序定义新的ClassLoader通常出于以下两种原因：

1.        自定义和扩展JVM加载类的方式。例如，增加对新的类库(网络、加密文件等)的支持。

2.        划分JVM名称空间，避免名称冲突。例如，可以利用划分技术同时运行同一应用程序的多个版本(基于空间的划分)。此项技术在应用服务器(如WebLogic Server)内的另一个重要用途是启用应用程序热重新部署，即在不重新启动JVM的情况下启动应用程序的新版本(基于时间的划分)。

ClassLoader按层级方式进行组织。除系统BootClassLoader外，其它ClassLoader都必须有父ClassLoader。

在理解类加载的时候，需要注意以下几点：

1.        永远无法在同一ClassLoader中重新加载类。“热重新部署”需要使用新的ClassLoader。每个类对其ClassLoader的引用都是不可变的：this.getClass().getClassLoader()。

2.        在加载类之前，ClassLoader始终会先询问其父ClassLoader(委托模型)。这意味着将永远无法重写“核心”类。

3.        同级ClassLoader间互不了解。

4.        由不同ClassLoader加载的同一类文件也会被视为不同的类，即便每个字节都完全相同。这是ClassCastException的一个典型原因。

5.        可以使用Thread.setContextClassLoader(a)将ClassLoader连接到线程的上下文。

基于以上的基本原理，可以加深大家对ClassCastException的理解，和在碰到问题时提供一种解决问题的思路。

参考文献：

dev2dev专刊 2005年 第二期

1.  数组的基本特性

         数组与其它种类的容器(List/Set/Map)之间的区别在于效率、确定的类型和保存基本类型数据的能力。数组是一种高效的存储和随机访问对象引用序列的方式，使用数组可以快速的访问数组中的元素。但是当创建一个数组对象(注意和对象数组的区别)后，数组的大小也就固定了，当数组空间不足的时候就再创建一个新的数组，把旧的数组中所有的引用复制到新的数组中。

         Java中的数组和容器都需要进行边界检查，如果越界就会得到一个RuntimeException异常。这点和C++中有所不同，C++中vector的操作符[]不会做边界检查，这在速度上会有一定的提高，Java的数组和容器会因为时刻存在的边界检查带来一些性能上的开销。

         Java中通用的容器类不会以具体的类型来处理对象，容器中的对象都是以Object类型处理的，这是Java中所有类的基类。另外，数组可以保存基本类型，而容器不能，它只能保存任意的Java对象。

         一般情况下，考虑到效率与类型检查，应该尽可能考虑使用数组。如果要解决一般化的问题，数组可能会受到一些限制，这时可以使用Java提供的容器类。 

2.  操作数组的实用功能

         在java.util.Arrays类中，有许多static静态方法，提供了操作数组的一些基本功能：

         equals()方法----用于比较两个数组是否相等，相等的条件是两个数组的元素个数必须相等，并且对应位置的元素也相等。

         fill()方法----用以某个值填充整个数组，这个方法有点笨。

         asList()方法----接受任意的数组为参数，将其转变为List容器。

         binarySearch()方法----用于在已经排序的数组中查找元素，需要注意的是必须是已经排序过的数组。当Arrays.binarySearch()找到了查找目标时，该方法将返回一个等于或大于0的值，否则将返回一个负值，表示在该数组目前的排序状态下此目标元素所应该插入的位置。负值的计算公式是“-x-1”。x指的是第一个大于查找对象的元素在数组中的位置，如果数组中所有的元素都小于要查找的对象，则x = a.size()。如果数组中包含重复的元素，则无法保证找到的是哪一个元素，如果需要对没有重复元素的数组排序，可以使用TreeSet或者LinkedHashSet。另外，如果使用Comparator排序了某个对象数组，在使用该方法时必须提供同样的Comparator类型的参数。需要注意的是，基本类型数组无法使用Comparator进行排序。

         sort()方法----对数组进行升序排序。

         在Java标准类库中，另有static方法System.arraycopy()用来复制数组，它针对所有类型做了重载。

3.  数组的排序

         在Java1.0和1.1两个版本中，类库缺少基本的算法操作，包括排序的操作，Java2对此进行了改善。在进行排序的操作时，需要根据对象的实际类型执行比较操作，如果为每种不同的类型各自编写一个不同的排序方法，将会使得代码很难被复用。一般的程序设计目标应是“将保持不变的事物与会发改变的事物相分离”。在这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。

Java有两种方式来实现比较的功能，一种是实现java.lang.Comparable接口，该接口只有一个compareTo()方法，并以一个Object类为参数，如果当前对象小于参数则返回负值，如果相等返回零，如果当前对象大于参数则返回正值。另一种比较方法是采用策略(strategy)设计模式，将会发生变化的代码封装在它自己的类(策略对象)中，再将策略对象交给保持不变的代码中，后者使用此策略实现它的算法。因此，可以为不同的比较方式生成不同的对象，将它们用在同样的排序程序中。在此情况下，通过定义一个实现了Comparator接口的类而创建了一个策略，这个策略类有compare()和equals()两个方法，一般情况下实现compare()方法即可。

使用上述两种方法即可对任意基本类型的数组进行排序，也可以对任意的对象数组进行排序。再提示一遍，基本类型数组无法使用Comparator进行排序。

Java标准类库中的排序算法针对排序的类型进行了优化——针对基本类型设计了“快速排序”，针对对象设计的“稳定归并排序”。一般不用担心其性能。

其它相关内容：
Java容器分析--List和Set
Java容器分析--Map

       要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由“Class对象”完成的，它包含了与类有关的信息。类是程序的重要组成部分，每个类都有一个Class对象，每当编写并编译了一个新类就会产生一个Class对象，它被保存在一个同名的.class文件中。在运行时，当我们想生成这个类的对象时，运行这个程序的Java虚拟机(JVM)会确认这个类的Class对象是否已经加载，如果尚未加载，JVM就会根据类名查找.class文件，并将其载入，一旦这个类的Class对象被载入内存，它就被用来创建这个类的所有对象。一般的RTTI形式包括三种：

1.       传统的类型转换。如“(Apple)Fruit”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个ClassCastException异常。

2.       通过Class对象来获取对象的类型。如

Class c = Class.forName(“Apple”);

Object o = c.newInstance();

3.       通过关键字instanceof或Class.isInstance()方法来确定对象是否属于某个特定类型的实例，准确的说，应该是instanceof / Class.isInstance()可以用来确定对象是否属于某个特定类及其所有基类的实例，这和equals() / ==不一样，它们用来比较两个对象是否属于同一个类的实例，没有考虑继承关系。

反射

       如果不知道某个对象的类型，可以通过RTTI来获取，但前提是这个类型在编译时必须已知，这样才能使用RTTI来识别。即在编译时，编译器必须知道所有通过RTTI来处理的类。

使用反射机制可以不受这个限制，它主要应用于两种情况，第一个是“基于构件的编程”，在这种编程方式中，将使用某种基于快速应用开发(RAD)的应用构建工具来构建项目。这是现在最常见的可视化编程方法，通过代表不同组件的图标拖动到图板上来创建程序，然后设置构件的属性值来配置它们。这种配置要求构件都是可实例化的，并且要暴露其部分信息，使得程序员可以读取和设置构件的值。当处理GUI时间的构件时还必须暴露相关方法的细细，以便RAD环境帮助程序员覆盖这些处理事件的方法。在这里，就要用到反射的机制来检查可用的方法并返回方法名。Java通过JavaBeans提供了基于构件的编程架构。

       第二种情况，在运行时获取类的信息的另外一个动机，就是希望能够提供在跨网络的远程平台上创建和运行对象的能力。这被成为远程调用(RMI)，它允许一个Java程序将对象分步在多台机器上，这种分步能力将帮助开发人员执行一些需要进行大量计算的任务，充分利用计算机资源，提高运行速度。

       Class支持反射，java.lang.reflect中包含了Field/Method/Constructor类，每个类都实现了Member接口。这些类型的对象都是由JVM在运行时创建的，用来表示未知类里对应的成员。如可以用Constructor类创建新的对象，用get()和set()方法读取和修改与Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。同时，还可以调用getFields()、getMethods()、getConstructors()等方法来返回表示字段、方法以及构造器的对象数组。这样，未知的对象的类信息在运行时就能被完全确定下来，而在编译时不需要知道任何信息。

    Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如：
    class c = Class.forName(“Example”);
    factory = (ExampleInterface)c.newInstance();

    其中ExampleInterface是Example的接口，可以写成如下形式：
    String className = "Example";
    class c = Class.forName(className);
    factory = (ExampleInterface)c.newInstance();

    进一步可以写成如下形式：
    String className = readfromXMlConfig;//从xml 配置文件中获得字符串
    class c = Class.forName(className);
    factory = (ExampleInterface)c.newInstance();

    上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。

    从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载java API的那个加载器。

    现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。

    最后用最简单的描述来区分new关键字和newInstance()方法的区别：
    newInstance: 弱类型。低效率。只能调用无参构造。
    new: 强类型。相对高效。能调用任何public构造。

API
同步-Synchronization
数据增长-Data growth
使用方法-Usage patterns

让我一个一个来解释吧。

API
在The Java Programming Language (Addison-Wesley, June 2000) 中Ken Arnold, James Gosling, 和 David Holmes 是这样描述Vector的，它是更ArrayList类似的一个东西，所以从API的观点来看，它们俩是很相似的。但是，它们之间还是有些微的差别的。

Synchronization
Vectors是可同步化的，意思就是说，任何操作Vector的内容的方法都是线程安全的，相反的，另一方面，ArrayList是不可同步化的，所以也不是线程安全的。如果你知道了这些的话，你就会发现，Vector的同步会让它在性能发方面有一些小问题。所以，如果你不需要线程安全的话，那么就使用ArrayList吧。为什么要为没有必要的同步付出代价呢？

Data growth
实际上，不管是ArrayList还是Vector，在它们内部都是使用一个Array来保存数据的。编程过程中，在使用它们任何一个的时候，你都需要记住这一点。你在往一个ArrayList或者Vector里插入一个元素的时候，如果内部数组空间不够了，这个对象(译者按：指的是你使用的ArrayList或者Vector)就要扩展它的大小。Vector在默认情况下是产生一个双倍大小，而ArrayList增加50%的大小。只要你合理的使用这些类，你就可以结束你在增加新的元素的时候所付出的性能代价。把对象(译者按：指的是你使用的ArrayList或者Vector)的初始化容量指定为你编程过程中所能用到的最大的容量总是最好的办法。仔细的指定容量，你可以避免以后改变内部Array容量，所要付出的代价。如果你并不知道到底有多少个数据，当是你知道数据的增长率，Vector确实有一点点优势，因为你可以指定增加值(译者按，如果没有猜错的话，作者说的方法应该是setSize(int newSize)  Sets the size of this vector.)。

Usage patterns
ArrayList和Vector在从指定位置取得元素，从容器的末尾增加和删除元素都非常的有效，所有的这些操作都能在一个常数级的时间(O(1))内完成。但是从一个其他的位置增加和删除一个元素就显得颇为费时，差不多需要的时间为O(n-i)，这里的n代表元素个数，i代表要增加和删除的元素所在的位置。这些操作需花费更多的时间，因为你需要挨个移动i和更高位置的元素。那么，以上这些到底说明了什么呢？

这意味着，如果你取得一个元素，或者从数组末尾增加或删除一个元素的话，随便你使用Vector和ArrayList。如果你想要对数组内容做其他操作的话，那么就为自己好另一个容器吧。比喻说，LinkedList可以在常数级时间(O(1))内为任意一个位置的元素增加和删除。但是，取得一个元素，会稍微慢一点，时间要用O(i) ，这个i是元素的位置。通过ArrayList也是很简单的，因为你可以简单使用一个索引，而不是构造一个iterator 。LinkedList也为每个插入的元素建立一个内部对象。所以，你也必须知道，同时产生了垃圾对象。

最后，Practical Java (Addison-Wesley, Feb. 2000) Peter Haggar 里的“实践41“建议你使用一个普通的原始的数组来代替Vector和ArrayListe，特别是对效率优先的代码来说。通过使用数组(array)，你可以避免同步，额外的方法调用，非理想化的大小改变。你付出的只是额外的开发时间。

原文链接：http://www.javaworld.com/javaworld/javaqa/2001-06/03-qa-0622-vector.html

// Person的构造器设置姓和国家代码
Person person1 = new Person( "Tim", "US" );
Person person2 = new Person( "John", "US" );
Person person3 = new Person( "Al",  "US" );
Person person4 = new Person( "Tony", "GB" );

// Job的构造器设工作名称和薪水
person1.setJob( new Job( "Developer", 40000 ) );
person2.setJob( new Job( "Senator", 150000 ) );
person3.setJob( new Job( "Comedian", 3400302 ) );
person4.setJob( new Job( "Minister", 2000000 ) );

Person[] personArr = 
  new Person[] { person1, person2, 
                 person3, person4 };

List people = Arrays.asList( personArr );

Iterator peopleIter = people.getIterator();
while( peopleIter.hasNext() ) {
  Person person = (Person) peopleIter.next();

  if( person.getCountry() != null &&
      person.getCountry().equals( "US" ) &&
      person.getJob() != null &&
      person.getJob().getSalary() > 1000000 ) {
        print( person.getFirstName() + " "
               person.getLastName() );
      }
    }
  }
}

import org.apache.commons.jxpath.JXPathContext;

public List queryCollection(String xpath,
                            Collection col) {
    List results = new ArrayList();

    JXPathContext context = 
        JXPathContext.newContext( col );
 
    Iterator matching = 
        context.iterate( xpath );

    while( matching.hasNext() ) {
        results.add( matching.getNext() );
    }
    return results;
}

String query1 =
   ".[@country = 'US']/job[@salary > 1000000]/..";  
String query2 =
   ".[@country = 'GB' and @name = 'Tony']";  
String query3 = 
   "./job/name";

List richUsPeople = 
    queryCollection( query1, people );
List britishTony = 
    queryCollection( query2, people );
List jobNames = 
    queryCollection( query3, people );

queryCollection()方法使用了一个XPath表达式，将它应用到一个集合上。XPath表达式被JXPathContext求值， JXPathContext由JXPathContext.newContext()调用创建，并将它传入要执行查询的集合中。凋用context.iterate()来在集合中的每一个元素上应用XPath表达式，返回包含所有符合条件的“节点”（这里是“对象”）的Iterator。上例中执行的第一个查询，query1,执行了和不使用JXPath的例子相同的查询。query2选择所有国家为GB并且名字属性为Tony的Person对象，query3返回了一个String对象的List,包含了所有Job对象的name属性。

当我第一次看到Commons JXPath, 它是一个坏思想的想法触动了我。为什么要把XPath表达式应用到对象上?有点感觉不对。把XPath作为一个bean的集合的查询语言的这种意想不到的用法，在过去几年中已经好多次给我带来了便利。如果你发现你在list中循环来查找符合条件的元素，请考虑一下JXPath。更多的信息，请参考Jakarta Commons Cookbook的第12章，“查找和过滤”，它讨论了Commons JXPath和与Commons Digester配对的Jakarta Lucene。

还有更多
对Jakarta Commons纵深地探索仍然在调试中。在这一系列的下面几部分中，我会介绍一些相关的工具和功能。在Commons Collections中设置操作，在collection中使用Predicate对象，使用Commons Configuration来配置一个应用和使用Commons Betwixt来读写XML。能从Jakarta Commons得到的东西还有很多，不能在几千字中表达，所以我建议你看一下Jakarta Commons Cookbook。许多功能可能会，一眼看上去，有点普通，但Jakarta Commons的能量就蕴藏在这些工具的相互组合和与你的系统的集成当中。

Timothy M. O'Brien是一个专业的独立的开发者，在Chicago地区工作和生活。

资源
·onjava.com:onjava.com
·Matrix-Java开发者社区:http://www.matrix.org.cn/
·APACHE:APACHE.org

List allStudents = getAllStudents();

// 创建两个ArrayList来存放荣誉学生和问题学生
List honorRollStudents = new ArrayList();
List problemStudents = new ArrayList();

// 遍历所有学生，将荣誉学生放入一个List,问题学生放入另一个
Iterator allStudentsIter = allStudents.iterator();
while( allStudentsIter.hasNext() ) {
  Student s = (Student) allStudentsIter.next();

  if( s.getGrade().equals( "A" ) ) {
    honorRollStudents.add( s );
  } else if( s.getGrade().equals( "B" ) && 
             s.getAttendance() == PERFECT) {
    honorRollStudents.add( s );
  } else if( s.getGrade().equals( "D" ) || 
             s.getGrade().equals( "F" ) ) {
    problemStudents.add( s );
  } else if( s.getStatus() == SUSPENDED ) {
    problemStudents.add( s );
  }
}

// 对于的有荣誉学生，增加一个奖励并存储到数据库中
Iterator honorRollIter = 
    honorRollStudents.iterator();
while( honorRollIter.hasNext() ) {
  Student s = (Student) honorRollIter.next();
   
 // 给学生记录增加一个奖励
  s.addAward( "honor roll", 2005 );
  Database.saveStudent( s );
}

// 对所有问题学生，增加一个注释并存储到数据库中
Iterator problemIter = problemStudents.iterator();
while( problemIter.hasNext() ) {
  Student s = (Student) problemIter.next();

  // 将学生标记为需特殊注意
  s.addNote( "talk to student", 2005 );
  s.addNote( "meeting with parents", 2005 );
  Database.saveStudent( s );
}

import org.apache.commons.collections.Closure;
import org.apache.commons.collections.Predicate;

// 匿名的Predicate决定一个学生是否加入荣誉榜
Predicate isHonorRoll = new Predicate() {
  public boolean evaluate(Object object) {
    Student s = (Student) object;

    return( ( s.getGrade().equals( "A" ) ) ||
            ( s.getGrade().equals( "B" ) && 
              s.getAttendance() == PERFECT ) );
  }
};

//匿名的Predicate决定一个学生是否是问题学生
Predicate isProblem = new Predicate() {
  public boolean evaluate(Object object) {
    Student s = (Student) object;

    return ( ( s.getGrade().equals( "D" ) || 
               s.getGrade().equals( "F" ) ) ||
             s.getStatus() == SUSPENDED );
  }
};

//匿名的Closure将一个学生加入荣誉榜
Closure addToHonorRoll = new Closure() {
  public void execute(Object object) {
    Student s = (Student) object;
      
// 对学生增加一个荣誉记录
    s.addAward( "honor roll", 2005 );
    Database.saveStudent( s );
  }
};

// 匿名的Closure将学生标记为需特殊注意
Closure flagForAttention = new Closure() {
  public void execute(Object object) {
    Student s = (Student) object;
      
// 标记学生为需特殊注意
    s.addNote( "talk to student", 2005 );
    s.addNote( "meeting with parents", 2005 );
    Database.saveStudent( s );
  }
};

import org.apache.commons.collections.ClosureUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.functors.NOPClosure;

Map predicateMap = new HashMap();

predicateMap.put( isHonorRoll, addToHonorRoll );
predicateMap.put( isProblem, flagForAttention );
predicateMap.put( null, ClosureUtils.nopClosure() );

Closure processStudents = 
    ClosureUtils.switchClosure( predicateMap );

CollectionUtils.forAllDo( allStudents, processStudents );

package org.test;

public class Person {
  public String id;
  public String name;
  public int age;
                
  public Person() {}

  public String getId() { return id; }
  public void setId(String id) { 
    this.id = id;
  }

  public String getName() { return name; }
  public void setName(String name) {
    this.name = name;
  }

  public int getAge() { return age; }
  public void setAge(int age) {
    this.age = age;
  }
}

  
    Tom Higgins
    25
  
  
    Barney Smith
    75
  
  
    Susan Shields
    53
  

  
    
                          paramtype="java.lang.Object"/>
    
    
    
  

import org.apache.commons.digester.Digester;
import org.apache.commons.digester.xmlrules.DigesterLoader;

// 从XML规则集中配置Digester
URL rules = getClass().getResource("./person-rules.xml");
Digester digester = 
    DigesterLoader.createDigester(rules);

// 将空的List推入到Digester的堆栈
List people = new ArrayList();
digester.push( people );

// 解析XML文档
InputStream input = new FileInputStream( "data.xml" );
digester.parse( input );

digester.addObjectCreate("people/person", Person.class);
digester.addSetNext("people/person", "add", "java.lang.Object");
digester.addBeanPropertySetter("people/person", "name");
digester.addBeanPropertySetter("people/person", "age");

如果你曾经发现自己正在用一个有着2500行代码的类，用SAX来解析一个巨大的XML文档，或者使用DOM或JDOM的完整的一个集合类，你就会理解XML的解析比它应该做的要复杂的多，就大多数情况来说。如果你正在建一个有着严格的速度和内存要求的高效的系统，你会需要SAX解析器的速度。如果你需要DOM级别3的复杂度，你会需要像Apache Xerces的解析器。但如果你只是简单的试图将几个XML文档解析到对象中去的话，看一下Commons Digester, 并把你的规则定义在一个XML文件中。

任何时候你都应该将配置信息从硬编码中移出来。我会建议你在一个XML文件中定义规则并从文件系统或类路径中装入它。这样可以使你的程序更好地适应XML文档以及对象模型的变化。有关在XML文件中定义Digester规则的更多的资料，参看Jakarta Commons Cookbook一书的6.2节,“将XML文档转换为对象”

>>>>下一章

interface Sa {

  void today();

  void yesterday();

  boolean check();

}

public class Sab {

  private i = 10;

  private Sab_inner implements Sa {

void today() {

  return i;

}

void yesterday() {

  return --i;

}

Boolean check() {

  return i = = 0;

}

}

public Sa getSa() {

    return new Sab_inner();

}

}

         从上面这段代码可以看出，如果我们只是声明外围类Sab实现接口Sa，那么对于某个特定的Sab对象只能有一个Sa。但是如果使用了内部类，我们就可以通过方法getSa()来获得一个实现Sa接口的序列，这样就增加了应用上的灵活性。

         另外，一个内部类被嵌套多少层并不重要，它能透明访问所有它所嵌入的外围类的所有成员。

5.  在Java中实现C++的嵌套类功能也是通过嵌套类的机制来实现的，区别是C++中的嵌套类不能访问私有成员，在Java中则可以。

         在Java中，使用嵌套类可以使得内部类对象与其外围类对象之间有联系，语法上是将内部类声明为static。而在普通的内部类中是不能有static数据、static字段和嵌套类的。通常，我们可以在一个普通的内部类中，通过一个特殊的this引用链接到其外围类对象，如外围类是Fruit，那么在内部类中应该通过Fruit.this来引用外围类的对象。

6.  内部类的继承比较特殊，我通过一个例子来向大家展示：

class Fruit {

  class Inner {}

}

public class Apple extends Fruit.Inner {

  Apple(Fruit f) {

    f.super(); //为什么要这样使用我也不明白

}

public static void main(String[] args) {

  Fruit f = new Fruit();

  Apple a = new Apple(f);

}

}

         其中为什么要外围类调用super()方法我也不清楚，希望有人指点！

7.  当继承某个外围类的时候，内部类并没有发生任何改变，基类和继承类中的两个内部类是完全独立的实体，各自在自己的命名空间内。如果明确继承某个内部类，则会覆盖原来的内部类。如：

public class A extends Atop {

  public Inner extends Atop.Inner {}

}

8.  局部内部类和匿名内部类在功能上基本相似，它们的区别在于，如果我们需要一个已命名的构造器，或者需要重载构造器，就要使用局部内部类，它可以提供多个内部类对象。匿名内部类只能用于实例初始化。

1.  普通的非内部类不能被声明为private或protected，否则就失去了创建该类的意义。但是内部类通常可以被声明为private或protected类型，因为这样可以防止他人对该内部类实现的功能进行修改，达到隐藏实现细节的目的。例如：

class Fruit {

  private class Weight {

private String i;

private Weight(String j) {

  i = j;

}

public String read() {

  return i;

}

}

}

class test {

  public static void main(String[] args) {

Fruit f = new Fruit();

f.Weight w = f.new Weight(); //不能访问private类，如果Weight为protected类型则可以

}

}

2.  在方法或某控制语句(if/for/while等)的作用域内定义内部类，将只能在该范围内调用内部类的方法和成员变量。

3.  匿名内部类是一种特殊的内部类，如果希望它使用一个在其外部定义的对象，那么编译器会要求其参数引用是final的。

public class Fruit {

  public Tea cont(final int j) {

return new Tea() {

  private int i = j;

  public int read() {

    return i;

}

}; //注意这里的分号

}

public static void main(String[] args) {

  Fruit f = new Fruit();

  Tea t = f.cont;

}

}

而当方法cont(final int j)中的参数j只是被传递到匿名类中的构造器时，可以不用被声明为final类型，如return new Tea(j)。这里提到了匿名内部类的构造器，那么它是怎么被初始化的呢？

public class Fruit {

  public Tea cont(int j) {

return new Tea(j) {

System.out.println(j);

};

}

}

         还可以这样初始化匿名内部类：

public class Fruit {

  public Tea cont(final int j) {

return new Tea(j) {

  int i;

  // 初始化匿名内部类

  {

  i = j;

  System.out.print(i);

}

};

}

}

数据抽象、继承和多态是面向对象程序设计语言的三大特性。多态，我觉得它的作用就是用来将接口和实现分离开，改善代码的组织结构，增强代码的可读性。在某些很简单的情况下，或许我们不使用多态也能开发出满足我们需要的程序，但大多数情况，如果没有多态，就会觉得代码极其难以维护。

在Java中，谈论多态就是在讨论方法调用的绑定，绑定就是将一个方法调用同一个方法主体关联起来。在C语言中，方法(在C中称为函数)的绑定是由编译器来实现的，在英文中称为early binding(前期绑定)，因此，大家自然就会想到相对应的late binding(后期绑定)，这在Java中通常叫做run-time binding(运行时绑定)，我个人觉得这样称呼更贴切，运行时绑定的目的就是在代码运行的时候能够判断对象的类型。通过一个简单的例子说明：

/**

 * 定义一个基类

 */

public Class Parents {

  public void print() {

    System.out.println(“parents”);

}

}

/**

 * 定义两个派生类

 */

public Class Father extends Parents {

  public void print() {

    System.out.println(“father”);

}

}

public Class Mother extends Parents {

  public void print() {

    System.out.println(“mother”);

}

}

/**

 * 测试输出结果的类

 */

public Class Test {

  public void find(Parents p) {

    p.print();

}

public static void main(String[] args) {

  Test t = new Test();

  Father f = new Father();

  Mother m = new Mother();

  t.find(f);

  t.find(m);

}

}

最后的输出结果分别是father和mother，将派生类的引用传给基类的引用，然后调用重写方法，基类的引用之所以能够找到应该调用那个派生类的方法，就是因为程序在运行时进行了绑定。

学过Java基础的人都能很容易理解上面的代码和多态的原理，但是仍有一些关键的地方需要注意的，算是自己对多态的一个小结：

1.        Java中除了static和final方法外，其他所有的方法都是运行时绑定的。在我另外一篇文章中说到private方法都被隐式指定为final的，因此final的方法不会在运行时绑定。当在派生类中重写基类中static、final、或private方法时，实质上是创建了一个新的方法。

2.        在派生类中，对于基类中的private方法，最好采用不同的名字。

3.        包含抽象方法的类叫做抽象类。注意定义里面包含这样的意思，只要类中包含一个抽象方法，该类就是抽象类。抽象类在派生中就是作为基类的角色，为不同的子类提供通用的接口。

4.        对象清理的顺序和创建的顺序相反，当然前提是自己想手动清理对象，因为大家都知道Java垃圾回收器。

5.        在基类的构造方法中小心调用基类中被重写的方法，这里涉及到对象初始化顺序。

6.        构造方法是被隐式声明为static方法。

7.        用继承表达行为间的差异，用字段表达状态上的变化。

class Fruit {

  private final int[] m = {1, 2, 3};

  public static void main(String[] args) {

Fruit f = new Fruit();

for(int i = 0; i < m.length(); i++) {

  f.m[i]++;  //可以改变

}

f.m = new int[5];  //不能指向另外的一个对象，错误！

}

}

    对基本数据类型的数据使用final的另外一个用处就是可以做到根据对象的不同而使类的功能发生改变，例如：

class Apple {

  private final int i;  //没有初始化，需要在构造函数中赋值

  private static Random r = new Random();

  public Apple() {

    i = r.newInt(10);

}

public Apple(int j) {

  i += j;

}

}

    使用final方法，可以把方法锁定，防止继承类修改它。并且使用方法类在一般情况下可以提高效率，让编译器将针对该方法的所有调用都转为内嵌式的调用，即以方法体中的实际代码来代替方法调用的代码，这样就消除了方法调用的开销。但是对于private类型的方法而言意义不大，因为private方法都已经被隐式的制定为final，如果继承类试图将该方法声明为public/protected/默认的同名方法，将不能覆盖基类中的方法，这样做是声明了一个新的方法，这是Java中的多态，但是也说明了private方法将不会起到什么作用。
    final类的设计是为了防止以后对该类进行变动，并不希望它有子类，在final类中所有的方法都隐式指定为final的，并且这些方法无法被覆盖，而final类的字段将保持原义，不受final类的影响！

    这段时间在重新复习Java中的基本细节与概念，欢迎拍砖！共同学习！