解析 Java 类和对象的初始化过程

由一个单态模式引出的问题谈起

文档选项 打印本页 将此页作为电子邮件发送 级别： 初级 张 国建 (guojian.zhang@gmail.com), 软件工程师, 北京高伟达西南分软 2006 年 8 月 31 日 类的初始化和对象初始化是 JVM 管理的类型生命周期中非常重要的两个环节，Google 了一遍网络，有关类装载机制的文章倒是不少，然而类初始化和对象初始化的文章并不多，特别是从字节码和 JVM 层次来分析的文章更是鲜有所见。 本文主要对类和对象初始化全过程进行分析，通过一个实际问题引入，将源代码转换成 JVM 字节码后，对 JVM 执行过程的关键点进行全面解析，并在文中穿插入了相关 JVM 规范和 JVM 的部分内部理论知识，以理论与实际结合的方式介绍对象初始化和类初始化之间的协作以及可能存在的冲突问题。 问题引入 近日我在调试一个枚举类型的解析器程序，该解析器是将数据库内一万多条枚举代码装载到缓存中，为了实现快速定位枚举代码和具体枚举类别的所有枚举元素，该类在装载枚举代码的同时对其采取两种策略建立内存索引。由于该类是一个公共服务类，在程序各个层面都会使用到它，因此我将它实现为一个单例类。这个类在我调整类实例化语句位置之前运行正常，但当我把该类实例化语句调整到静态初始化语句之前时，我的程序不再为我工作了。 下面是经过我简化后的示例代码： ［清单一］ package com.ccb.framework.enums; import java.util.Collections; import java.util.HashMap; import java.util.Map; public class CachingEnumResolver { //单态实例　一切问题皆由此行引起 private static final CachingEnumResolver SINGLE_ENUM_RESOLVER = new CachingEnumResolver(); /*MSGCODE->Category内存索引*/ private static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //为了说明问题,我在这里初始化一条数据 CODE_MAP_CACHE.put("0","北京市"); } //private, for single instance private CachingEnumResolver() { //初始化加载数据 引起问题，该方法也要负点责任 initEnums(); } /** * 初始化所有的枚举类型 */ public static void initEnums() { // ~~~~~~~~~问题从这里开始暴露 ~~~~~~~~~~~// if (null == CODE_MAP_CACHE) { System.out.println("CODE_MAP_CACHE为空,问题在这里开始暴露."); CODE_MAP_CACHE = new HashMap(); } CODE_MAP_CACHE.put("1", "北京市"); CODE_MAP_CACHE.put("2", "云南省"); //..... other code... } public Map getCache() { return Collections.unmodifiableMap(CODE_MAP_CACHE); } /** * 获取单态实例 * * @return */ public static CachingEnumResolver getInstance() { return SINGLE_ENUM_RESOLVER; } public static void main(String[] args) { System.out.println(CachingEnumResolver.getInstance().getCache()); } } 想必大家看了上面的代码后会感觉有些茫然，这个类看起来没有问题啊，这的确属于典型的饿汉式单态模式啊，怎么会有问题呢？ 是的，他看起来的确没有问题，可是如果将他 run 起来时，其结果是他不会为你正确 work。运行该类，它的执行结果是： ［清单二］ CODE_MAP_CACHE为空,问题在这里开始暴露. {0=北京市} 我的程序怎么会这样？为什么在 initEnum() 方法里 CODE_MAP_CACHE 为空？为什么我输出的 CODE_MAP_CACHE 内容只有一个元素，其它两个元素呢？？？？！！ 看到这里，如果是你在调试该程序，你此刻一定觉得很奇怪，难道是我的 Jvm 有问题吗？非也！如果不是，那我的程序是怎么了？这绝对不是我想要的结果。可事实上无论怎么修改 initEnum() 方法都无济于事，起码我最初是一定不会怀疑到问题可能出在创建 CachingEnumResolver 实例这一环节上。正是因为我太相信我创建 CachingEnumResolver 实例的方法，加之对 Java 类初始化与对象实例化底层原理理解有所偏差，使我为此付出了三、四个小时--约半个工作日的大好青春。 那么问题究竟出在哪里呢？为什么会出现这样的怪事呢？在解决这个问题之前，先让我们来了解一下JVM的类和对象初始化的底层机制。 回页首 类的生命周期 上图展示的是类生命周期流向；在本文里，我只打算谈谈类的"初始化"以及"对象实例化"两个阶段。 回页首 类初始化 类"初始化"阶段，它是一个类或接口被首次使用的前阶段中的最后一项工作，本阶段负责为类变量赋予正确的初始值。 Java 编译器把所有的类变量初始化语句和类型的静态初始化器通通收集到 <clinit> 方法内，该方法只能被 Jvm 调用，专门承担初始化工作。 除接口以外，初始化一个类之前必须保证其直接超类已被初始化，并且该初始化过程是由 Jvm 保证线程安全的。另外，并非所有的类都会拥有一个 <clinit>() 方法，在以下条件中该类不会拥有 <clinit>() 方法： 该类既没有声明任何类变量，也没有静态初始化语句； 该类声明了类变量，但没有明确使用类变量初始化语句或静态初始化语句初始化； 该类仅包含静态 final 变量的类变量初始化语句，并且类变量初始化语句是编译时常量表达式。 回页首 对象初始化 在类被装载、连接和初始化，这个类就随时都可能使用了。对象实例化和初始化是就是对象生命的起始阶段的活动，在这里我们主要讨论对象的初始化工作的相关特点。 Java 编译器在编译每个类时都会为该类至少生成一个实例初始化方法--即 "<init>()" 方法。此方法与源代码中的每个构造方法相对应，如果类没有明确地声明任何构造方法，编译器则为该类生成一个默认的无参构造方法，这个默认的构造器仅仅调用父类的无参构造器，与此同时也会生成一个与默认构造方法对应的 "<init>()" 方法. 通常来说，<init>() 方法内包括的代码内容大概为：调用另一个 <init>() 方法；对实例变量初始化；与其对应的构造方法内的代码。 如果构造方法是明确地从调用同一个类中的另一个构造方法开始，那它对应的 <init>() 方法体内包括的内容为：一个对本类的 <init>() 方法的调用；对应用构造方法内的所有字节码。 如果构造方法不是通过调用自身类的其它构造方法开始，并且该对象不是 Object 对象，那 <init>() 法内则包括的内容为：一个对父类 <init>() 方法的调用；对实例变量初始化方法的字节码；最后是对应构造子的方法体字节码。 如果这个类是 Object，那么它的 <init>() 方法则不包括对父类 <init>() 方法的调用。 回页首 类的初始化时机 本文到目前为止，我们已经大概有了解到了类生命周期中都经历了哪些阶段，但这个类的生命周期的开始阶段--类装载又是在什么时候被触发呢？类又是何时被初始化的呢？让我们带着这三个疑问继续去寻找答案。 Java 虚拟机规范为类的初始化时机做了严格定义："initialize on first active use"--" 在首次主动使用时初始化"。这个规则直接影响着类装载、连接和初始化类的机制--因为在类型被初始化之前它必须已经被连接，然而在连接之前又必须保证它已经被装载了。 在与初始化时机相关的类装载时机问题上，Java 虚拟机规范并没有对其做严格的定义，这就使得 JVM 在实现上可以根据自己的特点提供采用不同的装载策略。我们可以思考一下 Jboss AOP 框架的实现原理，它就是在对你的 class 文件装载环节做了手脚--插入了 AOP 的相关拦截字节码，这使得它可以对程序员做到完全透明化，哪怕你用 new 操作符创建出的对象实例也一样能被 AOP 框架拦截--与之相对应的 Spring AOP，你必须通过他的 BeanFactory 获得被 AOP 代理过的受管对象，当然 Jboss AOP 的缺点也很明显--他是和 JBOSS 服务器绑定很紧密的，你不能很轻松的移植到其它服务器上。嗯~……，说到这里有些跑题了，要知道 AOP 实现策略足可以写一本厚厚的书了，嘿嘿，就此打住。 说了这么多，类的初始化时机就是在"在首次主动使用时"，那么，哪些情形下才符合首次主动使用的要求呢？ 首次主动使用的情形： 创建某个类的新实例时--new、反射、克隆或反序列化； 调用某个类的静态方法时； 使用某个类或接口的静态字段或对该字段赋值时（final字段除外）； 调用Java的某些反射方法时 初始化某个类的子类时 在虚拟机启动时某个含有main()方法的那个启动类。 除了以上几种情形以外，所有其它使用JAVA类型的方式都是被动使用的，他们不会导致类的初始化。 回页首 我的问题究竟出在哪里 好了，了解了JVM的类初始化与对象初始化机制后，我们就有了理论基础，也就可以理性的去分析问题了。 下面让我们来看看前面[清单一]的JAVA源代码反组译出的字节码： ［清单三］ public class com.ccb.framework.enums.CachingEnumResolver extends java.lang.Object{ static {}; Code: 0: new #2; //class CachingEnumResolver 3: dup 4: invokespecial #14; //Method "<init>":()V ① 7: putstatic #16; //Field SINGLE_ENUM_RESOLVER:Lcom/ccb/framework/enums/CachingEnumResolver; 10: new #18; //class HashMap ② 13: dup 14: invokespecial #19; //Method java/util/HashMap."<init>":()V 17: putstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 20: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 23: ldc #23; //String 0 25: ldc #25; //String 北京市 27: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ③ 32: pop 33: return private com.ccb.framework.enums.CachingEnumResolver(); Code: 0: aload_0 1: invokespecial #34; //Method java/lang/Object."<init>":()V 4: invokestatic #37; //Method initEnums:()V ④ 7: return public static void initEnums(); Code: 0: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; ⑤ 3: ifnonnull 24 6: getstatic #44; //Field java/lang/System.out:Ljava/io/PrintStream; 9: ldc #46; //String CODE_MAP_CACHE为空,问题在这里开始暴露. 11: invokevirtual #52; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 14: new #18; //class HashMap 17: dup 18: invokespecial #19; //Method java/util/HashMap."<init>":()V ⑥ 21: putstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 24: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 27: ldc #54; //String 1 29: ldc #25; //String 北京市 31: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ⑦ 36: pop 37: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 40: ldc #56; //String 2 42: ldc #58; //String 云南省 44: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ⑧ 49: pop 50: return public java.util.Map getCache(); Code: 0: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 3: invokestatic #66; //Method java/util/Collections.unmodifiableMap:(Ljava/util/Map;)Ljava/util/Map; 6: areturn public static com.ccb.framework.enums.CachingEnumResolver getInstance(); Code: 0: getstatic #16; //Field SINGLE_ENUM_RESOLVER:Lcom/ccb/framework/enums/CachingEnumResolver; ⑨ 3: areturn } 如果上面［清单一］显示，清单内容是在 JDK1.4 环境下的字节码内容，可能这份清单对于很大部分兄弟来说确实没有多少吸引力，因为这些 JVM 指令确实不像源代码那样漂亮易懂。但它的的确确是查找和定位问题最直接的办法，我们想要的答案就在这份 JVM 指令清单里。 现在，让我们对该类从类初始化到对象实例初始化全过程分析[清单一]中的代码执行轨迹。 如前面所述，类初始化是在类真正可用时的最后一项前阶工作，该阶段负责对所有类正确的初始化值，此项工作是线程安全的，JVM会保证多线程同步。 第１步：调用类初始化方法 CachingEnumResolver.<clinit>()，该方法对外界是不可见的，换句话说是 JVM 内部专用方法，<clinit>() 内包括了 CachingEnumResolver 内所有的具有指定初始值的类变量的初始化语句。要注意的是并非每个类都具有该方法，具体的内容在前面已有叙述。 第２步：进入 <clinit>() 方法内，让我们看字节码中的 "①" 行，该行与其上面两行组合起来代表 new 一个 CachingEnumResolver 对象实例，而该代码行本身是指调用 CachingEnumResolver 类的 <init>（）方法。每一个 Java 类都具有一个 <init>() 方法，该方法是 Java 编译器在编译时生成的，对外界不可见，<init>() 方法内包括了所有具有指定初始化值的实例变量初始化语句和java类的构造方法内的所有语句。对象在实例化时，均通过该方法进行初始化。然而到此步，一个潜在的问题已经在此埋伏好，就等着你来犯了。 第３步：让我们顺着执行顺序向下看，"④" 行，该行所在方法就是该类的构造器，该方法先调用父类的构造器 <init>() 对父对象进行初始化，然后调用 CachingEnumResolver.initEnum() 方法加载数据。 第４步："⑤" 行，该行获取 "CODE_MAP_CACHE" 字段值，其运行时该字段值为 null。注意，问题已经开始显现了。（作为程序员的你一定是希望该字段已经被初始化过了，而事实上它还没有被初始化）。通过判断，由于该字段为 NULL，因此程序将继续执行到 "⑥" 行，将该字段实例化为 HashMap()。 第５步：在 "⑦"、"⑧" 行，其功能就是为 "CODE_MAP_CACHE" 字段填入两条数据。 第６步：退出对象初始化方法 <init>()，将生成的对象实例初始化给类字段 "SINGLE_ENUM_RESOLVER"。（注意，此刻该对象实例内的类变量还未初始化完全，刚才由 <init>() 调用 initEnum() 方法赋值的类变量 "CODE_MAP_CACHE" 是 <clinit>() 方法还未初始化字段，它还将在后面的类初始化过程再次被覆盖）。 第７步：继续执行 <clinit>（）方法内的后继代码，"②" 行，该行对 "CODE_MAP_CACHE" 字段实例化为 HashMap 实例（注意：在对象实例化时已经对该字段赋值过了，现在又重新赋值为另一个实例，此刻，"CODE_MAP_CACHE"变量所引用的实例的类变量值被覆盖，到此我们的疑问已经有了答案）。 第8步：类初始化完毕，同时该单态类的实例化工作也完成。 通过对上面的字节码执行过程分析，或许你已经清楚了解到导致错误的深层原因了，也或许你可能早已被上面的分析过程给弄得晕头转向了，不过也没折，虽然我也可以从源代码的角度来阐述问题，但这样不够深度，同时也会有仅为个人观点、不足可信之嫌。 回页首 如何解决 要解决上面代码所存在的问题很简单，那就是将 "SINGLE_ENUM_RESOLVER" 变量的初始化赋值语句转移到 getInstance() 方法中去即可。换句话说就是要避免在类还未初始化完成时从内部实例化该类或在初始化过程中引用还未初始化的字段。 回页首 写在最后 静下浮燥之心，仔细思量自己是否真的掌握了本文主题所引出的知识，如果您觉得您已经完全或基本掌握了，那么很好，在最后，我将前面的代码稍做下修改，请思考下面两组程序是否同样会存在问题呢？ 程序一 public class CachingEnumResolver { public static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //为了说明问题,我在这里初始化一条数据 CODE_MAP_CACHE.put("0","北京市"); initEnums(); } 程序二 public class CachingEnumResolver { private static final CachingEnumResolver SINGLE_ENUM_RESOLVER; public static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //为了说明问题,我在这里初始化一条数据 CODE_MAP_CACHE.put("0","北京市"); SINGLE_ENUM_RESOLVER = new CachingEnumResolver(); initEnums(); } 最后，一点关于 JAVA 群体的感言：时下正是各种开源框架盛行时期，Spring 更是大行其道，吸引着一大批 JEE 开发者的眼球（我也是 fans 中的一员）。然而，让我们仔细观察一下--以 Spring 群体为例，在那么多的 Spring fans 当中，有多少人去研究过 Spring 源代码？又有多少人对 Spring 设计思想有真正深入了解呢？当然，我是没有资格以这样的口吻来说事的，我只是想表明一个观点--学东西一定要"正本清源"。 献上此文，谨以共勉。 关于作者   北京高伟达西南分软 Java EE 软件工程师，三年 Java EE 项目经验，行业方向为银行 OCRM 系统。对 JAVA 有着浓厚的兴趣，业余研究 AOP/ESB 方向。

import java.util.*;

/**

* A tree is a data structure that holds values of type V.

* Each tree has a single value of type V and can have any number of

* branches, each of which is itself a Tree.

*/

public class Tree {

// The value of the tree is of type V.

V value;



// A Tree can have branches, each of which is also a Tree



List<tree branches = new ArrayList<tree();



// Here's the constructor. Note the use of the type variable V.

public Tree(V value) { this.value = value; }



// These are instance methods for manipulating the node value and branches.

// Note the use of the type variable V in the arguments or return types.

V getValue() { return value; }

void setValue(V value) { this.value = value; }

int getNumBranches() { return branches.size(); }

Tree getBranch(int n) { return branches.get(n); }

void addBranch(Tree branch) { branches.add(branch); }

}

中的类型变量V是不受约束的：Tree可以被参数化为任何类型。以前我们常常会设置一些约束条件在需要使用的类型上：也许我们需要强制一个类型参数实现一个或多个接口，或是一个特定类的子类。这可以通过指明类型绑定来完成。我们已经看到了统配符的上界，而且使用简单的语法可以指定一般类型变量的上界。后面的代码，还是使用Tree这个例子，并且通过实现Serializable和Comparable来重写。为了做到这点，例子中使用类型变量绑定来确保值类型的Serializable和Comparable。

import java.io.Serializable;

import java.util.*;



public class Tree>

implements Serializable, Comparable<tree



{

V value;

List<tree branches = new ArrayList<tree();



public Tree(V value) { this.value = value; }



// Instance methods

V getValue() { return value; }

void setValue(V value) { this.value = value; }

int getNumBranches() { return branches.size(); }

Tree getBranch(int n) { return branches.get(n); }

void addBranch(Tree branch) { branches.add(branch); }



// This method is a nonrecursive implementation of Comparable<tree



// It only compares the value of this node and ignores branches.

public int compareTo(Tree that) {

if (this.value == null && that.value == null) return 0;

if (this.value == null) return -1;

if (that.value == null) return 1;

return this.value.compareTo(that.value);

}



// javac -Xlint warns us if we omit this field in a Serializable class

private static final long serialVersionUID = 833546143621133467L;

}

一个类型变量的绑定是通过extends后的名字和一个类型列表（这可以是参数化的，就像Comparable一样）表达的。注意当有不止一个绑定时，就像上面例子中的，绑定的类型要用&作为分隔符，而不是使用逗号。都后用来分隔类型变量，如果用来分隔类型变量绑定，就会模棱两可。一个类型变量可以有任何数量的绑定，包括任何数量的借口和至多一个类。

范型中的通配符
上一章的例子中我们看到了通配符和控制参数化类型的通配符绑定。这些在范型中同样非常有用。当前设计的Tree要求每个节点有相同类型的值，V。也许这样太严格了，也许我们应该让Tree的branches能够存放V的子类而不全是V。这个版本的Tree（删除了Comparable和Serializable接口的实现）这样做会更灵活。

public class Tree {

// These fields hold the value and the branches

V value;

List<tree<? extends V>> branches = new ArrayList<tree<? extends V>>();



// Here's a constructor

public Tree(V value) { this.value = value; }



// These are instance methods for manipulating value and branches

V getValue() { return value; }

void setValue(V value) { this.value = value; }

int getNumBranches() { return branches.size(); }

Tree<? extends V> getBranch(int n) { return branches.get(n); }

void addBranch(Tree<? extends V> branch) { branches.add(branch); }

}

通配符绑定允许我们在枝节点上增加一个Tree，比如，一个树枝Tree：

Tree t = new Tree(0); // Note autoboxing

t.addBranch(new Tree(1));  // int 1 autoboxed to Integer

通过getBranch()查询树枝，而树枝的返回类型不知道，所以必须使用统配符来表达。接下来的两个是合法的，但第三个不是：

Tree<? extends Number> b = t.getBranch(0);

Tree<?> b2 = t.getBranch(0);

Tree b3 = t.getBranch(0); // compilation error

当我们这样来查询一个树枝时，不能精确确定它的返回类型，但是存在类型的上限，所以，我们可以这样做：

Tree<? extends Number> b = t.getBranch(0);

Number value = b.getValue();

那我们不能做什么呢？设定树枝的值，或者在原有的树枝上添加新的树枝。早前章节解释的，上界的存在不会改变返回值的类型不可知，编译器没有足够的信息让我们安全的给setValue()或者一个树枝（包括值类型）的addBranch()传递一个值。下面的两行代码都是非法的：

b.setValue(3.0); // Illegal, value type is unknown

b.addBranch(new Tree(Math.PI));

这个例子在设计时找到了一个平衡点：使用绑定通配符使得数据结构更加灵活，但是减少了安全使用其中方法的可能。这个设计是好是坏就要根据上下文联系了。通常，好的范型设计是非常困难的。幸运的是，大多我们要使用的已经在java.util包中设计好了，而不用我们自己再去设计。

范型方法
　　正如前面说的，范型只能被实例成员调用，而不是静态成员。同实例方法一样，静态方法也可以使用通配符。尽管静态方法不能使用包含他们的类中的类型变量，但是他们可以声明自己的类型变量。当一个方法声明了自己的类型变量，就叫做范型方法。

这里有一个要添加到Tree中的静态方法。他不是一个范型方法，但是使用了绑定的通配符，就好像先前我们看到的sumList()一样：

/** Recursively compute the sum of the values of all nodes on the tree */

public static double sum(Tree<? extends Number> t) {

double total = t.value.doubleValue();

for(Tree<? extends Number> b : t.branches) total += sum(b);

return total;

}

　　通过通配符的上界绑定，声明自己的类型变量来重写这个方法：

public static  double sum(Tree t) {

N value = t.value;

double total = value.doubleValue();

for(Tree<? extends N> b : t.branches) total += sum(b);

return total;

}

　　范型的sum()不比通配符版本的简单，而且声明变量并没有让我们获得什么。这种情况下，通配符方案要比范型方法更有效，当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时，范型方法才是需要的。请看下面的例子：

// This method returns the largest of two trees, where tree size

// is computed by the sum() method. The type variable ensures that 

// both trees have the same value type and that both can be passed to sum().

public static  Tree max(Tree t, Tree u) {

double ts = sum(t);

double us = sum(u);

if (ts > us) return t;

else return u;

}

　　

这个方法使用类型变量N来约束参数和返回值有相同类型，并且参数是Number或者他的子类。

　　使得参数具有相同类型也许是有争议的，应该让我们能调用max()不论是Tree或者Tree。一种方法是使用两个不相干的类型变量来表示两个不相干的值类型。注意，我们不能在方法的返回时使用变量而必须使用通配符：

public static 

Tree<? extends Number> max(Tree t, Tree u) {...}

　　既然两个类型变量N和M没有任何联系，而且每个仅在签名的时候使用，他们没有提供比通配符更多的好处，这种方法最好这样写：

public static Tree<? extends Number> max(Tree<? extends Number> t,

Tree<? extends Number> u) {...}

所有在这里的范型方法都是静态的，这并不是必须的，实例方法也可以声明自己的类型变量。

调用范型方法
当你使用范型时，必须指定实际类型参数来代替相应的类型变量。但这些对范型方法有些不同：编译器总是能计算出基于你所传递的参数的相应范型方法参数。考虑一下上面定义的max()，作为例子：

public static  Tree max(Tree t, Tree u) {...}

当你调用这个方法时，不需要指明N，因为N是隐含地由t和u指明。在后面的代码中，编译器决定N为Integer：

Tree x = new Tree(1);

Tree y = new Tree(2);

Tree z = Tree.max(x, y);

编译器判断范型方法的参数类型称为类型推断。类型推断是相对于知觉推断的。而实际编译器的实现方法是一种非常复杂的过程，超过了这本书的讨论范围。更多的细节在The Java Language Specification, Third Edition的第十五章。
让我们看一个更加复杂的类型推断，考虑一下这个方法：

public class Util {

/** Set all elements of a to the value v; return a. */

public static  T[] fill(T[] a, T v) {

for(int i = 0; i < a.length; i++) a[i] = v;

return a;

}

}

这里有两个该方法的调用：

Boolean[] booleans = Util.fill(new Boolean[100], Boolean.TRUE);

Object o = Util.fill(new Number[5], new Integer(42));

在第一个例子中，编译器可以轻松的推断出T是Boolean类型，第二个例子中，编译器判断T是Number。
在非常罕见的情况下，你可能会显示的指明范型方法的参数类型。有时候这是必要的，比如，当范型方法不需要参数时。考虑一下java.util.Collections.emptySet()：返回一个空集合，但是不同于Collections.singleton()（可以在参考部分察看），他不带任何参数，但需要指明返回类型。通过在方法名前的<>中，可以显示的指明参数类型：

Set empty = Collections.emptySet();

　　类型参数不能同没有限制的方法名结合使用：他们必须跟随在一个.后或者在关键字new后，或者在关键字this前，或者构造函数的super前。
可以证明，如果如果你将Collections.emptySet()的返回值赋给一个变量，就像我们上边通过类型推断机制推断基于变量类型的参数类型。尽管显示的类型说明可以更加清楚，但这不是必要的，可以像下面一样重写：

Set empty = Collections.emptySet();

　　在方法调用表达式中，显示的说明emptySet()的返回值类型是必要的。比如，假设你要调用一个名为printWords()的方法，该方法仅需一个Set的参数，如果你想传递一个空的集合给该方法，就要像下面一样写：

printWords(Collections.emptySet());

这种情况下，显示的类型说明是必要的。

范型方法和数组
早先我们看到，编译器不允许创建一个类型参数化的数组。但是对于范型的使用会是不同的。考虑一下前面定义的Util.fill()，它得以第一个参数和返回值类型都是T[]。而方法体内不必创建任何参数为T的数组，所以这个方法是合法的。

如果你创建一个方法使用varargs（参见第二章的2.6.4）和类型变量，记住调用varargs隐含创建一个数组，请看下面的例子：

/** Return the largest of the specified values or null if there are none */

public static > T max(T... values) { ... }

你可以使用一个Integer类型来调用这个方法，因为编译器会在调用的时候插入必要的数组创建代码。但是你不能将参数转换为Comparable来调用这个方法，因为创建一个Comparable[]是不合法的。

参数化异常
异常是在运行时抛出和捕获的。没有办法让编译器完成类型检查，来保证在catch块中抛出的未知的类型匹配异常。由于这个原因，catch块很可能不包含类型变量和通配符。既然不可能保证在运行时捕获一个编译器时类型参数完整性异常，所以不允许创建任何Throwable类型的子类。参数化异常是不允许的。
但是你可以使用类型变量在throw块里的方法签名中。看看下面的例子：

public interface Command {

public void doit(String arg) throws X;

}

这个接口描述了一个“command”：一块代码只有一个String类型的参数，没有返回值。代码可能抛出一个类型为X的异常。这里有一个例子使用这个接口：

Command save = new Command() {

public void doit(String filename) throws IOException {

PrintWriter out = new PrintWriter(new FileWriter(filename));

out.println("hello world");

out.close();

}

};



try { save.doit("/tmp/foo"); }

catch(IOException e) { System.out.println(e); }

范型个案研究：比较和枚举
Java1.5引入的范型新特性，在1.5的API中有使用，特别多的是在java.util包中，但是在java.lang，java.lang.reflect和java.util.concurrent中也有。这些API都是经过仔细的斟酌创建的，通过学习这些API我们可以学到很多好的设计方法。

java.util中的范形是比较简单的：因为大多都是集合类，类型变量也是代表集合中的元素。java.lang中的几个重要范型是比较难以理解的，他们不是集合，而且第一眼很不容易理解为什么设计成范型。学习这些范型可以让我们更深层次的理解范形的工作机制，并且介绍一些我们没有提到的概念。特别的，我们要检查Comparable接口和Enum类（枚举类型的超类，后面一张讲解）并且学习一些重要但是很少使用的范型特性，比如通配符下界。

在java1.5中，Comparable接口被修改为范型的。大多数的类都实现了这个接口，考虑一下Integer：

public final class Integer extends Number implements Comparable

原先的Comparable接口在类型安全方面是有问题的。两个继承了Comparable接口的对象可能不能相互比较。JDK5.0前，非范形的Comparable接口是非常有用但是不安全的，而现在的接口，捕获了我们需要的信息：他告诉我们一个对象是可比较的，并且可以同什么比较。

现在，考虑一下comparable类的子类。Integer是final的，所以不能有子类，那么让我们看看java.math.BigInteger：

public class BigInteger extends Number implements Comparable

如果我们实现一个BiggerInteger类是BigInteger的子类，他从父类那里继承了Comparable接口，但是注意继承的是Comparable而不是Comparable。这意味着BigInteger和BiggerInteger是可以相互比较的，这是非常好的。BiggerInteger可以重载compareTo()，但是不允许实现一个不同的参数化的Comparable。这就是说BiggerInteger不能同时继承BigInteger和实现Comparable。

当你使用可比较的对象时（当写排序算法的时候）记住两点。首先，使用原生类型是不够充分的：考虑到类型安全，必须指明同什么比较。接下来，类型是不允许同自己比较的：有时候他会同他的祖先比较。为了具体说明，考虑java.util.Collections.max()：

这是一个冗长而且复杂的方法标签，我们来一步步考虑：
方法中包含一个类型变量T，并且有复杂的绑定，稍后我们返回来讨论。
方法的返回值类型是T。
方法名是max()。

方法的参数是一个集合。元素的类型指定为绑定的通配符。我们并不知道元素的确切类型，但直到有一个上限T。所以我们知道元素的类型要么为T，要么是T的子类。集合的任何元素都可以作为返回值使用。

这些是比较简单的，本章我们已经看到了通配符上界，我们再来看看max()中的类型变量声明：

>

要说明的第一点，T必须实现了Comparable接口。（范型的语法使用关键字extends来代表类型绑定，不论是类或接口）这是期望的，因为这个方法是找到集合中最大的元素。但是观察这个参数化的Comparable接口，这是一个通配符，但是这个通过关键字super来绑定，而不是extends。这是下界绑定。? extends T是我们熟悉的上界绑定：这意味着T或者其子类。? super T比较少用：这意味着T或者他的超类。

总结一下，类型变量声明表明：“T是一个实现了Comparable接口或者他的父类实现了该接口的类型。”Collections.min()和Collections.binarySearch()有着相同的声明。
对其他的下界通配符（对于Comparable接口没有作用）的例子，Collections中的addAll()，copy()，和fill()。观察addAll()的声明：

public static  boolean addAll(Collection<? super T> c, T... a)

这是一个varargs方法，接受任意数量的参数，并且传递给他们一个T[]，命名为a。他将a中的所有元素都赋给集合c。集合的元素类型虽然不知道，但是有一个下界：元素均为T或者T的超类。不论类型是什么，我们可以确定数组的元素都是类型的实例，所以将数组的元素添加到集合中是合法的。

返回到我们先前讨论的上界通配符，如果有一个集合的元素是上界通配符，那么都是只读的。考虑List<? extends Serializable>。我们知道，所有的元素都是Serializable，所以像get()这样的方法返回一个Serializable类型的返回值。编译器不允许我们调用add()这样的方法，因为实际的元素类型是不可知的。不能够添加绝对的Serializable对象到list中，因为实现他们的类可能不是正确的类型。

既然上界统配符的结果是只读的，所以你可能会期望下界通配符来实现只写的集合。实际并不是这样，假设这里有一个List<? extends Integer>。元素的实际类型是不知道的，但是可能性是Integer或者他的祖先类Number和Object。无论实际类型是什么，将Integer类型（而不是Number和Object对象）的元素添加到list中是安全的。无论实际类型是什么，list中所有元素都是Object对象的实例，所以list中像get()一样的方法返回Object。

最后，让我们把注意力放到java.lang.Enum类。Enum是所有枚举类型的父类，它实现了Comparable接口，但是有一个让人迷惑的范型声明方法：

public class Enum> implements Comparable, Serializable

第一眼，类型变量E的声明在一个循环中。再仔细的看一看：声明真正说明了，Enum必须是一个本身就是Enum类型的类型。这种表面上的循环是很显然的，如果我们看到了implements子句。正如我们看到的，Comparable类通常被定义为可以同自己比较的。而且他们的子类也可以同他们的父类比较。从另一个方面将，Enum实现了Comparable接口不是为了他本身，而是为了他的子类E。


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


Java, java, J2SE, j2se, J2EE, j2ee, J2ME, j2me, ejb, ejb3, JBOSS, jboss, spring, hibernate, jdo, struts, webwork, ajax, AJAX, mysql, MySQL, Oracle, Weblogic, Websphere, scjp, scjd Java中的泛型 第二部分

ammay 2009-12-14 22:55 发表评论

]]>

