14、泛型

泛型

泛型（Generics）在 JDK1.5 推出，目的是建立具有类型的安全集合框架

1、泛型的使用

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

jdk7新特性类型推断：

Map<String,Integer> map = new HashMap<>();

1、泛型类与泛型接口

可以使用 class 名称<泛型列表>{} 声明一个类，这样的类称为泛型类
如：class People<E>

• 其中 E 代表泛型，没有指定 E 为何种类型的数据，它可以是如何类和接口，但不能是基本数据类型
• 「泛型列表」给出的泛型可以作为类的「成员变量的类型」，「方法的返回值类型」，「局部变量的类型」
• 「静态方法中」不能使用类的泛型

可以使用 interface 名称<泛型列表> 声明一个接口，这样的接口称作泛型接口，如：interface Computer<E>

使用泛型类声明对象：

• 泛型类声明和创建对象时，类名有多了 <> ，<> 中可使用具体的类型或 ?
• 如果定义了泛型类，实例化没有指明类的泛型，则认为类型为 Object 类型（建议实例化时要指明泛型）
• 当子类继承了带泛型的父类，并指明了泛型类型，则实例化子类对象时，不在需要指明泛型

public class Order<T> {
    String name;
    int id;
    T orderT; // 成员变量
    //如下的方法都不是泛型方法
    public Order(){
        //编译不通过
        //T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }
    public Order(String name,int id,T orderT){
        this.orderT = orderT;
        this.name = name;
        this.id = id;
    }
    public T getOrderT(){
        return orderT;
    }
    public void setOrderT(T orderT){
        this.orderT = orderT;
    }
    // 不可使用
    /*public static void show(T orderT){
        System.out.println(orderT);
    }*/
}

public class SubOrder extends Order<Integer> {//SubOrder不是泛型类了
}
public class SubOrder1<T> extends Order<T>{//SubOrder1<T>仍然是泛型类
}

public class GenericTest1 {
    @Test
    public void test(){
        Order order = new Order();
        order.setOrderT(123);

        Order<String> order1 = new Order<>("A",1,"AA");
        order1.setOrderT("AB");
        //当子类继承了带泛型的父类，并指明了泛型类型，则实例化子类对象时，不在需要指明泛型
        SubOrder sub1 = new SubOrder();
        sub1.setOrderT(123);

        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("AA");
    }
    @Test
    public void test2(){
        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        //泛型不同的引用不能互相赋值
        //list1 = list2;
    }
}

//异常类不能是泛型的
/*public class MyException<T> extends Exception{
}*/

• 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>
• 泛型类的构造器如下： public GenericClass(){}
  而下面是错误的： public GenericClass<E>(){}
• 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致
• 泛型不同的引用不能相互赋值
• 泛型如果不指定，将被擦除，泛型对应的类型均按照 Object 处理，但不等价于 Object
• 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
• 泛型的指定中不能使用基本数据类型，可以使用包装类替换
• 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在 静态方法中不能使用类的泛型
• 不能使用 new E[]。但是可以： E[] elements = (E[])new Object[capacity]
• 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
  • 子类不保留父类的泛型：按需实现
  • 没有类型 擦除
  • 具体类型
  • 子类保留父类的泛型：泛型子类
  • 全部保留
  • 部分保留

结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型

2、泛型方法

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

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

public class Order<T> {
    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的参数没有任何关系
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }
}

2、泛型在继承方面的体现

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

public class GenericTest {
    @Test
    public void test(){
        Object obj = null;
        String str = null;
        obj = str;

        List<Object> list1 = null;
        List<String> list2 = null;
        //此时 list1 与 ist2 的类型不具有子父类关系
        //list1 = list2;

    }
}

3、通配符的使用

1、通配符：？

类A是类B的父类，G<A> 和 G<B> 是没有关系的，二者共同的父类是：G<?>

• 添加：对于 List<?> 就不能向其内部添加数据。除了添加 null 之外
• 读取：允许读取数据，读取数据的类型为 Object

public class GenericTest {
    @Test
    public void test(){
        Object obj = null;
        String str = null;
        obj = str;// 子父类关系(多态)

        List<Object> list1 = null;
        List<String> list2 = null;
        //此时 list1 与 list2 的类型不具有子父类关系
        //list1 = list2;
    }

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

        List<?> list = null;
        list = list1;//list作为list1，list2的通用父类
        list = list2;

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list = list3;
        //添加：对于List<?>就不能向其内部添加数据，除了添加null之外
        //list.add("123");
        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);
        }
    }

2、有限制条件的通配符的使用

• ? 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 test3(){
        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

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

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

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

        //读取数据
        list1 = list3;
        Person person = list1.get(0);
        //Student student = list1.get(0); 编译不通过
        list2 = list4;
        Object object = list2.get(0);
        //Person person1 = list2.get(0); 编译不通过

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