JDK5.0后的泛型程序设计

之前了解学习了C#的语言特征，的确，C#是很好的面向对象的语言，感觉很多跟JAVA大致相同，同时Microsoft给它新增了很多令人心动的特性，比如结构、泛型(这个跟C++的模板类似)、Foreach……这些都带来了很多方便。

JDK的更新日渐变化，越来完善的功能，给程序员带来很多便利。比如JDK5.0的泛型就是一个非常好的例子。下面讨论一下JAVA的泛型，仅供参考。

泛型的优势
利用泛型设计，可以使编写的代码为不同类型所重用。在JDK5.0之前泛型设计是由继承来实现。比如：
java 代码

   1. public static void getList(){   
   2.     List list = new ArrayList();   
   3.     String str = (String)list.get(1);   
   4. }  


这段代码中的ArrayLIst的get()方法是由继承Object来实现泛型的，所以在get()时必然要进行类型强制转换，可以查看JDK5.0以前的源程序，应该如下；
java 代码

   1. public class ArrayList{   
   2.         public Object get(int index) {}   
   3.         public boolean add(Object o) {}   
   4. }  

这种实现，在add()时没有进行有效性检查，可以增加任何类型，同时在get()需要进行强制类型转换时，可能会抛出异常，而且代码不直观。如果你使用JDK5.0的泛型设计，则可以避免上述情况：
java 代码
java 代码[code]

   1. public static void getList(){   
   2.     List<String> list = new ArrayList<String>();   
   3.     list.add(new String("1111"));   
   4.     String str = list.get(0);   
   5.     System.out.println(str);   
   6. }  

[/code]
通过<>内指定的类型参数，我们就可以很直观的知道List的类型，不需要强制的进行转换，避免了异常，编绎器也直接利用这个类型参数信息，能直接按类型参数处理，而且不是按Obejct来处理，相对更安全，同时编绎器会检查输入的类型是不是<>是指定的参数类型，如是要不是刚编绎无法通过，这当然要比在运行时异常要好啦。

泛型类的定义
要定义一个泛型类，其实也不是很难，下面我们定义一个有两个变量的泛型类。 [code]
java 代码

   1. public class ClassOne <T extends IClass,U>{   
   2.     private T a;   
   3.     private U b;   
   4.        
   5.     public T getA() {   
   6.         return a;   
   7.     }   
   8.   
   9.     public void setA(T a) {   
  10.         this.a = a;   
  11.     }   
  12.   
  13.     public U getB() {   
  14.         return b;   
  15.     }   
  16.   
  17.     public void setB(U b) {   
  18.         this.b = b;   
  19.     }   
  20. }  

[/code]
这里的ClassOne类，定义了两个变量类型参数，分别为T、U，按照Java文档中的说法，使用泛型定义命名时，E为集合的元素类型，K和V表示关键字和值的类型，T表示任意类型。其中可以看到T 继承了IClass接口，在泛型的定义中如果类继承父类或实现接口都用关键字"extends"来表示，如果是多个父类或接口可以用“&”连接，这说明T这个类型参数的类型必然继承IClass或实现IClass接口.

泛型方法的定义
下面看IClass接口，里面有一个泛型方法： [code]
java 代码

   1. public interface IClass {   
   2.     public <T> T view(T str);   
   3. }  

[/code]
IClass接口中只有一个view()方法，实现查看的功能。先定义一个ClassTwo实现IClass接口中的泛型方法view()。 [code]
java 代码

   1. public class ClassTwo implements IClass{       
   2.        
   3.     public <T> T view(T str) {   
   4.         System.out.println(str);   
   5.         return str;   
   6.     }   
   7. }  

[/code]
再看具体的ClassOne的实例调用 ,下面实例化ClassOne的类[code]
java 代码

   1. public static void main(String[] args) {   
   2.         ClassTwo t = new ClassTwo();   
   3.         ClassOne<ClassTwo,Integer> c = new ClassOne<ClassTwo,Integer>();   
   4.         c.setA(t);   
   5.         c.setB(new Integer(0));   
   6.         c.getA().<String>view(new String(""));   
   7.     }  

[/code]
以上说明了定义泛型类和泛型方法，有点像C++的模板，但是又不相同，当然我上面只是简单的介绍一些特性，更多信息需要参考JDK的文档。

遍历特性(foreach)
下面再来说明一个JDK5.0的新特性，这个就是foreach，在C#语言中，经常看到这样的：
c# 代码

   1. public static void ListTest()   
   2.         {   
   3.             string a = "jody",b="anita";   
   4.             ArrayList list = new ArrayList();   
   5.             list.Add(a);   
   6.             list.Add(b);   
   7.             foreach (string str in list)   
   8.             {   
   9.                 Console.WriteLine(str);   
  10.             }   
  11.         }  


C#代码的foreach{}非常方便的便遍历出ArrayList中的数据，并且不需要索引。而且JDK5.0以前需要进行如下：
java 代码

   1. public static void iterator(){   
   2.         List list = new ArrayList();   
   3.         Iterator it = list.iterator();   
   4.         while(it.hasNext()){   
   5.             System.out.println(it.next());   
   6.         }   
   7.     }  

java 代码

   1. public static void iterator1(){   
   2.         List list = new ArrayList();   
   3.         for(int i=0;i
   4.             System.out.println(list.get(i));   
   5.         }   
   6.     }  


如果是用JDK5.0以上，则可以像C#中一样，用for直接遍历出数据，不需要指定索引。 [code]
java 代码

   1. public static void getList1(){   
   2.         List<String><string></string> list = new ArrayList<String><string></string>();   
   3.         for(String str : list){   
   4.             System.out.println(str);   
   5.         }   
   6.     }  

[/code]
上面说明了JDK5.0以后版本的两个新特性，其中都与C++和C#语言中的思想差不多，现在JDK6.0\7.0都快出来了，应该有更多让人惊喜的功能，比如听说会封装WebService的实现。的确是很期待的