java泛型

一、泛型的定义：

本质是参数化类型，即操作的数据类型（包括输入参数和输出参数）指定为一个参数。

这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

例如：

一个泛型类的定义：

class  Gen<T> {

     private  T ob;  // 定义泛型成员变量

 

     public  Gen(T ob) {

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

     }

}

 

使用方法：

public  class  GenDemo {

     public  static  void  main(String[] args) {

         // 定义泛型类Gen的一个Integer版本

         Gen<Integer> intOb =  new  Gen<Integer>( 88 );

         intOb.showType();

         int  i = intOb.getOb();

         System.out.println( "value= "  + i);

         System.out.println( "----------------------------------" );

         // 定义泛型类Gen的一个String版本

         Gen<String> strOb =  new  Gen<String>( "Hello Gen!" );

         strOb.showType();

         String s = strOb.getOb();

         System.out.println( "value= "  + s);

     }

}

 

 

 

二、泛型的作用：

在1.5版本以前，没有泛型概念，是通过强制类型转换来实现参数的任意性的，但是强制类型转换的一个弊端就是必须事前知道转换后的参数类型，而且编译器在编译阶段不会提示错误，在运行时才会出错，存在安全性问题。

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

 

 

 

三、泛型的基本应用：

例如，有两个类如下，要构造两个类的对象，并打印出各自的成员x：

public class StringFoo {

    private String x;

 

    public StringFoo(String x) {

        this.x = x;

    }

 

    public String getX() {

        return x;

    }

 

    public void setX(String x) {

        this.x = x;

    }

}

 

public class DoubleFoo {

    private Double x;

 

    public DoubleFoo(Double x) {

        this.x = x;

    }

 

    public Double getX() {

        return x;

    }

 

    public void setX(Double x) {

        this.x = x;

    }

}

因为上面的类中，成员和方法的逻辑都一样，就是类型不一样，因此考虑重构。Object是所有类的父类，因此可以考虑用Object做为成员类型，这样就可以实现通用了，实际上就是“Object泛型”，暂时这么称呼。

泛型写法：

public  class  ObjectFoo {

     private  Object x;

 

     public  ObjectFoo(Object x) {

         this .x = x;

     }

 

     public  Object getX() {

         return  x;

     }

 

     public  void  setX(Object x) {

         this .x = x;

     }

}

 

 

四、泛型的高阶应用：

1. 一个接口限制。

例如：class GenericsFoo<T extends Collection>，这样类中的泛型T只能是Collection接口的实现类，当传入非Collection接口的实现类时就会编译出错。

 

注意：<T extends Collection>这里的限定使用关键字extends，后面可以是类也可以是接口。但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。例如：

public class CollectionGenFoo<T extends Collection> {

    private T x;

 

    public CollectionGenFoo(T x) {

        this.x = x;

    }

 

    public T getX() {

        return x;

    }

 

    public void setX(T x) {

        this.x = x;

    }

 

}

 

2. 多接口限制。

同java类的定义规则一致（一个类只能最多继承一个类，但可以实现多个接口，并且类在前接口在后），

泛型也可以最多继承一个类，实现多个接口，并且保证类在前面接口在后面。即：

<T extends SomeClass & interface1 & interface2 & interface3>

例如：

public  class  Demo<T  extends  Comparable & Serializable> {

     // T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了

}

 

3. 通配符使用。

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

注意：

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

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

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

 

 

五、泛型方法：

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

例如：

public  class  ExampleA {

     public  <T>  void  f(T x) {

         System.out.println(x.getClass().getName());

     }

 

     public  static  void  main(String[] args) {

         ExampleA ea =  new  ExampleA();

         ea.f( " " );

         ea.f( 10 );

         ea.f( 'a' );

         ea.f(ea);

     }

}

 

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

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