Java 范型攻略篇

在已发布的Java1.4中在核心代码库中增加了许多新的API(如Loging,正则表达式，NIO)等，在最新发布的JDK1.5和即将发布的JDK1.6中也新增了许多API，其中比较有重大意义的就是Generics(范型)。

　　一.什么是Generics?

　　Generics可以称之为参数类型(parameterized types),由编译器来验证从客户端将一种类型传送给某一对象的机制。如Java.util.ArrayList,编译器可以用Generics来保证类型安全。

　　在我们深入了解Generics之前,我们先来看一看当前的java 集合框架(Collection)。在j2SE1.4中所有集合的Root Interface是Collection

　　Collections example without genericity: Example 1

1 protected void collectionsExample() { 2  ArrayList list = new ArrayList(); 3  list.add(new String("test string")); 4  list.add(new Integer(9)); // purposely placed here to create a runtime ClassCastException 5  inspectCollection(list); 6 } 7 8 9 protected void inspectCollection(Collection aCollection) { 10  Iterator i = aCollection.iterator(); 11  while (i.hasNext()) { 12   String element = (String) i.next(); 13  } 14 }

　　以上的样例程序包含的两个方法，collectionExample方法建立了一个简单的集合类型ArrayList，并在ArrayList中增加了一个String和一个Integer对象.而在inspecCollection方法中，我们迭代这个ArrayList用String进行Cast。我们看第二个方法，就出现了一个问题,Collection在内部用的是Object，而我们要取出Collection中的对象时,需要进行Cast，那么开发者必需用实际的类型进行Cast,像这种向下造型，编译器无

　　法进行检查,如此一来我们就要冒在代码在运行抛出ClassCastException的危险。我们看inspecCollection方法，编译时没有问题，但在运行时就会抛出ClassCastException异常。所以我们一定要远离这个重大的运行时错误

　　二.使用Generics

　　从上一章节中的CassCastException这种异常，我们期望在代码编译时就能够捕捉到,下面我们使用范型修改上一章的样例程序。

　　//Example 2

1 protected void collectionsExample() { 2  ArrayList<String> list = new ArrayList<String>(); 3  list.add(new String("test string")); 4  // list.add(new Integer(9)); this no longer compiles 5  inspectCollection(list); 6 } 7 8 9 protected void inspectCollection(Collection<String> aCollection) { 10  Iterator<String> i = aCollection.iterator(); 11  while(i.hasNext()) { 12   String element = i.next(); 13  } 14 }

　　从上面第2行我们在创建ArrayList时使用了新语法，在JDK1.5中所有的Collection都加入了Generics的声明。例:

　　//Example 3

1 public class ArrayList<E> extends AbstractList<E> { 2  // details omitted... 3  public void add(E element) { 4   // details omitted 5  } 6  public Iterator<E> iterator() { 7   // details omitted 8  } 9 }

　　这个E是一个类型变量，并没有对它进行具体类型的定义,它只是在定义ArrayList时的类型占位符,在Example 2中的我们在定义ArrayList的实例时用String绑定在E上,当我们用add(E element)方法向ArrayList中增加对象时, 那么就像下面的写法一样: public void add(String element);因为在ArrayList所有方法都会用String来替代E,无论是方法的参数还是返回值。这时我们在看Example 2中的第四行，编译就会反映出编译错误。

所以在java中增加Generics主要的目的是为了增加类型安全。

　　通过上面的简单的例子我们看到使用Generics的好处有:

• 　　1.在类型没有变化时，Collection是类型安全的。
• 　　2.内在的类型转换优于在外部的人工造型。
• 　　3.使Java 接口更加强壮,因为它增加了类型。
• 　　4.类型的匹配错误在编译阶段就可以捕捉到，而不是在代码运行时。

　　受约束类型变量

　　虽然许多Class被设计成Generics，但类型变量可以是受限的

public class C1<T extends Number> { }
public class C2<T extends Person & Comparable> { }

　　第一个T变量必须继承Number，第二个T必须继承Person和实现Comparable

　　三.Generics 方法

　　像Generics类一样，方法和构造函数也可以有类型参数。方法的参数的返回值都可以有类型参数，进行Generics。

　　//Example 4

1 public <T extends Comparable> T max(T t1, T t2) { 2  if (t1.compareTo(t2) > 0) 3   return t1; 4  else return t2; 5 }

　　这里，max方法的参数类型为单一的T类型，而T类型继承了Comparable，max的参数和返回值都有相同的超类。下面的Example 5显示了max方法的几个约束。

　　//Example 5

1 Integer iresult = max(new Integer(100), new Integer(200)); 2 String sresult = max("AA", "BB"); 3 Number nresult = max(new Integer(100), "AAA"); // does not compile

　　在Example 5第1行参数都为Integer，所以返回值也是Integer，注意返回值没有进行造型。

　　在Example 5第2行参数都为String，所以返回值也是String，注意返回值没有进行造型。以上都调用了同一个方法。

　　在Example 5第3行产生以下编译错误:

Example.java:10: incompatible types
found  : java.lang.Object&java.io.Serializable&java.lang.Comparable<?>
required: java.lang.Number
    Number nresult = max(new Integer(100), "AAA");

　　这个错误发生是因为编译器无法确定返回值类型，因为String和Integer都有相同的超类Object,注意就算我们修正了第三行，这行代码在运行仍然会报错，因为比较了不同的对象。

　　四.向下兼容

　　任何一个新的特色在新的JDK版本中出来后，我们首先关心的是如何于以前编写的代码兼容。也就是说我们编写的Example 1程序不需要任何的改变就可以运行,但是编译器会给出一个"ROW TYPE"的警告。在JDK1.4中编写的代码如何在JVM1.5中完全兼容运行,我们要人工进行一个:Type erasure处理过程

　　五.通配符

　　//Example 6

List<String> stringList = new ArrayList<String>(); //1 List<Object> objectList = stringList ;//2 objectList .add(new Object()); // 3 String s = stringList .get(0);//4

      乍一看，Example 6是正确的。但stringList本意是存放String类型的ArrayList,而objectList中可以存入任何对象，当在第3行进行处理时，stringList也就无法保证是String类型的ArrayList,此时编译器不允许这样的事出现，所以第3行将无法编译。

//Example 7

void printCollection(Collection<Object> c)  { for (Object e : c) {  System.out.println(e); }}

Example 7的本意是打印所有Collection的对象,但是正如Example 6所说的，编译会报错，此时就可以用通配符“？”来修改Example 7

//Example 8

void printCollection(Collection<?> c)  { for (Object e : c) {  System.out.println(e); }}

       Example 8中所有Collection类型就可以方便的打印了

       有界通配符 <T extends Number>(上界) <T super Number>(下界)

六.创建自己的范型

以下代码来自ttp://www.java2s.com/ExampleCode/Language-Basics

1.一个参数的Generics

//Example 9(没有使用范型) class NonGen {     Object ob; // ob is now of type Object    // Pass the constructor a reference to      // an object of type Object    NonGen(Object o) {       ob = o;     }     // Return type Object.    Object getob() {       return ob;     }     // Show type of ob.     void showType() {       System.out.println("Type of ob is " +                          ob.getClass().getName());     }   }   // Demonstrate the non-generic class.   public class NonGenDemo {     public static void main(String args[]) {       NonGen iOb;        // Create NonGen Object and store      // an Integer in it. Autoboxing still occurs.      iOb = new NonGen(88);       // Show the type of data used by iOb.      iOb.showType();      // Get the value of iOb.      // This time, a cast is necessary.      int v = (Integer) iOb.getob();       System.out.println("value: " + v);       System.out.println();       // Create another NonGen object and       // store a String in it.      NonGen strOb = new NonGen("Non-Generics Test");       // Show the type of data used by strOb.      strOb.showType();      // Get the value of strOb.      // Again, notice that a cast is necessary.       String str = (String) strOb.getob();       System.out.println("value: " + str);       // This compiles, but is conceptually wrong!      iOb = strOb;      v = (Integer) iOb.getob(); // runtime error!    }   }

//Example 10(使用范型) class Example1<T>{  private T t;  Example1(T o){   this.t=o;   }  T getOb(){   return t;  }  void ShowObject(){   System.out.println("对象的类型是："+t.getClass().getName());  } } public class GenericsExample1 {  /**   * @param args   */  public static void main(String[] args) {   // TODO Auto-generated method stub   Example1<Integer> examplei=new Example1<Integer>(100);   examplei.ShowObject();   System.out.println("对象是："+examplei.getOb());   Example1<String> examples=new Example1<String>("Bill");   examples.ShowObject();   System.out.println("对象是："+examples.getOb());  } }

        我们来看Example 9没有使用范型，所以我们需要进行造型，而Example 10我们不需要任何的造型

2.二个参数的Generics

//Example 11 class TwoGen<T, V> {     T ob1;     V ob2;     // Pass the constructor a reference to      // an object of type T.     TwoGen(T o1, V o2) {       ob1 = o1;       ob2 = o2;     }     // Show types of T and V.     void showTypes() {       System.out.println("Type of T is " +                          ob1.getClass().getName());       System.out.println("Type of V is " +                          ob2.getClass().getName());     }     T getob1() {       return ob1;     }     V getob2() {       return ob2;     }   }  public class GenericsExampleByTwoParam {  /**   * @param args   */  public static void main(String[] args) {   // TODO Auto-generated method stub   TwoGen<Integer, String> tgObj =         new TwoGen<Integer, String>(88, "Generics");       // Show the types.       tgObj.showTypes();       // Obtain and show values.       int v = tgObj.getob1();       System.out.println("value: " + v);       String str = tgObj.getob2();       System.out.println("value: " + str);     }   }

     3.Generics的Hierarchy

//Example 12 class Stats<T extends Number> {      T[] nums; // array of Number or subclass     // Pass the constructor a reference to       // an array of type Number or subclass.     Stats(T[] o) {        nums = o;      }      // Return type double in all cases.     double average() {        double sum = 0.0;       for(int i=0; i < nums.length; i++)          sum += nums[i].doubleValue();       return sum / nums.length;     }    }   public class GenericsExampleByHierarchy {    /**   * @param args   */  public static void main(String[] args) {   // TODO Auto-generated method stub    Integer inums[] = { 1, 2, 3, 4, 5 };       Stats<Integer> iob = new Stats<Integer>(inums);         double v = iob.average();       System.out.println("iob average is " + v);       Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };       Stats<Double> dob = new Stats<Double>(dnums);         double w = dob.average();       System.out.println("dob average is " + w);       // This won't compile because String is not a       // subclass of Number.  //     String strs[] = { "1", "2", "3", "4", "5" };  //     Stats<String> strob = new Stats<String>(strs);    //     double x = strob.average();  //     System.out.println("strob average is " + v);     }    }

      4.使用通配符

//Example 14 class StatsWildCard<T extends Number> {  T[] nums; // array of Number or subclass  // Pass the constructor a reference to  // an array of type Number or subclass.  StatsWildCard(T[] o) {   nums = o;  }  // Return type double in all cases.  double average() {   double sum = 0.0;   for (int i = 0; i < nums.length; i++)    sum += nums[i].doubleValue();   return sum / nums.length;  }  // Determine if two averages are the same.  // Notice the use of the wildcard.  boolean sameAvg(StatsWildCard<?> ob) {   if (average() == ob.average())    return true;   return false;  } } public class GenericsExampleByWildcard {  /**   * @param args   */  public static void main(String[] args) {   // TODO Auto-generated method stub   Integer inums[] = { 1, 2, 3, 4, 5 };   StatsWildCard<Integer> iob = new StatsWildCard<Integer>(inums);   double v = iob.average();   System.out.println("iob average is " + v);   Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };   StatsWildCard<Double> dob = new StatsWildCard<Double>(dnums);   double w = dob.average();   System.out.println("dob average is " + w);   Float fnums[] = { 1.0F, 2.0F, 3.0F, 4.0F, 5.0F };   StatsWildCard<Float> fob = new StatsWildCard<Float>(fnums);   double x = fob.average();   System.out.println("fob average is " + x);   // See which arrays have same average.   System.out.print("Averages of iob and dob ");   if (iob.sameAvg(dob))    System.out.println("are the same.");   else    System.out.println("differ.");   System.out.print("Averages of iob and fob ");   if (iob.sameAvg(fob))    System.out.println("are the same.");   else    System.out.println("differ.");  } }

5.使用边界通配符

//Example 15 class TwoD {    int x, y;    TwoD(int a, int b) {      x = a;      y = b;    }  }  // Three-dimensional coordinates.  class ThreeD extends TwoD {    int z;    ThreeD(int a, int b, int c) {      super(a, b);      z = c;    }  }  // Four-dimensional coordinates.  class FourD extends ThreeD {    int t;    FourD(int a, int b, int c, int d) {      super(a, b, c);      t = d;     }  }  // This class holds an array of coordinate objects.  class Coords<T extends TwoD> {    T[] coords;    Coords(T[] o) { coords = o; }  }  // Demonstrate a bounded wildcard.  public class BoundedWildcard {    static void showXY(Coords<?> c) {      System.out.println("X Y Coordinates:");      for(int i=0; i < c.coords.length; i++)        System.out.println(c.coords[i].x + " " +                           c.coords[i].y);      System.out.println();    }    static void showXYZ(Coords<? extends ThreeD> c) {      System.out.println("X Y Z Coordinates:");      for(int i=0; i < c.coords.length; i++)        System.out.println(c.coords[i].x + " " +                           c.coords[i].y + " " +                           c.coords[i].z);      System.out.println();    }    static void showAll(Coords<? extends FourD> c) {      System.out.println("X Y Z T Coordinates:");      for(int i=0; i < c.coords.length; i++)        System.out.println(c.coords[i].x + " " +                           c.coords[i].y + " " +                           c.coords[i].z + " " +                           c.coords[i].t);      System.out.println();    }    public static void main(String args[]) {      TwoD td[] = {        new TwoD(0, 0),        new TwoD(7, 9),        new TwoD(18, 4),        new TwoD(-1, -23)      };      Coords<TwoD> tdlocs = new Coords<TwoD>(td);          System.out.println("Contents of tdlocs.");      showXY(tdlocs); // OK, is a TwoD  //  showXYZ(tdlocs); // Error, not a ThreeD  //  showAll(tdlocs); // Erorr, not a FourD      // Now, create some FourD objects.      FourD fd[] = {        new FourD(1, 2, 3, 4),        new FourD(6, 8, 14, 8),        new FourD(22, 9, 4, 9),        new FourD(3, -2, -23, 17)      };      Coords<FourD> fdlocs = new Coords<FourD>(fd);          System.out.println("Contents of fdlocs.");      // These are all OK.      showXY(fdlocs);       showXYZ(fdlocs);      showAll(fdlocs);    }  }

      6.ArrayList的Generics

//Example 16 public class ArrayListGenericDemo {   public static void main(String[] args) {     ArrayList<String> data = new ArrayList<String>();     data.add("hello");     data.add("goodbye");     // data.add(new Date()); This won't compile!     Iterator<String> it = data.iterator();     while (it.hasNext()) {       String s = it.next();       System.out.println(s);     }   } }

      7.HashMap的Generics

//Example 17 public class HashDemoGeneric {   public static void main(String[] args) {     HashMap<Integer,String> map = new HashMap<Integer,String>();     map.put(1, "Ian");     map.put(42, "Scott");     map.put(123, "Somebody else");     String name = map.get(42);     System.out.println(name);   } }

8.接口的Generics

//Example 18 interface MinMax<T extends Comparable<T>> {    T min();    T max();  }  // Now, implement MinMax  class MyClass<T extends Comparable<T>> implements MinMax<T> {    T[] vals;    MyClass(T[] o) { vals = o; }    // Return the minimum value in vals.    public T min() {      T v = vals[0];      for(int i=1; i < vals.length; i++)        if(vals[i].compareTo(v) < 0) v = vals[i];      return v;    }    // Return the maximum value in vals.    public T max() {      T v = vals[0];      for(int i=1; i < vals.length; i++)        if(vals[i].compareTo(v) > 0) v = vals[i];      return v;    }  }  public class GenIFDemo {    public static void main(String args[]) {      Integer inums[] = {3, 6, 2, 8, 6 };      Character chs[] = {'b', 'r', 'p', 'w' };      MyClass<Integer> iob = new MyClass<Integer>(inums);      MyClass<Character> cob = new MyClass<Character>(chs);      System.out.println("Max value in inums: " + iob.max());      System.out.println("Min value in inums: " + iob.min());      System.out.println("Max value in chs: " + cob.max());      System.out.println("Min value in chs: " + cob.min());    }  }

      9.Exception的Generics

//Example 20 interface Executor<E extends Exception> {     void execute() throws E; } public class GenericExceptionTest {     public static void main(String args[]) {         try {             Executor<IOException> e =                 new Executor<IOException>() {                 public void execute() throws IOException                 {                     // code here that may throw an                     // IOException or a subtype of                     // IOException                 }             };             e.execute();         } catch(IOException ioe) {             System.out.println("IOException: " + ioe);             ioe.printStackTrace();         }     } }