java 泛型全解 - 绝对最详细

时间 2019-11-26

标签 java 绝对详细栏目 Java 繁體版

原文原文链接

背景

对于java的泛型我一直属于只知其一;不知其二的，日常真心用的很少。直到阅读《Effect Java》,看到不少日常不了解的用法，才下定决心，须要系统的学习，而且记录下来。java

一、泛型的概述：

1.1 泛型的由来

根据《Java编程思想》中的描述，泛型出现的动机：git

有不少缘由促成了泛型的出现，而最引人注意的一个缘由，就是为了建立容器类。
复制代码

泛型的思想很早就存在，如C++中的模板（Templates）。模板的精神：参数化类型github

1.2 基本概述

泛型的本质就是"参数化类型"。一提到参数，最熟悉的就是定义方法的时候须要形参，调用方法的时候，须要传递实参。那"参数化类型"就是将原来具体的类型参数化
泛型的出现避免了强转的操做，在编译器完成类型转化，也就避免了运行的错误。

1.3 泛型的目的

Java泛型也是一种语法糖，在编译阶段完成类型的转换的工做，避免在运行时强制类型转换而出现ClassCastException,类型转化异常。

1.4 实例

JDK 1.5时增长了泛型，在很大的程度上方便在集合上的使用。编程

不使用泛型：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add(11);
        list.add("ssss");
        for (int i = 0; i < list.size(); i++) {
            System.out.println((String)list.get(i));
        }
    }
复制代码

由于list类型是Object。因此int,String类型的数据都是能够放入的，也是均可以取出的。可是上述的代码，运行的时候就会抛出类型转化异常，这个相信你们都能明白。数组

使用泛型：

public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("hahah");
        list.add("ssss");
        for (int i = 0; i < list.size(); i++) {
            System.out.println((String)list.get(i));
        }
    }
复制代码

在上述的实例中，咱们只能添加String类型的数据，不然编译器会报错。bash

二、泛型的使用

泛型的三种使用方式：泛型类，泛型方法，泛型接口app

2.1 泛型类

泛型类概述：把泛型定义在类上
定义格式：

public class 类名 <泛型类型1,...> {
    
}
复制代码

注意事项：泛型类型必须是引用类型（非基本数据类型）

2.2 泛型方法

泛型方法概述：把泛型定义在方法上
定义格式：

public <泛型类型> 返回类型 方法名（泛型类型 变量名） {
    
}
复制代码

注意要点：
- 方法声明中定义的形参只能在该方法里使用，而接口、类声明中定义的类型形参则能够在整个接口、类中使用。当调用fun()方法时，根据传入的实际对象，编译器就会判断出类型形参T所表明的实际类型。

class Demo{  
  public <T> T fun(T t){   // 能够接收任意类型的数据  
   return t ;     // 直接把参数返回  
  }  
};  
public class GenericsDemo26{  
  public static void main(String args[]){  
    Demo d = new Demo() ; // 实例化Demo对象  
    String str = d.fun("汤姆") ; // 传递字符串  
    int i = d.fun(30) ;  // 传递数字，自动装箱  
    System.out.println(str) ; // 输出内容  
    System.out.println(i) ;  // 输出内容  
  }  
};
复制代码

2.3 泛型接口

泛型接口概述：把泛型定义在接口
定义格式：

public interface 接口名<泛型类型> {
    
}
复制代码

实例：

/**
 * 泛型接口的定义格式:        修饰符  interface 接口名<数据类型> {}
 */
public interface Inter<T> {
    public abstract void show(T t) ;
}

/**
 * 子类是泛型类
 */
public class InterImpl<E> implements Inter<E> {
    @Override
    public void show(E t) {
        System.out.println(t);
    }
}


Inter<String> inter = new InterImpl<String>() ;
inter.show("hello") ;
复制代码

2.4 源码中泛型的使用，下面是List接口和ArrayList类的代码片断。

//定义接口时指定了一个类型形参，该形参名为E
public interface List<E> extends Collection<E> {
   //在该接口里，E能够做为类型使用
   public E get(int index) {}
   public void add(E e) {} 
}

//定义类时指定了一个类型形参，该形参名为E
public class ArrayList<E> extends AbstractList<E> implements List<E> {
   //在该类里，E能够做为类型使用
   public void set(E e) {
   .......................
   }
}
复制代码

