1介绍

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

下面是一个不用泛型例子:

 List myIntList=new LinkedList(); //1
myIntList.add(newInteger()); //2
Integer x=(Integer)myIntList.iterator().next(); //3

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

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

 List<Integer> myIntList=newLinkedList<Integer>(); //1’
myIntList.add(newInteger()); //2’
Integerx=myIntList.iterator().next(); //3’

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

 2定义简单的泛型

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

 public interface List<E> {
<span style="white-space: pre;"> </span>void add(E x);
<span style="white-space: pre;"> </span>Iterator<E> iterator();
}
public interface Iterator<E> {
<span style="white-space: pre;"> </span>E next();
<span style="white-space: pre;"> </span>boolean hasNext();
}

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

也许可以这样认为,List<Integer>表示List中的类型参数E会被替换成Integer。

 public interface IntegerList {
<span style="white-space: pre;"> </span>void add(Integer x)
<span style="white-space: pre;"> </span>Iterator<Integer> iterator();
}

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

 /*会导致编译时错误*/
public class Erasure{
public void test(List<String> ls){
System.out.println("Sting");
}
public void test(List<Integer> li){
System.out.println("Integer");
}
}

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

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

3.泛型和子类型

为了彻底理解泛型,这里看个例子:(Apple为Fruit的子类)

List<Apple> apples = new ArrayList<Apple>(); //1
List<Fruit> fruits = apples; //2

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

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

 

4.通配符

4.1通配符?

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

 //不使用泛型
void printCollection(Collection c) {
<span style="white-space: pre;"> </span>Iterator i=c.iterator();
<span style="white-space: pre;"> </span>for (k=;k < c.size();k++) {
<span style="white-space: pre;"> </span>System.out.println(i.next());
<span style="white-space: pre;"> </span>}
}
 //使用泛型
void printCollection(Collection<Object> c) {
for (Object e:c) {
System.out.println(e);
}
}

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

//使用通配符?,表示可以接收任何元素类型的集合作为参数
void printCollection(Collection<?> c) {
<span style="white-space: pre;"> </span>for (Object e:c) {
<span style="white-space: pre;"> </span>System.out.println(e);
<span style="white-space: pre;"> </span>}
}

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

  1. Collection<?> c=new ArrayList<String>();
  2. c.add(newObject()); //compile time error,不管加入什么对象都出错,除了null外。
  3. c.add(null); //OK

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

4.2边界通配符

1)?extends通配符

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

  1. public abstract class Shape {
  2. <span style="white-space: pre;">    </span>public abstract void draw(Canvas c);
  3. }
  4. public class Circle extends Shape {
  5. <span style="white-space: pre;">    </span>private int x,y,radius;
  6. <span style="white-space: pre;">    </span>public void draw(Canvas c) { ... }
  7. }
  8. public class Rectangle extends Shape
  9. <span style="white-space: pre;">    </span>private int x,y,width,height;
  10. <span style="white-space: pre;">    </span>public void draw(Canvasc) { ... }
  11. }

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

  1. //原始版本
  2. public void drawAll(List<Shape> shapes) {
  3. <span style="white-space: pre;">    </span>for (Shapes:shapes) {
  4. <span style="white-space: pre;">        </span>s.draw(this);
  5. <span style="white-space: pre;">    </span>}
  6. }
  1. //使用边界通配符的版本
  2. public void drawAll(List<?exends Shape> shapes) {
  3. <span style="white-space: pre;">    </span>for (Shapes:shapes) {
  4. <span style="white-space: pre;">        </span>s.draw(this);
  5. <span style="white-space: pre;">    </span>}
  6. }

这里就又有个问题要注意了,如果我们希望在List<?exends Shape> shapes中加入一个矩形对象,如下所示:

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

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

       2)?super通配符

这里还有一种边界通配符为?super。比如下面的代码:

  1. List<Shape> shapes = new ArrayList<Shape>();
  2. List<? super Cicle> cicleSupers = shapes;
  3. cicleSupers.add(new Cicle()); //OK, subclass of Cicle also OK
  4. cicleSupers.add(new Shape()); //ERROR

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

3)边界通配符总结

<!--[if !supportLists]-->l         <!--[endif]-->如果你想从一个数据类型里获取数据,使用 ? extends 通配符

<!--[if !supportLists]-->l         <!--[endif]-->如果你想把对象写入一个数据结构里,使用 ? super 通配符

<!--[if !supportLists]-->l         <!--[endif]-->如果你既想存,又想取,那就别用通配符。

 