public static void main(String[] args) {

    // This list is intended to hold only strings.

    // The compiler doesn't know that so we have to remember ourselves.

    List wordlist = new ArrayList();  



    // Oops! We added a String[] instead of a String.

    // The compiler doesn't know that this is an error.

    wordlist.add(args);



    // Since List can hold arbitrary objects, the get() method returns

    // Object.  Since the list is intended to hold strings, we cast the

    // return value to String but get a ClassCastException because of

    // the error above.

    String word = (String)wordlist.get(0);

}

public static void main(String[] args) {

    // This list can only hold String objects

    List<String> wordlist = new ArrayList<String>();



    // args is a String[], not String, so the compiler won't let us do this

    wordlist.add(args);  // Compilation error!



    // We can do this, though.  

    // Notice the use of the new for/in looping statement

    for(String arg : args) wordlist.add(arg);



    // No cast is required.  List<String>.get() returns a String.

    String word = wordlist.get(0);

}

public static void main(String[] args) {

    // A map from strings to their position in the args[] array

    Map<String,Integer> map = new HashMap<String,Integer>();



    // Note that we use autoboxing to wrap i in an Integer object.

    for(int i=0; i < args.length; i++) map.put(args[i], i);  



    // Find the array index of a word.  Note no cast is required!

    Integer position = map.get("hello");



    // We can also rely on autounboxing to convert directly to an int,

    // but this throws a NullPointerException if the key does not exist 

    // in the map

    int pos = map.get("world");

}

