JAVA泛型深入理解

最新推荐文章于 2023-02-07 10:25:16 发布

樱花灬乱舞

最新推荐文章于 2023-02-07 10:25:16 发布

阅读量329

点赞数 1

分类专栏：笔记开发经验文章标签： java

本文链接：https://blog.csdn.net/a296191519/article/details/117131189

版权

开发经验同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

笔记

3 篇文章 0 订阅

订阅专栏

泛型的定义：

参数化的类型

为什么需要用到泛型（泛型的好处）？

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、泛型类的静态上下文中类型变量失效

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

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属性中的字节码进行擦除，实际上元数据中还是保留了泛型信息，这也是我们能通过反射手段取得参数化类型的根本依据。