泛型系列教材（三）- 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>

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

package generic;
  
import java.util.ArrayList;
 
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
  
public class TestGeneric {
  
    public static void main(String[] args) {
         
        ArrayList<APHero> apHeroList = new ArrayList<APHero>();
        apHeroList.add(new APHero());
        
        ArrayList<? extends Hero> heroList = apHeroList;
         
        //? extends Hero 表示这是一个Hero泛型的子类泛型
         
        //heroList 的泛型可以是Hero
        //heroList 的泛型可以使APHero
        //heroList 的泛型可以使ADHero
         
        //可以确凿的是，从heroList取出来的对象，一定是可以转型成Hero的
         
        Hero h= heroList.get(0);
         
        //但是，不能往里面放东西
        heroList.add(new ADHero()); //编译错误，因为heroList的泛型 有可能是APHero
         
    }
     
}

示例 2 :

? super

edit 顶折

纠问

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

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

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

package generic;
 
import java.util.ArrayList;
 
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
 
public class TestGeneric {
    public static void main(String[] args) {
 
        ArrayList<? super Hero> heroList = new ArrayList<Object>();
         
        //? super Hero 表示 heroList的泛型是Hero或者其父类泛型
         
        //heroList 的泛型可以是Hero
        //heroList 的泛型可以是Object
         
        //所以就可以插入Hero
        heroList.add(new Hero());
        //也可以插入Hero的子类
        heroList.add(new APHero());
        heroList.add(new ADHero());
         
        //但是，不能从里面取数据出来,因为其泛型可能是Object,而Object是强转Hero会失败
        Hero h= heroList.get(0);
         
    }
 
}

示例 3 :

泛型通配符?

edit 顶折

纠问

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

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

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

package generic;
 
import java.util.ArrayList;

import property.Item;
import charactor.APHero;
import charactor.Hero;
 
public class TestGeneric {
 
    public static void main(String[] args) {
 
        ArrayList<APHero> apHeroList = new ArrayList<APHero>();
        
        //?泛型通配符，表示任意泛型
        ArrayList<?> generalList = apHeroList;

        //?的缺陷1： 既然?代表任意泛型，那么换句话说，你就不知道这个容器里面是什么类型
        //所以只能以Object的形式取出来
        Object o = generalList.get(0);

        //?的缺陷2： 既然?代表任意泛型，那么既有可能是Hero,也有可能是Item
        //所以，放哪种对象进去，都有风险，结果就什么什么类型的对象，都不能放进去
        generalList.add(new Item()); //编译错误 因为?代表任意泛型，很有可能不是Item
        generalList.add(new Hero()); //编译错误 因为?代表任意泛型，很有可能不是Hero
        generalList.add(new APHero()); //编译错误  因为?代表任意泛型，很有可能不是APHero
 
    }
}

示例 4 :

总结

edit 顶折

纠问

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

示例 5 :

练习- extends

edit 顶折

纠问

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

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

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

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

package generic;

import java.util.ArrayList;

import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;

public class TestGeneric {

	public static void iterate(ArrayList<Hero> list) {
		for (Hero hero : list) {
			System.out.println(hero.name);
		}
	}

	public static void iterateAP(ArrayList<APHero> list) {
		for (Hero hero : list) {
			System.out.println(hero.name);
		}
	}

	public static void iterateAD(ArrayList<ADHero> 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);
		iterateAP(aphs);
		iterateAD(adhs);
	}

}

示例 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的子类

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

package generic;
 
import java.util.ArrayList;
 
import charactor.ADHero;
import charactor.APHero;
import charactor.Hero;
 
public class TestGeneric {
 
    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);
    }
 
}

示例 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 中的子类泛型转型成父类泛型

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

问答区域

2021-08-25 遍历

Ernest

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

public class Main {
    public static void main(String[] args) {
        ArrayList<Hero> heroes = new ArrayList<>();
        heroes.add(new Hero("a"));
        heroes.add(new ADHero("b",1));
        heroes.add(new APHero("c",1));
        iterate(heroes);
    }
    public static void iterate(ArrayList<? extends Hero> list) {
        for (Hero hero : list) {
            System.out.println(hero.name);
        }
    }
}

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

