Java基础---泛型

泛型的出现

先来看一段代码：

public void test1() {        List list = new ArrayList();        list.add("qqyumidi");        list.add("corn");        list.add(100);        for (int i = 0; i < list.size(); i++) {            String name = (String) list.get(i); // 1            System.out.println("name:" + name);        }    }

由于list默认的类型为Object类型，因此这段代码在编译阶段正常，而运行时则会在//1处出现“java.lang.ClassCastException”异常。在编码过程中，这类错误编码过程中很容易出现。
在如上的编码过程中，我们发现主要存在两个问题：

• 1、编译时没有对存储的对象的类型做限制，全当是Object，取出时也是Object，但可以强转成本身的类型，也就是说运行时类型任然为其本身类型
• 2、//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，很容易出现“java.lang.ClassCastException”异常。

那么，有没有一种方法，在编译时就检查并统一类型，使得在取出做（或者不需要做）类型转换时避免报错呢？答案就是使用泛型。

什么是泛型？

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

看着好像有点复杂，首先我们看下上面那个例子采用泛型的写法：

public void test2() {        /*        List list = new ArrayList();        list.add("qqyumidi");        list.add("corn");        list.add(100);        */        List<String> list = new ArrayList<String>();        list.add("qqyumidi");        list.add("corn");//        list.add(100);   // 1  提示编译错误        for (int i = 0; i < list.size(); i++) {            String name = list.get(i); // 2            System.out.println("name:" + name);        }    }

• 采用泛型写法后，在//1处想加入一个Integer类型的对象时会出现编译错误
• 通过List<String>，直接限定了list集合中只能含有String类型的元素

• 从而在//2处无须进行强制类型转换

  因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。
  在List<String>中，String是类型实参，也就是说，相应的List接口中肯定含有类型形参。且get()方法的返回结果也直接是此形参类型（也就是对应的传入的类型实参）。

自定义泛型

我们看一个最简单的泛型类和方法定义：

public  void test3() {        Box<String> name = new Box<String>("corn");        System.out.println("name:" + name.getData());    }    class Box<T> {        private T data;        public Box() {        }        public Box(T data) {            this.data = data;        }        public T getData() {            return data;        }    }

在泛型接口、泛型类和泛型方法的定义过程中，我们常见的如T、E、K、V等形式的参数常用于表示泛型形参，由于接收来自外部使用时候传入的类型实参。那么对于不同传入的类型实参，生成的相应对象实例的类型是不是一样的呢？

public void test4() {        Box<String> name = new Box<String>("corn");        Box<Integer> age = new Box<Integer>(712);        System.out.println("name class:" + name.getClass());      // class com.zitech.genericdemo.MainActivity$Box        System.out.println("age class:" + age.getClass());        // class com.zitech.genericdemo.MainActivity$Box        System.out.println(name.getClass() == age.getClass());    // true    }

由此，我们发现：

• 在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型
• 传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Box）
• 当然，在逻辑上我们可以理解成多个不同的泛型类型。

究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

泛型类

容器类应该算得上最具重用性的类库之一。先来看一个没有泛型的情况下的容器类如何定义：

public class Container {    private String key;    private String value;    public Container(String k, String v) {        key = k;        value = v;    }    public String getKey() {        return key;    }    public void setKey(String key) {        this.key = key;    }    public String getValue() {        return value;    }    public void setValue(String value) {        this.value = value;    }}

Container类保存了一对key-value键值对，但是类型是定死的，也就说如果我想要创建一个键值对是String-Integer类型的，当前这个Container是做不到的，必须再自定义。那么这明显重用性就非常低。

当然，我可以用Object来代替String，并且在Java SE5之前，我们也只能这么做，由于Object是所有类型的基类，所以可以直接转型。但是这样灵活性还是不够，因为还是指定类型了，只不过这次指定的类型层级更高而已，有没有可能不指定类型？有没有可能在运行时才知道具体的类型是什么？

所以，就出现了泛型。

public class Container<K, V> {    private K key;    private V value;    public Container(K k, V v) {        key = k;        value = v;    }    public K getKey() {        return key;    }    public void setKey(K key) {        this.key = key;    }    public V getValue() {        return value;    }    public void setValue(V value) {        this.value = value;    }}

在编译期，是无法知道K和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。可以看一下现在Container类对于不同类型的支持情况：

public class Main {    public static void main(String[] args) {        Container<String, String> c1 = new Container<String, String>("name", "findingsea");        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);        Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);        System.out.println(c1.getKey() + " : " + c1.getValue());        System.out.println(c2.getKey() + " : " + c2.getValue());        System.out.println(c3.getKey() + " : " + c3.getValue());    }}

输出：

name : findingseaage : 241.1 : 2.2

泛型接口

在泛型接口中，生成器是一个很好的理解，看如下的生成器接口定义：

public interface Generator<T> {    public T next();}

然后定义一个生成器类来实现这个接口：

public class FruitGenerator implements Generator<String> {    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};    @Override    public String next() {        Random rand = new Random();        return fruits[rand.nextInt(3)];    }}

调用：

public class Main {    public static void main(String[] args) {        FruitGenerator generator = new FruitGenerator();        System.out.println(generator.next());        System.out.println(generator.next());        System.out.println(generator.next());        System.out.println(generator.next());    }}

输出：

BananaBananaPearBanana

泛型方法

一个基本的原则是：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛化，那么应该有限采用泛型方法。下面来看一个简单的泛型方法的定义：

public class Main {    public static <T> void out(T t) {        System.out.println(t);    }    public static void main(String[] args) {        out("findingsea");        out(123);        out(11.11);        out(true);    }}

可以看到方法的参数彻底泛化了，这个过程涉及到编译器的类型推导和自动打包，也就说原来需要我们自己对类型进行的判断和处理，现在编译器帮我们做了。这样在定义方法的时候不必考虑以后到底需要处理哪些类型的参数，大大增加了编程的灵活性。

再看一个泛型方法和可变参数的例子：

public class Main {    public static <T> void out(T... args) {        for (T t : args) {            System.out.println(t);        }    }    public static void main(String[] args) {        out("findingsea", 123, 11.11, true);    }}

输出和前一段代码相同，可以看到泛型可以和可变参数非常完美的结合。

注意：

• 只有引用类型才能作为泛型方法的实际参数，而不能是基本类型。如果传入的是int类型，那么java会自动装箱。如果有int数组，数组是一个对象，但数组里面的int则是基本类型，会报错。
• 泛型类中的静态方法中不能使用类级别的泛型，可使用单独的方法级别的泛型。

通配符

类型通配符

接着上面的结论，我们知道，Box<Number>和Box<Integer>实际上都是Box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Box<Number>和Box是否可以看成具有父子关系的泛型类型呢？

为了弄清这个问题，我们继续看下下面这个例子:

public void test5() {        Box<Number> name = new Box<Number>(99);        Box<Integer> age = new Box<Integer>(712);        getData1(name);        //The method getData(Box<Number>) in the type GenericTest is        //not applicable for the arguments (Box<Integer>)//        getData1(age);   // 1}public void getData1(Box<Number> data){    System.out.println("data :" + data.getData());}

我们发现，在代码//1处出现了错误提示信息：The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。显然，通过提示信息，我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类。那么，原因何在呢？

public void test5() {        Box<Integer> a = new Box<Integer>(712);//        Box<Number> b = a;  // 1        Box<Float> f = new Box<Float>(3.14f);//        b.setData(f);        // 2    }public void getData1(Box<Number> data){    System.out.println("data :" + data.getData());}

这个例子中，显然//1和//2处肯定会出现错误提示的。在此我们可以使用反证法来进行说明。

假设Box<Number>在逻辑上可以视为Box<Integer>的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box<Number>不能视为Box<Integer>的父类。

好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总不能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型，由此，类型通配符应运而生。

类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>…等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

public void test6() {        Box<String> name = new Box<String>("corn");        Box<Integer> age = new Box<Integer>(712);        Box<Number> number = new Box<Number>(314);        getData2(name);        getData2(age);        getData2(number);    }public void getData2(Box<?> data){    System.out.println("data :" + data.getData());}

<? extends T>

表示类型的上界，表示参数化类型的可能是T 或是 T的子类。示例：

static class Food{}static class Fruit extends Food{}static class Apple extends Fruit{}static class RedApple extends Apple{}List<? extends Fruit> flist = new ArrayList<Apple>();// complie error:// flist.add(new Apple());// flist.add(new Fruit());// flist.add(new Object());flist.add(null); // only work for null 

List<? extends Frut> 表示 “具有任何从Fruit继承类型的列表”，编译器无法确定List所持有的类型，所以无法安全的向其中添加对象。可以添加null,因为null 可以表示任何类型。所以List 的add 方法不能添加任何有意义的元素，但是可以接受现有的子类型List 赋值。

Fruit fruit = flist.get(0);Apple apple = (Apple)flist.get(0);

由于，其中放置是从Fruit中继承的类型，所以可以安全地取出Fruit类型。

flist.contains(new Fruit());flist.contains(new Apple());

在使用Collection中的contains 方法时，接受Object 参数类型，可以不涉及任何通配符，编译器也允许这么调用。

<? super T>

表示类型下界（Java Core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至Object。示例：

List<? super Fruit> flist = new ArrayList<Fruit>();flist.add(new Fruit());flist.add(new Apple());flist.add(new RedApple());// compile error:List<? super Fruit> flist = new ArrayList<Apple>();

List<? super Fruit> 表示“具有任何Fruit超类型的列表”，列表的类型至少是一个 Fruit 类型，因此可以安全的向其中添加Fruit 及其子类型。由于List<? super Fruit>中的类型可能是任何Fruit 的超类型，无法赋值为Fruit的子类型Apple的List.

// compile error:Fruit item = flist.get(0);

因为，List<? super Fruit>中的类型可能是任何Fruit 的超类型，所以编译器无法确定get返回的对象类型是Fruit,还是Fruit的父类Food 或 Object.

小结

• extends 可用于的返回类型限定，不能用于参数类型限定。
• super 可用于参数类型限定，不能用于返回类型限定。
• 带有super超类型限定的通配符可以向泛型对易用写入，带有extends子类型限定的通配符可以向泛型对象读取。——《Core Java》

声明方法返回子类型

在Spring Security的源码里有一个 ProviderManagerBuilder 接口，声明如下

public interface ProviderManagerBuilder<B extends ProviderManagerBuilder<B>> extends SecurityBuilder<AuthenticationManager> {    B authenticationProvider(AuthenticationProvider authenticationProvider);}

其实现类 AuthenticationManagerBuilder：

public class AuthenticationManagerBuilder extends AbstractConfiguredSecurityBuilder<AuthenticationManager, AuthenticationManagerBuilder> implements ProviderManagerBuilder<AuthenticationManagerBuilder> {  //...  public AuthenticationManagerBuilder authenticationProvider(    AuthenticationProvider authenticationProvider) {    this.authenticationProviders.add(authenticationProvider);    return this;  }  //...}

上面有很多干扰项，我们来简化一下

接口 A 定义如下

public interface A<T extends A<T>> {    T add();}

说明： A 接口只有一个 add 方法，返回泛型 T 。 T 的声明有些饶

public class B implements A<B> {  @Override  public B add() {    return null;  }}

注意，此处类 B 里的add方法返回类型 B 。也就是说，接口 A 里声明的方法时并不知道子类型 B 的存在，通过继承和泛型，可以放返回值动态的适配子类型，这一切都要归功于

泛型递归模式（Recurring Generic Pattern）

public interface A<T extends A<T>> 对于参数类型 T 是递归定义的。有如GNU的定义“GNU’s Not Unix!”。

典型的例子是 java.lang.Enum：

public abstract class Enum<E extends Enum<E>>    implements Comparable<E>, Serializable {    //...}

java所有的枚举类型都隐式的继承 java.lang.Enum ，不允许通过现实的继承声明枚举类型，甚至集成 java.lang.Enum 也是编译器所不允许的。

假设有一个枚举类 StatusCode ,其等价的声明如下

public class StatusCode extends Enum<StatusCode>

现在我们来验证一下泛型约束，

• 1、因为 Enum ,所以 E=StatusCode
• 2、根据 <E extend Enum<E>> 和 E=StatusCode 可得， <StatusCode extend Enum<StatusCode>> ，
• 3、由于 public class StatusCode extends Enum<StatusCode> 第二步的结论显然成立。

为什么Enum的声明这么绕？直接Enum 不行么？

因为 Enum<E> 实现了 Comparable<E> 接口，该接口有一个 compareTo 方法

public int compareTo(E o) {}

强制约束了进行 compareTo 的调用对象类型和参数类型都严格一致，不会出现子类和超类或者兄弟类之间的比较。

项目源码 GitHub求赞，谢谢！

引用：
Java总结篇系列：Java泛型 - Windstep - 博客园
？super T 和? extends T区别 - wf110 - 博客园
Java泛型：泛型类、泛型接口和泛型方法 - findingea - SegmentFault
Java泛型让声明方法返回子类型 – 编码人生
关于Java的泛型在所声明的对象中如何获取class或者实例的方法的总结 - 铭久 - 博客园
Java中的泛型方法 - 杨元 - 博客园
Java 泛型 | 菜鸟教程

Java泛型编程最全总结 - 切梦 - ITeye技术网站
JavaSE6Tutorial/CH12.md at master · JustinSDK/JavaSE6Tutorial
https://github.com/JustinSDK/JavaSE6Tutorial/blob/master/docs/CH12.md