JAVA泛型详解

       泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分贝成为泛型类、泛型接口、泛型方法。Java语言引入泛型的好处就是安全简单。

     在Java SE 1.5之前，没有泛型的情况下，通过堆类型Object的引用来实现参数的“任意化”，这样做的缺点就是要进行显式的强制类型转换，而这种转换要求开发者对实际的参数类型可以预知的情况下进行。对于强制类型转换错误的信息，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

   泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。

   一、泛型的规则

    1，泛型的参数类型只能是类类型（包含自定义类），不能是简单类型。

    2，同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

    3，泛型的类型参数可以有多个

    4，泛型的参数可以使用extends语句，例如<T extends superclass>. 习惯上称之为有界类型。

    5，泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");

  二、下面举一个实现了泛型的例子。

   

package com.fanxing.demo;public class Gen<T> {  private T ob;public Gen(T ob) {super();this.ob = ob;}public T getOb() {return ob;}public void setOb(T ob) {this.ob = ob;}  public void showType(){System.out.println("T的实际类型是：" +ob.getClass().getName());}  }

package com.fanxing.demo;public class FanxingText {public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("泛型测试");Gen<Integer> intm = new Gen<Integer>(1000);int s = intm.getOb();intm.showType();System.out.println("s等于"+s);System.out.println("----------");Gen<String> strm = new Gen<String>("我是字符串");String mString = strm.getOb();strm.showType();System.out.println("mString等于"+mString);}}

 如果上面的例子不使用泛型

  

package com.fanxing.demo;public class UnGen {private Object ob;public Object getOb() {return ob;}public void setOb(Object ob) {this.ob = ob;}public UnGen(Object ob) {super();this.ob = ob;}public void showType(){System.out.println("T的实际类型是：" +ob.getClass().getName());}}

package com.fanxing.demo;public class FanxingText {public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("泛型测试");UnGen intm = new UnGen(new Integer(1000));int s = (int) intm.getOb();intm.showType();System.out.println("s等于"+s);System.out.println("----------");UnGen strm = new UnGen(new String("我是字符串"));String mString = (String) strm.getOb();strm.showType();System.out.println("mString等于"+mString);}}

可以看到两个例子运行的结果是一样的。

 三、深入泛型

  下面是两个普通的类：

   1，

package com.fanxing.demo;public class AString {   private String xString;   public AString(String xString) {super();this.xString = xString;}public String getxString() {return xString;}public void setxString(String xString) {this.xString = xString;}   }

2,

package com.fanxing.demo;public class BString {private String bString;public String getbString() {return bString;}public void setbString(String bString) {this.bString = bString;}public BString(String bString) {super();this.bString = bString;}}

3,重构上面的代码

 

package com.fanxing.demo;public class CObject {private Object cObject;public Object getcObject() {return cObject;}public void setcObject(Object cObject) {this.cObject = cObject;}public CObject(Object cObject) {super();this.cObject = cObject;}}

package com.fanxing.demo;public class FanxingText {public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("泛型测试");UnGen intm = new UnGen(new Integer(1000));int s = (int) intm.getOb();intm.showType();System.out.println("s等于"+s);System.out.println("----------");UnGen strm = new UnGen(new String("我是字符串"));String mString = (String) strm.getOb();strm.showType();System.out.println("mString等于"+mString);AString aString = new AString("我是A");BString bString = new BString("我是B");CObject cObject = new CObject(new String("我是String类型"));CObject cObject2 = new CObject(new Integer(20));CObject cObject3 = new CObject(new Object());System.out.println("类型分别是"+cObject.getcObject());System.out.println("类型分别是"+cObject2.getcObject());System.out.println("类型分别是"+cObject3.getcObject());}}

 在java5之前为了类的通用性，往往将参数类型和方法设为Object类型，在使用的过程中必须进行强制类型转换。这就要求我们事先知道各个Object的类型是什么，如果强制类型转换错误，程序在运行的时候就会报错，那么所以需要泛型来解决这个问题，就必须要进行强制类型转换了。

使用<T>来声明一个类型持有者名称，然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。
当然T仅仅是个名字，这个名字可以自行定义。
class GenericsFoo<T> 声明了一个泛型类，这个T没有任何限制，实际上相当于Object类型，实际上相当于 class GenericsFoo<T extends Ob