2.5 泛型类派生子类

父类派生子类的时候不能在包含类型形参，须要传入具体的类型ide

错误的方式：

public class A extends Container<K, V> {}学习

正确的方式：

public class A extends Container<Integer, String> {}测试

也能够不指定具体的类型，系统就会把K,V形参当成Object类型处理

public class A extends Container {}

2.6 泛型构造器

构造器也是一种方法，因此也就产生了所谓的泛型构造器。
和使用普通方法同样没有区别，一种是显示指定泛型参数，另外一种是隐式推断

public class Person {
    public <T> Person(T t) {
        System.out.println(t);
    }
    
}
复制代码

使用：

public static void main(String[] args) {
    new Person(22);// 隐式
    new <String> Person("hello");//显示
}
复制代码

特殊说明：
- 若是构造器是泛型构造器，同时该类也是一个泛型类的状况下应该如何使用泛型构造器：由于泛型构造器能够显式指定本身的类型参数（须要用到菱形，放在构造器以前），而泛型类本身的类型实参也须要指定（菱形放在构造器以后），这就同时出现了两个菱形了，这就会有一些小问题，具体用法再这里总结一下。如下面这个例子为表明
```
public class Person<E> {
    public <T> Person(T t) {
        System.out.println(t);
    }
}
复制代码
```
正确用法：
```
public static void main(String[] args) {
    Person<String> person = new Person("sss");
}
复制代码
```
PS：编译器会提醒你怎么作的

2.7 高级通配符

2.7.1背景：

2.7.2 <? extends T> 上界通配符

上界通配符顾名思义，<? extends T>表示的是类型的上界【包含自身】，所以通配的参数化类型多是T或T的子类。
- 正由于没法肯定具体的类型是什么，add方法受限（能够添加null，由于null表示任何类型），但能够从列表中获取元素后赋值给父类型。如上图中的第一个例子，第三个add()操做会受限，缘由在于List和List是List<? extends Animal>的子类型。
```
它表示集合中的全部元素都是Animal类型或者其子类
 List<? extends Animal>
复制代码
```
这就是所谓的上限通配符，使用关键字extends来实现，实例化时，指定类型实参只能是extends后类型的子类或其自己。
- 例如：
- 这样就肯定集合中元素的类型，虽然不肯定具体的类型，但最起码知道其父类。而后进行其余操做。
```
//Cat是其子类
    List<? extends Animal> list = new ArrayList<Cat>();
复制代码
```

2.7.3 <? super T> 下界通配符

下界通配符<? super T>表示的是参数化类型是T的超类型（包含自身），层层至上，直至Object
- 编译器无从判断get()返回的对象的类型是什么，所以get()方法受限。可是能够进行add()方法，add()方法能够添加T类型和T类型的子类型，如第二个例子中首先添加了一个Cat类型对象，而后添加了两个Cat子类类型的对象，这种方法是可行的，可是若是添加一个Animal类型的对象，显然将继承的关系弄反了，是不可行的。
```
它表示集合中的全部元素都是Cat类型或者其父类
 List <? super Cat>   
复制代码
```
这就是所谓的下限通配符，使用关键字super来实现，实例化时，指定类型实参只能是extends后类型的子类或其自己
- 例如
```
//Animal是其父类
List<? super Cat> list = new ArrayList<Animal>();
复制代码
```

2.7.4 <?> 无界通配符

任意类型，若是没有明确，那么就是Object以及任意的Java类了
无界通配符用<?>表示，?表明了任何的一种类型，能表明任何一种类型的只有null（Object自己也算是一种类型，但却不能表明任何一种类型，因此List和List的含义是不一样的，前者类型是Object，也就是继承树的最上层，然后者的类型彻底是未知的）

三、泛型擦除

3.1 概念

编译器编译带类型说明的集合时会去掉类型信息

3.2 验证明例：

public class GenericTest {
    public static void main(String[] args) {
        new GenericTest().testType();
    }

