泛型通配符的作用

为了让大家更好地理解泛型通配符的作用及使用场景，我们先来看一个例子：
我们假定有一个抽象类Shape，它有一个抽象方法draw，我们规定draw方法将会打印一串描述性的字符串。Triangle、Rectangle、Circle是Shape的子类，均重写了draw方法()。

// 超类
abstract class Shape{
	/**
	** draw方法将会打印一串描述性的字符串
	**/
    abstract protected void draw();
}

class Triangle extends Shape{
    @Override
    protected void draw() {
        System.out.println("draw a Triangle");
    }
}
class Rectangle extends Shape{
    @Override
    protected void draw() {
        System.out.println("draw a Rectangle");
    }
}
class Circle extends Shape{
    @Override
    protected void draw() {
        System.out.println("draw a Circle");
    }
}

我们现在有这样一个需求：我们需要提供一个方法，它能够接受任意一个Shape，然后在方法内部调用它的draw方法。
我们可以利用方法可以重载这一特性来实现：

    public static void shapeToDraw(Triangle triangle){
        triangle.draw();
    }

    public static void shapeToDraw(Rectangle rectangle){
        rectangle.draw();
    }

    public static void shapeToDraw(Circle circle){
        circle.draw();
    }	

	// 调用
	shapeToDraw(new Triangle());	// 打印draw a Triangle
	shapeToDraw(new Circle());	// 打印draw a Circle

我们可以为每一种具体的子类实现一个特定的方法，所有的方法除了入参以外完全一样。编译器会根据实际传入的参数类型帮我们判断哪一个方法是我们真正需要的。 虽然方法的重载非常有用，但是用在此处却不太合适。想象一下，如果Shape有100个子类，为了兼顾所有的情况，我们需要提供100个对应的方法！

稍微有一点经验的开发者很容易想到下面的实现：

	public static void shapeToDraw(Shape shape){
	    shape.draw();
	}
	                                                          
	// 调用
	shapeToDraw(new Triangle());	// 打印draw a Triangle
	shapeToDraw(new Circle());	// 打印draw a Circle

shapeToDraw(Shap shap)方法接收一个抽象的Shape，而不是具体的子类。得益于Java的多态性，该程序可以正常地运行，且具备一定的扩展性。例如，如果后续我们为Shape再添加一个子类Square，该方法不需要做任何修改。

现在，我们的需求发生了变化： 我们需要提供一个方法，它能够接受任意一个Shape集合，然后在方法内部依次调用集合元素的draw方法。(为了简化问题，我们假定集合特指List)
有了上面需求的经验，我们可以很容易地得到如下实现：

    public static void shapesToDraw(List<Shape> shapes){
        for (Shape shape : shapes){
            shape.draw();
        }
    }

shapesToDraw方法接受一个List<Shape>，在方法内部迭代调用draw方法。由于List<Shape>里面可以装载Shape的所有子类，因此这个实现看起来似乎是完美的。但是如果使用者传入的是一个List<Circle>呢？该方法还能正常运行吗？答案是不能。该方法不能接收List<Circle>作为入参，原因是：一个List<Circle>并不是一个List<Shape>，这确实让人感到非常费解，因为Circle是Shape的子类，那么一个Circle就是一个Shape，为什么一个List<Circle>不能是一个List<Shape>呢？
要想理解这个悖论，我们可以看一下下面这个例子：

// 先初始化一个 List<Shape> 和一个 List<Circle>
List<Shape> shapeList;
List<Circle> circleList = new ArrayList<>();
// 我们假定一个 List<Circle> 是一个 List<Shape>，那么这样赋值是完全没有问题的
shapeList = circleList; 	//实际上编译不能通过

// 往List<Shape>中添加一个Triangle，这当然没有任何问题
shapeList.add(new Triangle());
// 因为 shapeList 与 circleList 指向同一个List，因此往 shapeList 中添加的元素通过 circleList 当然可以访问到
// 但是 circleList 是一个 List<Circle>,因此调用get方法应该返回一个Circle ，然而实际上，该位置存放的却是一个Triangle！
Circle circle = circleList.get(0);		// 转型错误！

