JAVA---＞定义泛型结构：泛型类、泛型接口、泛型方法

泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
例如：GenericClass<T>{}

一些常用的泛型类型变量：
E：元素（Element），多用于java集合框架
K：关键字（Key）
N：数字（Number）
T：类型（Type）
V：值（Value）

1 泛型类的说明

import java.util.Objects;

/**
 * 自定义泛型类
 */
public class Order<T> {

    private int orderId;
    private String orderName;
    private T[] arr;

    private T orderT;
    public Order(){
//        arr = new T[12];//错误的
        arr = (T[]) new Object[12];//正确的
    }
    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public T getOrderT() {
        return orderT;
    }

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

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



    public Order(int orderId,T orderT){
        this.orderId = orderId;
        this.orderT = orderT;
    }
    //静态方法中不能使用类的泛型。
//    public static void show(){
//        System.out.println("orderT ： " + orderT);
//    }
}

/**
 * 如果继承时，没有父类的泛型参数的类型，则默认此类型为Object。
 * 此中写法不规范，不建议
 */
public class SubOrder extends Order {
}

/**
 * 继承泛型类时，可以指明泛型参数的类型。
 */
public class SubOrder1 extends Order<String> { //SubOrder1:不是一个泛型类！
}

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

public class GenericTest {
    /*
    1. 创建自定义的泛型类对象时，如果没有使用类的泛型，则默认泛型参数的类型为：Object
    2. 泛型参数，只能使用引用类型来充当。不能使用基本数据类型
    3. 创建泛型类对象时，一旦指明了泛型参数的类型，则在泛型类中，凡是使用类的泛型的位置，都替换为指定的泛型参数的类型。
    4. 指明类的泛型参数的场景：① 创建泛型类的对象时  ② 子类继承泛型类时，可以指明泛型参数的类型。
     */
    @Test
    public void test1() {
        Order o1 = new Order();
        Object orderT = o1.getOrderT();

        ArrayList list = new ArrayList();
        list.add(123);
        list.add("ABC");

        Order<Integer> order = new Order<>();
        Integer orderT1 = order.getOrderT();

        Order<String> order1 = new Order<>(12, "AA");
    }

    @Test
    public void test2() {
        SubOrder o1 = new SubOrder();
        Object orderT = o1.getOrderT();

        SubOrder1 o2 = new SubOrder1();
        String orderT1 = o2.getOrderT();

        SubOrder2<Double> o3 = new SubOrder2<>();
        Double orderT2 = o3.getOrderT();
    }

    @Test
    public void test3(){
        ArrayList list1 = new ArrayList();
        ArrayList list2 = list1;

        ArrayList<Integer> list3 = new ArrayList<>();
        //泛型不同的引用不能相互赋值。
//        ArrayList<String> list4 = list3;
    }
}

补充说明：

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

2 泛型方法的说明

public class SubOrder1 extends Order<String> { //SubOrder1:不是一个泛型类！

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

public class Order<T> {

    //...
    //泛型方法
    public <E> List<E> copyArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }
}

//泛型方法的测试
    //1. 泛型方法所属的类可以是泛型类，也可以不是泛型类
    //2. 当调用泛型方法时，指明泛型方法中的泛型参数的类型
    //3. 泛型方法可以声明为静态的
    @Test
    public void test4(){
        Order<String> order = new Order<>();//此时类的泛型是：String
        Integer[] arr = new Integer[]{1,2,3};
        List<Integer> list = order.copyArrayToList(arr);//泛型方法的参数是：Integer

    }

3 应用举例

import java.util.List;

/**
 * DAO: data(base) access object
 * 封装了对数据库中表的CRUD操作
 */
public class DAO<T> {

    //增
    public void add(T instance){

    }
    //删
    public void remove(int id){

    }
    //改
    public void update(int id,T newInstance){

    }
    //查：一条记录
    public T getInstance(){

        return null;
    }
    //查：多条记录
    public List<T> getForList(String sql){

        return null;
    }

    //泛型方法
    // 可能会查询表的条目数；最大的生日；最多的工资数
    public <E> E getValue(String sql){
        return null;
    }

}

import java.sql.Date;

public class Customer {
    private int id;
    private String name;
    private String email;
    private Date birth;

    //。。。
}

public class CustomerDAO extends DAO<Customer> {
}

public class Student {
}

public class StudentDAO extends DAO<Student> {
}

测试：

public class DAOTest {
    public static void main(String[] args) {
        CustomerDAO dao = new CustomerDAO();

        dao.getForList("select id,name,email,birth from custoemrs where id < 10");

        StudentDAO dao1 = new StudentDAO();
        Student student = dao1.getInstance();
    }
}

四、泛型在继承上的体现

4.1 情况1

/*
   1. 类A是类B的父类，但是 G<A> 与 G<B>没有继承关系。
     */
    @Test
    public void test1() {
        Object obj = null;
        String str = null;

        obj = str;//多态

        Object[] arr = null;
        String[] arr1 = null;

        arr = arr1;//多态

        //*************************
        ArrayList<Object> list1 = null;
        ArrayList<String> list2 = new ArrayList<>();
        //编译不通过
//        list1 = list2;
        /*
        反证法：
        假设：list1 = list2;
        list1.add(123);非法的。
         */

        method(list1);
        method1(list2);


    }

    public void method(ArrayList<Object> list) {

    }

    public void method1(ArrayList<String> list) {

    }

4.2 情况2

 /*
    2. 类A是类B的父类或接口，A<G> 是 B<G>的父类，可以向上转型（多态）
     */
    @Test
    public void test2() {
        List<String> list1 = null;
        ArrayList<String> list2 = new ArrayList<>();

        list1 = list2;

        method2(list2);
    }

    public void  method2(List<String> list){

    }