27.泛型 - 《Java 基础》

为什么要有泛型
在集合中使用泛型
自定义泛型结构
泛型在继承上的体现
通配符的使用
- 通配符的使用：注意点
：有限制的通配符

为什么要有泛型

泛型的设计背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的
对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来
解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于
这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个
参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就
是类型参数，即泛型。

泛型的概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。
JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

那么为什么要有泛型呢，直接Object不是也可以存储数据吗？

1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
1. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。

27.泛型 - 图1

27.泛型 - 图2

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

在集合中使用泛型

    @Test
    public void test(){
        ArrayList<Integer> list = new ArrayList<>();//类型推断
        list.add(78);
        list.add(88);
        list.add(77);
        list.add(66);
        //编译时，就会进行类型检查，保证数据安全
        //list.addAll("TOM");
        //遍历方式一：
        //for(Integer i : list){
        //不需要强转
        //System.out.println(i);
        //}
        //遍历方式二：
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    @Test
    public void  test2(){
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("Tom1",34);
        map.put("Tom2",44);
        map.put("Tom3",33);
        map.put("Tom4",32);
    //添加失败
    //map.put(33, "Tom");
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        Iterator<Map.Entry<String,Integer>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Map.Entry<String,Integer> entry = iterator.next();
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
    }

自定义泛型结构

自定义泛型类
自定义泛型接口
自定义泛型方法

1.泛型的声明

interface List 和 class GenTest其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。常用T表示，是Type的缩写。

2.泛型的实例化：

一定要在类名后面指定类型参数的值（类型）。如：

List strList = new ArrayList();
Iterator iterator = customers.iterator();
T只能是类，不能用基本数据类型填充。但可以使用包装类填充
把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想

使用泛型的主要优点是能够在编译时而不是在运行时检测错误。

1、泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
2、泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass(){}
3、实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
4、泛型不同的引用不能相互赋值。
5、尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有
一个ArrayList被加载到JVM中。
6、泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
7、如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
8、jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
9、泛型的指定中不能使用基本数据类型，可以使用包装类替换。
10、异常类不能声明为泛型类
11、在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
12、不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];参考：ArrayList源码中声明：Object[]elementData，而非泛型参数类型数组。
13、父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。
- 子类不保留父类的泛型：按需实现
  - 没有类型擦除
  - 具体类型
- 子类保留父类的泛型：泛型子类
  - 全部保留
  - 部分保留
14、方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。

自定义泛型类：Order

/**
 * @author tongfangping
 */
public 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 T getOrderT(){
        return orderT;
    }
    public void setOrderT(T orderT){
        this.orderT=orderT;
    }
    //静态方法中不能使用类的泛型
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }
    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有人任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没有关系
    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的，并非在实例化时确定。
    public <E>List<E> copyFormArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for (E e:arr
             ) {
            list.add(e);
        }
        return list;
    }
    @Override
    public String toString() {
        return "Order{" +
                "ordername='" + ordername + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}

子类：SubOrder

/**
 * @author tongfangping
 */
public class SubOrder extends Order<Integer> {//SubOrder：不再是个泛型类
}

子类：SubOrder1

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是个泛型类
}

测试类：GenerocTest1

/**
 * @author tongfangping
 */
public class GenerocTest1 {
    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此类泛型类型为Object类型
        Order order =  new Order();
        order.setOrderT(132);
        order.setOrderT("ABC");
        //建议：实例化时指明类的泛型
        Order<String>order1 = new Order<String>("orderAA",1001,"order:AA");
        order1.setOrderT("AA:hello");
    }
    @Test
    public void test2(){
        SubOrder subOrder = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型类型。
        subOrder.setOrderT(111);
        SubOrder1<String> subOrder1 = new SubOrder1<>();
        subOrder1.setOrderT("order2...");
    }
    @Test
    public void test3(){
        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = null;
        //泛型不同的引用不能相互赋值
        //list1 = list2;
    }
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer>  list = order.copyFormArrayToList(arr);
        System.out.println(list);
    }
}

异常类：MyException

/**
 * @author tongfangping
 */
//异常类不能声明为泛型类
//public class MyException<T>extends Exception {
//}