由于将一个List<Circle> 当成一个 List<Shape> 会出现上述问题，因此，Java 语言规定, 即使集合之间的元素存在继承关系，也不能认为泛型的集合之间存在继承关系，

显然这不是我们希望的，因为使用者当然希望程序将一个 List<Circle> 看做是一个 List<Shape>。那么该如何实现呢？答案是：泛型通配符。
我们只需要将上述程序稍作修改，就能满足现在的需求：

    public static void shapesToDraw(List<? extends Shape> shapes){
        for (Shape shape : shapes){
            shape.draw();
        }
    }

List<? extends Shape>描述了这样一类List：List的泛型类型是Shape的子类(当然也可以是Shape本身)。 这一点是非常重要的，在使用泛型通配符之前，我们只能描述List内部元素的类型，如List<Shape>描述了一个内部元素是Shape子类(因为Shape是一个抽象类)的List。而有了泛型通配符以后，我们拥有了描述泛型类型的能力！

泛型通配符上界

基本语法形式：

List<? extends Shape>

它规定了泛型类型的上界。也就是说，如果使用上述表达式作为某个方法的入参，那么在实际调用方法时，可以传入的泛型类型必须为 Shape的子类。另外还有一点需要特别注意：

因为我们只知道泛型类型是Shape的子类而不能确定其具体的泛型类型，因此往该List中添加任何元素都是非法的(会引起编译错误)。

我们可以这样理解这句话：
我们只知道 List<? extends Shape> 接受的 List 泛型是 Shape 的子类，因此它既可以是List<Circle> 也可以是List<Triangle>，还可以是List<Rectangle>。当我们想要往这个List中添加数据的时候会发生什么？我们根本不知道应该向它传入什么样的数据！！！ 我们应该向它传入一个Circle吗？如果调用方法的时候实际传入的参数是一个List<Triangle>怎么办？List<Triangle>并不能装载一个Circle！那我们向它传入一个Triangle？一个Rectangle？都不行！不论我们向它传入什么类型的对象，我们都会遇到前面的问题。最根本的原因是：我们无法确定泛型的类型，因此我们无法确定应该向该List添加什么类型的元素。

当我需要从List<? extends Shape>中取出元素的时候，会发生什么呢？
因为我们知道List<? extends Shape>实际的泛型类型一定是Shape的子类，那么List中的元素类型也一定是Shape的子类，因此我们使用Shape或者Shape的父类(本例中Shape没有父类)去接收取出的元素一定是安全的。

泛型通配符下界

基本语法形式：

List<? super Triangle>

它规定了泛型类型的下界。也就是说，如果使用上述表达式作为某个方法的入参，那么在实际调用方法时，可以传入的泛型类型必须为 Triangle的父类(当然也包括Triangle本身)。在本例中，传入的参数类型可以是List<Triangle>、List<Shape>，当然也可以是List<Object>。另外还有一点需要特别注意：

因为我们只知道泛型类型是Triangle的父类而不能确定其具体的泛型类型，因此从该List取出元素的时候，我们不能知道该元素的确切类型。但是我们知道，任何一个类都是Object的子类，因此可以使用Object来接收该元素，除此之外的其他任何类型都不行。(但是得到一个Object类型的元素对我们来说似乎没有太大的作用，因为我们使用泛型就是希望能够得到更加确切的数据类型，而不是一个笼统的Object)

当我们需要往List<? super Triangle>中添加元素的时候，会发生什么呢？
因为我们知道List<? super Triangle>实际的泛型类型一定是Triangle的父类，那么List中的元素类型也一定是Triangle的父类，因此我们往List中添加Triangle或者Triangle的子类元素一定是安全的。

基于上述原因，阿里巴巴Java开发手册中规定：

List<?>

通过上面的分析我们已经知道了List<?>表示List的泛型类型(一定要注意是泛型类型，而不是元素类型)可以为任意类型。也就是说如果一个方法签名的参数是List<?>，那么实际传入的类型可以是List<Shape>、List<Circle>、List<Object>或者任意一个带泛型的List(甚至可以是不带泛型的List)。
当我们试图往这个List中插入元素的时候，我们会得到一个编译错误，原因是我们无法得知泛型的确切类型(与上文上界通配符中的解释一致)。
当我们试图从这个List中取出元素的时候，我们只能得到一个Object(与上文下界通配符中的解释一致)。