    public void testType(){
        ArrayList<Integer> collection1 = new ArrayList<Integer>();
        ArrayList<String> collection2= new ArrayList<String>();
        
        System.out.println(collection1.getClass()==collection2.getClass());
        //二者class类型同样,即字节码一致
        
        System.out.println(collection2.getClass().getName());
        //class均为java.util.ArrayList,并没有实际类型参数信息
    }
}
复制代码

输出结果：

true
java.util.ArrayList
复制代码

分析：
- 这是由于无论为泛型的类型形参传入哪种类型实参，对于Java来讲，它们依然被当成同一类处理，在内存中也只占用一块内存空间。从Java泛型这一律念提出的目的来看，其只是做用于代码编译阶段，在编译过程当中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译事后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
- 在静态方法、静态初始化块或者静态变量的声明和初始化中不容许使用类型形参。因为系统中并不会真正生成泛型类，因此instanceof运算符后不能使用泛型类

四、泛型与反射

把泛型变量当成方法的参数，利用Method类的getGenericParameterTypes方法来获取泛型的实际类型参数
例子：

public class GenericTest {

    public static void main(String[] args) throws Exception {
        getParamType();
    }
    
     /*利用反射获取方法参数的实际参数类型*/
    public static void getParamType() throws NoSuchMethodException{
        Method method = GenericTest.class.getMethod("applyMap",Map.class);
        //获取方法的泛型参数的类型
        Type[] types = method.getGenericParameterTypes();
        System.out.println(types[0]);
        //参数化的类型
        ParameterizedType pType  = (ParameterizedType)types[0];
        //原始类型
        System.out.println(pType.getRawType());
        //实际类型参数
        System.out.println(pType.getActualTypeArguments()[0]);
        System.out.println(pType.getActualTypeArguments()[1]);
    }

    /*供测试参数类型的方法*/
    public static void applyMap(Map<Integer,String> map){

    }
}
复制代码

输出结果：

java.util.Map<java.lang.Integer, java.lang.String>
interface java.util.Map
class java.lang.Integer
class java.lang.String
复制代码

经过反射绕开编译器对泛型的类型限制

public static void main(String[] args) throws Exception {
		//定义一个包含int的链表
		ArrayList<Integer> al = new ArrayList<Integer>();
		al.add(1);
		al.add(2);
		//获取链表的add方法，注意这里是Object.class，若是写int.class会抛出NoSuchMethodException异常
		Method m = al.getClass().getMethod("add", Object.class);
		//调用反射中的add方法加入一个string类型的元素，由于add方法的实际参数是Object
		m.invoke(al, "hello");
		System.out.println(al.get(2));
	}

复制代码

5 泛型的限制

5.1 模糊性错误

对于泛型类User<K,V>而言，声明了两个泛型类参数。在类中根据不一样的类型参数重载show方法。

public class User<K, V> {
    
    public void show(K k) { // 报错信息：'show(K)' clashes with 'show(V)'; both methods have same erasure
        
    }
    public void show(V t) {

    }
}
复制代码

因为泛型擦除，两者本质上都是Obejct类型。方法是同样的，因此编译器会报错。

换一个方式：

public class User<K, V> {

    public void show(String k) {

    }
    public void show(V t) {

    }
}
复制代码

使用结果：

能够正常的使用

5.2 不能实例化类型参数

编译器也不知道该建立那种类型的对象

public class User<K, V> {

    private K key = new K(); // 报错：Type parameter 'K' cannot be instantiated directly

}
复制代码

5.3 对静态成员的限制

静态方法没法访问类上定义的泛型；若是静态方法操做的类型不肯定，必需要将泛型定义在方法上。

若是静态方法要使用泛型的话，必须将静态方法定义成泛型方法。

public class User<T> {

    //错误
    private static T t;

    //错误
    public static T getT() {
        return t;
    }

    //正确
    public static <K> void test(K k) {

    }
}
复制代码

5.4 对泛型数组的限制

不能实例化元素类型为类型参数的数组，可是能够将数组指向类型兼容的数组的引用

public class User<T> {

    private T[] values;

    public User(T[] values) {
        //错误，不能实例化元素类型为类型参数的数组
        this.values = new T[5];
        //正确，能够将values 指向类型兼容的数组的引用
        this.values = values;
    }
}
复制代码

5.5 对泛型异常的限制

泛型类不能扩展 Throwable，意味着不能建立泛型异常类答案连接