Java 泛型

一、为什么使用泛型？

多种数据类型执行相同代码需要使用泛型

使用泛型后不需要强制转换

规范数据类型，减少异常

二、 泛型类/泛型接口/泛型方法

泛型接口与泛型类的定义基本相同。

/**
 * 泛型类
 */
public class Genericity<K, V> {
    private K data;
    private V result;

    public K getData() { return data; }

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

    public V getResult() { return result; }

    public void setResult(V result) { this.result = result; }

    public static void main(String[] args) {
        Genericity<String, Integer> genericity = new Genericity<String, Integer>();
        genericity.setData("只能传递String");
        genericity.setResult(1);
        //不需要强制转型
        String data = genericity.getData();
        Integer result = genericity.getResult();
    }
}

/**
 * 泛型接口
 */
public interface GenericityPort <T,V>{
    public T next(V v);
}

    /**
     * 泛型方法
     */
    public <T> T getText(T... ts) {
        return ts[ts.length / 2];
    }

泛型接口的实现

/**
 * 泛型接口的两种实现 传入实参
 */
public class ImplGenericityPort implements GenericityPort<String, Integer> {
    @Override
    public String next(Integer integer) {
        return "OK";
    }
}

/**
 * 泛型接口的两种实现 未传入实参
 */
public class ImplGenericityPort<T, V> implements GenericityPort<T, V> {

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

    public static void main(String[] args) {
        GenericityPort<String, Integer> genericityPort = new GenericityPort<String, Integer>() {
            @Override
            public String next(Integer integer) {
                return "OK";
            }
        };
    }
}

三、限定类型变量

 有时候需要对变量加以约束,如比较变量的大小,如何确定两个变量拥有compareTo方法。

    /**
     * 有问题的
     */
    public static <T> T comapare(T t1, T t2) {
        return (t1.compareTo(t2) > 0) ? t1 : t2;
    }

    /**
     * 解决方法 <T extends Comparable>
     */
    public static <T extends Comparable> T comapare(T t1, T t2) {
        return (t1.compareTo(t2) > 0) ? t1 : t2;
    }

T extends Comparable中

T表示应该绑定类型的子类型，Comparable表示绑定类型，子类型和绑定类型可以是类也可以是接口。

如果这个时候，我们试图传入一个没有实现接口Comparable的类的实例，将会发生编译错误。

同时extends左右都允许有多个，如 T,V extends Comparable & Serializable

注意限定类型中，只允许有一个类，而且如果有类，这个类必须是限定列表的第一个。

这种类的限定既可以用在泛型方法上也可以用在泛型类上。

 四、泛型中的约束和局限性

不能用基本类型实例化类型参数 int -> Integer

public class Restrict<T> {
    public static void main(String[] args) {
        //不允许
        Restrict<int> restrict1 = new Restrict();
        //允许
        Restrict<Integer> restrict2 = new Restrict();
    }
}

 运行时类型查询只适用

public class Restrict<T> {
    
    public static void main(String[] args) {
        Restrict<Integer> restrict = new Restrict();
        //不允许
        if(restrict instanceof Restrict<Integer>){}
        //允许
        if(restrict instanceof Restrict){}
    }
}

 运行时类型查询只适用 泛型类的静态上下问中类型变量失效 

//静态域或静态方法中不能引用类型变量
priviete startic T instance；
//静态泛型方法允许
privete static <T> T getInstance(){} 

不能在静态域或方法中引用类型变量。因为泛型是要在对象创建的时候才知道是什么类型的，而对象创建的代码执行先后顺序是static的部分，然后才是构造函数等等。所以在对象初始化之前static的部分已经执行了，如果你在静态部分引用的泛型，那么毫无疑问虚拟机根本不知道是什么东西，因为这个时候类还没有初始化。

不能实例化泛型变量

//不允许
new T();

不能创建泛型数组

    public static void main(String[] args) {
        Restrict<String>[] strRestrict;
        //不允许
        strRestrict = new Restrict<String>[10];
    }

不能捕获泛型类的实例

    //不允许
    public class Restrict<T>  extends Throwable/Exception{}

    //不允许
    public <T extends Throwable> void work(T t) {
        try {

        } catch (T e) {
            //do..
        }
    }

    //允许
    public <T extends Throwable> void work(T t) throws T{
        try {

        } catch (Throwable e) {
            //do..
            throw e;
        }
    }

五、泛型类的继承规则

public class Employee { }

class Worker extends Employee { }

class Pair<T>{}

class Main{
    public static void main(String[] args) {
        //问题，employeePair，workerPair 是否存在继承关系？
        Pair<Employee> employeePair;
        Pair<Worker> workerPair;

        //答：不存在
        //正常
        Employee employee = new Worker();
        //异常
        Pair<Employee> employeePair1 = new Pair<Worker>();
    }
}

但是泛型类可以继承或者扩展其他泛型类，比如List和ArrayList

六、通配符类型

？ extends X  表示类型的上界，类型参数是X的子类

？ super X  表示类型的下界，类型参数是X的超类

？ extends X 表示传递给方法的参数，必须是X的子类（包括X本身）

总结：主要用于安全地访问数据，可以访问X及其子类型，并且不能写入非null的数据。

？ super X  表示传递给方法的参数，必须是X的超类（包括X本身）

总结：主要用于安全地写入数据，可以写入X及其子类型。

无限定通配符 ？ 表示对类型没有什么限制，可以把？看成所有类型的父类，如Pair< ?>；

如：

ArrayList<T> al=new ArrayList<T>(); 指定集合元素只能是T类型

ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法。

在使用上：

？ getFirst() ： 返回值只能赋给 Object，；

void setFirst(?) ： setFirst 方法不能被调用， 甚至不能用 Object 调用；

七、虚拟机实现泛型

泛型思想早在C++语言的模板（Template）中就开始生根发芽，在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。，由于Java语言里面所有的类型都继承于java.lang.Object，所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会转嫁到程序运行期之中。

泛型技术在C#和Java之中的使用方式看似相同，但实现上却有着根本性的分歧，C#里面泛型无论在程序源码中、编译后的IL中（Intermediate Language，中间语言，这时候泛型是一个占位符），或是运行期的CLR中，都是切实存在的，List＜int＞与List＜String＞就是两个不同的类型，它们在系统运行期生成，有自己的虚方法表和类型数据，这种实现称为类型膨胀，基于这种方法实现的泛型称为真实泛型。

Java语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的Java语言来说，ArrayList＜int＞与ArrayList＜String＞就是同一个类，所以泛型技术实际上是Java语言的一颗语法糖，Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。

将一段Java代码编译成Class文件，然后再用字节码反编译工具进行反编译后，将会发现泛型都不见了，程序又变回了Java泛型出现之前的写法，泛型类型都变回了原生类型

上面这段代码是不能被编译的，因为参数List＜Integer＞和List＜String＞编译之后都被擦除了，变成了一样的原生类型List＜E＞，擦除动作导致这两种方法的特征签名变得一模一样。

由于Java泛型的引入，各种场景（虚拟机解析、反射等）下的方法调用都可能对原有的基础产生影响和新的需求，如在泛型类中如何获取传入的参数化类型等。因此，JCP组织对虚拟机规范做出了相应的修改，引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题，Signature是其中最重要的一项属性，它的作用就是存储一个方法在字节码层面的特征签名[3]，这个属性中保存的参数类型并不是原生类型，而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。

另外，从Signature属性的出现我们还可以得出结论，擦除法所谓的擦除，仅仅是对方法的Code属性中的字节码进行擦除，实际上元数据中还是保留了泛型信息，这也是我们能通过反射手段取得参数化类型的根本依据。