泛型
为什么要有泛型
就像是垃圾回收一样，如果只有一个垃圾桶，那么还要去分什么是可回收，什么是不可回收的。但是如果给垃圾桶
贴上标签，让它只能放可回收的或不可回收的，那么处理的时候就可以直接处理。
好处：
- 它解决了元素存储的安全问题。
- 解决获取元素时，需要类型强制转换的问题。
泛型的概念
所谓泛型（JDK1.5之后），就是允许在定义类、接口时通过一个标识表示类中某个属性的类 型或者是某个方法返
回值及参数类型。这个类型参数将在使用时（例如， 继承或实现这个接口，用这个类型声明变量、创建对象时）
确定（即传入实际的类型参数，也称为类型实参）
集合中使用泛型
无泛型时
public void test01() {
ArrayList list = new ArrayList<>();
//需求，存放学生成绩
list.add(78);
list.add(90);
list.add(80);
//问题一：类型不安全
list.add("Tom");
for(Object score:list){
//强转时可能出现类型转换异常
int stuScore = (Integer) score;
System.out.println(stuScore);
}
}
有泛型后
//List
public void test02() {
ArrayList<Integer> list = new ArrayList<>();
//需求，存放学生成绩
list.add(78);
//有了泛型，这样就会出错,编译时就会 进行类型检查
//list.add("Tom");
//方式一
for(Integer score:list){
//强转时可能出现类型转换异常
System.out.println(score);
}
//方式二
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
Integer score = iterator.next();
System.out.println(score);
}
}
//Map
public void test03() {
HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("Tom",97);
//会出错.
// hashMap.put("Tom","97");
Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
//方式一
while(iterator.hasNext()){
Map.Entry<String, Integer> next = iterator.next();
System.out.println(next.getKey());
System.out.println(next.getValue());
}
//方式二
for(Map.Entry<String, Integer> map :entries){
String key = map.getKey();
Integer value = map.getValue();
System.out.println(key+":"+value);
}
}
总结
- 集合接口或集合类在jdk5.0时都修改为带泛型的结构
- 在实例化 集合类时，可以指明具体的泛型类型，指明完后，在集合类或接口中凡是定义类或接口中，内部结构使用到类的泛型的位置都指定为设置的泛型
- 泛型的类型必须是类，不能是基本数据类型。
- 如果实例化时，没有指明泛型类型。则默认为Object类的。
自定义泛型结构
泛型的声明与实例化
声明：
interface List
以。相当于标签。
实例化：
一定要在类名后面指定类型参数的值(类型)，如
List<String> list = new ArrayList<>();
Iterator<Customer> iterator = customers.iterator();
自定义泛型类
使用方法
public class Order<T> {
String orderName;
int orderId;
//类的内部结构可以使用类的泛型
T orderT;
public Order() {
//编译不通过
//T[] arr= new T[10];
//泛型只是一个标签，而不是实例化本类，所以不能直接new
T[] arr = (T[]) new Object[10];
}
//静态方法中不能使用类的泛型，
// public static void show(T orderT){
// System.out.println(orderT);
// }
//catch中也不能使用泛型，编译不通过
// public void show(){
// try {
//
// }catch (T t){
//
// }
// }
}
总结
- 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如： <E1,E2,E3>
- 泛型类的构造器如下：public GenericClass(){}。 而下面是错误的：public GenericClass
(){} - 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
- 泛型不同的引用不能相互赋值。 >尽管在编译时ArrayList
和ArrayList 是两种类型，但是，在运行时只有 一个ArrayList被加载到JVM中。 - 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
- 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
- jdk1.7，泛型的简化操作：ArrayList
flist = new ArrayList<>(); - 泛型的指定中不能使用基本数据类型，可以使用包装类替换
- 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态 属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法 中不能使用类的泛型。
- 异常类不能是泛型的
- 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity]; 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
- 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
- 子类不保留父类的泛型：按需实现
- 没有类型 擦除
- 具体类型
- 子类保留父类的泛型：泛型子类
- 全部保留
- 部分保留
结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
不同情况
class Father<T1,T2>{ }
//子类不保留父类的泛型
// 1)没有类型，擦除,此时Son1已不是泛型类
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>{}
//----------情况二
//子类不保留父类的泛型
// 1)没有类型，擦除
class Son5<A,B> extends Father{}
// 2)具体类型
class Son6<A,B> extends Father<Integer,String>{}
//子类保留父类的全部泛型
// 1)全部保留
class Son7<T1,T2,A,B> extends Father<T1,T2>{}
// 2)部分保留
class Son8<T2,A,B> extends Father<Integer,T2>{}
自定义泛型方法
方法也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类
型就是传入数据的类型。
泛型方法的格式：
【访问权限】 <泛型> 返回类型 方法名([ 泛型标识 参数名称]) 抛出的异常
泛型方法声明泛型时也可以指定上限。
//在方法中出现了泛型的结构，泛型参数和类的泛型参数没有任何关系。
//泛型方法所属的类是不是泛型类都没关系。
//泛型方法可以是静态的
public static <E> List<E> copyFromArrayToList(E[] arr){
ArrayList<E> list = new ArrayList<>();
for(E e:arr){
list.add(e);
}
return list;
}
泛型在继承上的体现
类A是类B的父类，G和G二者不具备子父类关系,二者是并列关系
比如，String是Object的子类，但是List