2021-07-21 练习 - 二叉树

莫諾

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

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

public class Tnode<T> implements Comparable<T>{
	// 左子节点
	public Tnode<T> leftNode;
	// 右子节点
	public Tnode<T> rightNode;
	// 节点值
	public T value;
	
	public int compareTo(T anotherT) {
		if((Integer)value <= (Integer)anotherT) 
			return 1;
		else
			return -1;
	}
	// 插入 数据
	public void add(T v) {
		// 根节点值是null
		if (value == null)
			value = v;
		else {
			if(compareTo(v) == 1){
				if (leftNode == null) 
					leftNode = new Tnode<>();
				leftNode.add(v);
			}
			else {
				if (rightNode == null)
					rightNode = new Tnode<>();
				rightNode.add(v);
			}
		}
	}
...

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

2021-07-21 练习 - extends

莫諾

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

如代码所示，为了遍历不同泛型的3种集合，需要设计3个方法借助? extends，把代码减肥到只是用一种方法

public class TestGerneric {
	
	public static void iterate(ArrayList<? extends Hero> list) {
		for (Object h: list) 
			if ( h instanceof Hero)
				System.out.println(((Hero) h).name);
		
		for (Object adh: list) 
			if (adh instanceof ADHero)
				System.out.println(((ADHero) adh).name);
		
		for (Object aph: list)
			if (aph instanceof APHero) 
				System.out.println(((APHero) aph).name);
		
	}
	
	public static void main(String[] args) {
		
		ArrayList<Hero> heroList  = new ArrayList<>();
		ArrayList<APHero> apHeroList  = new ArrayList<>();
		ArrayList<ADHero> adHeroList  = new ArrayList<>();
		
		iterate(heroList);
		iterate(apHeroList);
		iterate(adHeroList);
	}
}

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

2020-11-09 答案

lx213

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

luoxi 123 done

public static void iterate(List<? extends Hero> h)
	{
		for (Hero hero : h)
		{
			System.out.println(hero.name);
		}
		System.out.println("done");
	}
	
	public static void main(String[] args) 
	{
		List<ADHero> ad = new ArrayList<>();
		ad.add(new ADHero());
		ad.add(new ADHero());
		ad.get(0).name = "luoxi";
		ad.get(1).name = "123";
		List<? extends Hero> h = ad;
		iterate(h);
	}

1 个答案

小党sdsdd
答案时间：2021-05-31

第二题

代码超过 5行，点击查看

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

2020-05-22 示例2

1013555811

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

示例 2 : ? super 可以往里面插入Hero以及Hero的子类这句话是不是说错了？不应该是“可以往里面插入Hero以及Hero的父类”吗？

6 个答案

cs-yyds
答案时间：2021-01-14

这块难道不需要实现comparebleTo 方法嘛

229865249
答案时间：2020-09-17

站长啥时候出个删评功能啊。。。 <? super Hero>限定了只能是Hero或者Hero的父类，因为？通配符不能具体匹配的父类，所以他不能接受Object 或者Hero的父类的调用，但是因为限定了是父类（即使不确定是什么类型，但肯定是父类），所以插子类进去是没有问题的，向上转型嘛。

229865249
答案时间：2020-09-17

qtlsd 说的是对的，站长这里没写错，如果照你这么说，是要进行子类强转父类的

229865249
答案时间：2020-09-17

我也觉得是

qtlsd
答案时间：2020-05-24

因为小转大是自动的，插入的时候子类被自动强转成父类了。

逆风刑云
答案时间：2020-05-22

二叉树

代码超过 5行，点击查看

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

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

提问之前请登陆

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

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

尽量提供截图、代码和异常信息，有助于分析和解决问题。也可进本站QQ群交流: 496725845

提问尽量提供完整的代码，环境描述，越是有利于问题的重现，您的问题越能更快得到解答。
对教程中代码有疑问，请提供是哪个步骤，哪一行有疑问，这样便于快速定位问题，提高问题得到解答的速度
在已经存在的几千个提问里，有相当大的比例，是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本，可以节约自己大量的学习时间。站长把教学中用的软件版本整理了，都统一放在了这里，方便大家下载： /k/helloworld/helloworld-version/1718.html

上传截图