• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

通配符详解

开发技术 开发技术 2周前 (04-30) 6次浏览

前言

泛型的本质,其实就是将类型参数化,就是对于要操作的数据类型指定为一个参数。泛型,是为了在编译的时候能检测到非法的类型。而使用通配符,则是在此之上做的一个扩展,使泛型的使用更加的灵活。

泛型的好处

如果不是用泛型,想要对参数类型的“任意化”,就要做显式的强制类型转换。但这里有个问题。请看一下代码。

public class Test{
	public static void main(String[] args) {
        
        showTest(); //不指定明确的类型,用Object
        showTest2(); //明确指定类型
    }
    
    //不指定明确的类型,用Object
    public static void showTest(){
        List<Object>  oblist = new ArrayList<>();
        oblist.add("abc");
        String  str =oblist.get(0);//这里再编译的时候不会出错,但是在运行的时候就会报错
        String  str2 =(String) oblist.get(0);//这里做了显式的强制类型转换
        System.out.println(str);
        System.out.println(str2);
    }
    
    //明确指定类型
    public static void showTest2(){
        List<String>  oblist = new ArrayList<>();
        oblist.add("abc");
        String  str =oblist.get(0);//因为指定了类型,所以获取到的值是不需要做类型转换的
        System.out.println(str);
    }
}

从上面的额代码可看出, 省去了强制转换,可以在编译时候检查类型安全。

通配符

常用的通配符有: T,E,K,V,?

其实也可以是A、B、C、D、E等的字母代替。使用 T,E,K,V,?只不过是约定俗成而已。

T,E,K,V,? 的约定如下:

T:(type) 表示具体的一个java类型。

E:代表Element。

K、V :分别代表java键值中的Key Value。

? :无界通配符,表示不确定的 java 类型

上边界限定通配符 < ? extends E>

上边界:用extends 关键字声明,表示参数化的类型可能是所指定的类型,或者是此类型的子类。

有时候,为什么要使用通配符,而不是简单的泛型呢?其中有一个很重要的原因,就是使用通配符, 可以让你的方法更具有通用性。

比如,有一个父类Animal,然后该父类有几个子类。比如猫猫、狗等。它们都有名字的属性,然后有一个动物列表。

你可以这样写:

List<Animal> animalList

也可以这样写

List<? extends Animal> animalList

如果想要获取列表里面的明细属性,则:

//方式一
public static void getNameList(List< Animal > animals) {
	for (Animal animal : animals) {
		System.out.println(animal.getName());
	}
}

//方式二
public static void getNameList2(List<? extends Animal > animals) {	
	for (Animal animal : animals) {
		System.out.println(animal.getName());
	}
}
public static void main(String[] args) {
    Dog dog = new Dog();
	dog.setName("aa");
	List< Dog > dogs = new ArrayList<>();
	dogs.add(dog);
	getNameList(dogs);//报错
	getNameList2(dogs);//不会报错
}

方式二的入参写法,限定了上界,但是不关心具体类型是什么,所以对于传入的类型是Animal、Animal的字类的都能支持,方式一则不行。

也可以使用<? extends Animal> 形式的通配符,实现向上转型

向上转型:

//Animal为一个父类,Dog为Animal的字类
Dog dog = new Dog(); //dog指向的对象在编译时和运行时都是Dog类型
//下面的就是向上转型
Animal dog = new Dog(); //dog指向的对象在编译时是Animal类型,而运行时时Dog类型

使用<? extends Animal> 形式的通配符,实现向上转型。

public class Test{
	public static void main(String[] args){
		List<? extends Animal> list = new ArrayList<Dog>();
		list.add(new Dog());  //不能添加,编译报错
		list.add(null);  //可以添加,不报错。
		Animal animal = list.get(0); // 允许返回。
	}
}

这里有个缺陷,不能对list做添加的操作,只能做读取。

当使用extends通配符时,我们无法想list中添加任何东西(null除外),那又为什么可以取出东西呢?

因为无论取什么出来,我们都可以通过向上转型用Animal指向它,这在Java中是被允许的,但不确定取到的是什么,所以必须用上限接收。

Animal animal = list.get(0);//使用上限Animal接收。正确用法。
Dog animal = list.get(0); //错误

下边界限定通配符 < ? super E>

又叫超类型通配符。与extends特性完全相反。