泛型的简单例子

Customer类

/**
 * @author tongfangping
 */
public class Customer {
}

DAO类

/**
 * @author tongfangping
 */
public class DAO<T> {//表的共性操作的DAO
    //添加一条记录
    public void add(T t){
    }
    //删除一条记录
    public boolean remove(int index){
        return false;
    }
    //修改一条记录
    public void update(int index){
    }
    //查询一条记录
    public T getIndex(int index){
        return null;
    }
    //查询多条记录
    public List<T> getForList(int index){
        return null;
    }
    //泛型方法
    //举例：获取表中一共有多少条记录？获取最大的员工入职时间？
    public <E> E getValue(){
        return null;
    }
}

Student类

/**
 * @author tongfangping
 */
public class Student {
}

子类：CustomerDAO

/**
 * @author tongfangping
 */
public class CustomerDAO extends DAO<Customer>{//只能操作某一个表的DAO
}

子类：StudentDAO

/**
 * @author tongfangping
 */
public class StudentDAO extends DAO<Student>{//只能操作某一个表的DAO
}

测试类：DAOTest

/**
 * @author tongfangping
 */
public class DAOTest {
    @Test
    public void test1(){
        CustomerDAO dao1 = new CustomerDAO();
        //此时的参数类型只能是Customer类型的实例
        //dao1.add(new String());
        dao1.add(new Customer());
        List<Customer> forList = dao1.getForList(10);
        StudentDAO dao2 = new StudentDAO();
        Student student = dao2.getIndex(1);
    }
}

泛型在继承上的体现

27.泛型 - 图3

public class GenericTest {
    /*
    1、泛型在继承方面的体现
        虽然类A是类B的父类，但是G<A> 和 G<B>二者不具备子父类关系，二者是并列关系。
        补充：类A是类B的父类，A<G> 是 B<G> 的父类
     */
    @Test
    public void test1(){
        List<Object> list1 = null;
        List<String> list2 = new ArrayList<String>();
        //此时的list1和list2的类型不具有子父类关系
        //list1 = list2;
    }
    @Test
    public void test2(){
        List<String> list1 = null;
        ArrayList<String> list2 = null;
        //此时的list1和list2的类型具有子父类关系
        list1 = list2;
    }

通配符的使用

1.使用类型通配符：
- ？比如：List ，Map
- List<?>是List、List等各种泛型List的父类。
2.读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
3.写入list中的元素时，不行。因为我们不知道c的元素类型，我们不能向其中添加对象。
- 唯一的例外是null，它是所有类型的成员。

/*
    2、通配符的使用
        通配符：？
        类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是:G<?>
     */
    @Test
    public void test3(){
        List<Object> list1 = null;
        List<String> list2 = null;
        List<?> list = null;
        //此时可以表示list1 和 list2的公共父类是List<?>
        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(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);
        }
    }

通配符的使用：注意点

//注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){
}

//注意点2：编译错误：不能用在泛型类的声明上
class GenericTypeClass<?>{
}

//注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();

：有限制的通配符

：允许所有泛型的引用调用
通配符指定上限
- 上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
通配符指定下限
- 下限super：使用时指定的类型不能小于操作的类，即>=
举例
- <? extends Number> ：(无穷小 , Number]，只允许泛型为Number及Number子类的引用调用
- <? super Number> [Number , 无穷大)，只允许泛型为Number及Number父类的引用调用
- <? extends Comparable>，只允许泛型为实现Comparable接口的实现类的引用调用

/**
 * @author tongfangping
 */
public class Person {
}

/**
 * @author tongfangping
 */
public class Student extends Person{
}

/*
    3、有限制条件的通配符的使用
        ? 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<>();
        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 p = list1.get(0);
        //编译失败
        //Student s = list1.get(0);
        list2 = list4;
        //编译通过
        Object object = list2.get(0);
        //编译失败
        //Person person = list2.get(0);
        //写入数据
        //编译失败
        //list1.add(new Student());
        //编译通过
        list2.add(new Person());
        //编译通过
        list2.add(new Student());
        //编译失败
        //list2.add(new Object());
    }