5.泛型方法

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

  1. static void fromArrayToCollection(Object[]a, Collection<?> c) {
  2. <span style="white-space: pre;">    </span>for (Object o:a) {
  3. <span style="white-space: pre;">        </span>c.add(o); //compile time error
  4. <span style="white-space: pre;">    </span>}
  5. }

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

  1. static <T> void fromArrayToCollection(T[] a, Collection<T>c){
  2. <span style="white-space: pre;">    </span>for(T o : a) {
  3. <span style="white-space: pre;">        </span>c.add(o);// correct
  4. <span style="white-space: pre;">    </span>}
  5. }

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

  1. Object[] oa = new Object[100];
  2. Collection<Object>co = new ArrayList<Object>();
  3. fromArrayToCollection(oa, co);// T inferred to be Object
  4. String[] sa = new String[100];
  5. Collection<String>cs = new ArrayList<String>();
  6. fromArrayToCollection(sa, cs);// T inferred to be String
  7. fromArrayToCollection(sa, co);// T inferred to be Object
  8. Integer[] ia = new Integer[100];
  9. Float[] fa = new Float[100];
  10. Number[] na = new Number[100];
  11. Collection<Number>cn = new ArrayList<Number>();
  12. fromArrayToCollection(ia, cn);// T inferred to be Number
  13. fromArrayToCollection(fa, cn);// T inferred to be Number
  14. fromArrayToCollection(na, cn);// T inferred to be Number
  15. fromArrayToCollection(na, co);// T inferred to be Object
  16. fromArrayToCollection(na, cs);// compile-time error

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

  1. public  <T> void go(T t) {
  2. System.out.println("generic function");
  3. }
  4. public void go(String str) {
  5. System.out.println("normal function");
  6. }
  7. public static void main(String[] args) {
  8. FuncGenric fg = new FuncGenric();
  9. fg.go("haha");//打印normal function
  10. fg.<String>go("haha");//打印generic function
  11. fg.go(new Object());//打印generic function
  12. fg.<Object>go(new Object());//打印generic function
  13. }

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

6.其他需要注意的小点

1)方法重载

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

  1. /*代码一:编译时错误*/
  2. public class Erasure{
  3. public void test(int i){
  4. System.out.println("Sting");
  5. }
  6. public int test(int i){
  7. System.out.println("Integer");
  8. }
  9. }
  1. /*代码二:正确 */
  2. public class Erasure{
  3. public void test(List<String> ls){
  4. System.out.println("Sting");
  5. }
  6. public int test(List<Integer> li){
  7. System.out.println("Integer");
  8. }
  9. }

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

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

  1. List<String>l1 = new ArrayList<String>();
  2. List<Integer>l2 = new ArrayList<Integer>();
  3. System.out.println(l1.getClass() == l2.getClass()); //True

3)instanceof

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

  1. Collection cs = new ArrayList<String>();
  2. if (cs instanceof Collection<String>){…}// compile error.如果改成instanceof Collection<?>则不会出错。

4)泛型数组问题

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

List<String>[] lsa = new ArrayList<String>[10]; //compile error.

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

  1. List<String>[] lsa = new ArrayList<String>[10]; // 实际上并不允许这样创建数组
  2. Object o = lsa;
  3. Object[] oa = (Object[]) o;
  4. List<Integer>li = new ArrayList<Integer>();
  5. li.add(new Integer(3));
  6. oa[1] = li;// unsound, but passes run time store check
  7. String s = lsa[1].get(0); //run-time error - ClassCastException

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

  1. List<?>[] lsa = new List<?>[10]; // ok, array of unbounded wildcard type
  2. Object o = lsa;
  3. Object[] oa = (Object[]) o;
  4. List<Integer>li = new ArrayList<Integer>();
  5. li.add(new Integer(3));
  6. oa[1] = li; //correct
  7. String s = (String) lsa[1].get(0);// run time error, but cast is explicit
  8. Integer it = (Integer)lsa[1].get(0); // OK

