使用泛型实现类型转化-使用通配符上限下限区分协变和逆变采取不同的转化方式

一时失言乱红尘 2022-06-11 00:13 43阅读 0赞

泛型作用:  
 泛型可以用于三种场景：  
 1、简单的限定参数类型；  
 2、用于类型转化的参数限定，即通配符类型上限和下限，因为在转化的时候，子类转父类是协转，是自动的，父类转子类是逆转，需要编写代码手动处理，即处理方式不同；  
 3、结合Java的反射特性由父类获得子类的参数类型或者生成子类的实现，实现代码的集约。  
   
 当子类转父类时，是自动的，当父类转子类时则需要单独处理，所以这个时候可以使用泛型进行限定

这个涉及到一个概念:协变与逆变,也即上面说到的类型转化，斜边是子类转父类，逆变是父类转子类

**参数化的类型 List<String>     
实际类型参数 String  
泛型         List<E>  
形式类型参数 E  
无限制通配符类型List<?>  
原生态类型List  
有限制类型参数<E extends Number>  
递归类型限制<T extends Comparable<T>>  
有限制通配符类型List<? extends Number>  
泛型方法static <E> List<E> asList(E\[\] a)  
类型令牌String.class**

场景：

ArrayList<Number> b=new  ArrayList<Number>();  
 ArrayList<AtomicInteger> c=new  ArrayList<AtomicInteger>();  
 入参是 ArrayList<Number>  
 可以使用ArrayList<AtomicInteger>处理吗？和泛型结合呢？  
 答案：子类可以自动转化为父类-协变，但是父类不能自动转化为子类-逆变

对象 instansof 类，判断 对象是不是这个类的一个实例，子类可以是父类的一个实例，如果是则为true

<? extends Number> 限定参数类型必须为Number或者Number的子类,即Number为类型上限

<? super Number>限定参数类型必须为Number或者Number的超类，即Number为类型下限

实验代码

package com.bestcxx.stu.springmvc.common.test.generic;
    
    import java.util.ArrayList;
    import java.util.concurrent.atomic.AtomicInteger;
    
    import org.junit.Test;
    
    /**
     * 泛型作用:
     * 泛型可以用于三种场景：
     * 1、简单的限定参数类型；
     * 2、用于类型转化的参数限定，即通配符类型上限和下限，因为在转化的时候，子类转父类是协转，是自动的，父类转子类是逆转，需要编写代码手动处理，即处理方式不同；
     * 3、结合Java的反射特性由父类获得子类的参数类型或者生成子类的实现，实现代码的集约。
     * 
     * 当子类转父类时，是自动的，当父类转子类时则需要单独处理，所以这个时候可以使用泛型进行限定
     * 这个涉及到一个概念:协变与逆变,也即上面说到的类型转化，斜边是子类转父类，逆变是父类转子类
     * @author Administrator
     *
     */
    public class GenericList {
    	/**
    	 * 问题：
    	 * ArrayList<Number> b=new  ArrayList<Number>();
    	 * ArrayList<AtomicInteger> c=new  ArrayList<AtomicInteger>();
    	 * 入参是 ArrayList<Number>
    	 * 可以使用ArrayList<AtomicInteger>处理吗？和泛型结合呢？
    	 * 答案：子类可以自动转化为父类，但是父类不能自动转化为子类
    	 */
    
    	
    	Integer i;
    	Number j;
    	AtomicInteger m;
    	
    	
    	@Test
    	public void testAtomicIntegerToNumber(){
    		ArrayList<Number> b=new  ArrayList<Number>();
    		ArrayList<AtomicInteger> c=new  ArrayList<AtomicInteger>();
    		ArrayList<String> d=new  ArrayList<String>();
    		m=new AtomicInteger(1);
    		for(int i=0;i<10;i++){
    			c.add(m);
    		}
    		//b=c;//报错
    		b.addAll(c);//不报错
    		//b=getListByNumber(d);//报错
    		b=getListByNumber(c);//不报错
    		
    		for(Number t:b){
    			System.out.println(t);
    		}
    		
    		
    	}
    	
    	@Test
    	public void testNumberToAtomicInteger(){
    		ArrayList<Number> b=new  ArrayList<Number>();
    		ArrayList<AtomicInteger> c=new  ArrayList<AtomicInteger>();
    		j=1;
    		for(int i=0;i<10;i++){
    			b.add(j);
    		}
    		//c=b;//报错
    		//c.addAll(b);//报错
    		c=getListByAtomicInteger(b);
    		for(AtomicInteger t:c){
    			System.out.println(t);
    		}
    		
    		
    	}
    	
    	/**
    	 *· ArrayList<? extends Number> list
    	 * 规定，入参Number为泛型类型的上限，即入参泛型类型可以为Number或者其子类
    	 * 子类可以自动向父类转化,但是父类不能转化为子类
    	 * @param list
    	 * @return
    	 */
    	public ArrayList<Number> getListByNumber(ArrayList<? extends Number> list){
    		ArrayList<Number> li=new ArrayList<Number>();
    		for(Object o:list){
    			if(o instanceof Number){
    				System.out.println("入参类型属于Number的子类");
    				li.add((Number)o);
    			}
    		}
    		return li;
    	}
    	
    	/**
    	 * ArrayList<? super AtomicInteger> list
    	 * 规定泛型类型下限，入参泛型类必须为AtomicInteger或者其之上的超类【public class AtomicInteger extends Number】
    	 * 父类不可以向子类转化
    	 * @param list
    	 * @return
    	 */
    	public ArrayList<AtomicInteger> getListByAtomicInteger(ArrayList<? super AtomicInteger> list){
    		ArrayList<AtomicInteger> li=new ArrayList<AtomicInteger>();
    		for(Object t:list){
    			//父类不会是子类的实现，所以下面的代码不会运行，避免强制转化
    			if(t instanceof AtomicInteger){
    				li.add((AtomicInteger) t);
    			}
    			
    			//li.add((AtomicInteger) t);//强制父类转化为子类，运行时报错
    			
    			li.add(new AtomicInteger((Integer) t));//单独处理，可以运行
    		}
    		return li;
    	}
    	
    
    }