下边界: 用 super 进行声明,表示参数化的类型可能是所指定的类型,或者是此类型的父类型,直至 Object。

private <T> void test(List<? super T> dst, List<T> src){
    for (T t : src) {
        dst.add(t);
    }
}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = new ArrayList<>();
    new Test3().test(animals,dogs);
}

dst 类型 “大于等于” src 的类型,这里的“大于等于”是指 dst 表示的范围比 src 要大,因此装得下 dst 的容器也就能装 src 。

参数声明

List<? super Dog> list = new ArrayList<Animal>(); //正确
List<? super Dog> list = new ArrayList<Object>();//因为 Object 是任何一个类的父级。正确

list元素的类型可以是任何Dog的父级,JVM在编译的时候当然是无法确定具体是哪个类型,但是可以确定的是任何的Dog的子类都可以转为Dog类,而任何的Dog的父类都不能转为Dog类。

所以,若使用了super通配符,则只能存入T类型及T类型的字类对象:

list.add(new Dog());//可以添加
list.add(null);//编译正常
list.add();//编译错误bu
Dog dog = list.get(0); //错误
Animal dog = list.get(0);//错误
Object dog = list.get(0);//正确用法

取出数据的时候,JVM在编译时并不能确定具体的父级,所以安全起见,就用顶级的父级Object来取出数据。这样就可以避免发生强制类型转换异常了。也只能使用Object取数据。

无边界通配符

使用的形式是一个单独的 ? ,表示无任何的限定。

List<?> list 表示 list 是持有某种特定类型的 List,但是不知道具体是哪种类型,因此时不安全的,即不能添加数据。但是可以用来取数据。

?和 T 的区别

先看一下代码:

//指定集合元素只能时T类型。d但是这个d
List<T>  list = new ArrayList<T>();

//表明集合的元素可以是任意的类型
List<?>  list = new ArrayList<?>();
public <T> void test(){
	List<T>  list = new ArrayList<T>();//指定集合元素只能是T类型,但是必须得配合方法使用,否则报错
}
//表明集合的元素可以是任意的类型,没什么意义,一般在方法中只是为了说明用法
List<?>  list = new ArrayList<?>();

但是不管用T还是用? ,它们的共同点都是不能往list里添加数据,且在获取数据的时候只能用Object来接收。

其实,? 和T都是表示不确定的类型,区别在于我们可以对 T 进行操作,但是对 ?不行,比如如下这种 :

T t = operate();  //可以
? opa = operate();//不可以

T通常用于泛型类和泛型方法的定义。

通常用于泛型方法的调用代码和形参,不能用于定义类和泛型方法。

区别1:通过 T 来 确保 泛型参数的一致性

例如

//通过T来确保泛型参数的一致性。
public <T extends Number> void test(List<T> list1, List<T> list2){
    //......所以这里的list集合的元素的类型是一致的
}

//通配符是 不确定的,所以这个方法不能保证两个 List 具有相同的元素类型
public <? extends Number> void test2(List<? extends Number> list1,List<? extends Number> list2){
	//.....这里的list的元素有可能一致,有可能不一致。
}

区别2:类型参数可以多重限定而?通配符不行

比如接口Apple继承Fruits ,接口Fruit继承Botany。下面就是T的多重限定的写法。使用 &

public static <T extends Fluit & Apple> void testB(T t){
	//...
}

使用 & 符号设定多重边界(Multi Bounds),指定泛型类型 T 必须是 Fluit和 Apple的共有子类型,此时变量 t 就具有了所有限定的方法和属性。对于通配符来说,因为它不是一个确定的类型,所以不能进行多重限定。

区别3:通配符可以使用超类限定而类型参数不行

类型参数 T 只具有 一种 类型限定方式:

T extends A

但是通配符 ? 可以进行 两种限定:

? extends A
? super A

总结

通配符的使用可以对泛型参数做出某些限制,使代码更安全,对于上边界和下边界限定的通配符总结如下:

使用通配符对泛型参数做出限制,能是代码更加的安全。

上下边界限定的通配符总结如下:

  1. 使用 List<? extends C> list 的形式,表示该元素类型的范围必须是 C 的字类( 包含 C 本身)。

  2. 使用 List<? super C> list 形式,表示该元素类型是 C 的超类型 ( 包含 C 本身 )。


程序员灯塔
转载请注明原文链接:通配符详解
喜欢 (0)