`
hanqunfeng
  • 浏览: 1541869 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

jdk1.5泛型介绍

    博客分类:
  • JAVA
阅读更多

原文地址:http://www.matrix.org.cn/resource/article/44/44344_Java+Generics

  .什么是Generics?

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

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

  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方法中,我们迭代这个ArrayListString进行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类型继承了Comparablemax的参数和返回值都有相同的超类。下面的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 51行参数都为Integer,所以返回值也是Integer,注意返回值没有进行造型。

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

  在Example 53行产生以下编译错误:

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");

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

  .向下兼容

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

  .通配符

  //Example 6

List<String>stringList=newArrayList<String>();//1
List<Object>objectList=stringList;//2
objectList.add(newObject());//3
Strings=stringList.get(0);//4

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

//Example 7

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

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

//Example 8

voidprintCollection(Collection<?>c)
{for(Objecte:c){
System.out.println(e);
}}


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

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

.创建自己的范型

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

1.一个参数的Generics

//Example9(没有使用范型)
classNonGen{
Objectob;//obisnowoftypeObject
//Passtheconstructorareferenceto
//anobjectoftypeObject
NonGen(Objecto){
ob=o;
}
//ReturntypeObject.
Objectgetob(){
returnob;
}
//Showtypeofob.
voidshowType(){
System.out.println("Typeofobis"+
ob.getClass().getName());
}
}
//Demonstratethenon-genericclass.
publicclassNonGenDemo{
publicstaticvoidmain(Stringargs[]){
NonGeniOb;
//CreateNonGenObjectandstore
//anIntegerinit.Autoboxingstilloccurs.
iOb=newNonGen(88);
//ShowthetypeofdatausedbyiOb.
iOb.showType();
//GetthevalueofiOb.
//Thistime,acastisnecessary.
intv=(Integer)iOb.getob();
System.out.println("value:"+v);
System.out.println();
//CreateanotherNonGenobjectand
//storeaStringinit.
NonGenstrOb=newNonGen("Non-GenericsTest");
//ShowthetypeofdatausedbystrOb.
strOb.showType();
//GetthevalueofstrOb.
//Again,noticethatacastisnecessary.
Stringstr=(String)strOb.getob();
System.out.println("value:"+str);
//Thiscompiles,butisconceptuallywrong!
iOb=strOb;
v=(Integer)iOb.getob();//runtimeerror!
}
}

 

//Example10(使用范型)
classExample1<T>{
privateTt;
Example1(To){
this.t=o;
}
TgetOb(){
returnt;
}
voidShowObject(){
System.out.println("
对象的类型是:"+t.getClass().getName());
}
}
publicclassGenericsExample1{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Example1<Integer>examplei=newExample1<Integer>(100);
examplei.ShowObject();
System.out.println("
对象是:"+examplei.getOb());
Example1<String>examples=newExample1<String>("Bill");
examples.ShowObject();
System.out.println("
对象是:"+examples.getOb());
}
}

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

2.二个参数的Generics

//Example11
classTwoGen<T,V>{
Tob1;
Vob2;
//Passtheconstructorareferenceto
//anobjectoftypeT.
TwoGen(To1,Vo2){
ob1=o1;
ob2=o2;
}
//ShowtypesofTandV.
voidshowTypes(){
System.out.println("TypeofTis"+
ob1.getClass().getName());
System.out.println("TypeofVis"+
ob2.getClass().getName());
}
Tgetob1(){
returnob1;
}
Vgetob2(){
returnob2;
}
}
publicclassGenericsExampleByTwoParam{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
TwoGen<Integer,String>tgObj=
newTwoGen<Integer,String>(88,"Generics");
//Showthetypes.
tgObj.showTypes();
//Obtainandshowvalues.
intv=tgObj.getob1();
System.out.println("value:"+v);
Stringstr=tgObj.getob2();
System.out.println("value:"+str);
}
}

3.GenericsHierarchy

//Example12
classStats<TextendsNumber>{
T[]nums;//arrayofNumberorsubclass
//Passtheconstructorareferenceto
//anarrayoftypeNumberorsubclass.
Stats(T[]o){
nums=o;
}
//Returntypedoubleinallcases.
doubleaverage(){
doublesum=0.0;
for(inti=0;i<nums.length;i++)
sum+=nums[i].doubleValue();
returnsum/nums.length;
}
}
publicclassGenericsExampleByHierarchy{

/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Integerinums[]={1,2,3,4,5};
Stats<Integer>iob=newStats<Integer>(inums);
doublev=iob.average();
System.out.println("iobaverageis"+v);
Doublednums[]={1.1,2.2,3.3,4.4,5.5};
Stats<Double>dob=newStats<Double>(dnums);
doublew=dob.average();
System.out.println("dobaverageis"+w);
//Thiswon'tcompilebecauseStringisnota
//subclassofNumber.
//Stringstrs[]={"1","2","3","4","5"};
//Stats<String>strob=newStats<String>(strs);
//doublex=strob.average();
//System.out.println("strobaverageis"+v);
}
}


4.
使用通配符

//Example14
classStatsWildCard<TextendsNumber>{
T[]nums;//arrayofNumberorsubclass
//Passtheconstructorareferenceto
//anarrayoftypeNumberorsubclass.
StatsWildCard(T[]o){
nums=o;
}
//Returntypedoubleinallcases.
doubleaverage(){
doublesum=0.0;
for(inti=0;i<nums.length;i++)
sum+=nums[i].doubleValue();
returnsum/nums.length;
}
//Determineiftwoaveragesarethesame.
//Noticetheuseofthewildcard.
booleansameAvg(StatsWildCard<?>ob){
if(average()==ob.average())
returntrue;
returnfalse;
}
}
publicclassGenericsExampleByWildcard{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Integerinums[]={1,2,3,4,5};
StatsWildCard<Integer>iob=newStatsWildCard<Integer>(inums);
doublev=iob.average();
System.out.println("iobaverageis"+v);
Doublednums[]={1.1,2.2,3.3,4.4,5.5};
StatsWildCard<Double>dob=newStatsWildCard<Double>(dnums);
doublew=dob.average();
System.out.println("dobaverageis"+w);
Floatfnums[]={1.0F,2.0F,3.0F,4.0F,5.0F};
StatsWildCard<Float>fob=newStatsWildCard<Float>(fnums);
doublex=fob.average();
System.out.println("fobaverageis"+x);
//Seewhicharrayshavesameaverage.
System.out.print("Averagesofiobanddob");
if(iob.sameAvg(dob))
System.out.println("arethesame.");
else
System.out.println("differ.");
System.out.print("Averagesofiobandfob");
if(iob.sameAvg(fob))
System.out.println("arethesame.");
else
System.out.println("differ.");
}
}

5.使用边界通配符

//Example15
classTwoD{
intx,y;
TwoD(inta,intb){
x=a;
y=b;
}
}
//Three-dimensionalcoordinates.
classThreeDextendsTwoD{
intz;
ThreeD(inta,intb,intc){
super(a,b);
z=c;
}
}
//Four-dimensionalcoordinates.
classFourDextendsThreeD{
intt;
FourD(inta,intb,intc,intd){
super(a,b,c);
t=d;
}
}
//Thisclassholdsanarrayofcoordinateobjects.
classCoords<TextendsTwoD>{
T[]coords;
Coords(T[]o){coords=o;}
}
//Demonstrateaboundedwildcard.
publicclassBoundedWildcard{
staticvoidshowXY(Coords<?>c){
System.out.println("XYCoordinates:");
for(inti=0;i<c.coords.length;i++)
System.out.println(c.coords[i].x+""+
c.coords[i].y);
System.out.println();
}
staticvoidshowXYZ(Coords<?extendsThreeD>c){
System.out.println("XYZCoordinates:");
for(inti=0;i<c.coords.length;i++)
System.out.println(c.coords[i].x+""+
c.coords[i].y+""+
c.coords[i].z);
System.out.println();
}
staticvoidshowAll(Coords<?extendsFourD>c){
System.out.println("XYZTCoordinates:");
for(inti=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();
}
publicstaticvoidmain(Stringargs[]){
TwoDtd[]={
newTwoD(0,0),
newTwoD(7,9),
newTwoD(18,4),
newTwoD(-1,-23)
};
Coords<TwoD>tdlocs=newCoords<TwoD>(td);
System.out.println("Contentsoftdlocs.");
showXY(tdlocs);//OK,isaTwoD
//showXYZ(tdlocs);//Error,notaThreeD
//showAll(tdlocs);//Erorr,notaFourD
//Now,createsomeFourDobjects.
FourDfd[]={
newFourD(1,2,3,4),
newFourD(6,8,14,8),
newFourD(22,9,4,9),
newFourD(3,-2,-23,17)
};
Coords<FourD>fdlocs=newCoords<FourD>(fd);
System.out.println("Contentsoffdlocs.");
//TheseareallOK.
showXY(fdlocs);
showXYZ(fdlocs);
showAll(fdlocs);
}
}

6.ArrayListGenerics

//Example16
publicclassArrayListGenericDemo{
publicstaticvoidmain(String[]args){
ArrayList<String>data=newArrayList<String>();
data.add("hello");
data.add("goodbye");
//data.add(newDate());Thiswon'tcompile!
Iterator<String>it=data.iterator();
while(it.hasNext()){
Strings=it.next();
System.out.println(s);
}
}
}

7.HashMapGenerics

//Example17
publicclassHashDemoGeneric{
publicstaticvoidmain(String[]args){
HashMap<Integer,String>map=newHashMap<Integer,String>();
map.put(1,"Ian");
map.put(42,"Scott");
map.put(123,"Somebodyelse");
Stringname=map.get(42);
System.out.println(name);
}
}

8.接口的Generics

//Example18
interfaceMinMax<TextendsComparable<T>>{
Tmin();
Tmax();
}
//Now,implementMinMax
classMyClass<TextendsComparable<T>>implementsMinMax<T>{
T[]vals;
MyClass(T[]o){vals=o;}
//Returntheminimumvalueinvals.
publicTmin(){
Tv=vals[0];
for(inti=1;i<vals.length;i++)
if(vals[i].compareTo(v)<0)v=vals[i];
returnv;
}
//Returnthemaximumvalueinvals.
publicTmax(){
Tv=vals[0];
for(inti=1;i<vals.length;i++)
if(vals[i].compareTo(v)>0)v=vals[i];
returnv;
}
}
publicclassGenIFDemo{
publicstaticvoidmain(Stringargs[]){
Integerinums[]={3,6,2,8,6};
Characterchs[]={'b','r','p','w'};
MyClass<Integer>iob=newMyClass<Integer>(inums);
MyClass<Character>cob=newMyClass<Character>(chs);
System.out.println("Maxvalueininums:"+iob.max());
System.out.println("Minvalueininums:"+iob.min());
System.out.println("Maxvalueinchs:"+cob.max());
System.out.println("Minvalueinchs:"+cob.min());
}
}

9.ExceptionGenerics

//Example20
interfaceExecutor<EextendsException>{
voidexecute()throwsE;
}
publicclassGenericExceptionTest{
publicstaticvoidmain(Stringargs[]){
try{
Executor<IOException>e=
newExecutor<IOException>(){
publicvoidexecute()throwsIOException
{
//codeherethatmaythrowan
//IOExceptionorasubtypeof
//IOException
}
};
e.execute();
}catch(IOExceptionioe){
System.out.println("IOException:"+ioe);
ioe.printStackTrace();
}
}
}

分享到:
评论

相关推荐

    JDK1.5泛型讲解和例子

    JDK1.5泛型讲解 不错的东西 对jdk需要研究的朋友不妨看看 新手也来学习学习```

    JDK1.5的泛型实现.pdf

    JDK1.5的泛型实现.pdf

    JDK1.5的泛型实现.zip

    **JDK 1.5 泛型实现** Java Development Kit (JDK) 1.5 是一个里程碑式的版本,因为它引入了泛型,这是一项重要的编程特性,极大地提高了代码的类型安全性和可读性。泛型允许在编译时进行类型检查,避免了运行时...

    jdk1.5 windows版本 64位

    标题:“jdk1.5 windows版本 64位” 描述:“jdk1.5 windows版本 64位,Java开发依赖环境” 标签:“windows” 在这个主题中,我们聚焦的是Oracle JDK 1.5(也被称为Java Development Kit,简称JDK)在Windows...

    jdk1.5x64位 windows版.zip

    其次,泛型(Generics)是JDK1.5的一大亮点。泛型允许在定义类、接口和方法时指定参数类型,增强了类型检查,减少了类型转换的麻烦,同时也减少了运行时的类型错误。泛型还引入了通配符,如"? extends T"和"? super ...

    linux系统jdk1.5下载

    JDK1.5引入了一些重要的特性,如增强的for循环(foreach)、匿名内部类的改进、枚举类型以及泛型的初步支持。这些特性对Java编程产生了深远影响,提升了代码的可读性和安全性。 然而,由于JDK1.5已不再受官方支持,...

    JDK1.5泛型使用下载

    Java泛型是在JDK 1.5版本中引入的一项重要特性,极大地增强了类型安全性和代码可读性。泛型允许开发者在类、接口和方法中声明类型参数,从而实现对数据类型的抽象。在泛型的帮助下,开发者可以在编译时进行类型检查...

    Java-jdk1.5安装包

    JDK1.5,也称为Java 5.0,是一个重要的版本,它引入了许多新的特性和改进,对Java语言的发展产生了深远影响。 一、泛型(Generics) 在Java 5.0中,最重要的特性之一就是泛型的引入。泛型允许开发者在定义类、接口...

    JDK1.5泛型.rar

    **Java泛型是JDK1.5引入的一个重要特性,极大地提高了代码的类型安全性和重用性。在泛型出现之前,程序员需要在运行时进行强制类型转换,这可能导致ClassCastException。泛型通过在类、接口和方法声明中引入类型参数...

    JDK 1.5的泛型實現(Generics in JDK 1.5)

    今天,JDK1.5終於內建泛型特性,不僅編譯器不再需要 任何外力(外掛附件)的幫助,整個 Java標準程式庫也被翻新(retrofit),許多 角落針對泛型做了改寫。 讓我們把帶有「參數化型別」(parameterized types)的 ...

    JDK1.5,JDK1.5

    泛型是JDK1.5最重要的特性之一,它允许在类、接口和方法声明中使用类型参数,以实现数据类型的参数化。泛型提高了代码的类型安全性和可读性,减少了类型转换的需要,并允许编译器检查类型错误。 2. **自动装箱与...

    包含 jdk1.5免安装、jdk1.6免安装、jdk1.8(32和64)

    这个压缩包包含了三个不同版本的JDK:JDK 1.5、JDK 1.6和JDK 1.8,其中1.5和1.6是早期版本,而1.8是最流行且广泛使用的版本之一。 **JDK 1.5(也称为Java 5.0)** JDK 1.5在2004年发布,引入了许多重要的新特性,如...

    详细介绍JDK1.5的各种新特性

    1. **泛型(Generics)**:泛型是JDK1.5引入的最大变革之一。它允许在类、接口和方法中使用类型参数,提高了代码的类型安全性和重用性。泛型帮助程序员在编译时检查类型错误,避免了运行时的强制类型转换,使代码...

    java经典教程-JDK1.5的泛型实现

    Java泛型是自JDK 1.5版本引入的一项重要特性,它极大地提高了代码的类型安全性和重用性。在本教程中,我们将深入探讨Java...通过阅读“JDK1.5的泛型实现.pdf”这份文档,你应该能更深入地理解泛型的细节和实际应用。

    JDK1.5新特性泛型_深入研究.doc

    ### JDK1.5新特性泛型深入研究 #### 一、引言 随着软件工程的发展,类型安全成为了程序设计中的一个重要考量因素。Java作为一种广泛使用的编程语言,在其发展历程中不断引入新的特性以满足日益增长的需求。JDK1.5...

    JDK1.5的泛型实现

    以下是关于JDK 1.5泛型实现的详细解释: 1. **类型参数**:泛型的基本单位是类型参数,它在声明时用尖括号 `&lt;T&gt;` 表示,其中 `T` 是一个占位符,代表某种未知的类型。例如,在创建一个可以存储任意类型的列表时,...

    IBMJDK1.5linux.zip

    在压缩包"IBMJDK1.5linux.zip"中,主要包含的是IBM JDK 1.5的安装文件和相关文档。安装完成后,开发者可以通过设置环境变量(如JAVA_HOME、PATH)来使用这个JDK。通常,这个JDK会包含Java编译器(javac)、Java解释...

    jdk1.5 windows 64位官方正式版,绝对有效

    在JDK1.5中,最重要的变化之一是引入了泛型。泛型允许在定义类、接口和方法时指定类型参数,从而增强了类型安全性和代码重用性。通过泛型,开发者可以在编译时检查类型,避免了运行时的强制类型转换,减少了可能的...

    Jdk15泛型的实现

    直至JDK1.5,泛型技术终于被正式集成到Java的核心功能中,不仅编译器原生支持泛型,整个Java标准库也进行了重构以更好地兼容泛型。 #### 泛型的关键概念与实践 **参数化类型(Parameterized Types)** 参数化类型...

    JDK1.5的32位和64位安装包

    首先,JDK1.5最重要的特性之一是泛型(Generics)。泛型允许在类、接口和方法中使用类型参数,从而提高了代码的类型安全性和可读性。通过泛型,开发者可以限制容器只能存储特定类型的对象,避免了强制类型转换,减少...

Global site tag (gtag.js) - Google Analytics