泛型中的无界通配符

超、凢脫俗 2022-05-30 07:12 154阅读 0赞

《JAVA编程思想》这本书确实是非常的晦涩难懂，所以我决定博客也跟着阅读进度一起更新，今天的阅读是无界通配符，废话不多说，来看下面的代码：

import java.util.ArrayList;
    import java.util.List;
    public class UnboundedWildcards1 { 
        static List list1;
        /* 警告：List使用的是原始类型，但是List1是一个泛型容器 * 所以此时应该使用泛型*/
        static List<?> list2;
        static List<? extends Object> list3;
        static void assign1(List list)/*报错信息和第5行一样*/
        {
            list1 = list;
            list2 = list;
            //list3 = list;
            /* 警告： * 泛型转换错误，这个时候只要List由原始类型转换为 * 任何泛型都可以。*/
        }
        static void assign2(List<?> list)
        {
            list1 = list;
            list2 = list;
            list3 = list;
            /* 我觉得这个地方list3 = list并没有报错的原因还是因为 * 类型擦除的原因*/
        }
        static void assign3(List<? extends Object> list)
        {
            list1 = list;
            list2 = list;
            list3 = list;
            /*不报错原因和assign2方法中解释的原因一样*/
        }
        public static void main(String[] args)
        {
            assign1(new ArrayList());
            /* 警告： * 1.ArrayList并不能转化成类型或者容器 * 2.ArrayList需要配合泛型进行使用*/
            assign2(new ArrayList());
            /*警告：警告内容同上*/
            //assign3(new ArrayList());
            /* 警告： * 泛型转换异常，ArrayList虽然可以转化为List和List<?> * 但是由于assign3方法中参数要求转化为 * List<? extends Object>所以这个时候转型错误*/
            assign1(new ArrayList<String>());
            assign2(new ArrayList<String>());
            assign3(new ArrayList<String>());
            //以上所有泛型都可以转化为<?>从而被所有接受
            List<?> wildList = new ArrayList();
            wildList = new ArrayList<String>();
            assign1(wildList);
            assign2(wildList);
            assign3(wildList);
        }
    }

从这段代码可以看出,

List<?> a1 = new ArrayList<>();
    List<? extends Object> a2 = new ArrayList<>();
    a2 = a1;//ok
    List<? extends Object> a3 = new ArrayList<>();
    a2 = a3;//ok

但是可以从第一段代码可以看出，两者对于原始类型的转化严格程度是不同的，看下面这段代码：

import java.util.*;
    //import static net.mindview.util.Print.*;
    class BerylliumSphere{}
    public class ArrayOfGenericType { 
        public static void main(String[] args){
            List a0 = new ArrayList();
            List<Object> a1 = new ArrayList<>();
            List<?> a2 = new ArrayList<>();
            List<? extends Object> a3 = new ArrayList<>();
            List<? super Object> a4 = new ArrayList<>();
    
            a0 = a1;
            a0 = a2;
            a0 = a3;
            a0 = a4;
            //可见原型容器可以接受所有参数类容器的转型
    
            a1 = a0;
            a1 = a2;//List<?>不能转换位List<Object>
            a1 = a3;//List<? extends Object>不能转换位List<Object>
            a1 = a4;
    
            a2 = a0;//这个地方并没有出现警告
            a2 = a1;
            a2 = a3;
            a2 = a4;
    
            a3 = a0;//警告：在未检查的情况下进行泛型转换
            a3 = a1;
            a3 = a2;
            a3 = a4;
    
            a4 = a0;//警告：在未检查的情况下进行泛型转换
            a4 = a1;
            a4 = a2;//List<?>不能转型为List<? super Object>，范围扩大
            a4 = a3;//List<? extends Object>不能转型为List<? super Object>，范围扩大
    
            a0.add(new Object());
            a1.add(new Object());
            a2.add(new Object());//编译错误，无解通配符实际范围要小于Object
            a3.add(new Object());//编译错误，? extends Object不能将Object作为参数是因为泛型的范围小于Object
            a4.add(new Object());
        }
    }

可以看出 ? extends Object 相比较于 ? 对于原始类型的要求更加严格。  
接下来再看一段代码

import java.util.*;
    @SuppressWarnings("rawtypes")
    public class unboundedWildcards2 { 
        static Map map1;
        static Map<?,?> map2;
        static Map<String, ?> map3;
        static void assign1(Map map){map1 = map;}
        static void assign2(Map<?,?> map){map2 = map;}
        static void assign3(Map<String, ?> map){map3 = map;}
        public static void main(String[] args)
        {
            assign1(new HashMap());
            assign2(new HashMap());
            //assign3(new HashMap());
            /* 警告: * 因为这个地方第一个泛型指明了参数String，所以 * 这个时候用原始类型进行转换就会报错*/
            assign1(new HashMap<String,Integer>());
            assign2(new HashMap<String,Integer>());
            assign3(new HashMap<String,Integer>());
        }
    }

从上面的代码可以看出，如果指定了泛型那么泛型就必须符合指定的泛型。  
下面用一大段代码总结一下无界通配符这一个小节：