结论

1. 泛型通配符定义的是泛型的类型，而不是集合元素的类型；
2. 上界通配符，形如<? extends T>适合频繁往外读取数据的场景；
3. 下界通配符，形如<? super T>适合频繁插入数据的场景；
4. 无法往List<?>插入任何数据，只能从List<?>中得到Object类型的元素。

这是我参与11月更文挑战的第7天，活动详情查看：2021最后一次更文挑战」。

茫茫人海千千万万，感谢这一秒你看到这里。希望我的文章对你的有所帮助！

愿你在未来的日子，保持热爱，奔赴山海！

前言：昨天我们终于讲完了泛型通配符的基本使用，

所以，接下来我们将会对泛型通配符的学习--泛型通配符的高级使用！

👺泛型通配符

在我们之前的学习泛型的过程当中，在当我们使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

😟5.2 通配符高级使用

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

比如：现已知Object类，Animal类，Dog类，Cat类，其中Animal是Dog，Cat的父类

class Animal{}//父类
​
class Dog extends Animal{}//子类
​
class Cat extends Animal{}//子类
复制代码

• 首先我们先看下，泛型的上限<? extends 类 >：

  //        ArrayList<? extends Animal> list = new ArrayList<Object>();//报错
          ArrayList<? extends Animal> list2 = new ArrayList<Animal>();
          ArrayList<? extends Animal> list3 = new ArrayList<Dog>();
          ArrayList<? extends Animal> list4 = new ArrayList<Cat>();
  复制代码

  可以看出，泛型的上限只能是该类型的类型及其子类。

  

• 我们再来看看泛型的下限<? super 类 >：

          ArrayList<? super Animal> list5 = new ArrayList<Object>();
          ArrayList<? super Animal> list6 = new ArrayList<Animal>();
  //        ArrayList<? super Animal> list7 = new ArrayList<Dog>();//报错
  //        ArrayList<? super Animal> list8 = new ArrayList<Cat>();//报错
  复制代码

  可以看出，泛型的下限只能是该类型的类型及其父类。

  

• 一般泛型的上限和下限也是用来参数的传递：

• http://www.360doc.com/content/21/1104/07/46403850_1002672849.shtml
  http://www.360doc.com/content/21/1107/21/46403850_1003191175.shtml
  http://www.360doc.com/content/21/1107/21/46403850_1003190908.shtml

  再比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
复制代码

学到这里，我们泛型也就学完了！

🌸总结

相信各位看官都对泛型有了全部的深入的了解和体验，在平时开发，比较常见使用在泛型的使用有集合框架中的List和Map。当然还有很多的应用，期待你慢慢发现！

那我们继续期待欢迎期待下一章的到来！

让我们也一起加油吧！本人不才，如有什么缺漏、错误的地方，也欢迎各位人才大佬评论中批评指正！当然如果这篇文章确定对你有点小小帮助的话，也请亲切可爱的人才大佬们给个点赞、收藏下吧，一键三连，非常感谢！

https://gitee.com/numerical-control-system
https://www.thinksaas.cn/user/space/50002/
https://zhuanlan.zhihu.com/p/430534517
https://zhuanlan.zhihu.com/p/430536898
https://zhuanlan.zhihu.com/p/430537972

泛型

泛型：是一种未知的数据类型，当我们不知道要是用什么样的数据类型的时候，可以使用泛型。泛型我们也可以看做是一个变量，用来接收数据类型。
E e:element 元素
T t: type 类型
ArrayList在定义集合的时候，不知道在集合当中存储什么类型的数据，所以类型使用泛型。E： 未知的数据类型。

概述：可以在类中或方法当中预知的使用未知的数据类型。一般在创建对象的时候，将未知的数据类型确定为具体的数据类型，当没有指定泛型时，默认类型是Object。

使用泛型的好处

1. 避免了类型转换的麻烦，存储的是什么样的数据类型，取出的就是什么样的数据类型。
2. 把运行时异常（代码运行之后会抛出异常）提升到编译器阶段（写代码时就报错）。
   备注：泛型其实也是数据类型的一部分，一般我们将类名与泛型合并在一起看做数据类型。

