Java——Java泛型

 该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。

 

一、泛型概述

1、定义：

所谓泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参（或叫泛型）将在声明变量、创建对象、调用方法时动态地指定（即传入实际的类型参数，也可称为类型实参）。Java5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

 

2、泛型初体验：一个被举了无数次的栗子

List arrayList =  new  ArrayList();
arrayList.add( "aaaa" );
arrayList.add( 100 );

for ( int  i =  0 ; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d( "泛型测试" , "item = "  + item);
}

　　

运行上述代码，我们可以在控制台看到这样的错误信息：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

　　

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

 

3、泛型的特性：

先思考如下一段代码：

List sList= new  ArrayList();
List iList= new  ArrayList();
System.out.println(sList.getClass()==iList.getClass());

 

先不要看结果，自己思考一下。

 

结果：

true

　　

我们看到输出的结果为true，通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。（泛型的这一特性在下述文字中会有详解介绍）

小结：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

 

 

二、泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

1、泛型类：

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型的基本写法：

class  类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private  泛型标识  /*（成员变量类型）*/  var;
  .....

  }
}

　　

看不懂？看不懂就对了，下面我们来看一个栗子：

public  class  Apple {

    //使用T类型定义变量
    private  T info;
    public  Apple() {}

    //下面方法使用T类型定义构造器
    public  Apple(T info){
        this .info=info;
    }

    public  T getInfo() {
        return  info;
    }

    public  void  setInfo(T info) {
        this .info = info;
    }

    public  static  void  main(String[] args) {
        //由于传给T形参的是String,所以构造器参数只能是String
        Apple apple= new  Apple( "苹果" );
        System.out.println(apple.getInfo());

        //由于传给T形参的是Double,所以构造器参数只能是Double
        Apple apple2= new  Apple( 5.56 );
        System.out.println(apple2.getInfo());

    }


}

　　

这里的T可以写成任意符合，常用的有如下几个符合：

• ？：表示不确定的 java 类型
• T (type)： 表示具体的一个java类型
• K V (key value)： 分别代表java键值中的Key Value
• E (element) ：代表Element

 

2、泛型接口：

泛型接口与泛型类的定义及使用基本相同。下面是Java5改写后的List接口，Map接口的代码片段

public  interface  List{
    //在该接口中，E可以作为类型使用
    //下面方法可以使用E作为参数类型
    void  add(E x);
    Iterator iterator();
}


//定义该接口时指定了两个泛型形参，其参数名为K,V
public  interface  Map{
    //在该接口中K,V完全可以作为类型使用
    Set keySet()
    V put(K key,V value);
}

　　

下面我们来看一个泛型案例：

定义一个泛型接口：

//定义一个泛型接口
public  interface  Generator {
    public  T next();
}

　　

现在有一个类实现了这个泛型接口，类的代码如下：

class  FruitGenerator  implements  Generator{
    @Override
    public  T next() {
        return  null ;
    }
}

　　

我们看到了这个类中也使用了泛型，并未传入实际的参数

未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中，即：class FruitGenerator implements Generator

如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错："Unknown class"

 

public  class  FruitGenerator  implements  Generator {

    private  String[] fruits =  new  String[]{ "Apple" ,  "Banana" ,  "Pear" };

    @Override
    public  String next() {
        Random rand =  new  Random();
        return  fruits[rand.nextInt( 3 )];
    }
}

　　

这段代码也是实现了Generator接口，不同的是传入了实际的类型String

传入泛型实参时：定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型即：Generator，public T next();中的的T都要替换成传入的String类型。

 

3、泛型通配符：

为什么要使用泛型通配符：

正如前面讲的，当使用一个泛型类时（包括声明变量和创建对象两种情况），都应该为这个泛型类传入一个类型实参。如果没有传入类型实际参数，编译器就会提出泛型警告。假设现在需要定义一个方法，该方法里有一个集合形参，集合形参的元素类型是不确定的，那应该怎样定义呢？

考虑如下代码：

public  void  test(List c) {
    for ( int  i= 0 ;i
        System.out.println(c.get(i));
    }
}

　　

上面程序当然没有问题：这是一段最普通的遍历List集合的代码。问题是上面程序中List是一个有泛型声明的接口，此处使用List 接口时没有传入实际类型参数，这将引起泛型警告。为此，考虑为List 接口传入实际的类型参数——因为List集合里的元素类型是不确定的

 

泛型通配符的使用：

为了表示各种泛型List的父类，可以使用类型通配符，类型通配符是一个问号（?），将一个问号作为类型实参传给List集合，写作：List（意思是元素类型未知的List）。这个问号（?）被称为通配符，它的元素类型可以匹配任何类型。可以将上面方法改写为如下形式：

public  void  test(List c) {
    for ( int  i= 0 ;i
        System.out.println(c.get(i));
    }
}

　　

这样就不会出现警告了，但这种带通配符的List仅表示它是各种泛型List的父类，并不能将其他元素加入到其中，例如将String放入其中

List c=new ArrayList();//这段代码将报错

因为程序无法确定c集合中元素的类型，所以不能向其中添加对象。根据前面的List接口定义的代码可以发现：add0方法有类型参数E作为集合的元素类型，所以传给add的参数必须是E类的对象或者其子类的对象。但因为在该例中不知道E是什么类型，所以程序无法将任何对象“丢进”该集合。唯一的例外是null，它是所有引用类型的实例。

 

设置类型通配符的上限：

现在想实现一个简单的绘图程序，代码如下：

public  abstract  class  Shape{
    public  abstract  void  draw(Canvas c);
}

//定义Shape的子类Circle
public  class  Circle  extends  Shape{
    //实现画图方法，以打印字符串来模拟画图方法实现
    public  void  draw(Canvas c)
    {
        System.out.println( "在画布" +c+ "上画一个圆" );
    }
}

//定义Shape的子类Rectangle
public  class  Rectangle  extends  Shape{
    //实现画图方法，以打印字符串来模拟画图方法实现
    public  void  draw（Canvas c）
    {
        System.out.print1n( "把一个矩形画在画布" +c+ "上" );
    }
}

　　

上面定义了三个形状类，其中Shape是一个抽象父类，该抽象父类有两个子类：Circle和Rectangle。接下来定义一个Canvas类，该画布类可以画数量不等的形状（Shape子类的对象），那应该如何定义这个Canvas类呢？考虑如下的Canvas实现类。

//同时在画布上绘制多个形状
public  void  drawAll(Listshapes) {
    for (Shape s:shapes)
        s.draw( this );
}

　　

注意上面的drawAll()方法的形参类型是List，而List并不是List的子类型，因此，下面代码将引起编译错误。

List circleList= new  ArrayList();
Canvas c= new  Canvas();
//不能把List当成List使用，所以下面代码引起编译错误
c.drawAll(circleList);

　　

这时我们可以通过通配符的上限来解决这个问题：

List extends  Shape>

　　

List是受限制通配符的例子，此处的问号（?）代表一个未知的类型，就像前面看到的通配符一样。但是此处的这个未知类型一定是Shape的子类型（也可以是Shape本身），因此可以把Shape称为这个通配符的上限（upper bound）。

 

设置类型通配符的下限：

除可以指定通配符的上限之外，Java也允许指定通配符的下限，通配符的下限用<？super类型>的方式来指定，通配符下限的作用与通配符上限的作用恰好相反。

指定通配符的下限就是为了支持类型型变。比如Foo是Bar的子类，当程序需要一个A变量时，程序可以将A、A