import java.util.*;
    
    class Holder<T>
    {
        private T value;
        public Holder() {}
        public Holder(T val){ value = val;}
        public void set(T arg){ value = arg;}
        public T get(){
       return  value;}
        public boolean equals(Object obj)
        {
            return value.equals(obj);
            //Object的.equals方法是判断对象是否相同，而不是值
        }
    }
    @SuppressWarnings({
       "unused","rawtypes"})
    public class Wildcards { 
        static void rawArgs(Holder holder, Object arg)
        {
            //holder.set(arg);
            /* 警告： * 警告的原因是holder是一个泛型容器，但是这个地方用的 * 是原始类型，导致类型不正确*/
            //holder.set(new Wildcards());
            // 警告：原因同上
            //T t = holder.get();
            // 错误：在个方法中并不存在泛型
            Object obj = holder.get();
            //***虽然Holder.get()返回的是一个泛型，但是仍然可以转换
            //***为Object类型
        }
        static void unboundedArg(Holder<?> holder, Object arg)
        {
            //holder.set(arg);
            /* 警告：由于Holder是一个泛型容器，这个时候使用了无 * 界通配符将导致Object不能作为.set()方法的参数*/
            //holder.set(new Wildcards());
            // 警告：原因同上
            //T t = holder.get();
            // 错误：不存在T作为类型
            Object obj = holder.get();
        }
        static <T> T exact1(Holder<T> holder)
        {
            T t = holder.get();
            return t;
        }
        //*** .get()泛型方法+泛型容器将不会报错
        // 如果将参数中的Holder<T>改为Holder将导致报错，并且
        // 错误原因为.get()方法的返回值为Object，不能将Object转化
        // 为T类型
        static <T> T exact2(Holder<T> holder,T arg)
        {
            holder.set(arg);
            T t = holder.get();
            return t;
        }
        /* 想要泛型容器Holder的.set()方法不报错，要注意： * .set()方法的参数要求为泛型，并且其参数的范围应该要 * 小于Holder容器的泛型参数的范围，否则将报错，比如： * 如果arg的泛型为<Object>但holder的为<? extends Object> * 就会导致报错，但是如果arg的泛型为<Object>但是holder的为 * <? super Object>就不会报错，但是这样的话.get()方法 * 就会报错*/
        static <T> T wildSubtype(Holder<? extends T>holder, T arg)
        {
            //holder.set(arg);
            //* 错误：原因同上，holder的泛型范围不能小于arg的范围
            T t = holder.get();
            return t;
        }
        static <T> void wildSupertype(Holder<? super T> holder,T arg)
        {
            holder.set(arg);
            //T t = holder.get();
            //* 错误：原因同上，holder的范围大于t,不能向下转型
            Object t = holder.get();
            //虽然这个不会报错，但是已经失去了类型信息
        }
        public static void main(String[] args)
        {
            Holder raw = new Holder<Long>();
            //或者
            raw = new Holder();
    
            Holder<Long> qualified = new Holder<Long>();
            Holder<?> unbounded = new Holder<Long>();
            Holder<? extends Long> bounded = new Holder<Long>();
            Holder<? super Long> spbounded = new Holder<Long>();
            Long lng = 1L;
    
            rawArgs(raw,lng);
            rawArgs(qualified, lng);
            rawArgs(unbounded, lng);
            rawArgs(bounded, lng);
            rawArgs(spbounded, lng);
            /* 由上面的结果可以看出不管holder是怎么样的泛型参数 * 都可以由原型Holder来进行引用*/
    
            unboundedArg(raw, lng);
            unboundedArg(qualified, lng);
            unboundedArg(unbounded, lng);
            unboundedArg(bounded, lng);
            rawArgs(spbounded, lng);
            /* 看来不仅是原型Holder可以引用泛型holder，holder<?> * 也可以引用带各种泛型的holder*/
    
            //Object r1 = exact1(raw);
            /* 警告：1.exact1方法需要的是泛型的holder容器，不能 * 使用原型容器 2.raw所引用的原型容器在没有检查的情况 * 下转换成了泛型容器*/
            Long r2 = exact1(qualified);
            Object r3 = exact1(unbounded);
            Long r4 = exact1(bounded);
            //Long r5 = exact1(spbounded);
            /* 错误：此时返回值是Long的超集，故不能用其子集表示它*/
    
            Long r6 = exact2(raw, lng);
            /* 警告：原因是：1.参数不正确，exact2()方法需要一个泛型 * Holder容器而不是一个原型 2.raw所引用的原型容器在 * 没有进行检查的情况下进行了转换*/
            Long r7 = exact2(qualified, lng);
            //Long r8 = exact2(unbounded, lng);
            /* 错误：可以理解为这个时候unbounded使用的无界通配符 * 的范围大于exact2()中的泛型T所以此时报错*/
            //Long r9 = exact2(bounded, lng);
            /* 错误：理由同上*/
            Object r10 = exact2(spbounded, lng);
    
            //Long r11 = wildSubtype(raw, lng);
            /* 警告：原因是：1.参数不正确，exact2()方法需要一个泛型 * Holder容器而不是一个原型 2.raw所引用的原型容器在 * 没有进行检查的情况下进行了转换*/
            Long r12 = wildSubtype(qualified, lng);
            Object r13 = wildSubtype(unbounded, lng);
            Long r14 = wildSubtype(bounded, lng);
            Object r15 = wildSubtype(spbounded, lng);
            //由上面的情况可以看出<? extends T>这种泛型可以减少泛
            //型所带来的烦恼
    
            //wildSupertype(raw, lng);
            /* 警告：原因是：1.参数不正确，exact2()方法需要一个泛型 * Holder容器而不是一个原型 2.raw所引用的原型容器在 * 没有进行检查的情况下进行了转换*/
            wildSupertype(qualified, lng);
            //wildSupertype(unbounded, lng);
            /* 这是我觉得非常特殊的一个情况，可能是泛型设计是的一个 * 错误,看下面的代码： * List<? super Object> l1 = new ArrayList<Object>(); * List<?> l2 = new ArrayList<Object>(); * l1 = l2;//错误 * 看来在不管什么情况下就算是使用了super都不能进行引用 * 但是<?>和<? extends Object>之间却可以很好的转化*/
            //wildSupertype(bounded, lng);
            wildSupertype(spbounded, lng);
        }
    }