什么是java泛型编程_JAVA泛型编程笔记

1介绍

Java泛型编程是JDK1.5版本后引入的。泛型让编程人员能够使用类型抽象&＃xff0c;通常用于集合里面。

下面是一个不用泛型例子&＃xff1a;

1 List myIntList&＃61;new LinkedList(); //1

2 myIntList.add(newInteger(0)); //2

3 Integer x&＃61;(Integer)myIntList.iterator().next(); //3

注意第3行代码&＃xff0c;但这是让人很不爽的一点&＃xff0c;因为程序员肯定知道自己存储在List里面的对象类型是Integer&＃xff0c;但是在返回列表中元素时&＃xff0c;还是必须强制转换类型&＃xff0c;这是为什么呢&＃xff1f;原因在于&＃xff0c;编译器只能保证迭代器的next()方法返回的是Object类型的对象&＃xff0c;为保证Integer变量的类型安全&＃xff0c;所以必须强制转换。

这种转换不仅显得混乱&＃xff0c;更可能导致类型转换异常ClassCastException&＃xff0c;运行时异常往往让人难以检测到。保证列表中的元素为一个特定的数据类型&＃xff0c;这样就可以取消类型转换&＃xff0c;减少发生错误的机会&＃xff0c; 这也是泛型设计的初衷。下面是一个使用了泛型的例子&＃xff1a;

1 List myIntList&＃61;newLinkedList(); //1’

2 myIntList.add(newInteger(0)); //2’

3 Integerx&＃61;myIntList.iterator().next(); //3’

在第1行代码中指定List中存储的对象类型为Integer&＃xff0c;这样在获取列表中的对象时&＃xff0c;不必强制转换类型了。

2定义简单的泛型

下面是一个引用自java.util包中的接口List和Iterator的定义&＃xff0c;其中用到了泛型技术。

1 public interface List{2 voidadd(E x);3 Iteratoriterator();4 }5 public interface Iterator{6 E next();7 boolean hasNext();8 }

这跟原生类型没有什么区别&＃xff0c;只是在接口后面加入了一个尖括号&＃xff0c;尖括号里面是一个类型参数(定义时就是一个格式化的类型参数&＃xff0c;在调用时会使用一个具体的类型来替换该类型)。

也许可以这样认为&＃xff0c;List表示List中的类型参数E会被替换成Integer。

1 public interfaceIntegerList {2 voidadd(Integer x)3 Iteratoriterator();4 }

类型擦除指的是通过类型参数合并&＃xff0c;将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码&＃xff0c;并将其实例关联到这份字节码上&＃xff0c;因此泛型类型中的静态变量是所有实例共享的。此外&＃xff0c;需要注意的是&＃xff0c;一个static方法&＃xff0c;无法访问泛型类的类型参数&＃xff0c;因为类还没有实例化&＃xff0c;所以&＃xff0c;若static方法需要使用泛型能力&＃xff0c;必须使其成为泛型方法。类型擦除的关键在于从泛型类型中清除类型参数的相关信息&＃xff0c;并且再必要的时候添加类型检查和类型转换的方法。在使用泛型时&＃xff0c;任何具体的类型都被擦除&＃xff0c;唯一知道的是你在使用一个对象。比如&＃xff1a;List和List在运行事实上是相同的类型。他们都被擦除成他们的原生类型&＃xff0c;即List。因为编译的时候会有类型擦除&＃xff0c;所以不能通过同一个泛型类的实例来区分方法&＃xff0c;如下面的例子编译时会出错&＃xff0c;因为类型擦除后&＃xff0c;两个方法都是List类型的参数&＃xff0c;因此并不能根据泛型类的类型来区分方法。

1 /*会导致编译时错误*/

2 public classErasure{3 public void test(Listls){4 System.out.println("Sting");5 }6 public void test(Listli){7 System.out.println("Integer");8 }9 }

那么这就有个问题了&＃xff0c;既然在编译的时候会在方法和类中擦除实际类型的信息&＃xff0c;那么在返回对象时又是如何知道其具体类型的呢&＃xff1f;如List编译后会擦除掉String信息&＃xff0c;那么在运行时通过迭代器返回List中的对象时&＃xff0c;又是如何知道List中存储的是String类型对象呢&＃xff1f;

擦除在方法体中移除了类型信息&＃xff0c;所以在运行时的问题就是边界&＃xff1a;即对象进入和离开方法的地点&＃xff0c;这正是编译器在编译期执行类型检查并插入转型代码的地点。泛型中的所有动作都发生在边界处&＃xff1a;对传递进来的值进行额外的编译期检查&＃xff0c;并插入对传递出去的值的转型。

