泛型的使用与通配符

泛型的使用

1.jdk1.5新特性泛型

把元素的类型设计成一个参数，这个参数类型叫做泛型。

2.为什么要使用泛型？

• 类型无限制，类型不安全。
• 类型强制转换时，容易出现异常。ClassCastException

3.在集合中使用泛型

• 集合接口或类在jdk5.0时都修改为带泛型的结构。
• 在实例化集合类时，可以指明具体的泛型类型。
• 指明完以后，在集合类或接口中凡是定义接口或类时，内部结构使用到类的泛型位置，都指定为实例化的泛型。
• 泛型的类型必须是一个类。使用基本数据类型时，需要转换为包装类。
• 如果实例化时，没有指明泛型的类型，默认为Object类型。
• 如果泛型结构是一个接口或抽象类，则不能创建泛型类的对象。
• jdk1.7 泛型的简化操作：

ArrayList<Integer> list = new ArrayList<>();

• 泛型类可以有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>

代码举例：

public class GenericTest {

    @Test
    public void test1(){
        //在集合中使用泛型的情况：以ArrayList为例
//        ArrayList<Integer> list = new ArrayList<Integer>();
        //jdk7新特性：类型推断
        ArrayList<Integer> list = new ArrayList<>();
        list.add(99);
        list.add(100);
        list.add(88);
        //方式一：
        for (Integer integer:list){
            System.out.print(integer+" ");
        }
        System.out.println();
        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
        System.out.println();
        
        //在集合中使用泛型的情况：以ArrayList为例
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("Tom",123);
        map.put("Jerry",456);
        map.put("Jack",789);
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator1 = set.iterator();
        while (iterator1.hasNext()){
            //System.out.print(iterator1.next()+" ");
            Map.Entry<String, Integer> ee = iterator1.next();
            String key = ee.getKey();
            Integer value = ee.getValue();
            System.out.println(key + ":"+value);
        }
    }
}

自定义泛型结构：泛型类，泛型接口；泛型方法

泛型类被某个类继承

①public class SubOrder extends Order//此时子类时普通类
由于子类在继承带泛型的父类时，指明了泛型类型，则实例化子类对象时，不再需要指明泛型。
②public class SubOrder1 extends Order//此时子类也是泛型类

自定义泛型的注意点

①泛型不同的引用不能相互赋值

ArrayList<Integer>list1=null;
ArrayList<String>list2=null;

此时list1和list2不能相互赋值。

②类型推断

Order<String> order1 = new Order<>();

③静态方法中不能使用类的泛型。

④异常类不能是泛型的。

⑤不能使用new E[]。但是可以：E[] elements = (E[]) new Object[];

代码举例：

//自定义泛型类
public class Order<T> {
    String orderName;
    Integer orderId;

    //类的内部结构就可以使用类的泛型
    T orderT;

    public Order(){

    }

    public Order(String orderName, Integer orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

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


//测试自定义泛型类
@Test
public void test1(){
  //如果定义了泛型类，实例化没指明类的泛型，则认为此泛型类型为Object类型。
  //若果定义了类是泛型类的，建议实例化时要指明类的泛型。
  Order order=new Order();
  order.setOrderT(123);
  order.setOrderT("abc");

  Order<String> order1 = new Order<String>("orderAA",23,"order:AA");
  order1.setOrderT("AA:hello");
}

泛型方法

在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
换句话说，泛型方法所属的类是不是泛型类都没有关系。
泛型方法可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

public static <E> List<E> copyFromArrayToList(E[] arr){
    ArrayList<E> list = new ArrayList<>();
    for(E e : arr){
        list.add(e);
    }
    return list;
}


//测试泛型方法
@Test
public void test4(){
  Order<String> order = new Order<>();
  Integer[] arr = new Integer[]{1,2,3,4};
  //泛型方法在调用时，指明泛型参数的类型。
  List<Integer> list = order.copyFromArrayToList(arr);

  System.out.println(list);
}

泛型在继承方面的体现

/*
虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。
补充：类A是类B的父类，A<G> 是 B<G> 的父类
*/
@Test
public void test1(){
    Object obj = null;
    String str = null;
    obj = str;

    Object[] arr1 = null;
    String[] arr2 = null;
    arr1 = arr2;
    //编译不通过
//        Date date = new Date();
//        str = date;
    List<Object> list1 = null;
    List<String> list2 = new ArrayList<String>();
    //此时的list1和list2的类型不具有子父类关系
    //编译不通过
//        list1 = list2;
    /*
    反证法：
    假设list1 = list2;
       list1.add(123);导致混入非String的数据。出错。

     */

    show(list1);
    show1(list2);
}
public void show1(List<String> list){}
public void show(List<Object> list){}

通配符的使用

/*
通配符：?
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
*/
@Test
    public void test3(){
        List<Object> list1 = null;
        List<String> list2 = null;

        List<?> list = null;

        list = list1;
        list = list2;
        //编译通过
//        print(list1);
//        print(list2);

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list = list3;
        //添加(写入)：对于List<?>就不能向其内部添加数据。
        //除了添加null之外。
//        list.add("DD");
//        list.add('?');

        list.add(null);

        //获取(读取)：允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println(o);
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

有限制条件的通配符的使用。

/*
? extends A:
        G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类

? super A:
        G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类
*/
@Test
    public void test4(){

        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<Student>();
        List<Person> list4 = new ArrayList<Person>();
        List<Object> list5 = new ArrayList<Object>();

        list1 = list3;
        list1 = list4;
//        list1 = list5;

//        list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据：
        list1 = list3;
        Person p = list1.get(0);
        //编译不通过
        //Student s = list1.get(0);

        list2 = list4;
        Object obj = list2.get(0);
        编译不通过
//        Person obj = list2.get(0);

        //写入数据：
        //编译不通过
//        list1.add(new Student());

        //编译通过
        list2.add(new Person());
        list2.add(new Student());

    }