泛型
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];
子父类关系泛型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的父类
