泛型的定义:

参数化的类型

为什么需要用到泛型(泛型的好处)?

1、多种数据类型执行相同的代码

       2、泛型中的类型在使用时指定,不需要强制类型转换

 

     2、泛型类、泛型接口、泛型方法

        1、泛型类定义 引入一个类型变量T(其他大写字母都可以,不过常用的就是T,E,K,V等等),并且用<>括起来,并放在类名的后面。泛型类是允许有多个类型变量的。

class GenericClass <T>{
 public T data;

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

    public void  setData(T data){

        this.data=data;
    }

   public T getData(){

        return data;
   }

}

  

    2、泛型接口的定义与泛型类类似

public interface GenericInterface <T>{

    public T setValue();

}

泛型接口有两种实现方式:

1、不传泛型实参

class GenericIMP<T> implements GenericInterface<T>{
    @Override
    public T setValue() {
        return null;
    }
}

 2、传入泛型实参

class GenericIMP implements GenericInterface<String>{

    @Override
    public String setValue() {
        return null;
    }
}

       

  3、泛型方法  调用方法的时候指明泛型的具体类型 ,泛型方法可以在任何地方和任何场景中使用,包括普通类和泛型类。注意泛型类中定义的普通方法和泛型方法的区别。

      1、普通类中的泛型方法

        

public class GenericMethod {


    public <T> T getData(T...a){



        return a[2];

    }
    

    public static  void main(String[] argus){
        GenericMethod genericMethod=new GenericMethod();
          System.out.println(genericMethod.<Integer>getData(11,154525,33));



    }

  

2、泛型类中的泛型方法必须有<>标志,泛型类的类型影响类的普通方法,不会影响泛型方法,所以setDataValue 在泛型类定义为String的时候不能传入整形,而setData则不受影响

class GenericMethod2<T> {

    public <T> T setData(T a) {

        return a;
    }

    public T setDataValue(T a) {

        return a;
    }

    public <K> K setValue(K a) {

        return a;
    }

    public static void main(String[] argus) {
        
        GenericMethod2<String> genericMethod1 = new GenericMethod2();
        genericMethod1.setDataValue(1);
        genericMethod1.setData(11);
        genericMethod1.setValue("");

    }


}

3、泛型中 extends 解析

     1、实现泛型方法比较两个数的大小

public static <T extends Comparable> T min(T a,T b){

      if(a.compareTo(b)>0){

          return a;
      }else{
          return b;
      }

  } ;

其中,T extends Comparable 限定了 参数的条件 必须是可比较的  ,

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

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

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

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

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

 

4、泛型中存在一定的约束性和局限性

public class Restrict<T> {
    private T data;

    //不能实例化类型变量
//    public Restrict() {
//        this.data = new T();
//    }


    //静态域或者方法里不能引用类型变量
    //private static T instance;
    //静态方法 本身是泛型方法就行
    //private static <T> T getInstance(){}


    public static void main(String[] args) {
        //Restrict<double> restrict= new Restrict<>();  //不能用基本数据类型实例化参数
        Restrict<Double> restrict = new Restrict<>();

//        if(restrict instanceof  Restrict<Double>)
//        if(restrict instanceof  Restrict<T>)      //不能使用instanceof

        Restrict<String> restrictString = new Restrict<>();

        System.out.println(restrict.getClass() == restrictString.getClass());
        System.out.println(restrict.getClass().getName());
        System.out.println(restrictString.getClass().getName());


        Restrict<Double>[] restrictArray;
        //Restrict<Double>[] restricts = new Restrict<Double>[10];  //不能创建参数化类型的数组
        //ArrayList<String>[] list1 = new ArrayList<String>[10];
        //ArrayList<String>[] list2 = new ArrayList[10];

    }


}

   1、基本数据类型不能实例化参数

  2、运行时类型查询只适用于原始类型

   3、泛型类的静态上下文中类型变量失效

不能创建参数化类型的数组

   5、不能实例化类型变量

    6、不能捕获泛型类的实例

 

5、泛型 中通配符的使用

  1、? extends  X

? extends X  表示类型的上界,类型参数是X的子类   要用于安全地访问数据,可以访问X及其子类型,并且不能写入非null的数据。

   2、? super  X

  ? super X  表示类型的下界,类型参数是X的超类   主要用于安全地写入数据,可以写入X及其子类型

 

6、虚拟机是如何实现泛型的?类型擦除

  

泛型思想早在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 使用类型擦除实现泛型的原因在于,JDK1.5之前Java是没有泛型的,之后的版本引入之后,为了适配之前的版本就采用了这种模式。

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

public static String method(List<String> stringList){
        System.out.println("List");
        return "OK";
    }

    public static Integer method(List<Integer> stringList){
        System.out.println("List");
        return 1;
    }

 

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

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

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