论坛首页 → Java企业应用论坛 →

JDK5.0后的泛型程序设计

浏览 9080 次
锁定老帖子 主题：JDK5.0后的泛型程序设计
精华帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隐藏帖 (0)
作者 正文
  • tvjody
  • 等级: 初级会员
  • 性别:
  • 文章: 145
  • 积分: 40
  • 来自: 广州
   发表时间：2007-08-17  

之前了解学习了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的实现。的确是很期待的
返回顶楼
         
  • tvjody
  • 等级: 初级会员
  • 性别:
  • 文章: 145
  • 积分: 40
  • 来自: 广州
   发表时间：2007-08-17  
JavaEye的HTML编辑器会把“<>”以及之间的内容替换掉，而泛型是的类型参数是用<>来定义的，所以这里用"[ ]"代表"<>"
具体问题已经跟管理员联系了
返回顶楼
          回帖地址
0 请登录后投票
  • Chamjoneu
  • 等级: 一星会员
  • 文章: 33
  • 积分: 108
  • 来自: Shanghai
   发表时间：2007-08-20  

tvjody 写道：

泛型的优势
利用泛型设计，可以使编写的代码为不同类型所重用。在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来处理，相对更安全，同时编绎器会检查输入的类型是不是<>是指定的参数类型，如是要不是刚编绎无法通过，这当然要比在运行时异常要好啦。




范性另一个大的优势在于解决了 不必要的装箱 和 拆箱 问题
返回顶楼
          回帖地址
0 请登录后投票
  • 过儿oO
  • 等级: 初级会员
  • 性别:
  • 文章: 161
  • 积分: 66
  • 来自: 大连
   发表时间：2007-08-21   
  List<String> list = new ArrayList<String>();    
        for(String str : list)
        {    
            System.out.println(str);    
        }

玩了一下这个，这个for循环如果我想判断是容器中的哪个元素怎么办？
返回顶楼
          回帖地址
0 请登录后投票
  • laiseeme
  • 等级: 初级会员
  • 性别:
  • 文章: 3853
  • 积分: 0
  • 来自: 沈阳
   发表时间：2007-08-21  
那你还是老老实实用原先那种循环
返回顶楼
          回帖地址
0 请登录后投票
  • 过儿oO
  • 等级: 初级会员
  • 性别:
  • 文章: 161
  • 积分: 66
  • 来自: 大连
   发表时间：2007-08-21  
laiseeme 写道
那你还是老老实实用原先那种循环


看来只有如此了
返回顶楼
          回帖地址
0 请登录后投票
  • birdjavaeye
  • 等级: 二星会员
  • 性别:
  • 文章: 120
  • 积分: 201
  • 来自: 地球
   发表时间：2007-08-21  
Chamjoneu 写道
范性另一个大的优势在于解决了 不必要的装箱 和 拆箱 问题

java泛型不能减少box unbox，不允许List<int>，得用List<Integer>
而C#支持<int>这样的，虚拟机对这种值类型有优化，能减少box unbox
返回顶楼
          回帖地址
0 请登录后投票
论坛首页 → Java企业应用版

跳转论坛:
Global site tag (gtag.js) - Google Analytics