Java基础巩固系列 泛型

代码示例：

/*
 * 泛型的使用
 * 1.在集合中使用泛型
 * 2.自定义泛型类、泛型接口、泛型方法
 * 3.泛型与继承的关系
 * 4.通配符
 * */
public class TestGeneric {

    /*
    * 通配符的使用
    * */
    @Test
    public void test7() {
        List<String> list = new ArrayList<>();
        list.add("AA");
        list.add("BB");
        List<?> list1 = list;

        //可以读取声明为通配符的集合类的对象
       Iterator<?> iterator=  list1.iterator();
       while (iterator.hasNext()){
           System.out.println(iterator.next());
       }

       //不允许向声明为通配符的集合类中写入对象.唯一例外的是null
//        list1.add("CC");
//        list1.add(123);
        list.add(null);
    }


    /*
    * 通配符 ?
    * List<A>、List<B>、。。。。。都是List<?>的子类
    *
    * ? extends A:可以存放A及其子类
    * ? super A:可以存放A及其父类
    * */
    @Test
    public void test6() {
        List<?> list = null;
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        list = list1;
        list = list2;

        show(list1);
//        show(list2);
        show1(list1);
        show1(list2);

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

    public void show(List<Object> list){

    }

    public void show1(List<?> list){

    }

    /*
    * 泛型与继承的关系
    * 若类A是类B的子类，那么List<A>就不是List<B>的子接口
    * */
    @Test
    public void test5() {
        Object obj = null;
        String str = "AA";
        obj = str;

        Object[] obj1 = null;
        String[] str1 = new String[]{"AA","bb","cc"};
        obj1 = str1;

        List<Object> list = null;
        List<String> list1 = new ArrayList<>();
//        list = list1;
        //假设list = list1满足
        //list.add(123);
        //String str = list1.get(0); // 出现问题，所以假设不满足

    }



    //自定义泛型类的使用
    @Test
    public void test4() {
        //1.当实例化泛型类的对象时，指明泛型的类型。
        // 指明以后，对应的类中所有使用泛型的位置，都变为实例化中指定的泛型的类型
        //2.如果我们自定义了泛型类，但是在实例化时没有使用，那么默认的类型是Object类的
        Order<Boolean> order = new Order<>();
//        order.getT();
        order.setT(true);
        System.out.println(order.getT());
        order.add();
        System.out.println(order.list);

        SubOrder o = new SubOrder();
        List<Integer> list = o.list;
        System.out.println(list);

        //当通过对象调泛型方法时，指明泛型方法的类型。
        Integer i = order.getE(23);
        Double d = order.getE(2.3);

        Integer[] in = new Integer[]{1, 2, 3, 4};
        List<Integer> list2 = new ArrayList<>();
        List<Integer> list3 = order.fromArrayToCollection(in, list2);
        System.out.println(list3);
    }

    @Test
    public void test3() {
        Map<String, Integer> map = new HashMap<>();
        map.put("AA", 78);
        map.put("BB", 97);
        map.put("CC", 99);

        Set<Map.Entry<String, Integer>> set = map.entrySet();
        for (Map.Entry<String, Integer> o : set) {
            System.out.println(o.getKey() + "------>" + o.getValue());
        }
    }


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

//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//        }

        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    //1.在集合中没有使用泛型的情况下
    @Test
    public void test1() {
        List list = new ArrayList();
        list.add(89);
        list.add(84);
        list.add(86);
        //1.没有使用泛型，任何Object及其子类的对象都可以添加进来
        list.add(new String("AA"));

        for (int i = 0; i < list.size(); i++) {
            //2.强转为int型时，可能报ClassCastException异常
            System.out.println((Integer) list.get(i));
        }
    }
}

自定义泛型类Order<T>：

//自定义泛型类
public class Order<T> {
    private String orderName;
    private int orderId;
    private T t;
    List<T> list = new ArrayList<>();


    public void setT(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    //声明泛型方法
    public <E> E getE(E e) {
        return e;
    }

    //实现数组到集合的复制
    public <E> List<E> fromArrayToCollection(E[] e, List<E> list) {
        for (E e1 : e) {
            list.add(e1);
        }
        return list;
    }

    //不可以在静态方法中使用泛型的声明
//    public static void show(){
//        System.out.println(t);
//    }

    public void info(){
        //不可以在try-catch中使用类的泛型的声明
//        try {
//
//        }catch (T e){
//
//        }
    }

    public void add() {
        list.add(t);
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }


    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", t=" + t +
                ", list=" + list +
                '}';
    }
}

//继承泛型类或泛型接口时，可以指明泛型的类型
class SubOrder extends Order<Integer> {

}