Java使用泛型的困顿

public class ArrayList//JDK1.5之前的
{
    public Object get(int i){......}
    public void add(Object o){......}
    ......
    private Object[] elementData;
}

/**jdk1.5之前的写法，容易出问题*/
ArrayList arrayList1=new ArrayList();
arrayList1.add(1);
arrayList1.add(1L);
arrayList1.add("asa");
int i=(Integer) arrayList1.get(1);//因为不知道取出来的值的类型，类型转换的时候容易出错        

 /** jdk1.5之后加入泛型*/
 ArrayList<String> arrayList2=new ArrayList<String>();  //限定数组列表中的类型
 //      arrayList2.add(1); //因为限定了类型，所以不能添加整形
 //      arrayList2.add(1L);//因为限定了类型，所以不能添加整长形
 arrayList2.add("asa");//只能添加字符串
 String str=arrayList2.get(0);//因为知道取出来的值的类型，所以不需要进行强制类型转换

public abstract interface List<E> extends Collection<E>
{
    ....................
    public abstract E get(int paramInt);
    public abstract boolean add(E paramE);
    ....................
}

import java.util.ArrayList;
import java.util.List;


public class TestMain {
    public static void main(String[]args) throws Exception{
        List<Integer> intList = new ArrayList<Integer>();
        intList.add(10);
        List<Number> numberList = intList;//此处编译报错//numberList.get(0); ------1
    }
}

public class TestMain {
    public static void main(String[] args) {
        Item<Dog> item = new Item<Dog>(new Dog());
        item.get();
        Item<? extends Pet> item2 = new Item<Dog>(new Dog());
        item2.get().out();
        /**知道某种限制，但是不知道具体是什么**/
        List<? extends Pet> list = new ArrayList<Dog>();
        /**
         * The method add(capture#2-of ? extends Pet) in the type List<capture#2-of ? extends Pet>
         *  is not applicable for the arguments (Dog)
         * list.add(new Dog());
         * 从错误代码得知，编译期list的类型是List<? extends Pet>，所以通配符还是个未知类型；
         * 只知道是某种Pet的子类，但是并不知道具体的子类是什么，无法确保类型兼容；
         * 即使list.add(new Object()); （Object类型与Pet的子类不兼容） 也是不可以的；
         * list.add(null);这个可以；所以对于使用通配符的泛型，只能“取”不能“加”；
         * 编译器只允许加null;因为只有 Pet的子类 = null；等式成立；
         */
        //list.get(0);
        List<? super Dog> list2 = new ArrayList<Dog>();
        /**
         * 这关系到泛型的边界(bounds)，list通配符使用的是上边界，无法确定具体的类；
         * 这里list2用的是下边界，取放的是Dog某种超类,但是并不知道具体的超类是什么；
         * 我们只知道Dog的子类可以跟Dog超类类型兼容
         * 所以这种形式的通配符只能“存”不能“取”
         */
        list2.add(new Dog());
        /**
         * list2.add(new Object());
         */
        list2.add(new PettyDog());
        /**ClassCastException**/
        //list2.add((Dog) new Run());
    }
}
interface Pet {
    public void out();
}
class Item<T extends Pet> {
    T item;
    public Item(T item) {
        this.item = item;
    }
    public T get() {
        return item;
    }
    public void put(T item) {
    }
}
class Run {
    
}
class Dog extends Run implements Pet {
    @Override
    public void out() {
        System.out.println("The Dog!");
    }
    public void getMsg(Item<?> item) {
        item.get();
        /**
         *The method put(capture#3-of ?) in the type Item<capture#3-of ?>
         * is not applicable for the arguments (Item<capture#4-of ?>)
         * capture:占位符被称为这个特殊通配符的捕获
         * item.put(item);
         */
    }
}
class PettyDog extends Dog {
}