3.泛型和子类型

为了彻底理解泛型&＃xff0c;这里看个例子&＃xff1a;(Apple为Fruit的子类)

List apples &＃61; new ArrayList(); //1

List fruits &＃61; apples; //2

第1行代码显然是对的&＃xff0c;但是第2行是否对呢&＃xff1f;我们知道Fruit fruit &＃61; new Apple()&＃xff0c;这样肯定是对的&＃xff0c;即苹果肯定是水果&＃xff0c;但是第2行在编译的时候会出错。这会让人比较纳闷的是一个苹果是水果&＃xff0c;为什么一箱苹果就不是一箱水果了呢&＃xff1f;可以这样考虑&＃xff0c;我们假定第2行代码没有问题&＃xff0c;那么我们可以使用语句fruits.add(new Strawberry())(Strawberry为Fruit的子类)在fruits中加入草莓了&＃xff0c;但是这样的话&＃xff0c;一个List中装入了各种不同类型的子类水果&＃xff0c;这显然是不可以的&＃xff0c;因为我们在取出List中的水果对象时&＃xff0c;就分不清楚到底该转型为苹果还是草莓了。

通常来说&＃xff0c;如果Foo是Bar的子类型&＃xff0c;G是一种带泛型的类型&＃xff0c;则G不是G的子类型。这也许是泛型学习里面最让人容易混淆的一点。

4.通配符

4.1通配符&＃xff1f;

先看一个打印集合中所有元素的代码。

1 //不使用泛型

2 voidprintCollection(Collection c) {3 Iterator i&＃61;c.iterator();4 for (k&＃61;0;k

1 //使用泛型

2 void printCollection(Collectionc) {3 for(Object e:c) {4 System.out.println(e);5 }6 }

很容易发现&＃xff0c;使用泛型的版本只能接受元素类型为Object类型的集合如ArrayList();如果是ArrayList&＃xff0c;则会编译时出错。因为我们前面说过&＃xff0c;Collection并不是所有集合的超类。而老版本可以打印任何类型的集合&＃xff0c;那么如何改造新版本以便它能接受所有类型的集合呢&＃xff1f;这个问题可以通过使用通配符来解决。修改后的代码如下所示&＃xff1a;

//使用通配符&＃xff1f;&＃xff0c;表示可以接收任何元素类型的集合作为参数

void printCollection(Collection> c) {

for (Object e:c) {

System.out.println(e);

}

}

这里使用了通配符&＃xff1f;指定可以使用任何类型的集合作为参数。读取的元素使用了Object类型来表示&＃xff0c;这是安全的&＃xff0c;因为所有的类都是Object的子类。这里就又出现了另外一个问题&＃xff0c;如下代码所示&＃xff0c;如果试图往使用通配符&＃xff1f;的集合中加入对象&＃xff0c;就会在编译时出现错误。需要注意的是&＃xff0c;这里不管加入什么类型的对象都会出错。这是因为通配符&＃xff1f;表示该集合存储的元素类型未知&＃xff0c;可以是任何类型。往集合中加入元素需要是一个未知元素类型的子类型&＃xff0c;正因为该集合存储的元素类型未知&＃xff0c;所以我们没法向该集合中添加任何元素。唯一的例外是null&＃xff0c;因为null是所有类型的子类型&＃xff0c;所以尽管元素类型不知道&＃xff0c;但是null一定是它的子类型。

Collection> c&＃61;newArrayList();

c.add(newObject()); //compile time error&＃xff0c;不管加入什么对象都出错&＃xff0c;除了null外。

c.add(null); //OK

另一方面&＃xff0c;我们可以从List> lists中获取对象&＃xff0c;虽然不知道List中存储的是什么类型&＃xff0c;但是可以肯定的是存储的类型一定是Object的子类型&＃xff0c;所以可以用Object类型来获取值。如for(Object obj: lists)&＃xff0c;这是合法的。

4.2边界通配符

1)&＃xff1f;extends通配符

假定有一个画图的应用&＃xff0c;可以画各种形状的图形&＃xff0c;如矩形和圆形等。为了在程序里面表示&＃xff0c;定义如下的类层次&＃xff1a;

publicabstractclassShape {

    publicabstractvoiddraw(Canvas c);

}

publicclassCircle extendsShape {

    privateintx,y,radius;

    publicvoiddraw(Canvas c) { ... }

}

publicclassRectangle extendsShape

    privateintx,y,width,height;

    publicvoiddraw(Canvasc) { ... }

}