// Look at all those nested angle brackets!

Map<String, List<List<int[]>>> map = getWeirdMap();



// The compiler knows all the types and we can write expressions

// like this without casting.  We might still get NullPointerException

// or ArrayIndexOutOfBounds at runtime, of course.

int value = map.get(key).get(0).get(0)[0];



// Here's how we break that expression down step by step.

List<List<int[]>> listOfLists = map.get(key);

List<int[]> listOfIntArrays = listOfLists.get(0);

int[] array = listOfIntArrays.get(0);

int element = array[0];

List<String> words = // ...initialized elsewhere...

Iterator<String> iterator = words.iterator();

String firstword = iterator.next();

List l = new ArrayList();

l.add("hello");  

l.add(new Integer(123));

Object o = l.get(0);

List<Object> l = new ArrayList<Object>();

l.add("hello");  

l.add(123);              // autoboxing

Object o = l.get(0);

ArrayList<Integer> l = new ArrayList<Integer>();

List<Integer> m = l;                            // okay

Collection<Integer> n = l;                      // okay

ArrayList<Number> o = l;                        // error

Collection<Object> p = (Collection<Object>)l;   // error, even with cast

List<Integer> li = new ArrayList<Integer>();

li.add(123);



// The line below will not compile.  But for the purposes of this

