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

泛型作用:
 泛型可以用于三种场景：
 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;
}

}