[泛型与File]自定义泛型类及其注意点

Order类：

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

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

    T orderT;

    public Order(){
        //编译不通过
//        T[] arr = new T[10];

        //编译通过
//        T[] arr = (T[]) new Object[10];
    };

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

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
//静态方法中不能使用类的泛型
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }

}

/*
如何自定义泛型结构：泛型类、泛型接口;泛型方法

1. 关于自定义泛型类、泛型接口：
 */
public class GenericTest1 {
    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");

        order1.setOrderT("AA:hello");
    }

    @Test
    public void test2(){
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型 则实例化子类对象时，不再需要指明泛型
        sub1.setOrderT(369);

        SubOrder1<String> sub2 = new SubOrder1<>();//类型推断
        sub2.setOrderT("order2...");
    }

    @Test
    public void test3(){

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

    @Test
    public void test4(){
        class Father<T1,T2>{

        }
        //子类不保留父类的泛型
        //1)没有类型 擦除
        class Son1 extends Father{//等价于class Son extends Father<Object,Object>
        }
        //2)具体类型
        class Son2 extends Father<Integer,String>{
        }

        //子类保留父类的泛型
        //1)全部保留
        class Son3<T1,T2> extends Father<T1,T2>{
        }
        //2)部分保留
        class Son4<T2> extends Father<Integer,T2>{
        }

    }

}

SubOrder：

public class SubOrder extends Order<Integer>{//SubOrder不是泛型类
}

SubOrder1：

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