泛型的定义和使用

泛型用来灵活的将数据类型应用到不同的类，方法，接口当中，将书库类型作为参数进行传递。

定义

修饰符 class 类名<代表泛型的变量>{
      //  ....
}

例如

public class ArrayList<E>{
  public boolean add(E e){
    }
    public E get(int index){ 
    }
    //...
}

备注： 定义的时候使用未知的泛型的变量，使用的需要确定泛型具体类型。

定义并使用含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名（泛型参数）{}

例如：

public class GenericMethod{
    //带有泛型的方法
 public <VIP> void show(VIP vip){
  System.out.println(vip);
   }
   //定义一个含有泛型的返回值
   public <VIP> VIP show02(VIP vip){
   //...
   return vip;
   }
}

public class Test{
public static void main(String []args){
    //创建对象
    GenericMethod gm=new GenericMethod();
    //调用带有泛型的方法
    gm.show("abc");//VIP vip 形参  String str  str="abc"
    gm.show(123);// VIP--->Integer   vip=123;
  
}

}

定义并使用泛型的接口

定义格式：

修饰符 interface 接口名 <代表泛型的变量>{}

例如：

public interface Collection<E>{
  public void add(E e);
  public Iterator<E> iterator();
}
  //自定义一个泛型接口
public interface AInterface<T>{
    public abstract void add(T t);
    public abstract T get();
    //....
}

使用格式：
1.定义实现类是可以确定泛型的类型

public class Test implements AInterface<String>{
  @ Override
        public void add(T t){
        //....
    }
    @ Override 
        public String get(){
    //.....
    }
}

备注：此时泛型的值就是String类型

2.1始终不知道泛型的类型，直到创建对象的时候才可以确定。

public class MyInterfaceimpl02<T> implements AInterface<T>{
 @ Override
        public void add(T t){
        //....
    }
    @ Override 
        public T get(){
    //.....
    }

}

2.2确定泛型

/*
使用泛型
*/

public class Demo04Generic{
    public static void main(String []args){
        MyInterface<String> my=new MyInterfaceImpl<String>();
        my.add("abc");
        
    }
    
}

泛型的通配符

当使用泛型类或者泛型接口的时候，传递的数据中，泛型的类型不确定，我们可以通过通配符<?>，一旦使用泛型通配符之后，就只能使用Object类中的共性方法，集合当中元素自身的方法无法使用。

通配符的基本使用

当不知道使用什么类型来接收的时候，此时可以使用<?>来表示，代表未知的通配符。此时只能接受数据，不能往该集合中存储数据。

public static void main(String []args){
    
    //可以存储整数的集合
    Collection<Integer>  list= new ArrayList<>();
    //此时list可以存储整数的数据 
    //展示list集合当中的数据
    
    gerElement(list);
    //存储String字符串的集合
    Collection<String> list2=new ArrayList<>();
    //此时list可以存储字符串的数据 
    
}


public static void gerElement( Collection<？> coll){
    //可以接收Integer数据
    //此时？ 可以代表任意类型
}

备注：泛型不存在继承关系。

通配符的高级用法—受限泛型

之前使用泛型的时候，实际上是可以直接设置的，只要是类就可以，但是在java的泛型中，还可以指定一个泛型上限和下限。

泛型的上限

• 格式： 类型名称<? extends 类名>对象名
• 意义：只能接收该类型及其子类

泛型的下限

• 格式：类型名称<? super 类名>对象名
• 意义：只能接收该类型及其父类

比如说：已知顶级父类Object String Integer Number ,Integer是Number的子类。

public static void main(String []args){
    
      Collection<Integer> list1=new ArrayList<>();
      Collection<String> list2=new ArrayList<>();
      Collection<Number> list3=new ArrayList<>();
      Collection<Object> list4=new ArrayList<>();
    
    
}
//定义方法  可以接收任意类型
public static void getElement(Collection<?> coll){
    //...
}
    //定义方法，只能接收数字类型   Number类和它的子类
public static void getElement(Collection <? extends Number> coll){
    //...
}
    //定义方法，接收Number类型及其以上类型
public static void getElement(Collection<? super Number> coll){
    //...
}