// thought-experiment, assume that it does compile and see how much

// trouble we get ourselves into.

List<Object> lo = li;  



// Now we can retrieve elements of the list as Object instead of Integer

Object number = lo.get(0);



// But what about this?

lo.add("hello world");



// If the line above is allowed then the line below throws ClassCastException

Integer i = li.get(1);  // Can't cast a String to Integer!

// Here's a basic parameterized list.

List<Integer> li = new ArrayList<Integer>();



// It is legal to assign a parameterized type to a nonparameterized variable

List l = li;   



// This line is a bug, but it compiles and runs.

// The Java 5.0 compiler will issue an unchecked warning about it.

// If it appeared as part of a legacy class compiled with Java 1.4, however,

// then we'd never even get the warning.  

l.add("hello");



// This line compiles without warning but throws ClassCastException at runtime.

// Note that the failure can occur far away from the actual bug.

Integer i = li.get(0);

// Here's a basic parameterized list.

List<Integer> li = new ArrayList<Integer>();



// Wrap it for runtime type safety

List<Integer> cli = Collections.checkedList(li, Integer.class);



// Now widen the checked list to the raw type

List l = cli;   



// This line compiles but fails at runtime with a ClassCastException.

// The exception occurs exactly where the bug is, rather than far away

l.add("hello");

String[] words = new String[10];

Object[] objs = words;

objs[0] = 1;  // 1 autoboxed to an Integer, throws ArrayStoreException

List<String>[] wordlists = new ArrayList<String>[10];

ArrayList<Integer> ali = new ArrayList<Integer>();

ali.add(123);

Object[] objs = wordlists;

objs[0] = ali;                       // No ArrayStoreException

String s = wordlists[0].get(0);      // ClassCastException!

public static void printList(PrintWriter out, List list) {

    for(int i=0, n=list.size(); i < n; i++) {

        if (i > 0) out.print(", ");

        out.print(list.get(i).toString());

    }

}

public static void printList(PrintWriter out, List<Object> list) {

    for(int i=0, n=list.size(); i < n; i++) {

        if (i > 0) out.print(", ");

        out.print(list.get(i).toString());

    }

}

public static void printList(PrintWriter out, List<?> list) {

    for(int i=0, n=list.size(); i < n; i++) {

        if (i > 0) out.print(", ");

        Object o = list.get(i);

        out.print(o.toString());

    }

}

List<Object> l = new ArrayList<Object>();

public static double sumList(List<?> list) {

    double total = 0.0;

    for(Object o : list) {

        Number n = (Number) o;  // A cast is required and may fail

        total += n.doubleValue();

    }

    return total;

}

public static double sumList(List<? extends Number> list) {

    double total = 0.0;

    for(Number n : list) total += n.doubleValue();

    return total;

}

泛型是 Sun 公司发布的 JDK 5.0 中的一个重要特性，它的最大优点是提供了程序的类型安全同可以向后兼容。为了帮助读者更好地理解和使用泛型，本文通过一些示例从基本原理，重要概念，关键技术，以及相似技术比较等多个角度对 Java 语言中的泛型技术进行了介绍，重点强调了泛型中的一些基本但又不是很好理解的概念。

为了避免和 C++ 中的模板混淆，本文简要介绍了 Java 中的泛型和 C++ 中的模板的主要区别，希望这种比较能够帮助读者加深对泛型的理解。

引言

很多 Java 程序员都使用过集合（Collection），集合中元素的类型是多种多样的，例如，有些集合中的元素是 Byte 类型的，而有些则可能是 String 类型的，等等。Java 语言之所以支持这么多种类的集合，是因为它允许程序员构建一个元素类型为 Object 的 Collection，所以其中的元素可以是任何类型。

当使用 Collection 时，我们经常要做的一件事情就是要进行类型转换，当转换成所需的类型以后，再对它们进行处理。很明显，这种设计给编程人员带来了极大的不便，同时也容易引入错误。

在很多 Java 应用中，上述情况非常普遍，为了解决这个问题，使 Java 语言变得更加安全好用，近些年的一些编译器对 Java 语言进行了扩充，使 Java 语言支持了"泛型"，特别是 Sun 公司发布的 JDK 5.0 更是将泛型作为其中一个重要的特性加以推广。

本文首先对泛型的基本概念和特点进行简单介绍，然后通过引入几个实例来讨论带有泛型的类，泛型中的子类型，以及范化方法和受限类型参数等重要概念。为了帮助读者更加深刻的理解并使用泛型，本文还介绍了泛型的转化，即，如何将带有泛型的 Java 程序转化成一般的没有泛型的 Java 程序。这样，读者对泛型的理解就不会仅仅局限在表面上了。考虑到多数读者仅仅是使用泛型，因此本文并未介绍泛型在编译器中的具体实现。Java 中的泛型和 C++ 中的模板表面上非常相似，但实际上二者还是有很大区别的，本文最后简单介绍了 Java 中的泛型与 C++ 模板的主要区别。

回页首

泛型概览

泛型本质上是提供类型的"类型参数"，它们也被称为参数化类型（parameterized type）或参量多态（parametric polymorphism）。其实泛型思想并不是 Java 最先引入的，C++ 中的模板就是一个运用泛型的例子。

GJ（Generic Java）是对 Java 语言的一种扩展，是一种带有参数化类型的 Java 语言。用 GJ 编写的程序看起来和普通的 Java 程序基本相同，只不过多了一些参数化的类型同时少了一些类型转换。实际上，这些 GJ 程序也是首先被转化成一般的不带泛型的 Java 程序后再进行处理的，编译器自动完成了从 Generic Java 到普通 Java 的翻译。具体的转化过程大致分为以下几个部分：

• 将参数化类型中的类型参数"擦除"（erasure）掉；
• 将类型变量用"上限（upper bound）"取代，通常情况下这些上限是 Object。这里的类型变量是指实例域，本地方法域，方法参数以及方法返回值中用来标记类型信息的"变量"，例如：实例域中的变量声明 A elem;，方法声明 Node (A elem){};，其中，A 用来标记 elem 的类型，它就是类型变量。
• 添加类型转换并插入"桥方法"（bridge method），以便覆盖（overridden）可以正常的工作。

转化后的程序和没有引入泛型时程序员不得不手工完成转换的程序是非常一致的，具体的转化过程会在后面介绍。GJ 保持了和 Java 语言以及 Java 虚拟机很好的兼容性，下面对 GJ 的特点做一个简要的总结。

• 类型安全。 泛型的一个主要目标就是提高 Java 程序的类型安全。使用泛型可以使编译器知道变量的类型限制，进而可以在更高程度上验证类型假设。如果没有泛型，那么类型的安全性主要由程序员来把握，这显然不如带有泛型的程序安全性高。
• 消除强制类型转换。泛型可以消除源代码中的许多强制类型转换，这样可以使代码更加可读，并减少出错的机会。
• 向后兼容。支持泛型的 Java 编译器（例如 JDK5.0 中的 Javac）可以用来编译经过泛型扩充的 Java 程序（GJ 程序），但是现有的没有使用泛型扩充的 Java 程序仍然可以用这些编译器来编译。
• 层次清晰，恪守规范。无论被编译的源程序是否使用泛型扩充，编译生成的字节码均可被虚拟机接受并执行。也就是说不管编译器的输入是 GJ 程序，还是一般的 Java 程序，经过编译后的字节码都严格遵循《Java 虚拟机规范》中对字节码的要求。可见，泛型主要是在编译器层面实现的，它对于 Java 虚拟机是透明的。
• 性能收益。目前来讲，用 GJ 编写的代码和一般的 Java 代码在效率上是非常接近的。 但是由于泛型会给 Java 编译器和虚拟机带来更多的类型信息，因此利用这些信息对 Java 程序做进一步优化将成为可能。

以上是泛型的一些主要特点，下面通过几个相关的例子来对 Java 语言中的泛型进行说明。

回页首

带有泛型的类

