68_Java_泛型_通配符

@Test
    public void test1(){
        ////在集合中使用泛型之前的情况：
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(123);
//        integers.add("alex"); // 报错

        Iterator<Integer> iterators = integers.iterator();
        while (iterators.hasNext()){
            Integer next = iterators.next();  // 返回值就是 integer类型
            System.out.println(next);
        }
    }
    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test2(){
        HashMap<String, Integer> map1 = new HashMap<>();
        map1.put("Tom",87);
        Set<Map.Entry<String, Integer>> entries = map1.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Integer> next = iterator.next();
            System.out.println(next.getKey() + "" + next.getValue());
        }
    }

   //关于自定义泛型类、泛型接口
    @Test
    public void test3(){
        order<String> alex = new order<>("alex", 35, "Male");
        System.out.println(alex);
        String bob = alex.getObj("bob40");
        System.out.println(bob);

        // 静态泛型方法
        List<Integer> objStaic = order.getObjStaic(Arrays.asList(123, 345)); // 传入list 返回list
        System.out.println(objStaic);
        List<? extends Serializable> alex1 = order.getObjStaic(Arrays.asList(123, "alex"));
        System.out.println(alex1);

    }
}

//SubOrder<T,K,V>:仍然是泛型类
class subOrder<T,K,V> extends  order<T>{

}
//SubOrder1 不是泛型类
class subOrder1 extends order<Integer>{

}

class order<T>{
    String orderName;
    int orderId;
    T orderT;

    public order() {
    }

    public order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

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

    // 静态泛型方法
    public static <F> F getObjStaic(F f){
        return f;
    }

    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;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}

// 泛型接口

public class InterFaceGenTest {
    public static void main(String[] args) {
        implInfo<String> s1 = new implInfo<>();
        s1.setT("alex");
        System.out.println(s1.getObj());
    }
}

interface  Info<T>{
    public T getObj();
}

class  implInfo<T> implements  Info<T> {
    private  T t;
    @Override
    public T getObj() {
        return this.t;
    }

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

1. 泛型在继承方面的体现

虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。
补充：类A是类B的父类，A<G> 是 B<G> 的父类

public class GenericTest2 {
    @Test
    public void test1(){
        //A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。
        //类A是类B的父类，A<G> 是 B<G> 的父类

        //此时的list1和list2的类型不具有子父类关系
        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();

        ArrayList<String> list3 = new ArrayList<>();
        list2 = list3; //类A是类B的父类 A<G> 是 B<G> 的父类

    }
}

2. 通配符的使用
       通配符：?   类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
     

    @Test
    public void test2(){
       // 通配符：? 类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
        List<Object> list1 = null;
        List<String> list2 = null;
        List<?> list = null;
        list = list1;   // 子类对象付给 父类引用 - 多态
        list = list2;

        ////除了添加null之外 对于List<?>就不能向其内部添加数据
        //list.add(22);  //报错 Required type: capture of ?
        // list.add(null); 可以添加 null
    }

       
3.有限制条件的通配符的使用。
    ? extends A:  <? extends Number> (无穷小，Number] 只允许泛型为Number及 Number子类的引用调用
                  G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类

    ? super A:   <? super Number> [Number, 无穷大) 只允许泛型为Number 及Number父类的引用调用
                 G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类