Java泛型分析

泛型是JAVA中应用频率很高的一个知识点，广泛引用在面向对象编程，各种框架的搭建等方面。以下是这篇博客的 大纲。

一.什么是泛型以及为什么要使用泛型

二.泛型的使用(泛型类，泛型接口，泛型方法，边界符，通配符，类型擦除)

三.泛型的使用场景

四.泛型的注意事项

 

 

一.什么是泛型以及为什么要使用泛型

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型再实际生产中应用很多，比如列举出List接口中的一部分代码如下，就用到了很多泛型的概念。

 

public interface List<E> extends Collection<E> { 
    Iterator<E> iterator();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
 }

在jdk1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是必须要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常(ClassCastException)，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

 

 

二.泛型的使用(泛型类，泛型接口，泛型方法，通配符，边界符，类型擦除)

2.1泛型类

2.1.1泛型类的最基本写法

 

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

  }
}

 

2.1.2测试类

 

//这里的T即Type的首字母，代表类型的意思，常用的还有E（element）、K（key）、V（value）等。当然不用这些字母指代类型参数也完全可以。
//在实例化泛型类时，必须指定T的具体类型
public class Test<T> {
    //param这个成员变量的类型为T,T的类型由外部指定  
    private T param;

    //泛型构造方法形参key的类型也为T，T的类型由外部指定
    public Test(T param) {
	this.param = param;
    }

    //泛型方法getParam的返回值类型为T，T的类型由外部指定
    public T getParam() {
    	return param;
    }
}

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Test<Integer> testInteger = new Test<Integer>(123);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Test<String> testString = new Test<String>("param");

 

2.1.3注意事项

1)泛型的类型参数只能是类类型，不能是简单类型。
2)不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
if(test_num instanceof Test<Number>){ 
} 

 

 

2.2泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中。注意，在声明泛型接口实现类的时候，分为将泛型的声明传入实现类与不传入实现类

 

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

2.2.1如果将泛型声明带入实现类，如下

 

class Test<T> implements MyCollection<T>{
    @Override
    public T next() {
        return null;
    }
}

2.2.2如果不带入泛型声明，那么这里就需要声明泛型对应的实际参数类型，比如下面这样

 

public class Test implements MyCollection<String> {

    private String[] testCollection = new String[]{aaa", "bbb", "ccc"};

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

 

 

 

 

2.3泛型方法

 

 

 

 

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

2.3.1泛型方法的使用

如下列出的部分List的源码里面的部分抽象方法，如果参数或者返回值是该泛型接口或者泛型类中存在的，比如List中的E，那么方法的访问修饰符与返回类型之间就不需要加<E>或者相应的类型参数，否则的话则必须要加，不然在编译的时候就会报错。

 

public interface List<E> extends Collection<E> { 
    Iterator<E> iterator();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean containsAll(Collection<?> c);
    E set(int index, E element);
    E remove(int index);
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
 }

泛型方法的基本语法如下：

 

public class GenericTest {
   //这个类是个泛型类，在上面已经介绍过
   public class Generic<T>{     
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }

        /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

    /** 
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

     /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

    /**
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
    public void showkey(T genericObj){

    }
    */

    public static void main(String[] args) {


    }
}

2.3.2静态泛型方法注意事项

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。如下

public class Test<T> {
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void insert(T t){..},此时编译器会提示错误信息：
          "Testcannot be refrenced from static context"
     */
    public static <T> void insert(T t){
    }
}

2.3.3泛型方法总结

 

泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个static的方法而已，无法访问泛型类型的参数。所以如果static方法要使用泛型能力，就必须使其成为泛型方法。

 

 

2.4通配符

当具体类型不确定的时候，这个通配符就是?；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用?通配符来表未知类型。

例如Class<?>classType = Class.forName("java.lang.String");

 

Class<T>和Class<?>的区别：
Class<T>在实例化的时候，T需要替换成具体的类
Class<?>是个通配泛型，?可以代表任何类型
比如：Class<T> T表示一种特定的参数类型 如Class<Integer>  Class<?>则表示任意类型，比如Class<?> clazz = Class.forName("java.lang.Thread");因为不知道TestforName的类型，这里只能用?不能用T。可以查看jdk的Class类源码的forName方法，返回值也是Class<?>

 

 

2.5边界符

 

2.5.1泛型的上下边界说明

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。形如”<? extends BoundingType>”的代码叫做通配符的子类型限定(上边界)。与之对应的还有通配符的超类型限定(下边界)，格式是这样的：<? super BoundingType>。

2.5.2边界符的应用

拿个自己项目中的某个方法来说

 

public List<? extends SourceBean> extractData(){
}

 

这样返回的List里面的元素类型只能是继承自SourceBean的了。

再来一个泛型方法的例子：

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T test(Test<T extends Number> args)，编译器会报错："Unexpected bound"
public <T extends Number> T test(Test<T> args){
    
}

通过上面的两个例子可以看出：泛型的上下边界添加，必须与泛型的声明在一起 。

 

 

 

2.6类型擦除

类型擦除相关的，具体可以看这篇博客Java泛型类型擦除部分

 

 

 

 

三.泛型的使用场景

java中的泛型这一概念提出的目的，其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
一提到泛型，相信大家用到最多的就是在集合中，其实，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。

泛型的本质就是将数据类型参数化，可以将泛型定义在接口,类和方法上。简单举几个场景：
    不想写多个重载函数的场景。

    约束对象类型的场景，可以定义边界（T extends ...），如JDK集合List，Set。

    用户希望返回他自定义类型的返回值场景，如Json返回Java bean。

    在用反射的应用中，也经常会用到泛型，如Class<T>。

    对网页，对资源的分析，返回场景，一般都有泛型。
其实泛型的应用还是很广的，一句话就是希望将数据类型参数化的地方，就可以用它
 

写框加和抽象必备技能：在写框架或者工具类的时候需要用的，泛型的类型检查可以避免一些错误或者运行时类型检查，可以少些instanceof 判断

JDK集合，Future<T>，WeakReference<T>，Class<T>等都是用泛型知识写好的的API

 

四.泛型的注意事项

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends super等关键字，例如<T extends superclass>。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(Java.lang.String);
6、不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
7、不能创建一个确切的泛型类型的数组。