为了帮助大家更好地理解 Java 语言中的泛型，我们在这里先来对比两段实现相同功能的 GJ 代码和 Java 代码。通过观察它们的不同点来对 Java 中的泛型有个总体的把握，首先来分析一下不带泛型的 Java 代码，程序如下：

1	interface Collection {
            2	   	public void add (Object x);
            3		public Iterator iterator ();
            4	}
            5
            6	interface Iterator {
            7	   	public Object next ();
            8		public boolean hasNext ();
            9	}
            10
            11	class NoSuchElementException extends RuntimeException {}
            12
            13	class LinkedList implements Collection {
            14
            15		protected class Node {
            16		   	Object elt;
            17			Node next = null;
            18			Node (Object elt) { this.elt = elt; }
            19		}
            20
            21		protected Node head = null, tail = null;
            22
            23		public LinkedList () {}
            24
            25		public void add (Object elt) {
            26			if (head == null) { head = new Node(elt); tail = head; }
            27			else { tail.next = new Node(elt); tail = tail.next; }
            28		}
            29
            30		public Iterator iterator () {
            31
            32			return new Iterator () {
            33				protected Node ptr = head;
            34				public boolean hasNext () { return ptr != null; }
            35				public Object next () {
            36					if (ptr != null) {
            37						Object elt = ptr.elt; ptr = ptr.next; return elt;
            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|
            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|
            38					} else throw new NoSuchElementException ();
            39				}
            40			};
            41		}
            42	}
            

接口 Collection 提供了两个方法，即添加元素的方法 add(Object x)，见第 2 行，以及返回该 Collection 的 Iterator 实例的方法 iterator()，见第 3 行。Iterator 接口也提供了两个方法，其一就是判断是否有下一个元素的方法 hasNext()，见第 8 行，另外就是返回下一个元素的方法 next()，见第 7 行。LinkedList 类是对接口 Collection 的实现，它是一个含有一系列节点的链表，节点中的数据类型是 Object，这样就可以创建任意类型的节点了，比如 Byte， String 等等。上面这段程序就是用没有泛型的传统的 Java 语言编写的代码。接下来我们分析一下传统的 Java 语言是如何使用这个类的。

代码如下：

1	class Test {
            2		    public static void main (String[] args) {
            3			// byte list
            4			LinkedList xs = new LinkedList();
            5			xs.add(new Byte(0)); xs.add(new Byte(1));
            6			Byte x = (Byte)xs.iterator().next();
            7			// string list
            8			LinkedList ys = new LinkedList();
            9			ys.add("zero"); ys.add("one");
            10			String y = (String)ys.iterator().next();
            11			// string list list
            12			LinkedList zss = new LinkedList();
            13			zss.add(ys);
            14			String z = (String)((LinkedList)zss.iterator().next()).iterator().next();
            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|
            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|
            15			// string list treated as byte list
            16			Byte w = (Byte)ys.iterator().next(); // run-time exception
            17			}
            18	}
            

从上面的程序我们可以看出，当从一个链表中提取元素时需要进行类型转换，这些都要由程序员显式地完成。如果我们不小心从 String 类型的链表中试图提取一个 Byte 型的元素，见第 15 到第 16 行的代码，那么这将会抛出一个运行时的异常。请注意，上面这段程序可以顺利地经过编译，不会产生任何编译时的错误，因为编译器并不做类型检查，这种检查是在运行时进行的。不难发现，传统 Java 语言的这一缺陷推迟了发现程序中错误的时间，从软件工程的角度来看，这对软件的开发是非常不利的。接下来，我们讨论一下如何用 GJ 来实现同样功能的程序。源程序如下：

1	interface Collection<A> {
            2		public void add(A x);
            3		public Iterator<A> iterator();
            4	}
            5
            6	interface Iterator<A> {
            7		public A next();
            8		public boolean hasNext();
            9	}
            10
            11	class NoSuchElementException extends RuntimeException {}
            12
            13	class LinkedList<A> implements Collection<A> {
            14		protected class Node {
            15			A elt;
            16			Node next = null;
            17			Node (A elt) { this.elt = elt; }
            18		}
            19
            20		protected Node head = null, tail = null;
            21
            22		public LinkedList () {}
            23
            24		public void add (A elt) {
            25			if (head == null) { head = new Node(elt); tail = head; }
            26			else { tail.next = new Node(elt); tail = tail.next; }
            27		}
            28
            29		public Iterator<A> iterator () {
            30			return new Iterator<A> () {
            31				protected Node ptr = head;
            32				public boolean hasNext () { return ptr != null; }
            33				public A next () {
            34					if (ptr != null) {
            35						A elt = ptr.elt; ptr = ptr.next; return elt;
            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|
            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|
            36					} else throw new NoSuchElementException ();
            37				}
            38			};
            39	 	}
            40	}
            

程序的功能并没有任何改变，只是在实现方式上使用了泛型技术。我们注意到上面程序的接口和类均带有一个类型参数 A，它被包含在一对尖括号（< >）中，见第 1，6 和 13 行，这种表示法遵循了 C++ 中模板的表示习惯。这部分程序和上面程序的主要区别就是在 Collection, Iterator, 或 LinkedList 出现的地方均用 Collection<A>, Iterator<A>, 或 LinkedList<A> 来代替，当然，第 22 行对构造函数的声明除外。

下面再来分析一下在 GJ 中是如何对这个类进行操作的，程序如下：

1	class Test {
            2		public static void main (String [] args) {
            3			// byte list
            4			LinkedList<Byte> xs = new LinkedList<Byte>();
            5			xs.add(new Byte(0)); xs.add(new Byte(1));
            6			Byte x = xs.iterator().next();
            7			// string list
            8			LinkedList<String> ys = new LinkedList<String>();
            9			ys.add("zero"); ys.add("one");
            10			String y = ys.iterator().next();
            11			// string list list
            12			LinkedList<LinkedList<String>>zss=
            newLinkedList<LinkedList<String>>();
            13			zss.add(ys);
            14			String z = zss.iterator().next().iterator().next();
            15			// string list treated as byte list
            16			Byte w = ys.iterator().next(); // compile-time error
            17		}
            18	}
            

在这里我们可以看到，有了泛型以后，程序员并不需要进行显式的类型转换，只要赋予一个参数化的类型即可，见第 4，8 和 12 行，这是非常方便的，同时也不会因为忘记进行类型转换而产生错误。另外需要注意的就是当试图从一个字符串类型的链表里提取出一个元素，然后将它赋值给一个 Byte 型的变量时，见第 16 行，编译器将会在编译时报出错误，而不是由虚拟机在运行时报错，这是因为编译器会在编译时刻对 GJ 代码进行类型检查，此种机制有利于尽早地发现并改正错误。

类型参数的作用域是定义这个类型参数的整个类，但是不包括静态成员函数。这是因为当访问同一个静态成员函数时，同一个类的不同实例可能有不同的类型参数，所以上述提到的那个作用域不应该包括这些静态函数，否则就会引起混乱。

回页首

泛型中的子类型

在 Java 语言中，我们可以将某种类型的变量赋值给其父类型所对应的变量，例如，String 是 Object 的子类型，因此，我们可以将 String 类型的变量赋值给 Object 类型的变量，甚至可以将 String [ ] 类型的变量（数组）赋值给 Object [ ] 类型的变量，即 String [ ] 是 Object [ ] 的子类型。

上述情形恐怕已经深深地印在了广大读者的脑中，对于泛型来讲，上述情形有所变化，因此请广大读者务必引起注意。为了说明这种不同，我们还是先来分析一个小例子，代码如下所示：

1			List<String> ls = new ArrayList<String>();
            2			List<Object> lo = ls;
            3	lo.add(new Integer());
            4	String s = ls.get(0);
            

上述代码的第二行将 List<String> 赋值给了 List<Object>，按照以往的经验，这种赋值好像是正确的，因为 List<String> 应该是 List<Object> 的子类型。这里需要特别注意的是，这种赋值在泛型当中是不允许的！List<String> 也不是 List<Object> 的子类型。

如果上述赋值是合理的，那么上面代码的第三行的操作将是可行的，因为 lo 是 List<Object>，所以向其添加 Integer 类型的元素应该是完全合法的。读到此处，我们已经看到了第二行的这种赋值所潜在的危险，它破坏了泛型所带来的类型安全性。

一般情况下，如果 A 是 B 的子类型，C 是某个泛型的声明，那么 C<A> 并不是 C<B> 的子类型，我们也不能将 C<A> 类型的变量赋值给 C<B> 类型的变量。这一点和我们以前接触的父子类型关系有很大的出入，因此请读者务必引起注意。

回页首

泛化方法和受限类型参数

在这一部分我们将讨论有关泛化方法（generic method ）和受限类型参数（bounded type parameter）的内容，这是泛型中的两个重要概念，还是先来分析一下与此相关的代码。

1	interface Comparable<A> {
            2		public int compareTo(A that);
            3	}
            4
            5	class Byte implements Comparable<Byte> {
            6		private byte value;
            7		public Byte(byte value) {this.value = value;}
            8		public byte byteValue() {return value;}
            9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            12	}
            13
            14	class Collections {
            15		public static <A implements Comparable<A>>
            16	            A max (Collection<A> xs) {
            17			    	Iterator<A> xi = xs.iterator();
            18			    	A w = xi.next();
            19			    	while (xi.hasNext()) {
            20						A x = xi.next();
            21						if (w.compareTo(x) < 0) w = x;
            22					}
            23					return w;
            24		}
            25	}
            

这里定义了一个接口 Comparable<A>，用来和 A 类型的对象进行比较。类 Byte 实现了这个接口，并以它自己作为类型参数，因此，它们自己就可以和自己进行比较了。

第 14 行到第 25 行的代码定义了一个类 Collections，这个类包含一个静态方法 max(Collection<A> xs)，它用来在一个非空的 Collection 中寻找最大的元素并返回这个元素。这个方法的两个特点就是它是一个泛化方法并且有一个受限类型参数。

之所以说它是泛化了的方法，是因为这个方法可以应用到很多种类型上。当要将一个方法声明为泛化方法时，我们只需要在这个方法的返回类型（A）之前加上一个类型参数（A），并用尖括号（< >）将它括起来。这里的类型参数（A）是在方法被调用时自动实例化的。例如，假设对象 m 的类型是 Collection<Byte>，那么当使用下面的语句：

Byte x = Collections.max(m);
            

调用方法 max 时，该方法的参数 A 将被推测为 Byte。

根据上面讨论的内容，泛化方法 max 的完整声明应该是下面的形式：

            < A >  A max (Collection<A> xs) {
            max 的方法体
            }
            

但是，我们见到的 max 在 < A > 中还多了 "implements Comparable<A>" 一项，这是什么呢？这就是我们下面将要谈到的"受限的类型参数"。在上面的例子中，类型参数 A 就是一个受限的的类型参数，因为它不是泛指任何类型，而是指那些自己和自己作比较的类型。例如参数可以被实例化为 Byte，因为程序中有 Byte implements Comparable<Byte> 的语句，参见第 5 行。这种限制（或者说是范围）通过如下的方式表示，"类型参数 implements 接口"，或是 "类型参数 extend 类"，上面程序中的"Byte implements Comparable<Byte>"就是一例。

