类型通配符
一、类型通配符
当声明一个方法时，某个形参的类型是一个泛型类或泛型接口类型，但是在声明方法时，又不确定该泛型实际类型，可以考虑使用类型通配符。
先来看下面一个案例
import java.util.ArrayList; import java.util.List; /* 泛型中通配符 常用的 T，E，K，V，？ ？无界通配符,表示不确定的 java 类型,代表任意类型,有位置有求 需要传入具体类型的位置，不能单独使用 声明，泛型类，泛型接口，泛型方法时不能单独使用 T (type) 表示具体的一个java类型 K V (key value) 分别代表java键值中的Key Value E (element) 代表Element 上界通配符 < ? extends E> 传入的类型，可以是当前类型以及当前类型的孩子 下界通配符 < ? super E> 传入的类型，可以使当前类型，也可以是当前类型的父类 ？和 T 的区别 * */ public class Demo1 { public static void main(String[] args) { List<String> list1 = new ArrayList<>(); list1.add("项羽"); list1.add("刘邦"); list1.add("张饵"); test1(list1); } public static void test1(List c){ for (int i = 0; i <c.size() ; i++) { System.out.println(c.get(i)); } } }
上面的方法执行是没有问题的，但是此处使用 List 接口时没有传入实际类型参数，这将引起泛型警告。如何消除这个警告呢？
方式一：
public class Demo1 { public static void main(String[] args) { List<Object> list1 = new ArrayList<>(); list1.add("项羽"); list1.add("刘邦"); list1.add("张饵"); test1(list1); } public static void test1(List<Object> c){ for (int i = 0; i <c.size() ; i++) { System.out.println(c.get(i)); } } }
这样的形参太局限了，只能传入 List<Object> 类型的实参。
方式二：声明一个泛型方法
public class Demo1 { public static void main(String[] args) { List<String> list1 = new ArrayList<>(); list1.add("项羽"); list1.add("刘邦"); list1.add("张饵"); test1(list1); } public static<T> void test1(List<T> c){ for (int i = 0; i <c.size() ; i++) { System.out.println(c.get(i)); } } }
该方法需要声明泛型形参T。
方式三：使用类型通配符
public class Demo1 { public static void main(String[] args) { List<String> list1 = new ArrayList<>(); list1.add("项羽"); list1.add("刘邦"); list1.add("张饵"); test1(list1); } public static void test1(List<?> c){ for (int i = 0; i <c.size() ; i++) { System.out.println(c.get(i)); } } }
那么方式二的泛型方法 test1() 和方式三的 test1() 使用类型通配符有什么区别？
方式三方法带通配符的List仅表示它可以接受指定了任意泛型实参的List，并不能把元素加入其中，例如如下代码将会引起编译错误：
public class Demo1 {
public static void main(String[] args) {
List<String> list1 = new ArrayList<>();
list1.add("项羽");
list1.add("刘邦");
list1.add("张饵");
test1(list1,"陈余");
}
public static void test1(List<?> c,String string){
c.add(string);
}
}
因为我们不知道上面程序中c集合里元素的类型，所以不能向其中添加对象，除了null对象，因为它是所有引用数据类型的实例。
方式二方法带泛型的List，表示该集合的元素类型是T，因此允许T系列的对象加入其中，例如如下代码是可行的：
public class Demo1 { public static void main(String[] args) { List<String> list1 = new ArrayList<>(); list1.add("项羽"); list1.add("刘邦"); list1.add("张饵"); test1(list1,"陈余"); } public static<T> void test1(List<T> c, T string){ c.add(string); for (int i = 0; i <c.size() ; i++) { System.out.println(c.get(i)); } } }
即如果不涉及添加元素到带泛型的集合中，那么两种方式都可以，如果涉及到添加元素到带泛型的集合中，使用类型通配符<?>的不支持
二、设定类型通配符的上限
当直接使用 List<?> 这种形式时，即表明这个 List 集合接收泛型实参指定为任意类型的 List。但有时候不想这样，只希望接收某些类型的 List。
Demo：一个图形的抽象父类 Graphic，两个子类 Circle和Rectangle，想定义一个方法，可以打印不同图形的面积。
import java.util.ArrayList; import java.util.List; public class Demo2 { public static void main(String[] args) { Graphic g1 = new Graphic("yuan",2,1); Graphic g2 = new Graphic("fang",3,2); List<Graphic> list1 = new ArrayList<>(); list1.add(g1); list1.add(g2); printArea(list1); } public static void printArea(List<Graphic> graphics){ for(Graphic g:graphics){ g.getArea(); } } } class Graphic{ String name; int lengths; int wides; public Graphic() { } public Graphic(String name, int lengths, int wides) { this.name = name; this.lengths = lengths; this.wides = wides; } public void getArea(){ if (name.equals("fang")){ int area=lengths*wides; System.out.println("父类面积是："+area); }else if (name.equals("yuan")){ Double area=Double.valueOf(lengths)*3.14; System.out.println("父类面积是："+area); } } }
但是，List<Graphic> 的形参只能接收 List<Graphic>的实参，如果想要接收 List<Circle>,List<Graphic>的集合，可以使用List<?>
package day19; import java.util.ArrayList; import java.util.List; public class Demo2 { public static void main(String[] args) { Graphic g1 = new Graphic("yuan",2,1); Graphic g2 = new Graphic("fang",3,2); Circle c1 = new Circle("yuan",3.0); List<Graphic> list1 = new ArrayList<>(); list1.add(g1); list1.add(g2); list1.add(c1); printArea(list1); } public static void printArea(List<?> graphics){ for(Object obj:graphics){ Graphic g=(Graphic)obj; g.getArea(); } } } class Graphic{ String name; int lengths; int wides; public Graphic() { } public Graphic(String name, int lengths, int wides) { this.name = name; this.lengths = lengths; this.wides = wides; } public void getArea(){ if (name.equals("fang")){ int area=lengths*wides; System.out.println("父类面积是："+area); }else if (name.equals("yuan")){ Double area=Double.valueOf(lengths)*3.14; System.out.println("父类面积是："+area); } } } class Circle extends Graphic{ String name; Double lengths; public Circle() { } public Circle(String name, Double lengths) { this.name = name; this.lengths = lengths; } @Override public void getArea() { Double area = lengths*3.14;
System.out.println(area);
}
}
但是这样有两个问题，一个是 List<?> 可以接收任意类型，不仅仅图形，第二个是需要强制类型转换。
为了解决这个问题，Java 允许设定通配符的上限：
<? extends Type>，这个通配符表示它必须是Type本身，或是Type的子类。
如：
import java.util.ArrayList; import java.util.List; public class Demo2 { public static void main(String[] args) { Graphic g1 = new Graphic("yuan",2,1); Graphic g2 = new Graphic("fang",3,2); Circle c1 = new Circle("yuan1",3.0); List<Graphic> list1 = new ArrayList<>(); list1.add(g1); list1.add(g2); list1.add(c1); printArea(list1); } public static void printArea(List<? extends Graphic> graphics){ for(Graphic g:graphics){ g.getArea(); } } } class Graphic{ String name; int lengths; int wides; public Graphic() { } public Graphic(String name, int lengths, int wides) { this.name = name; this.lengths = lengths; this.wides = wides; } public void getArea(){ if (name.equals("fang")){ int area=lengths*wides; System.out.println("父类面积是："+area); }else if (name.equals("yuan")){ Double area=Double.valueOf(lengths)*3.14; System.out.println("父类面积是："+area); } } } class Circle extends Graphic{ String name; Double lengths; public Circle() { } public Circle(String name, Double lengths) { this.name = name; this.lengths = lengths; } @Override public void getArea() { Double area = lengths*3.14; System.out.println(area); } }
与前面的完全相同，因为不知道这个受限制的通配符的具体类型，所以不能把 Graphic 对象或其子类对象加入到这个泛型集合中。
public static void printArea(List<? extends Graphic> graphics){ for(Graphic g:graphics){ graphics.add(new Circle("yuan1",3.0));//编译错误，因为不知道？的具体类型 g.getArea(); } } }
如果需要将 Graphic 对象或其子类对象加入这个泛型集合，那么就只能用泛型方法。
三、设定通配符的下限
假设自己实现一个工具方法：实现将 src 集合里元素复制到 dest 集合中的功能，因为 dest 集合需要接受 src 的所有元素，所以 dest 集合元素的类型应该是 src 集合元素的父类。为了表示两个参数之间的类型依赖，考虑同时使用通配符、泛型形参类实现该方法。
Demo:
package day19; import java.util.ArrayList; import java.util.Collection; public class Demo3 { public static void main(String[] args) { ArrayList<String> src = new ArrayList<>(); src.add("贾宝玉"); src.add("秦钟"); src.add("薛宝钗"); ArrayList<Object> dest = new ArrayList<>(); Object last=copy(dest,src); System.out.println(last); } public static <T> T copy(Collection<T> dest,Collection<? extends T> src){ T last=null; for (T t:src){ dest.add(t); last=t; } return last; } }
表面上看这个实现没有问题，实际上有一个问题，当遍历src元素的类型是不确定（但可以肯定是T的子类），程序只能用T来笼统的表示，所以返回值类型是T
发现返回的T是Object，也就是说，程序在复制集合元素的过程中，丢失了src集合元素的类型String。
对于上面的copy方法，可以这样理解两个集合参数之间的依赖关系：不管src集合元素的类型是什么，只要dest集合元素类型与src的元素类相同或是它的父类即可。
为了表示这种约束关系，Java允许设定通配符的下限：
<? super Type>，这个通配符表示它必须是Type本身或是Type的父类。
代码
import java.util.ArrayList; import java.util.Collection; public class Demo3 { public static void main(String[] args) { ArrayList<String> src = new ArrayList<>(); src.add("贾宝玉"); src.add("秦钟"); src.add("薛宝钗"); ArrayList<Object> dest = new ArrayList<>(); String last=copy(dest,src); System.out.println(last); } public static <T> T copy(Collection<? super T> dest,Collection<T> src){ T last=null; for (T t:src){ dest.add(t); last=t; } return last; } }
注意：只有类型通配符才可以设定下限，泛型形参是不能设定下限的
四、泛型方法与方法重载
因为泛型既允许设定通配符的上限，也允许设定通配符的下限，如果在一个类里包含这样两个方法定义，会报错：
public static <T> T copy(Collection<? super T> dest,Collection<T> src){ //....省略代码 } public static <T> T copy(Collection<T> dest,Collection<? extends T> src){ //....省略代码 }
