java基础之泛型

最新推荐文章于 2024-08-28 20:58:28 发布

跃ZHD

最新推荐文章于 2024-08-28 20:58:28 发布

阅读量909

点赞数 27

分类专栏： java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_41163858/article/details/140552947

版权

java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、泛型的定义

泛型解释为：将类型由原来的具体的类型参数化（也即参数化类型）。
对于一个普通的方法有形参，形参有参数类型，在使用该方法的时候传递的是实参。泛型就是将形参的数据类型参数化。
如下代码：

//方法1（普通方法）
 public void pnt(String var) {  //形参的数据类型为String， 形参var
    System.out.println(var);
 }

//方法2（泛型方法）
 public <T> void pnt2(T t) {   //未给出具体形参数据类型，形参的数据类型也是一个参数。
  	System.out.println(t.toString());
 }

二、泛型有什么作用、为什么要学习泛型？

2.1、约束：（尤其是对容器，保证容器中的数据类型统一）

      List ls = new ArrayList();
      ls.add("abc");
      ls.add(123);
      ls.add(new Object());

一个容器中有各种数据类型，在使用的时候很容易报错！上述代码如图1 所示，在从容器中获取元素的时候，需要进行各种数据类型判断，很容易出现ClassCastException 。引入泛型后，存储变成如图2所示，会严格的根据元素的数据类型进行分类（保证一个容器中只有一种数据类型【暂不考虑泛型的上下限问题】）。
在这里插入图片描述

2.2、提高代码的复用性

看下面代码示例：