为了画出集合中所有的形状&＃xff0c;我们可以定义一个函数&＃xff0c;该函数接受带有泛型的集合类对象作为参数。但是不幸的是&＃xff0c;我们只能接收元素类型为Shape的List对象&＃xff0c;而不能接收类型为List的对象&＃xff0c;这在前面已经说过。为了解决这个问题&＃xff0c;所以有了边界通配符的概念。这里可以采用public void drawAll(List extends Shape>shapes)来满足条件&＃xff0c;这样就可以接收元素类型为Shape子类型的列表作为参数了。

//原始版本

publicvoiddrawAll(List shapes) {

    for(Shapes:shapes) {

        s.draw(this);

    }

}

//使用边界通配符的版本

publicvoiddrawAll(List shapes) {

    for(Shapes:shapes) {

        s.draw(this);

    }

}

这里就又有个问题要注意了&＃xff0c;如果我们希望在List shapes中加入一个矩形对象&＃xff0c;如下所示&＃xff1a;

shapes.add(0, new Rectangle()); //compile-time error

那么这时会出现一个编译时错误&＃xff0c;原因在于&＃xff1a;我们只知道shapes中的元素时Shape类型的子类型&＃xff0c;具体是什么子类型我们并不清楚&＃xff0c;所以我们不能往shapes中加入任何类型的对象。不过我们在取出其中对象时&＃xff0c;可以使用Shape类型来取值&＃xff0c;因为虽然我们不知道列表中的元素类型具体是什么类型&＃xff0c;但是我们肯定的是它一定是Shape类的子类型。

2)&＃xff1f;super通配符

这里还有一种边界通配符为&＃xff1f;super。比如下面的代码&＃xff1a;

List shapes &＃61; newArrayList();

List superCicle> cicleSupers &＃61; shapes;

cicleSupers.add(newCicle()); //OK, subclass of Cicle also OK

cicleSupers.add(newShape()); //ERROR

这表示cicleSupers列表存储的元素为Cicle的超类&＃xff0c;因此我们可以往其中加入Cicle对象或者Cicle的子类对象&＃xff0c;但是不能加入Shape对象。这里的原因在于列表cicleSupers存储的元素类型为Cicle的超类&＃xff0c;但是具体是Cicle的什么超类并不清楚。但是我们可以确定的是只要是Cicle或者Circle的子类&＃xff0c;则一定是与该元素类别兼容。

3)边界通配符总结

l         如果你想从一个数据类型里获取数据&＃xff0c;使用 ? extends通配符

l         如果你想把对象写入一个数据结构里&＃xff0c;使用 ? super通配符

l         如果你既想存&＃xff0c;又想取&＃xff0c;那就别用通配符。

5.泛型方法

考虑实现一个方法&＃xff0c;该方法拷贝一个数组中的所有对象到集合中。下面是初始的版本&＃xff1a;

staticvoidfromArrayToCollection(Object[]a, Collection> c) {

    for(Object o:a) {

        c.add(o); //compile time error

    }

}

可以看到显然会出现编译错误&＃xff0c;原因在之前有讲过&＃xff0c;因为集合c中的类型未知&＃xff0c;所以不能往其中加入任何的对象(当然&＃xff0c;null除外)。解决该问题的一种比较好的办法是使用泛型方法&＃xff0c;如下所示&＃xff1a;

static voidfromArrayToCollection(T[] a, Collectionc){

    for(T o : a) {

        c.add(o);// correct

    }

}

注意泛型方法的格式&＃xff0c;类型参数需要放在函数返回值之前。然后在参数和返回值中就可以使用泛型参数了。具体一些调用方法的实例如下&＃xff1a;

Object[] oa &＃61; newObject[100];

Collectionco &＃61; newArrayList();

fromArrayToCollection(oa, co);// T inferred to be Object

String[] sa &＃61; newString[100];

Collectioncs &＃61; newArrayList();

fromArrayToCollection(sa, cs);// T inferred to be String

fromArrayToCollection(sa, co);// T inferred to be Object

Integer[] ia &＃61; newInteger[100];

Float[] fa &＃61; newFloat[100];

Number[] na &＃61; newNumber[100];

Collectioncn &＃61; newArrayList();

fromArrayToCollection(ia, cn);// T inferred to be Number

fromArrayToCollection(fa, cn);// T inferred to be Number

fromArrayToCollection(na, cn);// T inferred to be Number

fromArrayToCollection(na, co);// T inferred to be Object