JAVA泛型编程笔记的更多相关文章

  1. 0037 Java学习笔记-多线程-同步代码块、同步方法、同步锁

    什么是同步 在上一篇0036 Java学习笔记-多线程-创建线程的三种方式示例代码中,实现Runnable创建多条线程,输出中的结果中会有错误,比如一张票卖了两次,有的票没卖的情况,因为线程对象被多条 ...

  2. 0035 Java学习笔记-注解

    什么是注解 注解可以看作类的第6大要素(成员变量.构造器.方法.代码块.内部类) 注解有点像修饰符,可以修饰一些程序要素:类.接口.变量.方法.局部变量等等 注解要和对应的配套工具(APT:Annot ...

  3. Java学习笔记(04)

    Java学习笔记(04) 如有不对或不足的地方,请给出建议,谢谢! 一.对象 面向对象的核心:找合适的对象做合适的事情 面向对象的编程思想:尽可能的用计算机语言来描述现实生活中的事物 面向对象:侧重于 ...

  4. 0032 Java学习笔记-类加载机制-初步

    JVM虚拟机 Java虚拟机有自己完善的硬件架构(处理器.堆栈.寄存器等)和指令系统 Java虚拟机是一种能运行Java bytecode的虚拟机 JVM并非专属于Java语言,只要生成的编译文件能匹 ...

  5. 0030 Java学习笔记-面向对象-垃圾回收、(强、软、弱、虚)引用

    垃圾回收特点 垃圾:程序运行过程中,会为对象.数组等分配内存,运行过程中或结束后,这些对象可能就没用了,没有变量再指向它们,这时候,它们就成了垃圾,等着垃圾回收程序的回收再利用 Java的垃圾回收机制 ...

  6. 0028 Java学习笔记-面向对象-Lambda表达式

    匿名内部类与Lambda表达式示例 下面代码来源于:0027 Java学习笔记-面向对象-(非静态.静态.局部.匿名)内部类 package testpack; public class Test1{ ...

  7. 0025 Java学习笔记-面向对象-final修饰符、不可变类

    final关键字可以用于何处 修饰类:该类不可被继承 修饰变量:该变量一经初始化就不能被重新赋值,即使该值跟初始化的值相同或者指向同一个对象,也不可以 类变量: 实例变量: 形参: 注意可以修饰形参 ...

  8. [Java入门笔记] 面向对象编程基础(二):方法详解

    什么是方法? 简介 在上一篇的blog中,我们知道了方法是类中的一个组成部分,是类或对象的行为特征的抽象. 无论是从语法和功能上来看,方法都有点类似与函数.但是,方法与传统的函数还是有着不同之处: 在 ...

  9. 《Java学习笔记(第8版)》学习指导

    <Java学习笔记(第8版)>学习指导 目录 图书简况 学习指导 第一章 Java平台概论 第二章 从JDK到IDE 第三章 基础语法 第四章 认识对象 第五章 对象封装 第六章 继承与多 ...

随机推荐

  1. Python:ajax 学习笔记

    什么是 AJAX ? AJAX = 异步 JavaScript 和 XML. AJAX 是一种用于创建快速动态网页的技术. 通过在后台与服务器进行少量数据交换,AJAX 可以使网页实现异步更新.这意味 ...

  2. virtual-虚方法

    看来本人理论果然不行啊,这个东西折腾死我了.即便是到现在,还是云里雾里.... 个人认为virtual的特点就是可以被override而不是必需的,到目前为止我用它的地方也比较少. public cl ...

  3. c标签的使用方法

    1. c:forEach <c:forEach items="> 注意varStatus相当于for循环计数器,从1开始,用${varStatus.count}获得计数器的值.而 ...

  4. OC基础 内存管理

    OC基础  内存管理 我们所了解的c语言内存管理,如下: (1)c语言的内存分配:char *p = (char*)malloc(100*sizeof(char)); (2)c语言的内存释放:free ...

  5. acm poj1260 dp

    题目大意: 买珍珠,每买一种珍珠需要额外付出十个这种珍珠的钱,但你可以买比这种珍珠高品质的珍珠来替换它(那么就只需要那高品质付出那额外的十个珍珠的钱了,但是每个珍珠的价钱也变化了) 这是一个dp. 令 ...

  6. uva 759 - The Return of the Roman Empire

    #include <cstdio> #include <string> #include <map> using namespace std; ; , , , , ...

  7. ECharts开源图表使用方法简单介绍

    ECharts图表是基于Canvas,纯Javascript图表库,基于BSD开源协议,官网地址:http://echarts.baidu.com/index.html 需要先下载插件:https:/ ...

  8. 更换ios 开发者账号与下载别人的代码 真机调试时注意切换

    Buid Setting search sign

  9. WPF、WinForm(C#)多线程编程并更新界面(UI)(转载积累)

    using System;using System.Collections.Generic;using System.ComponentModel;using System.Drawing;using ...

  10. google 地图,多个标记 js库

    360 云盘:http://yunpan.cn/cVgU3X7JFxAGY (提取码:1f07) 百度云盘:链接: http://pan.baidu.com/s/1c0fbCWw 密码: w1pm 参 ...