泛型

1.为什么要有泛型?

2.泛型的使用

//自定义泛型类
public class Order<T> {
    String name;
    int id;
    T orderT;

    public Order() {
    }

    public Order(String name, int id, T orderT) {
        this.name = name;
        this.id = id;
        this.orderT = orderT;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public T getOrderT() {
        return orderT;
    }

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

    @Override
    public String toString() {
        return "Order{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", orderT=" + orderT +
                '}';
    }

    //泛型方法 : 注意,1.泛型方法所属的类是不是泛型类都没关系
    // 2.要在返回值的前面再加一个<E>
    //3.泛型方法可以声明为静态的 , 原因:泛型参数是在调用时确定的,而非实例化时确定
    public static <E> List<E> copyArrayToList(E[] array){
        List<E> list = new ArrayList<>();
        for (E e : array) {
            list.add(e);
        }
        return list;
    }
}

@Test
    public void method(){
        //实例化时指明泛型的类型
        Order<String> order1 = new Order<>("orderName",001,"admin");
        System.out.println(order1);

        //调用泛型方法
        Integer[] arr = new Integer[]{1,2,3,4,5};
        List<Integer> list = Order.copyArrayToList(arr);
        System.out.println(list);
    }

3.泛型使用的注意点:

4.通配符

//通配符的使用: ?
    //通配符的容器不能添加数据 List<?> , 但是可以读取数据list.get()
    /*
         有限制条件的通配符 :
         1. List<? extends A> list: 相当于 ?<=A , 就是说可以将A及A的子类赋值给list
         2. List<? super A> list: 相当于 ?>=A , 就是说可以将A及A的父类赋值给list
     *
     */

    @Test
    public void method3(){
        List<Object> list1=null;
        List<String> list2=null;

        //list1=list2; 错误的
        List<?> list = null;

        list=list1;
        list=list2;
    }