回页首

泛型的转化

在前面的几部分内容当中，我们介绍了有关泛型的基础知识，到此读者对 Java 中的泛型技术应该有了一定的了解，接下来的这部分内容将讨论有关泛型的转化，即如何将带有泛型的 Java 代码转化成一般的没有泛型 Java 代码。其实在前面的部分里，我们或多或少地也提到了一些相关的内容，下面再来详细地介绍一下。

首先需要明确的一点是上面所讲的这种转化过程是由编译器（例如：Javac）完成的，虚拟机并不负责完成这一任务。当编译器对带有泛型的 Java 代码进行编译时，它会去执行类型检查和类型推断，然后生成普通的不带泛型的字节码，这种字节码可以被一般的Java虚拟机接收并执行，这种技术被称为擦除（erasure）。

可见，编译器可以在对源程序（带有泛型的 Java 代码）进行编译时使用泛型类型信息保证类型安全，对大量如果没有泛型就不会去验证的类型安全约束进行验证，同时在生成的字节码当中，将这些类型信息清除掉。

对于不同的情况，擦除技术所执行的"擦除"动作是不同的，主要分为以下几种情况：

• 对于参数化类型，需要删除其中的类型参数，例如，LinkedList<A> 将被"擦除"为 LinkedList；
• 对于非参数化类型，不作擦除，或者说用它自己来擦除自己，例如 String 将被"擦除"为 String；
• 对于类型变量（有关类型变量的说明请参考"泛型概览"相关内容），要用它们的上限来对它们进行替换。多数情况下这些上限是 Object，但是也有例外，后面的部分将会对此进行介绍。

除此之外，还需要注意的一点是，在某些情况下，擦除技术需要引入类型转换（cast），这些情况主要包括：

情况 1. 方法的返回类型是类型参数；

情况 2. 在访问数据域时，域的类型是一个类型参数。

例如在本文"带有泛型的类"一小节的最后，我们给出了一段测试程序，一个 Test 类。这个类包含以下几行代码：

8			LinkedList<String> ys = new LinkedList<String>();
            9			ys.add("zero"); ys.add("one");
            10			String y = ys.iterator().next();
            这部分代码转换后就变成了如下的代码：
            8	       	LinkedList ys = new LinkedList();
            9           ys.add("zero"); ys.add("one");
            10	String y = (String)ys.iterator().next();
            

第 10 行的代码进行了类型转换，这是因为在调用 next() 方法时，编译器发现该方法的返回值类型是类型参数 A（请参见对方法 next() 的定义），因此根据上面提到的情况 1，需要进行类型转换。

上面介绍了泛型转化中的擦除技术，接下来，我们讨论一下泛型转化中的另外一个重要问题－－桥方法（bridge method）。

Java 是一种面向对象的语言，因此覆盖（overridden）是其中的一项重要技术。覆盖能够正常"工作"的前提是方法名和方法的参数类型及个数完全匹配（参数的顺序也应一致），为了满足这项要求，编译器在泛型转化中引入了桥方法（bridge method）。接下来，我们通过一个例子来分析一下桥方法在泛型转化中所起的作用。在本文"泛化方法和受限类型参数"一小节所给出的代码中，第 9 行到第 11 行的程序如下所示：

    9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            这部分代码经过转化，就变成了下面的样子：
            9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            12  public int compareTo(Object that){
            13			return this.compareTo((Byte)that);
            14		}
            

第 12 行的方法 compareTo(Object that) 就是一个桥方法，在这里引入这个方法是为了保证覆盖能够正常的发生。我们在前面提到过，覆盖必须保证方法名和参数的类型及数目完全匹配，在这里通过引入这个"桥"即可达到这一目的，由这个"桥"进行类型转换，并调用第 9 行参数类型为 Byte 的方法 compareTo(Byte that)，需要注意的一点是这里的 "Object" 也并不一定是完全匹配的类型，但由于它是 Java 语言中类层次结构的根，所以这里用 "Object" 可以接受其他任何类型的参数。

根据面向对象的基本概念，我们知道，重载（overloading）允许桥方法和原来的方法共享同一个方法名，正如上面例子所显示的那样，因此桥方法的引入是完全合法的。一般情况下，当一个类实现了一个参数化的接口或是继承了一个参数化的类时，需要引入桥方法。

到此，我们对泛型中的子类型，带有泛型的类，泛化方法，受限类型参数以及泛型的转化进行了简要的介绍，下面部分将结合这些技术对前面提到的例子进行一下总结，以便能够帮助读者更深刻更全面地理解泛型。

首先来分析一下本文提到的那个 Collection 的例子。这里先是定义了两个接口 Collection 和 Iterator，然后又定义了一个对接口 Collection 的一个实现 LinkedList。根据上面所介绍的对泛型的转化过程，这段代码转化后的 Java 程序为：

1	interface Collection {
            2	   	public void add (Object x);
            3	        public Iterator iterator ();
            4	}
            5
            6	interface Iterator {
            7	       	public Object next ();
            8	        public boolean hasNext ();
            9	}
            10
            11	class NoSuchElementException extends RuntimeException {}
            12
            13	class LinkedList implements Collection {
            14
            15		protected class Node {
            16	       	Object elt;
            17	        Node next = null;
            18	        Node (Object elt) { this.elt = elt; }
            19		}
            20
            21		protected Node head = null, tail = null;
            22
            23		public LinkedList () {}
            24
            25		public void add (Object elt) {
            26	       	if (head == null) {
            27		       	head = new Node(elt); tail = head;
            28			} else {
            29		       	tail.next = new Node(elt); tail = tail.next;
            30			}
            31		}
            32
            33		public Iterator iterator () {
            34	       	return new Iterator () {
            35		       	protected Node ptr = head;
            36	            public boolean hasNext () { return ptr != null; }
            37		       	public Object next () {
            38			       	if (ptr != null) {
            39				       	Object elt = ptr.elt; ptr = ptr.next; return elt;
            40					} else {
            41				       		throw new NoSuchElementException ();
            42						}
            43				}
            44			};
            45		}
            46	}
            

通过分析上述代码，我们不难发现，所有参数化类型 Collection, Iterator 和 LinkedList 中的类型参数 "A" 全都被擦除了。另外，剩下的类型变量 "A" 都用其上限进行了替换，这里的上限是 Object，见黑体字标出的部分，这是转化的关键部分。

下面我们分析一下在介绍有关泛化方法（generic method）和受限类型参数（bounded type parameter）时举的那个例子，该段 GJ 代码经过转换后的等价 Java 程序如下所示：

1	interface Comparable {
            2		public int compareTo(Object that);
            3	}
            4
            5	class Byte implements Comparable {
            6		private byte value;
            7		public Byte(byte value) {this.value = value;}
            8		public byte byteValue(){return value;}
            9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            12      public int compareTo(Object that){
            13			return this.compareTo((Byte)that);
            14		}
            15	}
            16
            17	class Collections {
            18		public static Comparable max(Collection xs){
            19			Iterator xi = xs.iterator();
            20			Comparable w = (Comparable)xi.next();
            21			while (xi.hasNext()) {
            22				Comparable x = (Comparable)xi.next();
            23				if (w.compareTo(x) < 0) w = x;
            23			}
            24			return w;
            25		}
            26	}
            

同样请读者注意黑体字标出的部分，这些关键点我们在前面已经介绍过了，故不赘述。唯一需要注意的一点就是第 18，20，22 行出现的Comparable。在泛型转化中，类型变量应该用其上限来替换，一般情况下这些上限是 "Object"，但是当遇到受限的类型参数时，这个上限就不再是 "Object" 了，编译器会用限制这些类型参数的类型来替换它，上述代码就用了对 A 进行限制的类型 "Comparable" 来替换 A。

桥方法的引入，为解决覆盖问题带来了方便，但是这种方法还存在一些问题，例如下面这段代码：

1	interface Iterator<A> {
            2		public boolean hasNext ();
            3		public A next ();
            4	}
            5	class Interval implements Iterator<Integer> {
            6		private int i;
            7		private int n;
            8		public Interval (int l, int u) { i = l; n = u; }
            9		public boolean hasNext () { return (i <= n); }
            10		public Integer next () { return new Integer(i++); }
            11	}
            

根据以上所讲的内容，这部分代码转换后的 Java 程序应该是如下这个样子：

1	interface Iterator {
            2
            3		public boolean hasNext ();
            4		public Object next ();
            5
            6	}
            7
            8	class Interval implements Iterator {
            9
            10		private int i;
            11		private int n;
            12		public Interval (int l, int u) { i = l; n = u; }
            13		public boolean hasNext () { return (i <= n); }
            14		public Integer next%1% () { return new Integer(i++); }
            15		// bridge
            16		public Object next%2%() { return next%1%(); }
            17
            18	}
            

相信有些读者已经发现了这里的问题，这不是一段合法的 Java 源程序，因为第 14 行和第 16 行的两个 next() 有相同的参数，无法加以区分。代码中的 %1% 和 %2% 是为了区分而人为加入的，并非 GJ 转化的结果。

不过，这并不是什么太大的问题，因为 Java 虚拟机可以区分这两个 next() 方法，也就是说，从 Java 源程序的角度来看，上述程序是不正确的，但是当编译成字节码时，JVM 可以对两个 next() 方法进行识别。这是因为，在 JVM 中，方法定义时所使用的方法签名包括方法的返回类型，这样一来，只要 GJ 编译出的字节码符合Java字节码的规范即可，这也正好说明了 GJ 和 JVM 中字节码规范要求的一致性！

最后，值得一提的是，JDK 5.0 除了在编译器层面对 Java 中的泛型进行了支持，Java 的类库为支持泛型也做了相应地调整，例如，集合框架中所有的标准集合接口都进行了泛型化，同时，集合接口的实现也都进行了相应地泛型化。

回页首

Java 中的泛型与 C++ 模板的比较

GJ 程序的语法在表面上与 C++ 中的模板非常类似，但是二者之间有着本质的区别。

首先，Java 语言中的泛型不能接受基本类型作为类型参数――它只能接受引用类型。这意味着可以定义 List<Integer>，但是不可以定义 List<int>。

其次，在 C++ 模板中，编译器使用提供的类型参数来扩充模板，因此，为 List<A> 生成的 C++ 代码不同于为 List<B> 生成的代码，List<A> 和 List<B> 实际上是两个不同的类。而 Java 中的泛型则以不同的方式实现，编译器仅仅对这些类型参数进行擦除和替换。类型 ArrayList<Integer> 和 ArrayList<String> 的对象共享相同的类，并且只存在一个 ArrayList 类。

回页首

总结

