泛型的定义

泛型：参数化的类型。很简单的一句话，那么什么叫做“参数化的类型”呢？。。。。。

为什么需要泛型？

假设现在有这样一个需求：把两个整数进行相加并返回计算结果。我们很轻松的就可以写出如下代码来完成此功能：

    public int addInt(int x, int y) {

        return x + y;
    }

后来有一天业务拓展，需要支持浮点数进行相加并返回计算结果。于是我们可以新增一个新的如下方法来完成新需求：

 public float addFloat(float x, float y) {

        return x + y;
    }

日子一天天的过去，又有了新的需求，需要支持double类型的相加，那么我们依然可以依葫芦画瓢的再增加一个新的方法来完成double类型的数据相加。诶？等等。。。观察上面的两个方法除了参数的类型和返回值不同之外，其他的都相同(方法名是可以相同的，称之为重载，此处为了区分类型，故写作不同名称)。于是为了解决这个问题，java就引入了泛型机制，可以很好的解决重复代码。

我们平常用的最多的数据结构恐怕就是List了。例如：

        List list = new ArrayList();
        list.add("element0");
        list.add("element1");
        list.add(100);

这段代码无论在编写阶段还是运行阶段都是不会报错的。

        for (int i = 0; i < list.size(); i++) {
            String value = (String) list.get(i);
            System.out.println("第" + (i + 1) + "个元素的值是： " + value);
        }

可是当我们需要用上面的代码遍历输出集合中元素的时候，却会报出ClassCastException。这时因为最后添加的一个元素是 int 类型，强转为 String 类型肯定是会报错的。于是这里就体现出了泛型的第二个好处：安全。于是我们经常如下去创建一个List：

        List<String> list = new ArrayList<>();
        list.add("element0");
        list.add("element1");
        list.add(100); // 编译器会提示此行代码报错

并且加了泛型之后在取值的时候也不需要强制类型转换了。
综上所述：1.适用于多种数据类型执行相同的代码。2.在编译期间就发现数据类型安全问题。这也就是我们为什么要使用泛型的原因。

泛型的使用

• 泛型类

public class GenericClass<T> {
    
    private T data;

    public GenericClass(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

• 泛型接口

public interface GenericInterface<T> {

    T next();
}

关于泛型接口的实现有两种：

public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public String next() {
        return null;
    }
}

public class GenericInterfaceImpl2<T> implements GenericInterface<T>{

    @Override
    public T next() {
        return null;
    }
}

这两种方式的区别就是一个是在使用的时候才确定具体类型，一个在声明类的时候就确定了类型。

• 泛型方法

    public <T> T genericMethod(T... t) {
        return t[t.length / 2];
    }

其中<T>是定义泛型方法所必须的，如果没有的话，即使这个方法带有 T 、或者 E 这种常见的泛型定义，那么它依然不是一个泛型方法。例如上面泛型类中的 getData() 或者 setData(T data)，前面没有<T>,它们依旧是普通的方法，只不过他们是定义在了泛型类中罢了。

类型变量的限定-用于方法上

    public static <T extends Comparable> T min(T a, T b) {
        if (a.compareTo(b) > 0) return a;else return b;
    }

extends 关键字从面相对象上严格来说是叫派生。那么 T extends Comparable 就可以理解为派生自 Comparable 这个接口的子类。故下面可以使用Comparable 接口中的 compareTo() 方法。假如尖括号中只有一个 T，那么参数a是无法调用compareTo()方法的。这就是所谓的类型变量的限定。
关于限定类型的使用有如下规则：

• 可以有多个限定类型，中间用 & 符号隔开
• 可以是类，也可以是接口。如果是类的话需要放在第一个的位置
• 有且只能有一个类，接口则没有限制。因为java是单继承，多实现。
  下面是简单示例：

    public static <T extends View & Comparable & Serializable> T min(T a, T b) {
        if (a.compareTo(b) > 0) return a;else return b;
    }

此时传入的参数需要满足是 View 的子类，且同时实现了Comparable 和 Serializable 接口才能使用。否则无法通过编译。

类型变量的限定-用于类上

public class GenericClass<T extends Comparable> {

