一 : 泛型的使用场景

• 在集合中使用泛型

若集合中没有使用泛型,任何Object及其子类的对象都可以添加进来,强转为非接收类型时,可能报ClassCastException的异常

泛型写法:

public void test2() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        Iterator<Integer>it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }

• 泛型与继承的关系

若类A 是 类B的子类,那么List<A>就不是List<B>的子接口

public void test5() {
        Object obj = null;
        String str = "雪芙";
        obj = str;
        
        Object[] obj1 = null;
        String[] str1 = new String[] {"AA","BB","CC"};
        obj1 = str1;
        
        
        //报错
        List<Object> list = null;
        List<String> list1 = new ArrayList<String>();
        List = List1;
        
        //假设 List = List1;满足
        //list.add(123)
        //list1.get(0);//出现问题,所以假设不满足
    }

• 通配符的使用

① List<A>,List<B>...都是List<?>子类

List<?> list = null;
        List<Object> list1 = new ArrayList<Object>();
        List<String> list2 = new ArrayList<String>();
        list = list1;
        list = list2;

②? extends A:可以存放A及其子类

List<? extends Number > list3 = null;
        List<Integer> list4 = null;
        list3 = list4;

③? super A:可以存放A及其父类

List<Object> list1 = new ArrayList<Object>();
List<? super Number > list5 = null;
list5 = list1;

• 通配符的注意事项

可以读取声明为通配符的集合类对象,但却不允许向声明为通配符的集合类中写入对象

List<String> list = new ArrayList<>();
        list.add("xf");
        list.add("22");
        List<?> list1 = list; 

可以读取声明为通配符的集合类的对象

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

不允许向声明为通配符的集合类中写入对象

错误:

list1.add("dfdf");  
list1.add(123);

二 : 自定义泛型类

注意 :
①不可以在静态方法中使用泛型的声明
② 不能再try-catch中使用类的泛型声明

public class Order<T> {
    private String orderName;
    private int orderId;
    private T t;
    
    List<T> list = new ArrayList<>();
    public void add() {
        list.add(t);
    }
    
    
    //声明泛型方法
    public <E>E getE(E e) {
        
        return e;
    }
    
    
    //不可以在静态方法中使用泛型的声明
//  public static void show() {
//      System.out.println(t);在实例化后
//      
//  }
    
    
    //不能再try-catch中使用类的泛型声明
//  public void info() {
//      try {
//          
//      } catch (T e) {
//
//      }
//      
//  }
    
    
    //实现数组到集合的复制
    public <E> List<E>  fromArrayToList(E[] e,List<E> list) {
        for(E e1: e) {
            list.add(e1);
        }
        return list;
    }
    
    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 getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }

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

继承泛型类或泛型接口时,可以指明泛型类型

class SubOrder extends Order<Integer>{
    
}

当实例化泛型类对象时,指明泛型类的类型,对应的类中所有泛型的位置,都变为实例化中指定的泛型的类型

Order<Boolean> order = new Order<Boolean>();
        order.setT(true);
        order.getT();
        order.add();
        List<Boolean> list = order.list;
        System.out.println(list);

如果我们自定义了泛型类,但在实例化时没有使用,那么默认是Object类型

Order order = new Order();

泛型方法,当通过对象调用泛型方法时(Order 中的fromArrayToList)指明泛型方法的类型

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