1.❤️❤️前言~🥳🎉🎉🎉

Hello, Hello~ 亲爱的朋友们👋👋，这里是E绵绵呀✍️✍️。

如果你喜欢这篇文章，请别吝啬你的点赞❤️❤️和收藏📖📖。如果你对我的内容感兴趣，记得关注我👀👀以便不错过每一篇精彩。

当然，如果在阅读中发现任何问题或疑问，我非常欢迎你在评论区留言指正🗨️🗨️。让我们共同努力，一起进步！

加油，一起CHIN UP！💪💪

🔗个人主页：E绵绵的博客
📚所属专栏：

1. JAVA知识点专栏

        深入探索JAVA的核心概念与技术细节

2.JAVA题目练习

        实战演练，巩固JAVA编程技能

3.c语言知识点专栏

        揭示c语言的底层逻辑与高级特性

4.c语言题目练习

        挑战自我，提升c语言编程能力

📘 持续更新中，敬请期待❤️❤️

借鉴的相关文章：Java 中的泛型（两万字超全详解）_java 泛型-CSDN博客

 

 2.泛型通配符

我们希望泛型能够处理某一类型范围的类型参数，比如某个泛型类和它的子类，为此 Java 引入了泛型通配符这个概念。

泛型通配符有 3 种形式：

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

接下来将分别介绍 3 种形式的泛型通配符。

2.1上界通配符 <? extends T>

  <? extends T> 的定义 

上界通配符 <? extends T>：T 代表了类型参数的上界，<? extends T>表示类型参数的范围是 T 和 T 的子类。需要注意的是： <? extends T> 也是一个数据类型实参，它和 Number、String、Integer 一样都是一种实际的数据类型。

下面给个例子： 

public class GenericType {
    public static void main(String[] args) {  
		ArrayList<Number> list01 = new ArrayList<Integer>();// 编译错误

		ArrayList<? extends Number> list02 = new ArrayList<Integer>();// 编译正确
    }  
}

我们发现，ArrayList< Integer > 和 ArrayList< Number > 之间不存在继承关系，所以编译错误。而引入上界通配符的概念后，我们便可以用 ArrayList<? extends Number> 接收 ArrayList< Integer > 。

所以这也就意味着ArrayList<? extends T>能接收AraayList<T或T的子类>。

所以综上所述，ArrayList<? extends Number> 可以代表 ArrayList< Integer >、ArrayList< Float >、… 、ArrayList< Number >中的某一个集合，但是我们不能指定 ArrayList<? extends Number> 的数据类型。（这里有点难理解）

public class GenericType {
    public static void main(String[] args) {  
		ArrayList<? extends Number> list = new ArrayList<>();
		
		list.add(new Integer(1));// 编译错误
		list.add(new Float(1.0));// 编译错误
    }  
}

可以这样理解，ArrayList<? extends Number> 集合表示了：我这个集合可能是 ArrayList< Integer > 集合，也可能是 ArrayList< Float > 集合，… ，还可能是 ArrayList< Number > 集合；但到底是哪一个集合，不能确定；程序员也不能指定。

所以，在上面代码中，创建了一个 ArrayList<? extends Number> 集合 list，但我们并不能往 list 中添加 Integer、Float 等对象，这也说明了 list 集合并不是某个确定了数据类型的集合

思考：那既然 ArrayList<? extends Number> 可以代表 ArrayList< Integer > 或 ArrayList< Float >，为什么不能向其中加入 Integer、Float 等对象呢？

其原因是 ArrayList<? extends Number> 表示的是一个未知类型的 ArrayList 集合，它可以代表 ArrayList< Integer >或 ArrayList< Float >… 等集合，但却不能确定它到底是 ArrayList< Integer > 还是 ArrayList< Float > 集合。
因此，泛型的特性决定了不能往 ArrayList<? extends Number> 集合中加入 Integer 、 Float 等对象，以防止在获取 ArrayList<? extends Number> 集合中元素的时候，产生 ClassCastException 异常。

那为什么还需要引入上界统配符的概念？---- 答：是为了拓展方法形参中类型参数的范围。下面有个例子： 

