JavaSE学习笔记——泛型

1. 集合中不使用泛型时：

   public void test1(){
   //1.在集合中没有使用泛型的时候
     List list = new ArrayList();
     list.add(89);
     list.add(87);
     list.add(67);
     //list.add(new String("AA"));
     //1. 没有使用泛型，任何Object及其子类的对象均可以添加进来
     for(int i = 0; i < list.size(); ++i){
         //2. 强转为int型的时候，可能报ClassCastException异常
         int score = (Integer)list.get(i);
         System.out.println(score);
     }
 }

2. 集合中使用了泛型

//2. 在集合中使用泛型
    @Test
    public void test2(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(78);
        list.add(58);
        //list.add("AA");

        for(int i = 0; i < list.size(); ++i){
            int score = list.get(i);
            System.out.println(score);
        }
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

1. 泛型类的使用

public class DAO <T>{
    Map<String, T> map = new HashMap<String, T>();

    public void delete(String id){
        map.remove(id);
    }
    public List<T> list(){
        List<T> list = new ArrayList<T>();
        for (String s:map.keySet()) {
            list.add(map.get(s));
        }
        return list;
    }
    public void update (String id, T entity){
        map.remove(id);
        map.put(id, entity);
    }
    public  T get(String id){
        return map.get(id);
    }
    public void save(String id, T entity){
        map.put(id, entity);
    }
}

public class TestDAO {
    public static void main(String[] args) {
        DAO<User> dao = new DAO<User>();
        dao.map = new HashMap<String, User>();
        dao.save("1001", new User(1,32,"梁朝伟"));
        dao.save("1002", new User(2, 34,"汤唯"));
        dao.save("1003", new User(3,23,"刘嘉玲"));
        User u = dao.get("1001");
        System.out.println(u);
        dao.update("1002", new User(4, 15,"成龙"));
        dao.delete("1003");
        List<User> list = dao.list();
        System.out.println(list);

    }
}
/**
* 对象实例化时如果不指定泛型，默认为Object
* 泛型类型不同的引用之间不能相互赋值
* 加入集合中的对象类型必须和泛型所指定的泛型类型一致
* 如果泛型类是一个接口或者抽象类，则不可以被实例化
* 不能在catch中使用泛型
* 静态方法中不能使用类的泛型
*/

2. 泛型方法的使用

//实现数组到集合的复制
    public <E> List<E> fromArrayToList(E[] e, List<E> list){
        for(E e1: e){
            list.add(e1);
        }
        return list;
    }
/**
* 泛型类中的普通方法不可以加static描述符
* 泛型类中的泛型方法可以加上static描述符
*/

1. A类是B类的子类，G是带泛型声明的类或者接口，则G<A>不是G<B>的子类。
2. 接口中也是同样的道理，泛型引用之间的继承关系，并不会影响到泛型类。

1. A类是B类的子类，G是带泛型声明的类或者接口，则G<?>是G<A>、G<B>的父类！
2. 对于List<?>,能够读取其中元素，读出来都是Object类型，但是不可以向其中写入任何类型数据。
   因为没有指明可以存放到其中的类型，只有null可以存放进去。
3. ? extends A:可以存放A及其子类 / ？Super A：可以存放A及其父类

    public void test6(){
        List<?> list = null;
        List<Object> list1 = new ArrayList<Object>();
        List<String> list2 = new ArrayList<String>();
        list = list1;//correct
        list = list2;//correct

        List<? extends Number> list3 = null;
        List<Integer> list4 = null;
        List<? super Number> list5 = null;
        list5 = list1;//correct
        list3 = list1;//wrong
    }