fromArrayToCollection(na, cs);// compile-time error

注意到我们调用方法时并不需要传递类型参数,系统会自动判断类型参数并调用合适的方法。当然在某些情况下需要指定传递类型参数&＃xff0c;比如当存在与泛型方法相同的方法的时候(方法参数类型不一致)&＃xff0c;如下面的一个例子&＃xff1a;

public voidgo(T t) {

System.out.println("generic function");

}

publicvoidgo(String str) {

System.out.println("normal function");

}

publicstaticvoidmain(String[] args) {

FuncGenric fg &＃61; newFuncGenric();

fg.go("haha");//打印normal function

fg.go("haha");//打印generic function

fg.go(newObject());//打印generic function

fg.go(newObject());//打印generic function

}

如例子中所示&＃xff0c;当不指定类型参数时&＃xff0c;调用的是普通的方法&＃xff0c;如果指定了类型参数&＃xff0c;则调用泛型方法。可以这样理解&＃xff0c;因为泛型方法编译后类型擦除&＃xff0c;如果不指定类型参数&＃xff0c;则泛型方法此时相当于是public void go(Object t)。而普通的方法接收参数为String类型&＃xff0c;因此以String类型的实参调用函数&＃xff0c;肯定会调用形参为String的普通方法了。如果是以Object类型的实参调用函数&＃xff0c;则会调用泛型方法。

6.其他需要注意的小点

1)方法重载

在JAVA里面方法重载是不能通过返回值类型来区分的&＃xff0c;比如代码一中一个类中定义两个如下的方法是不容许的。但是当参数为泛型类型时&＃xff0c;却是可以的。如下面代码二中所示&＃xff0c;虽然形参经过类型擦除后都为List类型&＃xff0c;但是返回类型不同&＃xff0c;这是可以的。

/*代码一&＃xff1a;编译时错误*/

publicclassErasure{

publicvoidtest(inti){

System.out.println("Sting");

}

publicinttest(inti){

System.out.println("Integer");

}

}/*代码二&＃xff1a;正确 */

publicclassErasure{

publicvoidtest(List ls){

System.out.println("Sting");

}

publicinttest(List li){

System.out.println("Integer");

}

}

2)泛型类型是被所有调用共享的

所有泛型类的实例都共享同一个运行时类&＃xff0c;类型参数信息会在编译时被擦除。因此考虑如下代码&＃xff0c;虽然ArrayList和ArrayList类型参数不同&＃xff0c;但是他们都共享ArrayList类&＃xff0c;所以结果会是true。

Listl1 &＃61; newArrayList();

Listl2 &＃61; newArrayList();

System.out.println(l1.getClass() &＃61;&＃61; l2.getClass()); //True

3)instanceof

不能对确切的泛型类型使用instanceOf操作。如下面的操作是非法的&＃xff0c;编译时会出错。

Collection cs &＃61; newArrayList();

if(cs instanceofCollection){…}// compile error.如果改成instanceof Collection>则不会出错。

4)泛型数组问题

不能创建一个确切泛型类型的数组。如下面代码会出错。

List[] lsa &＃61; new ArrayList[10]; //compile error.

因为如果可以这样&＃xff0c;那么考虑如下代码&＃xff0c;会导致运行时错误。

List[] lsa &＃61; newArrayList[10]; // 实际上并不允许这样创建数组

Object o &＃61; lsa;

Object[] oa &＃61; (Object[]) o;

Listli &＃61; newArrayList();

li.add(newInteger(3));

oa[1] &＃61; li;// unsound, but passes run time store check

String s &＃61; lsa[1].get(0); //run-time error - ClassCastException

因此只能创建带通配符的泛型数组&＃xff0c;如下面例子所示&＃xff0c;这回可以通过编译&＃xff0c;但是在倒数第二行代码中必须显式的转型才行&＃xff0c;即便如此&＃xff0c;最后还是会抛出类型转换异常&＃xff0c;因为存储在lsa中的是List类型的对象&＃xff0c;而不是List类型。最后一行代码是正确的&＃xff0c;类型匹配&＃xff0c;不会抛出异常。

List>[] lsa &＃61; newList>[10]; // ok, array of unbounded wildcard type

Object o &＃61; lsa;

Object[] oa &＃61; (Object[]) o;

Listli &＃61; newArrayList();

li.add(newInteger(3));

oa[1] &＃61; li; //correct

String s &＃61; (String) lsa[1].get(0);// run time error, but cast is explicit

Integer it &＃61; (Integer)lsa[1].get(0); // OK