// 改写前
public class PairHelper {
    static int addPair(Pair<Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

// 改写后
public class PairHelper {
    static int addPair(Pair<? extends Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }
}

在改写前，我们无法使 addPair(Pair< Number> p) 方法接收 Pair< Integer > 对象。而在有了上界通配符的概念后，这个问题便有了解决办法，就是将 <Number>改写为<? extends Number>。由于 Pair< Integer > 可以被 Pair<? extends Number>接收 ，所以就能调用 addPair() 方法，我们改写就成功了。

除了可以传入 Pair< Integer > 对象，我们还可以传入 Pair< Double > 对象，Pair< BigDecimal > 对象等等，因为 Double 类和 BigDecimal 类也都是 Number 的子类。

    <? extends T> 的用法

上面说到，我们无法确定 ArrayList<? extends Number> 具体是什么数据类型的集合，因此其 add() 方法会受限（即不能往集合中添加任何数据类型的对象）；但是可以往集合中添加 null，因为 null 表示任何类型。 

那我们该怎么办呢?以下是正确用法

上界通配符 <? extends T> 的正确用法： 

public class Test {
    public static void main(String[] args) {
    	// 创建一个 ArrayList<Integer> 集合
        ArrayList<Integer> integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);
        // 将 ArrayList<Integer> 传入 printIntVal() 方法
        printIntVal(integerList);
		
		// 创建一个 ArrayList<Float> 集合
        ArrayList<Float> floatList = new ArrayList<>();
        floatList.add((float) 1.0);
        floatList.add((float) 2.0);
        // 将 ArrayList<Float> 传入 printIntVal() 方法
        printIntVal(floatList);
    }
    
    public static void printIntVal(ArrayList<? extends Number> list) {
 		// 遍历传入的集合，并输出集合中的元素       
        for (Number number : list) {
            System.out.print(number.intValue() + " ");
        }
        System.out.println();
    }
}

 

在 printIntVal() 方法中，其形参为 ArrayList<? extends Number>，因此，可以给该方法传入 ArrayList< Integer >、ArrayList< Float > 等集合。

需要注意的是：在 printIntVal() 方法内部，必须要将传入集合中的元素赋值给Number 对象，而不能赋值给某个子类对象； 是因为根据 ArrayList<? extends Number> 的特性，并不能确定传入集合的数据类型（即不能确定传入的是 ArrayList< Integer > 还是 ArrayList< Float >）

假设在 printIntVal() 方法中存在下面代码：

  Integer intNum = (Integer) number;

若是传入集合为 ArrayList< Float >，则必然会产生ClassCastException 异常。

 下界通配符 <? super T> 的错误用法：

public class Test {
	public static void main(String[] args) {
		ArrayList<? extends Number> list = new ArrayList();
		list.add(null);// 编译正确
		list.add(new Integer(1));// 编译错误
		list.add(new Float(1.0));// 编译错误
	}
	
	public static void fillNumList(ArrayList<? extends Number> list) {
		list.add(new Integer(0));//编译错误
		list.add(new Float(1.0));//编译错误
		list.set(0, new Integer(2));// 编译错误
		list.set(0, null);// 编译成功，但不建议这样使用
	}
}

在 ArrayList<? extends Number> 集合中，不能添加任何数据类型的对象，只能添加空值 null，因为 null 可以表示任何数据类型。 

 <? extends T> 小结

一句话总结：使用 extends 通配符表示后该数据只可以读，不能写。

2.2下界通配符 <? super T>

 <? super T> 的定义

下界通配符 <? super T>：T 代表了类型参数的下界，<? super T>表示类型参数的范围是 T 和 T 的超类，直至 Object。需要注意的是： <? super T> 也是一个数据类型实参，它和 Number、String、Integer 一样都是一种实际的数据类型。

 下面给个例子：

public class GenericType {
    public static void main(String[] args) {  
		ArrayList<Integer> list01 = new ArrayList<Number>();// 编译错误

		ArrayList<? super Integer> list02 = new ArrayList<Number>();// 编译正确
    }  
}

我们发现，ArrayList< Integer > 和 ArrayList< Number > 之间不存在继承关系，所以编译错误。而引入上界通配符的概念后，我们便可以用 ArrayList<? super Number> 接收 ArrayList< Integer > 。

所以这也就意味着ArrayList<? super T>能接收AraayList<T或T的父类>。

ArrayList<? super Integer> 只能表示指定类型参数范围中的某一个集合，但我们不能指定 ArrayList<? super Integer> 的数据类型。（这里有点跟上界通配符一样难理解）

下面请看例子：

public class GenericType {
    public static void main(String[] args) {  
		ArrayList<? super Number> list = new ArrayList<>();
		
		list.add(new Integer(1));// 编译正确
		list.add(new Float(1.0));// 编译正确
		
		// Object 是 Number 的父类 
		list.add(new Object());// 编译错误
    }  
}

这里奇怪的地方出现了，为什么和ArrayList<? extends Number> 集合不同， ArrayList<? super Number> 集合中可以添加 Number 类及其子类的对象呢？

其原因是， ArrayList<? super Number> 的下界是 ArrayList< Number > 。因此，我们可以确定 Number 类及其子类的对象自然可以加入 ArrayList<? super Number> 集合中； 而 Number 类的父类对象就不能加入 ArrayList<? super Number> 集合中了，因为不能确定 ArrayList<? super Number> 集合的数据类型。

 <? super T> 的用法 

 下界通配符 <? super T> 的正确用法：

public class Test {
	public static void main(String[] args) {
		// 创建一个 ArrayList<? super Number> 集合
		ArrayList<Number> list = new ArrayList(); 
		// 往集合中添加 Number 类及其子类对象
		list.add(new Integer(1));
		list.add(new Float(1.1));
		// 调用 fillNumList() 方法，传入 ArrayList<Number> 集合
		fillNumList(list);
		System.out.println(list);
	}
	
