JAVA泛型之:(通配符上限)和(通配符下限)

时间：2023-03-09 04:05:08
JAVA泛型之<? extends T>:(通配符上限)和<? super T>(通配符下限)

　　一.通配符上限和通配符下限接受的类型

　　通配符上限：<? extends T>

　　通配符下限：<? super T>

　　以下代码是测试结果，注释为解释说明

 package xayd.hjj;

 import java.util.ArrayList;

 import java.util.List;

 class A{}

 class B extends A implements F{}

 class C extends A{}

 class D extends A{}

 class E{}

 interface F{}

 public class Test{

     public static void main(String[] args) {        

         //下面五行代码说明:List<? extends A>接受A或者继承A的类

         List<? extends A> listA = new ArrayList<A>();

         List<? extends A> listB = new ArrayList<B>();

         List<? extends A> listC = new ArrayList<C>();

         List<? extends A> listD = new ArrayList<D>();

         // List<? extends A> listE = new ArrayList<E>();  //编译不能通过,类E与类A无关

         //下面三行代码说明:List<? super B>接受B或者的父类

         List<? super B> listA1 = new ArrayList<A>();
　　　　　　 List<? super B> listA2 = new ArrayList<B>();

         List<? super B> listF = new ArrayList<F>();

         //List<? super B> listC1 = new ArrayList<C>();  //编译不能通过，类C不是类B的父类

30     }

 }

　

　　　二.通配符下限和通配符上限存取问题

　　　通配符上限：<? extends A>

　　　List<? extends A> list = new ArrayList<B>();

　　　这样定义一个list的时候，是不允许向这个list添加任何东西的。list可以接受其B类型和B的子类。像list中添加对象的时候因为编译器不能确定这个子类的确切类型，因此不允许向里添加任何对象。唯一可以添加的是null。也可以这样理解:Fruit是Apple的父类，也是orange的父类。但是你不能说Fruit就是Apple或者orange。

　　　代码测试如下：

 package xayd.hjj;

 import java.util.ArrayList;

 import java.util.List;

 class A{}

 class B extends A implements F{}

 class C extends A{}

 class D extends A{}

 class E{}

 interface F{}

 public class Test{

     public void a(List<? extends A> list){

         list.add(null);        //编译通过，但无实际意义

         // list.add(new B());  //编译不能通过

         // list.add(new A());  //编译不能通过

     }

     public static void main(String[] args) {

         Test test = new Test();

         List<? extends A> listB = new ArrayList<B>();

         test.a(listB);

     }

 }

　　

　　通配符下限：<? super B>

　　List<? super B> list = new ArrayList<A>();

　　这样定义一个list的时候，允许向这个list添加对象。list可以接受其B类型和B的父类。像list中添加对象的时候编译器能确定确切类型。也可以这样理解:Fruit是Apple的父类，也是orange的父类。我们可以说Apple就是一个Fruit。

　　　代码测试如下：

 package xayd.hjj;

 import java.util.ArrayList;

 import java.util.List;

 class A{}

 class B extends A implements F{}

 class C extends A{}

 class D extends A{}

 class E{}

 interface F{}

 public class Test{

     public void b(List<? super B> list){

         list.add(new B());     ////编译通过

         //list.add(new A());   //编译不能通过,要使用类型转换

         list.add((B) new A()); ////编译通过      

     }

     public static void main(String[] args) {

         List<? super B> listA = new ArrayList<A>();

         test.b(listA);

     }

 }

相关文章