泛型系列教材（三）- Java 泛型通配符 ? extends super 的用法

工具版本兼容问题

本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。不建议一开始就观看视频

11分34秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

示例 1 : ? extends
示例 2 : ? super
示例 3 : 泛型通配符?
示例 4 : 总结
示例 5 : 练习- extends
示例 6 : 答案- extends
示例 7 : 练习-二叉树
示例 8 : 答案-二叉树

示例 1 :

? extends

edit 顶折

纠问

ArrayList heroList<? extends Hero> 表示这是一个Hero泛型或者其子类泛型
heroList 的泛型可能是Hero
heroList 的泛型可能是APHero
heroList 的泛型可能是ADHero
所以可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的

但是，不能往里面放东西，因为
放APHero就不满足<ADHero>
放ADHero又不满足<APHero>

代码行数较多，请点击查看

示例 2 :

? super

edit 顶折

纠问

ArrayList heroList<? super Hero> 表示这是一个Hero泛型或者其父类泛型
heroList的泛型可能是Hero
heroList的泛型可能是Object

可以往里面插入Hero以及Hero的子类
但是取出来有风险，因为不确定取出来是Hero还是Object

代码行数较多，请点击查看

示例 3 :

泛型通配符?

edit 顶折

纠问

泛型通配符? 代表任意泛型
既然?代表任意泛型，那么换句话说，这个容器什么泛型都有可能

所以只能以Object的形式取出来
并且不能往里面放对象，因为不知道到底是一个什么泛型的容器

代码行数较多，请点击查看

示例 4 :

总结

edit 顶折

纠问

如果希望只取出，不插入，就使用? extends Hero
如果希望只插入，不取出，就使用? super Hero
如果希望，又能插入，又能取出，就不要用通配符？

示例 5 :

练习- extends

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

如代码所示，为了遍历不同泛型的3种集合，需要设计3个方法

借助? extends，把代码减肥到只是用一种方法

代码行数较多，请点击查看

示例 6 :

答案- extends

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

3分3秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

使用一个方法：