	public static void fillNumList(ArrayList<? super Number> list) {
		list.add(new Integer(0));
		list.add(new Float(1.0));
	}
}

 

与带有上界通配符的集合ArrayList<? extends T>只能添加null不同，带有下界通配符的集合ArrayList<? super Number> 中可以添加 Number 类及其子类的对象；ArrayList<? super Number>的下界就是ArrayList<Number>集合，因此，其中必然可以添加 Number 类及其子类的对象；但不能添加 Number 类的父类对象（不包括 Number 类）。

下界通配符 <? super T> 的错误用法：

public class Test {
    public static void main(String[] args) {
    	// 创建一个 ArrayList<Integer> 集合
        ArrayList<Integer> list = new ArrayList<>();
        list.add(new Integer(1));
        // 调用 fillNumList() 方法，传入 ArrayList<Integer> 集合
        fillNumList(list);// 编译错误
    }

    public static void fillNumList(ArrayList<? super Number> list) {
        list.add(new Integer(0));// 编译正确
        list.add(new Float(1.0));// 编译正确
		
		// 遍历传入集合中的元素，并赋值给 Number 对象；会编译错误
        for (Number number : list) {
            System.out.print(number.intValue() + " ");
            System.out.println();
        }
        // 遍历传入集合中的元素，并赋值给 Object 对象；可以正确编译
        // 但只能调用 Object 类的方法，不建议这样使用
        for (Object obj : list) {
            System.out.println(obj);使用
        }
    }
}

注意，ArrayList<? super Number> 代表了 ArrayList< Number >、 ArrayList< Object > 中的某一个集合，而 ArrayList< Integer > 并不属于 ArrayList<? super Number> 限定的范围，因此，不能往 fillNumList() 方法中传入 ArrayList< Integer > 集合。

并且，不能将传入集合的元素赋值给 Number 对象，因为传入的可能是 ArrayList< Object > 集合，向下转型可能会产生ClassCastException 异常。

不过，可以将传入集合的元素赋值给 Object 对象，因为 Object 是所有类的父类，不会产生ClassCastException 异常，但这样的话便只能调用 Object 类的方法了，不建议这样使用。

 <? super T> 小结

一句话总结：使用 super 通配符表示可以写，但不能读。

 2.3无限定通配符 <?>

我们已经讨论了<? extends T>和<? super T>作为方法参数的作用。实际上，Java 的泛型还允许使用无限定通配符<?>，即只定义一个?符号。

​​​​​​​无界通配符<?>：? 代表了任何一种数据类，需要注意的是： <?> 也是一个数据类型实参，它和 Number、String、Integer 一样都是一种实际的数据类型。

例如ArrayList<?> 可以接收 ArrayList< Integer>、ArrayList< Number >、ArrayList< Object >中的某一个集合。

 举例如下：

public class GenericType {
	public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>(123, 456);
        ArrayList<?> list02 = list01; // 安全地向上转型
    }
}

上述代码是可以正常编译运行的，因为 ArrayList<?> 可以接收ArrayList< Integer 》

ArrayList<?> 既没有上界也没有下界，因此，它可以代表所有数据类型的某一个集合，但我们不能指定 ArrayList<?> 的数据类型。

public class GenericType {
	public static void main(String[] args) {
        ArrayList<?> list = new ArrayList<>();
        list.add(null);// 编译正确
        Object obj = list.get(0);// 编译正确

		list.add(new Integer(1));// 编译错误
		Integer num = list.get(0);// 编译错误
    }
}

ArrayList<?> 集合的数据类型是不确定的，因此我们只能往集合中添加 null；而我们从 ArrayList<?> 集合中取出的元素，也只能赋值给 Object 对象，不然会产生ClassCastException 异常（原因可以结合上界和下界通配符理解）

 3.<? extends T>与<? super T> 对比

（1）对于<? extends 类型>，编译器将只允许读操作，不允许写操作。即只可以取值，不可以设值。
（2）对于<? super 类型>，编译器将只允许写操作，不允许读操作。即只可以设值（比如 set 操作），不可以取值（比如 get 操作）。

以上两点都是针对于源码里涉及到了类型参数的方法而言的。

比如对于 List 而言，不允许的写操作有 add 方法，因为它的方法签名是boolean add(E e);，此时这个形参 E 就变成了一个涉及了通配符的类型参数；而不允许的读操作有 get 方法，因为它的方法签名是E get(int index);，此时这个返回值 E 就变成了一个涉及了通配符的类型参数。

4.总结 

所以我们泛型的进阶部分就结束了，把通配符讲完了，我们数据结构部分也就结束了。接下来将学习新的篇章——数据库，数据库会不会开一个新的专栏有待商酌。

在此，我们诚挚地邀请各位大佬们为我们点赞、关注，并在评论区留下您宝贵的意见与建议。让我们共同学习，共同进步，为知识的海洋增添更多宝贵的财富！🎉🎉🎉❤️❤️💕💕🥳👏👏👏