<? extend T> <? super T> <T extend SomeClass> 泛型方法

 

class Food { }

class Fruit extends Food { }

class Apple extends Fruit { }

class Banana extends Fruit { }

class Plate{
    private T item;
    public Plate(T t){item=t;}
    public void set(T t){item=t;}
    public T get(){return item;}
}

?通配符  T参数类型

1、 

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

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

   //只能存放Fruit或者Fruit的子类
   Plate plate=new Plate<>(new Fruit());
   Plate plate1=new Plate<>(new Apple());
   Plate plate2=new Plate<>(new Food());//报错,不能存放Fruit的父类
   
   //set方法失效 
   plate.set(new Fruit());//报错 不兼容的类型: Fruit无法转换为CAP#1(CAP#1从? extends Fruit的捕获扩展Fruit)
   plate.set(new Apple());//报错 不兼容的类型: Apple无法转换为CAP#1(CAP#1从? extends Fruit的捕获扩展Fruit)
   plate.set(null);

   //get只能是Fruit或Fruit的父类
   Object object= plate.get();
   Food food=plate.get();
   Fruit fruit=plate.get();
   Apple apple=plate.get();//报错 不兼容的类型

  
   //集合 
  
   //同理 存放元素只能是Fruit或Fruit的子类
   List list;
   list = new ArrayList(); //报错
   list = new ArrayList();
   list = new ArrayList();
   
   //get 只能是Fruite或Fruit的父类
   List list = new ArrayList();
   Object item1 = list.get(0);
   Food item2 = list.get(0);
   Fruit item3 = list.get(0);
   Apple item4 = list.get(0); //报错

  

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

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

2、

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

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

  //赋值元素只能是Fruit或者Fruit父类
  Plate plate =new Plate<>(new Fruit());
  Plate plate1=new Plate<>(new Apple());//报错,不能存放Fruit的子类
  Plate plate2=new Plate<>(new Food());

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

  //get只能只能存放Object类
  Object object= plate.get();
  Food food=plate.get(); //报错
  Fruit fruit=plate.get();//报错
  Apple apple=plate.get();//报错

  //集合

  //同理 存放元素只能是Fruit或Fruit的父类
  List list;
  list = new ArrayList();
  list = new ArrayList(); 
  list = new ArrayList();
  list = new ArrayList();//报错

  //set
  list.add(new Food()); //报错
  list.add(new Object());//报错
  list.add(new Fruit());
  list.add(new Apple());

  
  //get 只能存放Object类
  List list = new ArrayList();
  Object item1 = list.get(0);
  Food item2 = list.get(0); //报错
  Fruit item3 = list.get(0);//报错
  Apple item4 = list.get(0); //报错


   
  

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、的区别

:通配符类型,?表示后续使用操作时可以是任意(SomeClass 或者它的子类)

:限制类型,T表示后续只能用T 进行某些判断或者操作

如下demo,遍历list,

 
 public static  void print(List list){
        for(T item:list){} //只能使用T
 }

 public static void print2(List list){
     
        for(Food item:list){}   //Fruit或者Fruit的父类

        for(Fruit item:list){}

  }

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

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

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

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

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

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

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

<? extend T> <? super T> <T extend SomeClass> 泛型方法_第1张图片

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

<? extend T> <? super T> <T extend SomeClass> 泛型方法_第2张图片

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

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

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

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

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

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

 

 

你可能感兴趣的:(Java)