public static void iterate(ArrayList<? extends Hero> list) {

就表示传递进去的集合的泛型可以是Hero的子类

代码行数较多，请点击查看

示例 7 :

练习-二叉树

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

把练习-支持泛型的二叉树改造成支持泛型 <T extends Comparable>，并在比较的时候使用compare方法

示例 8 :

答案-二叉树

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

4分57秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

把Node设计为

public class Node<T extends Comparable<T>> {

就表示只能使用那些实现了Comparable接口的泛型，比如Integer,Hero

Node<Integer> roots = new Node<>();

Node<Hero> heros = new Node<>();

但是GiantDragon就不行，因为它没有实现Comparable接口

Node<GiantDragon> dragons = new Node<>();

代码行数较多，请点击查看

package collection;
 
import java.util.ArrayList;
import java.util.List;
 
import charactor.GiantDragon;
import charactor.Hero;
 
public class Node<T extends Comparable<T>> {
 
    public Node<T> leftNode;
 
    public Node<T> rightNode;
 
    public T value;
 
    public void add(T t) {
 
        if (null == value)
            value = t;
 
        else {
 
            //t和value都是T 类型，而T类型extends Comparable，所以必然提供compare接口
            if (t.compareTo(value) <= 0) {
                if (null == leftNode)
                    leftNode = new Node<T>();
                leftNode.add(t);
            }
 
            else {
                if (null == rightNode)
                    rightNode = new Node<T>();
                rightNode.add(t);
            }
 
        }
 
    }
 
    public List<T> values() {
        List<T> values = new ArrayList<>();
 
        if (null != leftNode)
            values.addAll(leftNode.values());
 
        values.add(value);
 
        if (null != rightNode)
 
            values.addAll(rightNode.values());
 
        return values;
    }
 
    public static void main(String[] args) {
 
        int randoms[] = new int[] { 67, 7, 30, 73, 10, 0, 78, 81, 10, 74 };
 
        Node<Integer> roots = new Node<>();
        for (int number : randoms) {
            roots.add(number);
        }
 
        System.out.println(roots.values());
         
        //Hero实现了 Comparable接口，所以可以作为Node的泛型
        Node<Hero> heros = new Node<>();
         
        //GiantDragon 没有实现 Comparable接口，所以不能作为Node的泛型
        Node<GiantDragon> dragons = new Node<>();
         
    }
}

泛型系列教材（二）- Java 如何设计支持泛型的类

泛型系列教材（四）- Java 中的子类泛型转型成父类泛型

HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2024-07-12 用泛型<T extends Comparable>改造二叉树，并比较性能

虚心求学

关于 JAVA 中级-泛型-通配符的提问

int 型二叉树： [7, 7, 6, 6, 6, 5, 3, 2, 1, 0] double 型二叉树： [0.9758123368575745, 0.8923154875563853, 0.7669768894502831, 0.7567667361130371, 0.5612394437891686, 0.42546559978207377, 0.3880901172256477, 0.2706571923190054, 0.03478217244486337, 0.034118373480261255] Float 型二叉树： [0.835175, 0.77619874, 0.6672226, 0.6410905, 0.50696, 0.34440315, 0.3303914, 0.24499315, 0.06287497, 0.062285423] 对象型（Hero）二叉树 [[Hero - 9,0.61,0.74, [Hero - 6,0.93,0.74, [Hero - 7,0.64,0.61, [Hero - 7,0.27,0.60, [Hero - 8,0.83,0.57, [Hero - 5,0.77,0.57, [Hero - 7,0.42,0.49, [Hero - 7,0.45,0.34, [Hero - 1,0.45,0.18, [Hero - 6,0.59,0.04] 对象型（Item）二叉树 [name = potion - 8;price = 0, name = potion - 0;price = 0, name = potion - 0;price = 0, name = potion - 4;price = 1, name = potion - 9;price = 3, name = potion - 4;price = 5, name = potion - 7;price = 8, name = potion - 6;price = 8, name = potion - 9;price = 8, name = potion - 7;price = 9] 测试次数 100000（10万）次，结果如下： Tree.InOrder（递归）用时(ms):1140 Tree.postOrder(非递归) 用时(ms):1032 BubbleSort 用时(ms):27231 SelectSort 用时(ms):9157 一致性检查：冒泡排序与二叉树结果一致？：true 选择排序与二叉树结果一致？：true 冒泡排序与选择排序结果一致？：true 递归与非递归结果一致？：true

package j2se;
 
import java.util.ArrayList;
import java.util.List;
 
//自定义二叉树，插入的对象需实现 Comparable 接口
public class MyTree<E extends Comparable<E>>{
    private Node<E> root;
 
    public void add(E e) {
        if (root == null) {
            root = new Node<E>(e, 0);
        } else
            root.add(e, 1);
 
    }
    public void add(E key, Object obj) {
        if (root == null) {
            root = new Node<E>(key, obj, 0);
        } else
            root.add(key, obj, 1);
    }
 
    public void add(E[] arr) {
        for (E e : arr) {
            add(e);
        }
    }
    public List<? extends Comparable<E>> values(){
         
        return inOrder();
         
    }
    public int getDiemension(Node<E> node, int[] d, int[] c) {
        if (node == null)
            return d[0];
        c[0]++;
        d[0] = Math.max(node.Dimension, d[0]);
        if (node.Left != null)
            getDiemension(node.Left, d, c);
        if (node.Right != null)
            getDiemension(node.Right, d, c);
        return d[0];
    }
 
    public int getDimension() {
        return getDiemension(root, new int[] { 0 }, new int[] { 0 });
    }
 
    // 中序遍历
    public List<E> inOrder() {
        return order(root, OrderWay.inOrderWay,new ArrayList<>());
    }
 
    // 递归遍历
    public List<E> order(Node<E> node, OrderWay orderWay,List<E> memoryList) {
        if (node == null)
            return null;
        if (orderWay == OrderWay.preOrderWay)
            memoryList.add(node.Key);
        if (node.Left != null)
            order(node.Left, orderWay, memoryList);
        if (orderWay == OrderWay.inOrderWay)
            memoryList.add(node.Key);
        if (node.Right != null)
            order(node.Right, orderWay, memoryList);
        if (orderWay == OrderWay.postOrderWay)
            memoryList.add(node.Key);
 
        return memoryList;
    }
 
    // 非递归先序遍历
    public List<E> preOrderStack() {
        List<E> memoryList = new ArrayList<>();
        MyStack<Node<E>> stack = new MyStack<>();
        stack.push(root);
        while (stack.peek() != null) {
            Node<E> top = stack.pull();
            memoryList.add(top.Key);
            while (top != null) {
                if (top.Right != null)
                    stack.push(top.Right);
                top = top.Left;
                if (top != null)
                    memoryList.add(top.Key);
            }
        }
        return memoryList;
    }
 
    // 非递归中序遍历
    public List<E> inOrderStack() {
        List<E> memoryList = new ArrayList<>();
        MyStack<Node<E>> stack = new MyStack<>();
        Node<E> top = root;
        do {
            while (top != null) {
                if (top.Left != null || top.Right != null)
                    stack.push(top);
                else
                    memoryList.add(top.Key);
                top = top.Left;
            }
            top = stack.pull();
            if (top != null) {
                memoryList.add(top.Key);
                top = top.Right;
            }
        } while (top != null || stack.peek() != null);
        return memoryList;
    }
 
    // 非递归中序降序遍历
    public List<E> inOrderStackDescending() {
        List<E> memoryList = new ArrayList<>();
        MyStack<Node<E>> stack = new MyStack<>();
        Node<E> top = root;
        do {
            while (top != null) {
                if (top.Left != null || top.Right != null)
                    stack.push(top);
                else
                    memoryList.add(top.Key);
                top = top.Right;
            }
            top = stack.pull();
            if (top != null) {
                memoryList.add(top.Key);
                top = top.Left;
 
            }
        } while (top != null || stack.peek() != null);
        return memoryList;
    }
 
    //非递归后续遍历
    public List<E> postOrderStack() {
        List<E> memoryList = new ArrayList<>();
        MyStack<Node<E>> stack = new MyStack<>();
        Node<E> top = root;
        MyStack<Node<E>> memoryStack = new MyStack<>();
        // stack.push(root);
        do {
 
            while (top != null) {
                if (top.Left != null || top.Right != null)
                    stack.push(top);
                else
                    memoryList.add(top.Key);
                top = top.Left;
            }
            while (stack.peek() == memoryStack.peek() && stack.peek() != null) {
                stack.pull();
                memoryList.add(memoryStack.pull().Key);
            }
            if (stack.peek() != null) {
                memoryStack.push(stack.peek());
                top = stack.peek().Right;
            }
 
        } while (stack.peek() != null || top != null);
        return memoryList;
    }
 
    // 每次遍历记录数据，返回链表形式
    public List<E> orderDescending(Node<E> node, OrderWay orderWay, List<E> memoryList) {
        if (node == null)
            return null;
        if (orderWay == OrderWay.preOrderWay)
            memoryList.add(node.Key);
        if (node.Right != null)
            orderDescending(node.Right, orderWay, memoryList);
        if (orderWay == OrderWay.inOrderWay)
            memoryList.add(node.Key);
        if (node.Left != null)
            orderDescending(node.Left, orderWay, memoryList);
        if (orderWay == OrderWay.postOrderWay)
            memoryList.add(node.Key);
 
        return memoryList;
    }
 
    // 前序遍历
    public List<E> preOrder() {
        return order(root, OrderWay.preOrderWay,new ArrayList<>());
    }
 
    // 前序降序遍历
    public List<E> preOrderDescending() {
        return orderDescending(root, OrderWay.preOrderWay,new ArrayList<>());
    }
 
    // 中序降序遍历
    public List<E> inOrderDescending() {
        return orderDescending(root, OrderWay.inOrderWay,new ArrayList<>());
    }
 
    // 后序降序遍历
    public List<E> postOrderDescending() {
        return orderDescending(root, OrderWay.postOrderWay,new ArrayList<>());
    }
 
    // 后续遍历
    public List<E> postOrder() {
        return order(root, OrderWay.postOrderWay,new ArrayList<>());
    }
}
 
// 二叉树遍历方式
enum OrderWay {
    preOrderWay, inOrderWay, postOrderWay,
}
 
// 二叉树节点
class Node<E extends Comparable<E>> {
    public int Dimension;
    public E Key;
    public Object Obj;
    public Node<E> Left;
    public Node<E> Right;
 
    public Node(E e) {
        this.Key = e;
    }
 
    public Node(E e, Object obj) {
        this(e);
        this.Obj = obj;
    }
 
    public Node(E e, int id) {
        this.Key = e; 
        this.Dimension = id;
    }
 
    public Node(E e, Object obj, int id) {
        this(e, obj);
        this.Dimension = id;
    }
 
    public void add(E e) {
        if (e.compareTo(Key)<=0) {
            if (this.Left != null)
                this.Left.add(e);
            else {
                this.Left = new Node<E>(e);
                return;
            }
        } else {
            if (this.Right != null)
                this.Right.add(e);
            else {
                this.Right = new Node<E>(e);
                return;
            }
        }
    }
 
    public void add(E e, Object obj, int d) {
        if (e.compareTo(Key)<=0) {
            if (this.Left != null)
                this.Left.add(e, obj, d + 1);
            else {
                this.Left = new Node<E>(e, obj, d);
                return;
            }
        } else {
            if (this.Right != null)
                this.Right.add(e, obj, d + 1);
            else {
                this.Right = new Node<E>(e, obj, d);
                return;
            }
        }
    }
 
    public void add(E e, int d) {
        if (e.compareTo(Key)<=0) {
            if (this.Left != null)
                this.Left.add(e, d + 1);
            else {
                this.Left = new Node<E>(e, d);
                return;
            }
        } else {
            if (this.Right != null)
                this.Right.add(e, d + 1);
            else {
                this.Right = new Node<E>(e, d);
                return;
            }
        }
    }
 
}
 
----------------------下面为主函数调用--------------------------
 
ublic static void main(String[] args) throws Exception {
        Random r = new Random();
        //创建不同类型的数值型（实现Comparable）二叉树
        MyTree<Integer>t1 = new MyTree<>();
        MyTree<Double>t2 = new MyTree<>();
        MyTree<Float>t3 = new MyTree<>();
        //创建不同类型的对象（实现Comparable）二叉树
        MyTree<Hero>t4 = new MyTree<>();
        MyTree<Item>t5 = new MyTree<>();
         
        //用随机数值初始化以上二叉树
        for (int i = 0; i < 10; i++) {
            t1.add(r.nextInt(10));
        }
        for (int i = 0; i < 10; i++) {
            t2.add(r.nextDouble());
        }
         
        for (int i = 0; i < 10; i++) {
            t3.add(r.nextFloat());
        }
        for (int i = 0; i < 10; i++) {
            t4.add(new Hero("Hero - "+r.nextInt(10),r.nextFloat(),r.nextFloat(),r.nextInt(10)));
        }
        for (int i = 0; i < 10; i++) {
            t5.add(new Item("potion - "+r.nextInt(10),r.nextInt(10)));
        }
        //遍历二叉树，打印结果
        iterate(t1);
        iterate(t2);
        iterate(t3);
        iterate(t4);
        iterate(t5);
 
        //测试二叉树排序性能
        testBinaryTree();
    }
    public static void iterate(MyTree nums)//中序遍历二叉树，打印结果
    {
        System.out.println(nums.inOrderStackDescending()+"\r\n");
    }
 
------------------下面为测试二叉树性能方法---------------------------------
 
public static void testBinaryTree() throws IndexIsNagetiveException, IndexIsOutofRangeException {
        int number = 10 * 10000;
        System.out.println("测试次数" + number);
        int[] list = GetArrList(number);
         int[] list1 = getarr(list);
         int[] list2 = getarr(list);
 
        long startMs = System.currentTimeMillis();
        MyTree<Integer> mTree = GetMyTree(list);
        List<Integer> treelist1 = mTree.inOrderDescending();
        long endMs = System.currentTimeMillis();
        long timeTree = endMs - startMs;
        System.out.println("Tree.InOrder（递归） 用时(ms):" + timeTree);
 
 
        long startMs3 = System.currentTimeMillis();
        MyTree<Integer> mTree3 = GetMyTree(list);
        List<Integer>treelist3 = mTree3.inOrderStackDescending();
        long endMs3 = System.currentTimeMillis();
        long timeTree3 = endMs3 - startMs3;
        System.out.println("Tree.postOrder(非递归) 用时(ms):" + timeTree3);
         
         long timeBub = BubbleSort(list1);
         System.out.println("BubbleSort 用时(ms):" + timeBub);
          
         long timeSelect = SelectSort(list2);
         System.out.println("SelectSort 用时(ms):" + timeSelect);
          
         System.out.println("冒泡排序与二叉树结果一致？：" + compareSortRes(list1,
         treelist1));
         System.out.println("选择排序与二叉树结果一致？：" + compareSortRes(list2,
         treelist1));
         System.out.println("冒泡排序与选择排序结果一致？：" + compareSortRes2(list2,
         list1));
 
        System.out.println("递归与非递归结果一致？：" + compareSortRes3(treelist3, treelist1));
 
    }
 
------------下面为冒泡排序、选择排序的方法-------------
------------------以及以上结果一致性检验-------------------
 
public static int[] getarr(int[] list) {
        int[] arr = new int[list.length];
        int index = 0;
        for (int i : list) {
            arr[index++] = i;
        }
        return arr;
    }
 
    public static boolean compareSortRes(int[] list, List<Integer> treelist) {
        int length = list.length;
        for (int i = 0; i < length; i++) {
            if (list[i] != (int) ((double) Math.floor(treelist.get(i))))
                return false;
        }
        return true;
    }
 
    public static boolean compareSortRes2(int[] list, int[] list2) {
        int length = list.length;
        for (int i = 0; i < length; i++) {
            if (list[i] != list[i])
                return false;
        }
        return true;
    }
 
    public static boolean compareSortRes3(List<Integer> treelist3, List<Integer> treelist2) {
        if (treelist3 == null && treelist2 == null)
            return true;
        int length = treelist3.size();
        if (treelist3.size() != treelist2.size())
            return false;
        for (int i = 0; i < length; i++) {
            if ((double) treelist3.get(i) != (double) treelist2.get(i))
                return false;
        }
        return true;
    }
 
    public static MyTree<Integer> GetMyTree(int[] arr) {
        MyTree<Integer> mTree = new MyTree<>();
        for (int i : arr) {
            mTree.add(i);
        }
        return mTree;
    }
 
    public static int[] GetArrList(int Num) {
        int[] is = new int[Num];
        for (int i = 0; i < Num; i++) {
            is[i] = (int) (Math.random() * 100);
        }
        return is;
    }
 
    public static long BubbleSort(int[] list) {
        long startMs = System.currentTimeMillis();
        int length = list.length;
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - 1 - i; j++) {
                if (list[j] < list[j + 1]) {
                    int temp = list[j + 1];
                    list[j + 1] = list[j];
                    list[j] = temp;
                }
            }
        }
        long endMs = System.currentTimeMillis();
        return endMs - startMs;
    }
 
    public static long SelectSort(int[] list) {
        long startMs = System.currentTimeMillis();
        int length = list.length;
        for (int i = 0; i < length - 1; i++) {
            for (int j = i + 1; j < length; j++) {
                if (list[i] < list[j]) {
                    int temp = list[j];
                    list[j] = list[i];
                    list[i] = temp;
                }
            }
        }
        long endMs = System.currentTimeMillis();
        return endMs - startMs;
    }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-06-16 答案

大D

关于 JAVA 中级-泛型-通配符的提问

答案

1.public static void iterate(ArrayList<? extends Hero> list){
       for(Hero hero :list){
           System.out.println(hero.name);
       }
    }
 
    public static void main(String[] args) {
        ArrayList< Hero> hs = new ArrayList<>();
 
        ArrayList<APHero> aphs = new ArrayList<>();
 
        ArrayList<ADHero> adhs = new ArrayList<>();
 
 
 
        iterate(hs);
 
        iterate(adhs);
    }
 
 
2.
import java.util.ArrayList;
import java.util.List;
 
public class Node2<T extends Comparable<T>> {
    Node2<T> leftNode;
 
    Node2<T> rightNode;
 
    T t;
 
    public void add(T t){
      if(this.t==null){
          this.t=t;
      }else{
          if(t.compareTo(this.t)<=0){
              if(null==leftNode){
                  leftNode=new Node2<>();              }leftNode.add(t);
          }else{
              if(null==rightNode)
                  rightNode=new Node2<>();
              rightNode.add(t);
          }
      }
    }
    public List<T> order(){
        List<T> values=new ArrayList<>();
        if(null!=leftNode){
            values.addAll(leftNode.order());
        }
        values.add(t);
        if(null!=rightNode){
            values.addAll(rightNode.order());
        }
 
        return values;
    }
 
    public static void main(String[] args) {
        Node2<Hero> hero =new Node2<>();
        for(int i=0;i<10;i++){
            hero.add(new Hero("hero"+i,111,(int) (Math.random() * 901) + 100));
        }
        for(Hero h:hero.order()){
            System.out.println(h);
        }
    }
}

1 个答案

实习英雄
答案时间：2023-12-21

package generic; import java.util.ArrayList; import charactor.ADHero; import charactor.APHero; import charactor.Hero; public class TestGeneric { // 使用泛型通配符来处理 Hero 及其任何子类的 ArrayList public static void iterate(ArrayList<? extends Hero> list) { for (Hero hero : list) { System.out.println(hero.name); } } public static void main(String[] args) { ArrayList<Hero> hs = new ArrayList<>(); ArrayList<APHero> aphs = new ArrayList<>(); ArrayList<ADHero> adhs = new ArrayList<>(); // 现在可以使用同一个方法来处理不同的列表 iterate(hs); iterate(aphs); iterate(adhs); } }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-05-21 第一道题，还是不理解泛型和通配符泛型的区别

kaiyinV

关于 JAVA 中级-泛型-通配符的提问

如题，既然ArrayList<Hero> list的意思是一个容纳Hero以及它的子类的ArrayList，那为什么还要在方法签名里规定形参必须是（ArrayList<？extends Hero> h ），然后这个方法才能放得下ArrayList<APHero>呢？APHero不是Hero的子类吗，那按理说方法签名里的形参是（ArrayList<Hero> h ）的话，ArrayList<APHero>已经可以传进去了呀？

2 个答案

offer收割机陈嘉尉
答案时间：2023-12-01

不可以呀，ArrayList<Hero> h 和ArrayList<APHero> h1是两个完全不同类型的对象呀，它们也没有继承关系，有继承关系的是Hero h和APHero h1。泛型就是一个集合里面可以装同一类下的所有子类，而通配符泛型就是让一个集合类型可以指向多种泛型的集合类型，我理解的是通配符泛型就是泛型的泛型，泛型是集合内元素的多态，通配符泛型是集合本身的多态，如有错误请指教

四方1
答案时间：2023-07-25

他这题出得不好，没展示出通配符的特殊作用。但是上面教学讲的比较清楚。

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-05-13 答案

2021-08-25 遍历

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 20 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