    private T data;

    public GenericClass(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public T min(T t) {
        if (this.data.compareTo(t) > 0) {
            return t;
        } else {
            return this.data;
        }
    }
}

这里是把上面泛型类进行了一个改造，这时泛型的具体类型只能是 Comparable 的实现类。

泛型的约束和局限性

• 不能实例化类型变量
  还是以上面的泛型类为例。这时我们给它添加一个无参的构造方法。

public class GenericClass<T> {

    private T data;

    public GenericClass() {

    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

假如我们想要在构造方法中初始化 T 的实例是不允许的。编译器会直接报错：

• 静态域或静态方法不能引用类型变量

  
  
  
  

  编译器会直接报错。这个问题的答案其实很简单：泛型的具体类型是在创建出具体的泛型类的对象的时候才确定的，而静态代码的执行是早于对象的创建的。那么虚拟机根本就不知道静态的 T 是什么。但如果是静态泛型方法则是可以的：

    public static <E> void print(E e) {
        System.out.println(e.toString());
    }

• 基本数据类型不能作为泛型

        GenericClass<double> genericClass1 = new GenericClass<>(); // 报错 基本类型不可以
        
        GenericClass<Double> genericClass2 = new GenericClass<>(); // 需要用其包装类

• 不能使用 instanceof 关键字
  通常我们需要判断一个对象是不是某种类型的时候，都会用 instanceof 关键字来判断。可是判断某个对象是不是某个泛型类的类型时却不可以。例如：

        GenericClass<Float> genericFloat = new GenericClass<>();

        if (genericFloat instanceof GenericClass<Float>){ // 这一行编译器会报错

        }

• 不能实例化泛型数组

  
  
  
  

  可以声明泛型数组，但是却不能实例化。这是 java 语法规定。是不是很奇葩？

• 泛型类不能继承 Exception 或 Throwable

  
  
  
  

  非常简单粗暴，编译器直接提示泛型类不能派生自 Throwable。

• 不能捕获泛型类对象

  
  
  
  

  但是下面这种写法确实允许的：

  
  

通配符

假设现在有两个如下类，且存在继承关系：

public class Animal {
    
}

public class Dog extends Animal{
        
}

Dog 是 Animal 的子类，那么问题来了：

        GenericClass<Animal> animalGeneric = new GenericClass<>();
        GenericClass<Dog> dogGeneric = new GenericClass<>();

请问GenericClass<Animal> 和 GenericClass<Dog> 之间存在继承关系吗？答案显然是否定的。但是泛型类可以继承或扩展其他泛型类，例如 List 和 ArrayList 之间的关系：

public class GenericClassChild<T> extends GenericClass<T>{
    
}

再假设现在有如下一个方法：

    public static <T> void set(GenericClass<Animal> genericClass) {

    }

那么下面两种调用可以吗？

        set(animalGeneric); // 1
        set(dogGeneric); // 2

很显然，第一种是肯定可以的。第二种就不可以了。于是为了解决这种问题就有了通配符的概念。

• ? extends
  现在有如下4个类，且有如下继承关系：

  
  
  
  

  假设现在有如下4个对象和对应的打印方法：

        GenericClass<Fruit> fruit = new GenericClass<>();
        GenericClass<Apple> apple = new GenericClass<>();
        GenericClass<RedApple> redApple = new GenericClass<>();
        GenericClass<Orange> orange = new GenericClass<>();

        public static <T> void printExtends(GenericClass<? extends Apple> genericClass) {
      
        }

下面我们来看一下调用结果：

• ？super

        GenericClass<Fruit> fruit = new GenericClass<>();
        GenericClass<Apple> apple = new GenericClass<>();
        GenericClass<RedApple> redApple = new GenericClass<>();
        GenericClass<Orange> orange = new GenericClass<>();

        public static <T> void printSuper(GenericClass<? super Apple> genericClass) {

        }

下面我们来看一下调用结果：

可以看到？super正好是限定了传入参数的下边界。下面我们来看一下有什么限制：

虚拟机是如何实现泛型的？