JDK5.0后的泛型程序设计

tvjody

浏览: 305771 次
性别:
来自: 广州

最近访客更多访客>>

sunwf

Michael_ketty

hanjun0612

zdsdiablo

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Java EE

Java C C++C#WebService

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

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

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

java 代码

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

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

java 代码

public class ArrayList{
public Object get(int index) {}
public boolean add(Object o) {}
}

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

java 代码

java 代码[code]

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

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

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

java 代码

public class ClassOne <T extends IClass,U>{
private T a;
private U b;
public T getA() {
return a;
}
public void setA(T a) {
this.a = a;
}
public U getB() {
return b;
}
public void setB(U b) {
this.b = b;
}
}

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

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

java 代码

public interface IClass {
public <T> T view(T str);
}

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

java 代码

public class ClassTwo implements IClass{
public <T> T view(T str) {
System.out.println(str);
return str;
}
}

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

java 代码

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

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

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

c# 代码

public static void ListTest()
{
string a = "jody",b="anita";
ArrayList list = new ArrayList();
list.Add(a);
list.Add(b);
foreach (string str in list)
{
Console.WriteLine(str);
}
}

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

java 代码

public static void iterator(){
List list = new ArrayList();
Iterator it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}

java 代码

public static void iterator1(){
List list = new ArrayList();
for(int i=0;i
System.out.println(list.get(i));
}
}

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

java 代码

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

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

分享到：

Tomcat超过最大线程数出错，如何捕获异常 | Discuz! Passport 的AzDGCrypt算法

2007-08-17 11:36
浏览 6574
评论(7)
论坛回复 / 浏览 (6 / 9075)
分类:企业架构
查看更多

7 楼 zexunlee 2007-08-21

正好在JDK5的研究泛型机制。

6 楼 birdjavaeye 2007-08-21

Chamjoneu 写道

范性另一个大的优势在于解决了不必要的装箱和拆箱问题

java泛型不能减少box unbox，不允许List<int>，得用List<Integer>
而C#支持<int>这样的，虚拟机对这种值类型有优化，能减少box unbox

5 楼过儿oO 2007-08-21

laiseeme 写道

那你还是老老实实用原先那种循环

看来只有如此了

4 楼 laiseeme 2007-08-21

那你还是老老实实用原先那种循环

3 楼过儿oO 2007-08-21

  List<String> list = new ArrayList<String>();    
        for(String str : list)
        {    
            System.out.println(str);    
        }

玩了一下这个，这个for循环如果我想判断是容器中的哪个元素怎么办？

2 楼 Chamjoneu 2007-08-20

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

<div class='code_title'>java 代码</div>
<div class='dp-highlighter'>
<div class='bar'/>
<ol class='dp-j'>
 <li class='alt'>public static void getList(){ </li>
 <li class=''> List list = new ArrayList(); </li>
 <li class='alt'> String str = (String)list.get(1); </li>
 <li class=''>} </li>
</ol>
</div>
 
这段代码中的ArrayLIst的get()方法是由继承Object来实现泛型的，所以在get()时必然要进行类型强制转换，可以查看JDK5.0以前的源程序，应该如下；
<div class='code_title'>java 代码</div>
<div class='dp-highlighter'>
<div class='bar'/>
<ol class='dp-j'>
 <li class='alt'>public class ArrayList{ </li>
 <li class=''> public Object get(int index) {} </li>
 <li class='alt'> public boolean add(Object o) {} </li>
 <li class=''>} </li>
</ol>
</div>
这种实现，在add()时没有进行有效性检查，可以增加任何类型，同时在get()需要进行强制类型转换时，可能会抛出异常，而且代码不直观。如果你使用JDK5.0的泛型设计，则可以避免上述情况：
<div class='code_title'>java 代码</div>
<div class='code_title'>java 代码

</div>
<div class='dp-highlighter'>
<div class='bar'/>
<ol class='dp-j'>
    <li class='alt'><span><span class='keyword'>public</span><span> </span><span class='keyword'>static</span><span> </span><span class='keyword'>void</span><span> getList(){   </span></span> </li>
    <li class=''><span>    List<font color='#ff0000'>&lt;</font>String<font color='#ff0000'>&gt;</font> list = </span><span class='keyword'>new</span><span> ArrayList<font color='#ff0000'>&lt;</font>String<font color='#ff0000'>&gt;</font>();   </span> </li>
    <li class='alt'><span>    list.add(</span><span class='keyword'>new</span><span> String(</span><span class='string'>"1111"</span><span>));   </span> </li>
    <li class=''><span>    String str = list.get(</span><span class='number'>0</span><span>);   </span> </li>
    <li class='alt'><span>    System.out.println(str);   </span> </li>
    <li class=''><span>}  </span> </li>
</ol>
</div>

通过<>内指定的类型参数，我们就可以很直观的知道List的类型，不需要强制的进行转换，避免了异常，编绎器也直接利用这个类型参数信息，能直接按类型参数处理，而且不是按Obejct来处理，相对更安全，同时编绎器会检查输入的类型是不是<>是指定的参数类型，如是要不是刚编绎无法通过，这当然要比在运行时异常要好啦。 
 
 
 
 
</div>
范性另一个大的优势在于解决了不必要的装箱和拆箱问题

1 楼 tvjody 2007-08-17

JavaEye的HTML编辑器会把“<>”以及之间的内容替换掉，而泛型是的类型参数是用<>来定义的，所以这里用"[ ]"代表"<>"
具体问题已经跟管理员联系了

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论