本文通过一些示例从基本原理，重要概念，关键技术，以及相似技术比较等多个角度对 Java 语言中的泛型技术进行了介绍，希望这种介绍方法能够帮助读者更好地理解和使用泛型。本文主要针对广大的 Java 语言使用者，在介绍了泛型的基本概念后，重点介绍了比较底层的泛型转化技术，旨在帮助读者更加深刻地掌握泛型，笔者相信这部分内容可以使读者避免对泛型理解的表面化，也所谓知其然更知其所以然。

参考资料

• 诊断 Java 代码: 轻松掌握 Java 泛型（developerWorks，2003 年 5 月）：在本文当中，Eric Allen 通过描述诸如基本类型限制和多态方法等特性来说明泛型的优缺点。
  
  
• Java 理论和实践: 了解泛型（developerWorks，2005 年 1 月）：在本文当中，Brian Goetz 通过示例分析了刚刚接触泛型的新用户常犯的错误，从反面给用户以警示。
  
  
• 介绍 JDK 5.0 中的泛型（developerWorks，2004 年 12 月）：一篇关于 JDK 5.0 中的泛型的教程，该教程解释了在 Java 语言中引入泛型的动机，详细介绍了泛型的语法和语义，并讲述了如何在自己的类中使用泛型。
  
  
• 驯服 Tiger系列专栏：详细地讨论有关 Java SE 5 平台的改变，并提供一些例子作为快速参考。
  
  
• Java 理论与实践系列专栏：探索设计模式，可靠软件设计原则，以及应用于实际问题的“最佳实践”。
  
  
• GJ: Extending the Java programming language with type parameters：Gilad Bracha, Martin Odersky 等人写的一篇介绍 GJ 基本概念的文章。
  
  
• Generics in the Java Programming Language：Gilad Bracha 写的一篇详细介绍 JDK 5.0 中的泛型的文章。

关于作者

		周晶，2006年4月毕业于北京航空航天大学计算机学院，获计算机硕士学位。主要研究领域为高级编译技术，Java虚拟机技术。 beyond.zhou@gmail.com

因此在函数中使用以下语句是非法的。
ALTER 'CACHE INDEX' CALL COMMIT CREATE DELETE
DROP 'FLUSH PRIVILEGES' GRANT INSERT KILL
LOCK OPTIMIZE REPAIR REPLACE REVOKE
ROLLBACK SAVEPOINT 'SELECT FROM table'
'SET system variable' 'SET TRANSACTION'
SHOW 'START TRANSACTION' TRUNCATE UPDATE

在触发器中也有完全一样的限制.触发器相对而言比较新，因此会有（bugs）缺陷.所以我在这里给大家警告，就像我在存储过程书中所说那样.不要在含有重要数据的数据库中使用这个触发器，如果需要的话在一些以测试为目的的数据库上使用，同时在你对表创建触发器时确认这些数据库是默认的。

语法
1. 语法：命名规则

CREATE TRIGGER <触发器名称> <--
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名称>
FOR EACH ROW
<触发器SQL语句>
触发器必须有名字，最多64个字符，可能后面会附有分隔符.它和MySQL中其他对象的命名方式基本相象.

这里我有个习惯：就是用表的名字＋'_'＋触发器类型的缩写.因此如果是表t26，触发器是在事件UPDATE（参考下面的点（2）和（3））之前（BEFORE）的，那么它的名字就是t26_bu。
2. 语法：触发时间

CREATE TRIGGER <触发器名称>
{ BEFORE | AFTER } <--
{ INSERT | UPDATE | DELETE }
ON <表名称>
FOR EACH ROW
<触发的SQL语句>

触发器有执行的时间设置：可以设置为事件发生前或后。

3. 语法：事件

CREATE TRIGGER <触发器名称>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE } <--
ON <表名称>
FOR EACH ROW
<触发的SQL语句>

同样也能设定触发的事件：它们可以在执行insert、update或delete的过程中触发。
4. 语法：表

CREATE TRIGGER <触发器名称>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名称> <--
FOR EACH ROW
<触发的SQL语句>

触发器是属于某一个表的:当在这个表上执行插入、
更新或删除操作的时候就导致触发器的激活.
我们不能给同一张表的同一个事件安排两个触发器。

5. 语法：（ 步长）触发间隔

CREATE TRIGGER <触发器名称>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名称>
FOR EACH ROW <--
<触发的SQL语句>

触发器的执行间隔：FOR EACH ROW子句通知触发器
每隔一行执行一次动作，而不是对整个表执行一次。

6. 语法：语句

CREATE TRIGGER <触发器名称>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名称>
FOR EACH ROW
<触发的SQL语句> <--

触发器包含所要触发的SQL语句：这里的语句可以是任何合法的语句，
包括复合语句，但是这里的语句受的限制和函数的一样。
Privileges权限

你必须拥有相当大的权限才能创建触发器（CREATE TRIGGER）。
如果你已经是Root用户，那么就足够了。这跟SQL的标准有所不同。

因此在下一个版本的MySQL中，
你完全有可能看到有一种叫做CREATE TRIGGER的新权限。
然后通过这样的方法赋予：
GRANT CREATE TRIGGER ON <表名称> TO <用户或用户列表>;
也可以通过这样收回权限：
REVOKE CREATE TRIGGER ON <表名称> FROM <用户或用户列表>;
关于旧的和新创建的列的标识

在触发器的SQL语句中，你可以关联表中的任意列。但你不能仅使用列的名称去标识，那会使系统混淆，因为那里可能会有列的新名（这可能正是你要修改的，你的动作可能正是要修改列名），还有列的旧名存在。因此你必须用这样的语法来标识： "NEW . column_name"或者"OLD . column_name".这样在技术上处理（NEW | OLD . column_name）新和旧的列名属于创建了过渡变量（"transition variables"）。

对于INSERT语句,只有NEW是合法的；对于DELETE语句，只有OLD才合法；而UPDATE语句可以在和NEW以及OLD同时使用。下面是一个UPDATE中同时使用NEW和OLD的例子。
CREATE TRIGGER t21_au
BEFORE UPDATE ON t22
FOR EACH ROW
BEGIN
SET @old = OLD . s1;
SET @new = NEW.s1;
END;//

现在如果t21表中的s1列的值是55，那么执行了
"UPDATE t21 SET s1 = s1 + 1"之后@old的值会变成55，
而@new的值将会变成56。Example of CREATE and INSERT CREATE和INSERT的例子
创建有触发器的表
这里所有的例程中我都假定大家的分隔符已经设置成//（DELIMITER //）。
CREATE TABLE t22 (s1 INTEGER)//
CREATE TRIGGER t22_bi
BEFORE INSERT ON t22
FOR EACH ROW
BEGIN
SET @x = 'Trigger was activated!';
SET NEW.s1 = 55;
END;//
在最开始我创建了一个名字为t22的表，然后在表t22上创建了一个触发器t22_bi，当我们要向表中的行插入时，触发器就会被激活，执行将s1列的值改为55的动作。

使用触发器执行插入动作

mysql> INSERT INTO t22 VALUES (1)//

让我们看如果向表t2中插入一行数据触发器对应的表会怎么样？ 这里的插入的动作是很常见的，我们不需要触发器的权限来执行它。甚至不需要知道是否有触发器关联。
mysql> SELECT @x, t22.* FROM t22//
+------------------------+------+
| @x | s1 |
+------------------------+------+
| Trigger was activated! | 55 |
+------------------------+------+
1 row in set (0.00 sec)
大家可以看到INSERT动作之后的结果，和我们预期的一样，x标记被改动了，同时这里插入的数据不是我们开始输入的插入数据，而是触发器自己的数据。
"check"完整性约束例子
什么是"check"约束
在标准的SQL语言中，我们可以在（CREATE TABLE）创建表的过程中使用"CHECK (condition)"，
例如：
CREATE TABLE t25
(s1 INT, s2 CHAR(5), PRIMARY KEY (s1),
CHECK (LEFT(s2,1)='A'))
ENGINE=INNODB;
这里CHECK的意思是"当s2列的最左边的字符不是'A'时，insert和update语句都会非法"，MySQL的视图不支持CHECK，我个人是很希望它能支持的。但如果你很需要在表中使用这样的功能，我建议大家使用触发器来实现。
CREATE TABLE t25
(s1 INT, s2 CHAR(5),
PRIMARY KEY (s1))
ENGINE=INNODB//

CREATE TRIGGER t25_bi
BEFORE INSERT ON t25
FOR EACH ROW
IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;//

CREATE TRIGGER t25_bu
BEFORE UPDATE ON t25
FOR EACH ROW
IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;//
我只需要使用BEFORE INSERT和BEFORE UPDATE语句就行了，删除了触发器不会对表有影响，同时AFTER的触发器也不能修改NEW的过程变量（transition variables）。为了激活触发器，我执行了向表中的行插入s1＝0的数据，之后只要执行符合LEFT(s2,1) <> 'A'条件的动作都会失败：
INSERT INTO t25 VALUES (0,'a') /* priming the pump */ //
INSERT INTO t25 VALUES (5,'b') /* gets error '23000' */ //
Don't Believe The Old MySQL Manual

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/crazy_rain/archive/2007/07/05/1680128.aspx

ANT工程配置

终于把ANT搞定了，现在发布一个通用的ANT的build.xml文件，以备后用。

Java代码

