2021-01-05

参考地址：https://blog.csdn.net/moyuxueyi/article/details/107556913

＜? extend T＞ ＜? super T＞ ＜T extend SomeClass＞ 泛型方法

  1. class Food { }

  2.  

  3. class Fruit extends Food { }

  4.  

  5. class Apple extends Fruit { }

  6.  

  7. class Banana extends Fruit { }

  8.  

  9. class Plate<T>{

  10. private T item;

  11. public Plate(T t){item=t;}

  12. public void set(T t){item=t;}

  13. public T get(){return item;}

  14. }

？通配符  T参数类型

1、<? extend T> 

上界通配符，表示参数类型是T或者T的子类

不能存只能取，set()方法失效，但get()方法有效并且读取出来得东西只能是T或者T的父类甚至Object

 

  1. //只能存放Fruit或者Fruit的子类

  2. Plate<? extends Fruit> plate=new Plate<>(new Fruit());

  3. Plate<? extends Fruit> plate1=new Plate<>(new Apple());

  4. Plate<? extends Fruit> plate2=new Plate<>(new Food());//报错，不能存放Fruit的父类

  5.  

  6. //set方法失效

  7. plate.set(new Fruit());//报错 不兼容的类型: Fruit无法转换为CAP#1（CAP#1从? extends Fruit的捕获扩展Fruit）

  8. plate.set(new Apple());//报错 不兼容的类型: Apple无法转换为CAP#1（CAP#1从? extends Fruit的捕获扩展Fruit）

  9. plate.set(null);

  10.  

  11. //get只能是Fruit或Fruit的父类

  12. Object object= plate.get();

  13. Food food=plate.get();

  14. Fruit fruit=plate.get();

  15. Apple apple=plate.get();//报错 不兼容的类型

  16.  
  17.  

  18. //集合

  19.  

  20. //同理 存放元素只能是Fruit或Fruit的子类

  21. List<? extends Fruit> list;

  22. list = new ArrayList<Food>(); //报错

  23. list = new ArrayList<Fruit>();

  24. list = new ArrayList<Apple>();

  25.  

  26. //get 只能是Fruite或Fruit的父类

  27. List<? extends Fruit> list = new ArrayList<Fruit>();

  28. Object item1 = list.get(0);

  29. Food item2 = list.get(0);

  30. Fruit item3 = list.get(0);

  31. Apple item4 = list.get(0); //报错

  32.  
  33.  

add()/set()：编译器只知道类型是 Fruit 或 Fruit 的子类，所以有可能是 Fruit Apple Banana 其中一个类型，为保证类型安全不能添加除了 null 以外的任何元素，即使是 Fruit 本身也不行。

get()：既然编译器不知道此时集合中的元素是Fruit Apple Banana 的哪一个，返回类型只能是他们共同父类 Fruit 或者父类Food类甚至Object。

2、<? super  T>

下界通配符，表示参数类型是T或者T的超类型(父类型)

 set()方法正常，但get()只能存放Object对象里

 

  1. //赋值元素只能是Fruit或者Fruit父类

  2. Plate<? super Fruit> plate =new Plate<>(new Fruit());

  3. Plate<? super Fruit> plate1=new Plate<>(new Apple());//报错，不能存放Fruit的子类

  4. Plate<? super Fruit> plate2=new Plate<>(new Food());

  5.  

  6. //set正常

  7. plate.set(new Food());//报错 不兼容的类型: Food无法转换为CAP#（CAP#1从? super Fruit的捕获扩展Object 超 Fruit）

  8. plate.set(new Fruit());

  9. plate.set(new Apple());

  10. plate.set(null);

  11.  

  12. //get只能只能存放Object类

  13. Object object= plate.get();

  14. Food food=plate.get(); //报错

  15. Fruit fruit=plate.get();//报错

  16. Apple apple=plate.get();//报错

  17.  

  18. //集合

  19.  

  20. //同理 存放元素只能是Fruit或Fruit的父类

  21. List<? super Fruit> list;

  22. list = new ArrayList<Object>();

  23. list = new ArrayList<Food>();

  24. list = new ArrayList<Fruit>();

  25. list = new ArrayList<Apple>();//报错

  26.  

  27. //set

  28. list.add(new Food()); //报错

  29. list.add(new Object());//报错

  30. list.add(new Fruit());

  31. list.add(new Apple());

  32.  
  33.  

  34. //get 只能存放Object类

  35. List<? super Fruit> list = new ArrayList<Fruit>();

  36. Object item1 = list.get(0);

  37. Food item2 = list.get(0); //报错

  38. Fruit item3 = list.get(0);//报错

  39. Apple item4 = list.get(0); //报错

  40.  
  41.  

add()/set()：编译器只知道类型是 Fruit 或者 Fruit 的父类，所以有可能是 Fruit Object其中一个类型。编译器知道下界是 Fruit ，根据类型向上兼容所以可以添加的元素是 Fruit 以及 Fruit 的子类

get():既然编译器不确定集合类型是 Fruit Object 的哪一种，返回类型只能是他们的共同父类 Object 。

 

3、PECS原则（Producer Extends Consumer Super）

原则：

  • 频繁往外读取内容的，适合用上界Extends。
  • 经常往里插入的，适合用下界Super。

总结

  • extends 可用于返回类型限定，不能用于参数类型限定（换句话说：? extends xxx 只能用于方法返回类型限定，jdk能够确定此类的最大继承边界为xxx，只要是这个类的子类都能接收，但是传入参数无法确定具体类型，只能接受null的传入）。
  • super    可用于参数类型限定，不能用于返回类型限定（换句话说：? supper xxx 只能用于方法传参，因为jdk能够确定传入为xxx的子类，返回只能用Object类接收）。
  • ? 既不能用于方法参数传入，也不能用于方法返回。

 

4、<? extends SomeClass>与<T extends SomeClass>的区别

<? extend SomeClass>：通配符类型，？表示后续使用操作时可以是任意（SomeClass 或者它的子类）

<T extend SomeClass>：限制类型，T表示后续只能用T 进行某些判断或者操作

如下demo，遍历list，

 
  1.  

  2. public static <T extends Fruit> void print(List<T> list){

  3. for(T item:list){} //只能使用T

  4. }

  5.  

  6. public static void print2(List<? extends Fruit> list){

  7.  

  8. for(Food item:list){} //Fruit或者Fruit的父类

  9.  

  10. for(Fruit item:list){}

  11.  

  12. }

List<String> —- 参数化的类型 
List<E> —- 泛型 
List<?> —- 无限制通配符类型 
<E extends SomeClass> —- 有限制类型参数 
List <? extends SomeClass>—- 有限制通配符类型 
<T extends Comparable<T>> —– 递归类型限制 
static <E> List<E> asList(E[] a) —- 泛型方法

5、泛型方法的使用：static <E> List<E> asList(E[] a) 

拷贝：https://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html

Java中泛型类的定义也比较简单，例如：public class Test<T>{}。这样就定义了一个泛型类Test，在实例化该类时，必须指明泛型T的具体类型，例如：Test<Object> t = new Test<Object>();，指明泛型T的类型为Object。

但是Java中的泛型方法就比较复杂了。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

 定义泛型方法语法格式如下：

调用泛型方法语法格式如下：

 说明一下，定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

       Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。

       为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

       泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class<User>类型的对象，因此调用泛型方法时，变量c的类型就是Class<User>，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。

       当然，泛型方法不是仅仅可以有一个参数Class<T>，可以根据需要添加其他参数。

       为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

版权声明：本文为m0_37846887原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。