理解范型中的通配符？

理解范型中的通配符'？'

[java]  view plain copy

1. class A {  
2.     public void fun() {  
3.         System.out.println("A");  
4.     }  
5. }  
6.   
7. class B extends A {  
8.     @Override  
9.     public void fun() {  
10.         System.out.println("B");  
11.     }  
12.       
13. }  
14.   
15. class C extends B {  
16.     @Override  
17.     public void fun() {  
18.         System.out.println("C");  
19.     }  
20. }  

1. 为什么在泛型中需要通配符？

ArrayList<A> ls = new ArrayList<B>();//compile error

即使A是B的父类，这是因为B的list不是A的list的子类. '苹果可以是水果的子类，但是能够装苹果的袋子不是能够装水果的袋子的子类。'

所以这就需要通配符.

2. extends

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

arrlist可以指定A或者A的子类的ArrayList

但是

arrlist.add(new B());//就会有编译错误，这是因为add 的参数是 ? extends A, 是A的子孙类，此处无法确定'？'所代表的具体类型，如果是‘B’，那么arrlist 定义就可以翻译为ArrayList<B> arrlist = new ArrayList<B>(); 那么arrlist.add(new C());是错的。如果是'C'.那么arrlist 定义就可以翻译为ArrayList<C> arrlist = new ArrayList<B>(); 这样实际这条语句就是错的，所以怎么add都不对的。

arrlist.contains(new A());

arrlist.indexOf(new A());

以上两条语句是正确，因为contains和indexOf的参数是Object

A a= arrlist.get(0);//ok, 因为返回的是 ? extends A, 是A或者A的子类，所以可以赋值给类A
B b = arrlist.get(0);//error, 不能保证返回的一定是B或者B的子类

3. super

 

[java]  view plain copy

1. public static void write(List<? super B> ls) {//ls 要求容器内的元素必须是类B，或者B的父类，所以在add的时候，  
2.         //只能添加B 或者B的孩子，这是因为不能确保ls的泛化的元素是A，只能确认至少是B，即B是下界  
3.         ls.add(new B());  
4.         ls.add(new C());  
5.         //ls.add(new A());//不能添加A  
6.           
7.     }  
8.       
9.     public static void main(String[] args) {  
10.           
11.         // TODO Auto-generated method stub  
12.         //List<A> ls = new ArrayList<A>();//ok  
13.         List<B> ls = new ArrayList<B>();//ok  
14.         write(ls);  
15.         for (A a : ls)  
16.             a.fun();  
17. }  

http://blog.csdn.net/lonelyroamer/article/details/7927212

通配符有三种：

1、无限定通配符   形式<?>

2、上边界限定通配符 形式< ? extends Number>    //用Number举例

3、下边界限定通配符    形式< ? super Number>    //用Number举例

1、泛型中的？通配符

如果定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，如果这样写

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.Collection;  
3. import java.util.List;  
4. publicclass GernericTest {  
5.     publicstaticvoid main(String[] args) throws Exception{  
6.         List<Integer> listInteger =new ArrayList<Integer>();  
7.         List<String> listString =new ArrayList<String>();  
8.         printCollection(listInteger);  
9.         printCollection(listString);      
10.     }   
11.     publicstaticvoid printCollection(Collection<Object> collection){  
12.                for(Object obj:collection){  
13.             System.out.println(obj);  
14.         }    
15.     }  
16. }  

语句printCollection(listInteger);报错

The method printCollection(Collection<Object>) in the type GernericTest is not applicable for the arguments (List<Integer>)

这是因为泛型的参数是不考虑继承关系就直接报错。

这就得用？通配符

[java]  view plain copy

1. import java.util.ArrayList;  
2. import java.util.Collection;  
3. import java.util.List;  
4.   
5. publicclass GernericTest {  
6.     publicstaticvoid main(String[] args) throws Exception{  
7.         List<Integer> listInteger =new ArrayList<Integer>();  
8.         List<String> listString =new ArrayList<String>();  
9.         printCollection(listInteger);  
10.         printCollection(listString);  
11.     }  
12.     publicstaticvoid printCollection(Collection<?> collection){  
13.                for(Object obj:collection){  
14.             System.out.println(obj);  
15.         }  
16.     }  
17. }  

在方法public static void printCollection(Collection<?> collection){}中不能出现与参数类型有关的方法比如collection.add();因为程序调用这个方法的时候传入的参数不知道是什么类型的，但是可以调用与参数类型无关的方法比如collection.size();

总结：使用?通配符可以引用其他各种参数化的类型,?通配符定义的变量的主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

 

 

2、泛型中的?通配符的扩展

1:界定通配符的上边界

Vector<? extends 类型1> x = new Vector<类型2>();

类型1指定一个数据类型，那么类型2就只能是类型1或者是类型1的子类

Vector<? extends Number> x = new Vector<Integer>();//这是正确的

Vector<? extends Number> x = new Vector<String>();//这是错误的

 

2:界定通配符的下边界

Vector<? super 类型1> x = new Vector<类型2>();

类型1指定一个数据类型，那么类型2就只能是类型1或者是类型1的父类

Vector<? super Integer> x = new Vector<Number>();//这是正确的

Vector<? super Integer> x = new Vector<Byte>();//这是错误的

 

提示：限定通配符总是包括自己

原文：http://blog.csdn.net/sunmenggmail/article/details/8447319