1. <project name="hnwt114" default="build" basedir=".">   
2.     <!-- 工程根目录 -->   
3.     <property name="hnwt144.home" value="."/>   
4.     <!-- 工程根名 -->   
5.     <property name="hnwt144.name" value="HNWT114"/>   
6.     <!-- tomcat路径 -->   
7.     <property name="tomcat.home" value="D:\apache-tomcat-5.5.26"/>   
8.     <!-- tomcat部署路径 -->   
9.     <property name="webapps.home" value="${tomcat.home}/webapps"/>   
10.     <!-- JAVA源文件路径 -->   
11.     <property name="src.home" value="${hnwt144.home}/src"/>   
12.        
13.     <!-- class文件存放位置 -->   
14.     <property name="classes.home" value="${hnwt144.home}/classes"/>   
15.     <!-- 发布文件夹 -->   
16.     <property name="deploy.home" value="${hnwt144.home}/deploy"/>   
17.     <!-- webRoot路径 -->   
18.     <property name="web.home" value="${hnwt144.home}/webRoot"/>   
19.        
20.     <!-- 创建工程路径 -->   
21.     <property name="build.home" value="${hnwt144.home}/build"/>   
22.     <!-- /WEB-INF/classes -->   
23.     <property name="build.classes" value="${hnwt144.home}/WEB-INF/classes"/>   
24.     <!-- /WEB-INF/lib -->   
25.     <property name="build.lib" value="${hnwt144.home}/WEB-INF/lib"/>   
26.     <!-- 工程引用包 -->   
27.     <property name="lib.home" value="${web.home}/WEB-INF/lib"/>   
28.        
29.        
30.     <!-- 编译工程所需的JAR包 -->   
31.     <path id="compile.classpath">   
32.         <pathelement location="${classes.home}"/>   
33.         <fileset dir="${lib.home}">   
34.                 <include name="*.jar"/>   
35.                 <include name="*.zip"/>   
36.         </fileset>   
37.         <fileset dir="${tomcat.home}/common/lib">   
38.             <include name="*.jar"/>   
39.         </fileset>   
40.         <pathelement location="${tomcat.home}/common/classes"/>   
41.     </path>   
42.        
43.        
44.     <!-- 测试ANT -->   
45.     <target name="help">   
46.         <echo message="Please specify a target![usage:ant&lt;targetname&gt;]"/>   
47.         <echo message="Here is a list of possible targets:"/>   
48.         <echo message="  clean-all....Delete build dir,all .class and war files"/>   
49.         <echo message="  perpare....Creates directories if requied"/>   
50.         <echo message="  compile....Compiles source files"/>   
51.         <echo message="  build......Build war file from.class and other files"/>   
52.         <echo message="  deploy......Copy war file to the webapps directory"/>   
53.     </target>   
54.        
55.        
56.     <!-- 清除 -->   
57.     <target name="clean-all">   
58.         <delete dir="${build.home}"/>   
59.         <delete dir="${classes.home}"/>   
60.         <delete dir="${deploy.home}"/>   
61.            
62.         <delete dir="${webapps.home}/${hnwt114.home}" failonerror="false"/>   
63.         <delete dir="${webapps.home}/${hnwt114.name}.war"/>   
64.     </target>   
65.        
66.        
67.     <!-- 准备工作 -->   
68.     <target name="prepare">   
69.         <echo message="Tomcat Home=${tomcat.home}"/>   
70.         <echo message="Webapps Home=${webapps.home}"/>   
71.            
72.         <mkdir dir="${classes.home}"/>   
73.         <mkdir dir="${deploy.home}"/>        
74.            
75.         <mkdir dir="${build.home}"/>   
76.         <mkdir dir="${build.home}/WEB-INF"/>   
77.         <mkdir dir="${build.home}/WEB-INF/classes"/>   
78.         <mkdir dir="${build.home}/WEB-INF/lib"/>   
79.     </target>   
80.        
81.        
82.     <!-- 编译 -->   
83.     <target name="compile" depends="prepare">   
84.         <javac srcdir="${src.home}" destdir="${classes.home}" debug="no">   
85.             <classpath refid="compile.classpath"/>   
86.         </javac>   
87.     </target>   
88.        
89.     <!-- 构建临时工程 -->   
90.     <target name="build" depends="compile">   
91.         <copy todir="${build.home}">   
92.             <fileset dir="${web.home}"/>   
93.         </copy>   
94.         <copy todir="${build.home}/WEB-INF/classes">   
95.             <fileset dir="${classes.home}"/>   
96.         </copy>   
97.            
98.         <copy todir="${build.home}/WEB-INF/classes">   
99.             <fileset dir="${src.home}">   
100.                 <include name="**/*.properties"/>   
101.                 <include name="**/*.prop"/>   
102.             </fileset>   
103.         </copy>   
104.            
105.         <jar jarfile="${deploy.home}/${hnwt144.name}.war" basedir="${build.home}"/>   
106.     </target>   
107.     <!-- 发布 -->   
108.     <target name="deploy" depends="build">   
109.         <copy todir="${webapps.home}" file="${deploy.home}/${hnwt144.name}.war"/>   
110.     </target>   
111.            
112.     </project>  

ant 的使用说明

>>>>>>>>>>>声明
1.目的是学习，备忘，共享。个人表达能力有限，看不懂，表达错误的，见谅
>>>>>>>>>>>ant是什么
1.专业一点说是构建工具，是协助开发人员管理工程的工具
2.通俗一点说是懒人工具，帮助我们做一些重复的劳动
3.举个例子：发布一个web工程，你会如何做
a.将web工程打包
b.停止web工程
c.上传web工程
d.重启web工程
　通常，你可能会用IDE打包，然后登陆到服务器，把WEB工程shutdown，再用上传工具传war包，然后再重启
　有了ant，你不用这么累了，运行一个build.xml就OK。

>>>>>>>>>>ant的特点
1.跨平台，因为用JAVA写的
2.功能强大(这是一个口号)，扩展性比较好(这倒是实话，但代价是你得找支持的jar包)
3.上手容易，因为语法简单

>>>>>>>>>>ant的应用,eclipse下
1.传说牛人都不用IDE，我用eclipse，这玩意儿还是免费的，真棒。
2.exlipse3.0以后应该都内嵌ant，找找看：$eclipse\plugins\org.apache.ant_1.6.5

3.新建工程，工程根目录下新建build.xml
4.试试好不用，运行一下

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">   
3. <target name="main" depends="test" description="Main target">   
4. </target>   
5. <target name="test" description="test">   
6.     <echo> task start </echo>   
7. </target>   
8. </project>  

	<?xml version="1.0" encoding="UTF-8"?>
<project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">
<target name="main" depends="test" description="Main target">
</target>
<target name="test" description="test">
<echo> task start </echo>
</target>
</project>

5.ftp功能：
a.下载commons-net-1.4.0.jar jakarta-oro-2.0.8.jar NetComponents.jar optional.jar
b.上面这些jar，如果你的ant或jdk版本高，有的没有，但如果不是，劝你都下
c.eclipse下: Window->Preferance->Ant->Runtime->Ant Home Entries->自己加上jar

6.ssh:
a.下载jsch-0.1.41.jar
b.后面同[5]

7.给一个build.xml样例

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">   
3.     <target name="main" depends="taskover" description="Main target">   
4.     </target>   
5.        
6.     <!-- ***************************变量定义开始************************* -->   
7.     <!--工程名称-->   
8.     <property name="project.name" value="WebTest"/>   
9.     <!--打包war文件存放的位置-->   
10.     <property name="war.dir" location="E:\war"/>   
11.     <!--服务器IP-->   
12.     <property name="hostIP" value="10.4.116.212" />   
13.     <!--服务器OS帐户-->   
14.     <property name="userID" value="esb" />   
15.     <!--服务器OS密码-->   
16.     <property name="password" value="esb" />   
17.     <!--服务器tomcat路径-->   
18.     <property name="hostHome" value="/home/esb" />   
19.     <!-- *************************变量定义结束************************* -->   
20.        
21.     <!--　测试 -->   
22.     <target name="test" description="test">   
23.         <echo> task start </echo>   
24.     </target>   
25.     <!--　打包war文件 -->   
26.     <target name="pgWar" depends="test" description="Package application as a war">   
27.         <mkdir dir="${war.dir}" />   
28.         <war destfile="${war.dir}/${project.name}.war" webxml="web.xml">   
29.             <fileset dir="${basedir}">   
30.             </fileset>   
31.         </war>   
32.     </target>   
33.        
34.        
35.     <target name="remote-tomcat-stop" depends="pgWar" >   
36.             <sshexec host="${hostIP}" username="${userID}"  password="${password}"    
37.                 command="ps -ef|grep tomcat55|grep -v grep |awk '{print $2}'|xargs -n1 kill -9;ls;rm -rf /home/esb/tomcat55/webapps/WebTest*"    
38.                 trust="true" />   
39.             <sleep seconds="5"/>   
40.     </target>   
41.        
42.     <!-- 上传文件-->   
43.     <target name="uploadFile" depends="remote-tomcat-stop" >   
44.         <ftp server="${hostIP}" remotedir="${hostHome}/tomcat55/webapps" userid="${userID}"    
45.             password="${password}" depends="yes" >   
46.             <fileset dir="${war.dir}">   
47.                 <include name="**/*.war"/>   
48.             </fileset>   
49.         </ftp>   
50.     </target>   
51.        
52.     <!-- 远程重启tomcat-->   
53.         <target name="remote-tomcat-start" depends="uploadFile" >   
54.             <sshexec host="${hostIP}" username="${userID}"  password="${password}"    
55.                 command="cd /home/esb/tomcat55/bin;JAVA_HOME=/home/esb/jdk1.5/jdk1.5.0_06 export JAVA_HOME;nohup sh startup.sh;ls"    
56.                 trust="true" />   
57.             <sleep seconds="5"/>   
58.         </target>   
59.            
60.         <target name="taskover" depends="remote-tomcat-start" >   
61.             <echo> task over </echo>   
62.         </target>   
63.        
64. </project>  

<?xml version="1.0" encoding="UTF-8"?>
<project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">
<target name="main" depends="taskover" description="Main target">
</target>
<!-- ***************************变量定义开始************************* -->
<!--工程名称-->
<property name="project.name" value="WebTest"/>
<!--打包war文件存放的位置-->
<property name="war.dir" location="E:\war"/>
<!--服务器IP-->
<property name="hostIP" value="10.4.116.212" />
<!--服务器OS帐户-->
<property name="userID" value="esb" />
<!--服务器OS密码-->
<property name="password" value="esb" />
<!--服务器tomcat路径-->
<property name="hostHome" value="/home/esb" />
<!-- *************************变量定义结束************************* -->
<!--　测试 -->
<target name="test" description="test">
<echo> task start </echo>
</target>
<!--　打包war文件 -->
<target name="pgWar" depends="test" description="Package application as a war">
<mkdir dir="${war.dir}" />
<war destfile="${war.dir}/${project.name}.war" webxml="web.xml">
<fileset dir="${basedir}">
</fileset>
</war>
</target>
<target name="remote-tomcat-stop" depends="pgWar" >
<sshexec host="${hostIP}" username="${userID}"  password="${password}"
command="ps -ef|grep tomcat55|grep -v grep |awk '{print $2}'|xargs -n1 kill -9;ls;rm -rf /home/esb/tomcat55/webapps/WebTest*"
trust="true" />
<sleep seconds="5"/>
</target>
<!-- 上传文件-->
<target name="uploadFile" depends="remote-tomcat-stop" >
<ftp server="${hostIP}" remotedir="${hostHome}/tomcat55/webapps" userid="${userID}"
password="${password}" depends="yes" >
<fileset dir="${war.dir}">
<include name="**/*.war"/>
</fileset>
</ftp>
</target>
<!-- 远程重启tomcat-->
<target name="remote-tomcat-start" depends="uploadFile" >
<sshexec host="${hostIP}" username="${userID}"  password="${password}"
command="cd /home/esb/tomcat55/bin;JAVA_HOME=/home/esb/jdk1.5/jdk1.5.0_06 export JAVA_HOME;nohup sh startup.sh;ls"
trust="true" />
<sleep seconds="5"/>
</target>
<target name="taskover" depends="remote-tomcat-start" >
<echo> task over </echo>
</target>
</project>

>>>>>>>>>>>>>命令行下的ant应用
1.环境变量设一下
ANT_HOME= $ant路径
PATH = %ANT_HOME%;%ANT_HOME%\bin

2.测试
输入ant，看有反应没