private static int add(int a, int b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static float add(float a, float b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

private static double add(double a, double b) {
    System.out.println(a + "+" + b + "=" + (a + b));
    return a + b;
}

使用泛型后可以复用为一个方法（提高代码的复用）

private static <T extends Number> double add(T a, T b) {
    System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
    return a.doubleValue() + b.doubleValue();
}

3、泛型基础

3.1 泛型类

基础语法：

class 类名称 <泛型标识> {
  }
}

常见使用方式：
public class FX01<T> {

}

public class FX01<T> {


    private T t;


}

public class FX01<T> {
    
    private T t;
    
    public T classT(T t) {  //普通方法  非泛型方法
        return t;
    }
    
}

注意：泛型类中的静态方法和静态变量不可以使用泛型类所声明的类型参数

public class Test<T> {    
    public static T one;   // 编译错误
    public static T show(T one){ // 编译错误    
        return null;    
    }    
}

原因：执行顺序问题。
泛型类中的类型参数的确定是在创建泛型类对象的时候（例如 new ArrayList< Integer >）。
而静态变量和静态方法在类加载时已经初始化，直接使用类名调用；在泛型类的类型参数未确定时，静态成员有可能被调用，因此泛型类的类型参数是不能在静态成员中使用的。

3.2 泛型接口

基本语法：

public interface 接口名<类型参数> {
    ...
}

常见使用方式:

public interface IFX01<T> {

}


public interface IFX01<T> {

    T eat();
}


public interface List<E> extends Collection<E> {

	 default Spliterator<E> spliterator() {
	       retuen  null;
    }
}

注意,接口中的属性默认是被public static final 修饰。

public interface IFX01<T> {
    T t;  //编译失败!
}

3.3 泛型方法

基本语法：

public <类型参数> 返回类型 方法名（类型参数 变量名） {
    ...
}

常见使用方式：

public class FX01<T> {

	//普通泛型方法 （方法1）
    public <E> E pnt(E e) {   
        return e;
    }
    
     //静态泛型方法   （方法2）
    public static <EE> EE staPnt(EE ee) { 
        return ee;
    }

	//注意!!!   是普通方法，该方法的 类型参数=泛型类中定义的类型参数
    public T classT(T t) {     
        return t;
    }
}

特别注意的是：泛型类中定义的类型参数和泛型方法中定义的类型参数是相互独立的，它们一点关系都没有。

示例：

public class FX01<T> {

    public T classT(T t) {
        System.out.println(t);
        return t;
    }

    public <E> E pnt(E e) {
        System.out.println(e);
        return e;
    }

    public static void main(String[] args) {

        FX01<String> fx = new FX01<>();
        
        //调用与泛型类相同类型参数的方法
        fx.classT("");
        fx.classT(123); //编译不通过！
        fx.classT(new Object()); //编译不通过
        
        //调用单独的泛型方法  （下面方法全部编译通过）
        fx.<Integer>pnt(123);
        fx.pnt(123);
        fx.<String>pnt("abc");
        fx.pnt("abc");

        fx.<Object>pnt(new Object());
        fx.pnt(new Object());
        
    }
}

代码解释：

代码片段一：
 FX01<String> fx = new FX01<>(); 
 
解释：
创建对象时传递类型参数为String后；FX01类相当于是:
public class FX01<String> {
	//方法的返回值、形参的类型 发生了变化
    public String classT(String t) {
        System.out.println(t);
        return t;
    }

	//泛型方法没有任何变化!
    public <E> E pnt(E e) {
        System.out.println(e);
        return e;
    }
}


代码片段二：
fx.<Integer>pnt(123);
fx.pnt(123);
此时方法变为:
public Integer pnt(Integer  e) {
    System.out.println(e);
    return e;
}


fx.<String>pnt("abc");
fx.pnt("abc");
此时方法变为:
public String pnt(String e) {
    System.out.println(e);
    return e;
}

fx.<Object>pnt(new Object());
fx.pnt(new Object());
此时方法变为:
public Object pnt(Object e) {
    System.out.println(e);
    return e;
}

代码片段二更形象的显示出了泛型方法中数据类型的可变性。从上面示例中也可以验证了:泛型类中定义的类型参数和泛型方法中定义的类型参数是相互独立的，它们一点关系都没有。

4、泛型擦除

Java泛型这个特性是从JDK 1.5才开始加入的，因此为了兼容之前的版本，Java泛型的实现采取了“伪泛型”的策略，即Java在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。理解类型擦除对于用好泛型是很有帮助的，尤其是一些看起来“疑难杂症”的问题，弄明白了类型擦除也就迎刃而解了。

泛型的类型擦除原则是：

消除类型参数声明，即删除<>及其包围的部分。
根据类型参数的上下界推断并替换所有的类型参数为原生态类型：如果类型参数是无限制通配符或没有上下界限定则替换为Object，如果存在上下界限定则根据子类替换原则取类型参数的最左边限定类型（即父类）。
为了保证类型安全，必要时插入强制类型转换代码。
自动产生“桥接方法”以保证擦除类型后的代码仍然具有泛型的“多态性”。
擦除类定义中的类型参数 - 无限制类型擦除
当类定义中的类型参数没有任何限制时，在类型擦除中直接被替换为Object，即形如<T>和<?>的类型参数都被替换为Object。

擦除类定义中的类型参数 - 有限制类型擦除。
当类定义中的类型参数存在限制（上下界）时，在类型擦除中替换为类型参数的上界或者下界，比如形如和<? extends Number>的类型参数被替换为Number，<? super Number>被替换为Object。

在这里插入图片描述

擦除方法定义中的类型参数
擦除方法定义中的类型参数原则和擦除类定义中的类型参数是一样的，这里仅以擦除方法定义中的有限制类型参数为例。

4.1如何证明擦除？

原始类型相等

public class Test {

    public static void main(String[] args) {

        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("abc");

        ArrayList<Integer> list2 = new ArrayList<Integer>();
        list2.add(123);

        System.out.println(list1.getClass() == list2.getClass()); // true
    }
}

在这个例子中，我们定义了两个ArrayList数组，不过一个是ArrayList<String>泛型类型的，只能存储字符串；一个是ArrayList<Integer>泛型类型的，只能存储整数，最后，我们通过list1对象和list2对象的getClass()方法获取他们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下原始类型。

通过反射添加元素

public class FX03 {

    public static void main(String[] args) throws Exception {

        List<String> list = new ArrayList<>();

        list.add("123");
//        list.add(123456);  编译不通过

        Object invoke = list.getClass().getMethod("add", Object.class).invoke(list, 123456);

        System.out.println(list); // [123, 123456]
    }
}

在程序中定义了一个ArrayList泛型类型实例化为String对象，如果直接调用add()方法，那么只能存储字符串数据，不过当我们利用反射调用add()方法的时候，却可以存储数字，这说明了String泛型实例在编译之后被擦除掉了，只保留了原始类型(Object)。

5、什么是原始类型？

原始类型就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型，无论何时定义一个泛型，相应的原始类型都会被自动提供，类型变量擦除，并使用其限定类型（无限定的变量用Object）替换。

原始类型Object

因为在Pair中，T 是一个无限定的类型变量，所以用Object替换，其结果就是一个普通的类，如同泛型加入Java语言之前的已经实现的样子。在程序中可以包含不同类型的Pair，如Pair或Pair，但是擦除类型后他们的就成为原始的Pair类型了，原始类型都是Object。
从上面章节，我们也可以明白ArrayList被擦除类型后，原始类型也变为Object，所以通过反射我们就可以存储字符串了。
如果类型变量有限定，那么原始类型就用第一个边界的类型变量类替换。
比如: Pair这样声明的话：

public class Pair<T extends Comparable> {}

那么原始类型就是Comparable。要区分原始类型和泛型变量的类型。在调用泛型方法时，可以指定泛型，也可以不指定泛型:

在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到Object。
在指定泛型的情况下，该方法的几种类型必须是该泛型的实例的类型或者其子类。

public class Test {  
    public static void main(String[] args) {  

        /**不指定泛型的时候*/  
        int i = Test.add(1, 2); //这两个参数都是Integer，所以T为Integer类型  
        Number f = Test.add(1, 1.2); //这两个参数一个是Integer，一个是Float，所以取同一父类的最小级，为Number  
        Object o = Test.add(1, "asd"); //这两个参数一个是Integer，一个是String，所以取同一父类的最小级，为Object  

        /**指定泛型的时候*/  
        int a = Test.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类  
        int b = Test.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float  
        Number c = Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float  
    }  

    //这是一个简单的泛型方法  
    public static <T> T add(T x,T y){  
        return y;  
    }  
}

6、如何理解泛型的编译期检查？

既然说类型变量会在编译的时候擦除掉，那为什么我们往 ArrayList 创建的对象中添加整数会报错呢？不是说泛型变量String会在编译的时候变为Object类型吗？为什么不能存别的类型呢？既然类型擦除了，如何保证我们只能使用泛型变量限定的类型呢？

Java编译器是通过先检查代码中泛型的类型，然后在进行类型擦除，再进行编译。

public static  void main(String[] args) {  

    ArrayList<String> list = new ArrayList<String>();  
    list.add("123");  
    list.add(123);//编译错误  
}

在上面的程序中，使用add方法添加一个整型，在IDE中，直接会报错，说明这就是在编译之前的检查，因为如果是在编译之后检查，类型擦除后，原始类型为Object，是应该允许任意引用类型添加的。可实际上却不是这样的，这恰恰说明了关于泛型变量的使用，是会在编译之前检查的。

那么，这个类型检查是针对谁的呢？

ArrayList<String> list1 = new ArrayList(); //第一种 情况
ArrayList list2 = new ArrayList<String>(); //第二种 情况

这样是没有错误的，不过会有个编译时警告。
不过在第一种情况，可以实现与完全使用泛型参数一样的效果，第二种则没有效果(默认是Object)。因为类型检查就是编译时完成的，new ArrayList()只是在内存中开辟了一个存储空间，可以存储任何类型对象，而真正涉及类型检查的是它的引用，因为我们是使用引用来调用它的方法，比如说调用add方法，所以list1引用能完成泛型类型的检查。而引用list2没有使用泛型，所以不行。
在这里插入图片描述

在这里插入图片描述

6.1泛型中参数类型为什么不考虑继承关系？

ArrayList<String> list1 = new ArrayList<Object>(); //编译错误  
ArrayList<Object> list2 = new ArrayList<String>(); //编译错误

第一种情况展开如下：

ArrayList<Object> list1 = new ArrayList<Object>();  
list1.add(new Object());  
list1.add(new Object());  
ArrayList<String> list2 = list1; //编译错误

实际上，在第4行代码的时候，就会有编译错误。那么，我们先假设它编译没错。那么当我们使用list2引用用get()方法取值的时候，返回的都是String类型的对象（上面提到了，类型检测是根据引用来决定的），可是它里面实际上已经被我们存放了Object类型的对象，这样就会有ClassCastException了。所以为了避免这种极易出现的错误，Java不允许进行这样的引用传递。（这也是泛型出现的原因，就是为了解决类型转换的问题，我们不能违背它的初衷）。
在这里插入图片描述
第二种情况展开：

ArrayList<String> list1 = new ArrayList<String>();  
list1.add(new String());  
list1.add(new String());

ArrayList<Object> list2 = list1; //编译错误

没错，这样的情况比第一种情况好的多，最起码，在我们用list2取值的时候不会出现ClassCastException，因为是从String转换为Object。可是，这样做有什么意义呢，泛型出现的原因，就是为了解决类型转换的问题。我们使用了泛型，到头来，还是要自己强转，违背了泛型设计的初衷,所以java不允许这么干。再说，你如果又用list2往里面add()新的对象，那么到时候取得时候，我怎么知道我取出来的到底是String类型的，还是Object类型的呢？所以，要格外注意，泛型中的引用传递的问题。
在这里插入图片描述

7、通配符

<?> ：被称作无限定的通配符。
<? extends T> ：被称作有上界的通配符。
<? super T> ：被称作有下界的通配符。

7.1 : 无限定通配符 ?

在使用泛型类时, 我们可以使用一个具体的类型, 例如可以定义一个 List<Integer> 的对象, 我们的泛型参数就是 Integer ; 我们也可以使用通配符 ? 来表示一个未知类型, 例如 List<?> 就表示了泛型参数是某个类型, 只不过我们并不知道它的具体类型时什么. List<?>所声明的就是所有类型都是可以的, 但需要注意的是, List<?>并不等同于List。对于 List< Object > 来说, 它实际上确定了 List 中包含的是 Object 及其子类, 我们可以使用 Object 类型来接收它的元素. 相对地, List<?> 则表示其中所包含的元素类型是不确定, 其中可能包含的是 String, 也可能是 Integer。如果它包含了 String 的话, 往里面添加 Integer 类型的元素就是错误的。作为对比, 我们可以给一个 List< Object> 添加 String 元素, 也可以添加 Integer 类型的元素, 因为它们都是 Object 的子类。
正因为类型未知, 我们就不能通过 new ArrayList<?>() 的方法来创建一个新的ArrayList 对象, 因为编译器无法知道具体的类型是什么. 但是对于 List<?> 中的元素, 我们却都可以使用 Object 来接收, 因为虽然类型未知, 但肯定是Object及其子类。

    List<?> ls1 = new ArrayList<>();
    ls1.add(null);
    ls1.add(123);  //编译不通过
    Object o = ls1.get(0);

我们在上面提到了, List<?> 中的元素只能使用 Object 来接收参数, 这样作肯定时不太方便的, 不过幸运的是, Java 的泛型机制允许我们对泛型参数的类型的上界和下界做一些限制, 例如 List<? extends Number> 定义了泛型的上界是 Number, 即 List 中包含的元素类型是 Number 及其子类. 而 List<? super Number> 定义了泛型的下界, 即 List 中包含的是 Number 及其父类.

7.2 上界 ? extends T

? extends T 描述了通配符上界, 即具体的泛型参数需要满足条件: 泛型参数必须是 T 类型或它的子类, 例如:

List<? extends Number> numberArray = new ArrayList<Number>();  // Number 是 Number 类型的
List<? extends Number> numberArray = new ArrayList<Integer>(); // Integer 是 Number 的子类
List<? extends Number> numberArray = new ArrayList<Double>();  // Double 是 Number 的子类

上面三个操作都是合法的, 因为 ? extends Number 规定了泛型通配符的上界, 即我们实际上的泛型必须要是 Number 类型或者是它的子类, 而 Number（自身）、Integer, Double 显然都是 Number 的子类。

关于读取（根据上面的例子, 对于 List<? extends Number> numberArray 对象:）

我们能够从 numberArray 中读取到 Number 对象, 因为 numberArray 中包含的元素是 Number 类型或 Number 的子类型.
我们不能从 numberArray 中读取到 Integer 类型, 因为 numberArray 中可能保存的是 Double 类型.
同理, 我们也不能从 numberArray 中读取到 Double 类型.

关于写入（根据上面的例子, 对于 List<? extends Number> numberArray 对象:）

我们不能添加 Number 到 numberArray 中, 因为 numberArray 有可能是List< Double> 类型
我们不能添加 Integer 到 numberArray 中, 因为 numberArray 有可能是 List< Double> 类型
我们不能添加 Double 到 numberArray 中, 因为 numberArray 有可能是 List< Integer> 类型

代码示例：

  List<? extends Number> ls = new ArrayList<Integer>();

   //上述代码分开
   List<Integer> li = new ArrayList<Integer>();
   li.add(1);


   List<? extends Number> ln = li;
   ln.add(2.3F);  //编译不通过

如果ln.add(2.3F)允许放入到容器中，在执行li.get(1)的时候会出现异常。
在这里插入图片描述

7.3 下界 ? super T

? super T 描述了通配符下界, 即具体的泛型参数需要满足条件: 泛型参数必须是 T 类型或它的父类, 例如:

// 在这里, Integer 可以认为是 Integer 的 "父类"
List<? super Integer> array = new ArrayList<Integer>();
// Number 是 Integer 的 父类
List<? super Integer> array = new ArrayList<Number>();
// Object 是 Integer 的 父类
List<? super Integer> array = new ArrayList<Object>();

关于读取(对于上面的例子中的 List<? super Integer> array 对象:)

我们不能保证可以从 array 对象中读取到 Integer 类型的数据, 因为 array 可能是 List< Number> 类型的.
我们不能保证可以从 array 对象中读取到 Number 类型的数据, 因为 array 可能是 List< Object> 类型的.
唯一能够保证的是, 我们可以从 array 中获取到一个 Object 对象的实例.

关于写（对于上面的例子中的 List<? super Integer> array 对象:）

我们可以添加 Integer 对象到 array 中, 也可以添加 Integer 的子类对象到 array 中.
我们不能添加 Double/Number/Object 等不是 Integer 的子类的对象到 array 中.

代码示例:

List<? super Integer> array = new ArrayList<Number>();

//代码拆开看
ArrayList<Number> numbers = new ArrayList<Number>();
numbers.add(1);
numbers.add(300L);
numbers.add(2.3);

List<? super Integer> array = numbers;
//可以向array 中写入 Integer 或者Integer的子类
//因为 是Integer或Integer的子类一定是Number的子类。

在这里插入图片描述

7.4 易混淆点

有一点需要注意的是, List<? super T> 和 List<? extends T> 中, 我们所说的 XX 是 T 的父类(a superclass of T) 或 XX 是 T 的子类(a subclass of T) 其实是针对于泛型参数而言的. 例如考虑如下例子:

List<? super Integer> l1 = ...
List<? extends Integer> l2 = ...

那么这里 ? super Integer 和 ? extends Integer 的限制是对谁的呢? 是表示我们可以插入任意的对象 X 到 l1 中, 只要 X 是 Integer 的父类? 是表示我们可以插入任意的对象 Y 到 l2 中, 只要 Y 是 Integer 的子类?
其实不是的, 我们必须要抛弃上面的概念, ? super Integer 和 ? extends Integer 限制的其实是泛型参数, 即 List<? super Integer> l1 表示 l1 的泛型参数 T 必须要满足 T 是 Integer 的父类, 因此诸如 List, List<Number 的对象就可以赋值到 l1 中. 正因为我们知道了 l1 中的泛型参数的边界信息, 因此我们就可以向 l1 中添加 Integer 对象了, 推理过程如下:

令 T 是 l1 的泛型参数, 即:
l1 = List = List<? super Integer>
因此有 T 是 Integer 或 Integer 的父类.
如果 T 是 Integer, 则 l1 = List, 显然我们可以添加任意的 Integer 对象或 Integer 的子类对象到 l1 中.
如果 T 是 Integer 的父类, 那么同理, 对于 Integer 或 Integer 的子类的对象, 我们也可以添加到 l1 中.
按同样的分析方式, List<? extends Integer> l2 表示的是 l2 的泛型参数是 Integer 的子类型. 而如果我们要给一个 List 插入一个元素的话, 我们需要保证此元素是 T 或是 T 的子类, 而这里 List<? extends Integer> l2, l2 的泛型参数是什么类型我们都不知道, 进而就不能确定 l2 的泛型参数的子类是哪些, 因此我们就不能向 l2 中添加任何的元素了.

来一个对比:

对于 List<? super Integer> l1:

正确的理解: ? super Integer 限定的是泛型参数. 令 l1 的泛型参数是 T, 则 T 是 Integer 或 Integer 的子类, 因此 Integer 或 Integer 的子类的对象就可以添加到 l1 中.
错误的理解: ~~? super Integer限定的是插入的元素的类型, 因此只要是 Integer 或 Integer 的父类的对象都可以插入 l1 中~~

对于 List<? extends Integer> l2:

正确的理解: ? extends Integer 限定的是泛型参数. 令 l2 的泛型参数是 T, 则 T 是 Integer 或 Integer 的子类, 进而我们就不能找到一个类 X, 使得 X 是泛型参数 T 的子类, 因此我们就不可以向 l2 中添加元素. 不过由于我们知道了泛型参数 T 是 Integer 或 Integer 的子类这一点, 因此我们就可以从 l2 中读取到元素, 并可以存放到 Integer 中.
错误的理解: ~~? extends Integer 限定的是插入元素的类型, 因此只要是 Integer 或 Integer 的子类的对象都可以插入 l2 中~~

参考链接1：
参考链接2
参考链接3
参考链接4

跃ZHD

关注

27
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
java基础之泛型

泛型解释为：将类型由原来的具体的类型参数化（也即参数化类型对于一个普通的方法有形参，形参有参数类型，在使用该方法的时候传递的是实参。泛型就是将形参的数据类型参数化。//方法1（普通方法）public void pnt(String var) { //形参的数据类型为String，形参var//方法2（泛型方法）public <T> void pnt2(T t) { //未给出具体形参数据类型，形参的数据类型也是一个参数。
复制链接

扫一扫