ject>。
与Object泛型类相比，使用泛型所定义的类在声明和构造实例的时候，可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如
GenericsFoo<Double> douFoo=new GenericsFoo<Double>(new Double("33"));
当然，也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型，但是你在使用该对象的时候，就需要强制转换了。比如：GenericsFoo douFoo=new GenericsFoo(new Double("33"));
实际上，当构造对象时不指定类型信息的时候，默认会使用Object类型，这也是要强制转换的原因。

四、限制泛型

    在上面的例子中，由于没有限制class Gen<T> 类型持有者T的范围，实际上这里的限定类型相当于Object，这和Object泛型的实质是一样的。限制比如我们要限制T为集合接口类型。只需要：<T extends Collection>，这种类型的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。注意：这里使用的限定关键词 extends，后面可以是类也可以是接口。但是这里的extends所表达的意思已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。

 下面继续对上面的例子进行改进，我们只需要实现集合接口的类型：

  

package com.fanxing.demo;import java.util.Collection;public class CollectionGenFoo <T extends Collection>{    private T xT;public T getxT() {return xT;}public void setxT(T xT) {this.xT = xT;}public CollectionGenFoo(T xT) {super();this.xT = xT;}        }

  这样我们只需要写出具体的实现子类型就行，可是实现子类型也非常的多，一个一个写也非常麻烦。我们可以用通配符泛型来解决。先说另外一种多接口的限制：虽然Java泛型简单的用 extends 统一的表示了原有的 extends 和 implements 的概念，但仍要遵循应用的体系，Java 只能继承一个类，但可以实现多个接口，所以你的某个类型需要用 extends 限定，且有多种类型的时候，只能存在一个是类，并且类写在第一位，接口列在后面，也就是：

   <T extends SomeClass & interface1 & interface2 & interface3>  T类型就可以用SomeClass声明的方法和interface所拥有的特性了

上代码：

 

package com.fanxing.demo;public class a {public void pring(){System.out.println("继承的属性");}}

package com.fanxing.demo;public interface B {    void printb();}

package com.fanxing.demo;public class C extends a implements B{@Overridepublic void printb() {// TODO Auto-generated method stubSystem.out.println("B接口的特性");}@Overridepublic void pring() {// TODO Auto-generated method stubsuper.pring();}}

package com.fanxing.demo;public class MoreInterfaceX<T extends a & B> {private T xT;public T getxT() {return xT;}public void setxT(T xT) {this.xT = xT;}public MoreInterfaceX(T xT) {super();this.xT = xT;}}

CollectionGenFoo<ArrayList> cFoo = new CollectionGenFoo<ArrayList>(new ArrayList<>());System.out.println("编译通过");C cm = new C();MoreInterfaceX<C> mX = new MoreInterfaceX<C>(cm);mX.getxT().pring();mX.getxT().printb();

五、通配符泛型

  为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”，针对上面的例子，使用通配泛型格式为<? extends Collection>，“？”代表未知类型，这个类型是实现Collection接口。那么上面实现的方式可以写为

 

public class CollectionGenFooDemo {         public static void main(String args[]) {                 //CollectionGenFoo<ArrayList> listFoo = null;                 //listFoo = new CollectionGenFoo<ArrayList>(new ArrayList());         CollectionGenFoo<?> listFoo1 = null;                 listFoo1=new CollectionGenFoo<ArrayList>(new ArrayList());                 System.out.println("实例化成功!");         } }

注意：

1、如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。

2、通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。

3、泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。

 六、泛型方法

  是否拥有泛型方法，与其所在的类是否泛型没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前。如:

package com.fanxing.demo;import java.util.ArrayList;public class FanxingText {public <T> void f(T x) {System.out.println(x.getClass().getName());}public static void main(String[] args) {FanxingText ea = new FanxingText(); ea.f(" "); ea.f(10); ea.f('a'); ea.f(ea);}}

使用泛型方法时，不必指明参数类型，编译器会自己找出具体的类型。泛型方法除了定义不同，调用就像普通方法一样。

需要注意，一个static方法，无法访问泛型类的类型参数，所以，若要static方法需要使用泛型能力，必须使其成为泛型方法。

参考：百度百科: