泛型

jdk5.0新增特性
注意：1.泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，用包装类替换
2.若实例化时，没有指明泛型的类型。默认指明泛型的类型。默认类型为java.lang.Object类型
3.jdk7后新特性：类型推断

ArrayList<String> list = new ArrayList<String>();
        //新特性，前类型推断了后类型
        ArrayList<String> list1 = new ArrayList<>();

如何自定义泛型类、泛型接口；泛型方法

1.定义泛型类

public class OrderT01<T> {//泛型类
    String name;
    int age;
    T orderT;
}

实例化时指明泛型类型，操作更严谨

//未对操作的泛型指定需要的类型，默认Object类型
        OrderT01 o = new OrderT01();
        o.setOrderT("hong");
        o.setOrderT(12);

        //对泛型指定类型
        OrderT01<String> o1 = new OrderT01<>();
        o1.setOrderT("hong");
//        o1.setOrderT(12);//报错

继承泛型时：

//1.继承泛型类时，子类也必须有泛型标识;SubOrder01仍是泛型类
//public class SubOrder01<T> extends OrderT01<T> {
//
//}
//2.对继承的父类泛型确定其类型时，默认子类也为此类型；SubOrder01不是泛型类
public class SubOrder01 extends OrderT01<Integer> {
        
}

注意：

//1.泛型类的构造器和普通类的构造方式一样
public class OrderT01<T> {//泛型类
         T orderT;
         public OrderT01() {
          }
}

//2.不同类型的泛型不能相互赋值
        ArrayList<String> l1 = null;
        ArrayList<Integer> l2 = null;

        //l1=l2;//泛型不同的引用不能相互赋值

//3.若泛型结构是一个接口或抽象类，则不可以创建泛型类的对象

//4.静态方法中，不能使用反省类；原因是，泛型类是在创建对象的时候使用，而静态结构早于对象的创建
public class OrderT01<T> {//泛型类
public static void show(T t){   
    }
}

//5.异常类不能是泛型类

//6.
//编译不通过，原因是，此方式是创建对象，表明T的类型已经确定，但T只是一个参数，并没有指定确定的类型
//T[] t = new T[10];
        //此种方式可以编译通过，将创建的Object类型数组强转成泛型数组（T[]）
        T[] t = (T[]) new Object[10];

//7.子父类关系泛型 子父类关系泛型1.png 子父类关系泛型2.png

2.泛型方法:可以声明为静态的

一个泛型类中存在如下两个方法，其泛型用<E>表示，
public class Test<T>{//实例化Test时，确定其T类型
     <T> T[] toArray(T[] a);//泛型方法
    void add(E e); //非泛型方法
}

举例：自定义泛型方法

public class GenericMethod {
    //泛型方法，在方法中出现了泛型的结构，泛型参数和类的泛型没有任何关系
    //即，泛型方法所属类是不是泛型都没关系
 //List<E>返回E类型的List数组；E[] arr参数为E类型的数组；<E>表示此时的E是一个泛型参数，不是一个类
    public <E> List<E> copyFromArrayList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }
}

        GenericMethod g = new GenericMethod();
        Integer[] arr = new Integer[]{1,2,5,2};
        //泛型方法在调用时指明泛型类型Integer
        List<Integer> integers = g.copyFromArrayList(arr);
        for(Integer i : integers){
            System.out.println(i);
        }
//泛型方法可以声明为静态的，原因是：泛型参数是在调用方法时才确定其类型，并非在实例化时确定
 public static <E> List<E> copyFromArrayList(E[] arr){}

泛型在继承方面的体现

虽然A类是B类的父类，但是G<A>和G<B>二者不具备子父类关系，二者是并列的；A类是B类的父类（接口），A<G>是B<G>的父类

        ArrayList<Object> a1 = null;
        ArrayList<String> a2 = null;
        a1 = a2;

        List<String> l = null;
        ArrayList<String> a = null;
        l = a;

通配符（？）的使用

虽然A类是B类的父类，但是G<A>和G<B>二者不具备子父类关系，但二者共同的父类是G<？>

        ArrayList<Object> a1 = null;
        ArrayList<String> a2 = null;
        ArrayList<?> a = null;
        a = a1;
        a = a2;

使用通配符后数据的读取和写入操作

        List<?> l = null;
        List<String> l2 = new ArrayList<>();
        l2.add("AA");
        l2.add("BB");
        l2.add("CC");

        l = l2;
        //添加（写入）：除null之外，不能向 List<?>添加数据
//        l.add("s");
        l.add(null);

        //获取（读取）：允许读取数据，类型为Object
        Object o = l.get(0);
        System.out.println(o);//AA

有限制条件的通配符使用

? extends A:( 数学中理解，(-oo,A] )
G<? extends A>可以作为G<A>和G<B>的父类，其中B是A的子类
? super A:( 数学中理解，[A,+oo) )
G<? super A>可以作为G<A>和G<B>的父类，其中B是A的父类