泛型的个人理解

泛型：参数化的类。将实体类参数化，传递给方法进行使用。
这类参数称之为类型实参，由这些类型实参来限定比如集合的类型

List<String> String为类型实参 ，List为集合

泛型在逻辑上可以看成是多个不同的类型，但是实际上都是相同的基本类型
需要注意的是，Java之中并没有所谓的泛型数组

大体上泛型的使用有三种：
1.List<String> 限定集合的类型
2.Collection<T> 定义泛型接口
3.Collection<?> 类型通配符

部分代码实现参看如下代码块儿：

public class TestGenericity {


    public static void main(String[] args) {

//      CastObjectToString();
//      Box<String> name = new Box<String>("corn");
//      System.out.println("name:"+ name.getData());

        /*判断Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型*/
        Box<Number> name = new Box<Number>(99);
        Box<Integer> age = new Box<Integer>(712);
        getData(name);
//      通过提示信息，我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类
//      getData(age);
    }

    /** 
     * @Title: CastObjectToString 
     * @Description: TODO
     * @return: void
     */
    public static void CastObjectToString() {
        List<Object> list = new ArrayList<>();
        list.add("asdfas");
        list.add("adsfadsf");
        list.add(100);
//      由于list集合中不止有String类型的数据，还有Integer类型的数据
//      所以想要强制类型装换成String类型是不成功的

        for (int i = 0; i < list.size(); i++) {
            /*
             * 1.集合不会记住对象的类型，当对象被放进集合，再次取出来的时候，都会被编译成Object
             * 类型的对象，但是在进行运行的时候却还是以原有类型进行运行，
             * 
             * 2.此时进行强制类型转换就会容易发生错误
             * 
             * 3.使用泛型可以解决这个问题
             */
            String name = (String) list.get(i);
            System.out.println("name:" + name);
        }
    }


    public static void CastObjectToStringdIndex(){
        List<String> list = new ArrayList<>();
        list.add("sadfasdf");
        list.add("sdsa");
//      使用泛型将list集合的类型指定String类型，此时再想list
//      集合中加入Integer类型的对象，则会报错
//      list.add(100);   


        for (int i = 0; i < list.size(); i++) {
            String name = list.get(i);
            System.out.println("name:" + name);
        }

        /*
         * 采用泛型写法之后，想list集合中添加Integer类型的对象就会出现
         * 编译错误，无法编译通过。
         * 
         * 通过List<String> 直接限定了list集合中只能含有String类型的元素
         */
    }

    public static void getData(Box<Number> data){
        System.out.println("name："+ data.getData());
    } 
}

/*创建一个不指定泛型的内部类  Box*/
class Box<T>{
    private T data;
    public Box(){}
    public Box(T data){
        this.data = data;
    }
    public T getData(){
        return data;
    }
}

备注：其中类型通配符有两种特殊情况类型通配符上限和类型通配符下限
在上面的例子中，如果需要定义一个功能类似于getData()的方法，但对类型实参又有进一步的限制：只能是Number类及其子类。此时，需要用到类型通配符上限

如果需要一个功能与getData()方法类似的，但是对传递进去的类型实参由进一步的限制，只能是某个类及其子类，那么就需要用到通配符上限

参考代码如下：

  public class GenericTest {

      public static void main(String[] args) {

          Box<String> name = new Box<String>("corn");
         Box<Integer> age = new Box<Integer>(712);
          Box<Number> number = new Box<Number>(314);

          getData(name);
         getData(age);
         getData(number);

         //getUpperNumberData(name); // 1
         getUpperNumberData(age);    // 2
         getUpperNumberData(number); // 3
    }

    public static void getData(Box<?> data) {
         System.out.println("data :" + data.getData());
     }

     public static void getUpperNumberData(Box<? extends Number> data){
        System.out.println("data :" + data.getData());
     }

 }

类型通配符下限 就是传递进去的类型实参是继承自上限类型的实参，那么就称之为类型通配符下限

类型通配符上限通过形如
Box<? extends Number>形式定义，相对应的，类型通配符下限为Box<? super Number>形式，其含义与类型通配符上限正好相反
（来自：http://www.cnblogs.com/lwbqqyumidi/p/3837629.html）