一、泛型的概念

>所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。

>从 JDK1.5 以后， Java 引入了“参数化类型（ Parameterized type ）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List<String> ，这表明该List 只能保存字符串类型的对象。

> JDK1.5 改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

//例1
ArrayList<Integer> list = new ArrayList<>();//类型推断
list.add(78);
list.add(88);
list.add(77);
list.add(66);
//遍历方式一：
//for(Integer i : list){
//不需要强转
//System.out.println(i);
//}
//遍历方式二：
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

//例2
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("Tom1",34);
map.put("Tom2",44);
map.put("Tom3",33);
map.put("Tom4",32);
//添加失败
//map.put(33, "Tom");
Set<Entry<String,Integer>> entrySet = map.entrySet();
Iterator<Entry<String,Integer>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry<String,Integer> entry = iterator.next();
System.out.println(entry.getKey() + "--->" + entry.getValue());
}

二、自定义泛型结构

1、泛型类、泛型接口

1）泛型类的构造器如下： public GenericClass(){} 。而下面是错误的：public GenericClass<E>(){}

2）泛型不同的引用不能相互赋值。

>尽管在编译时 ArrayList<String> 和 ArrayList<Integer> 是两种类型，但是，在运行时只有一个ArrayList 被加载到 JVM 中。

3）泛型如果不指定，将被擦除，泛型对应的类型均按照 Object 处理，但不等价于Object 。 经验： 泛型要使用一路都用。要不用，一路都不要用。

4）泛型的指定中不能使用基本数据类型，可以使用包装类替换。

5）在类 / 接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

6）异常类不能是泛型的

7）不能使用 new E[] 。但是可以： E[] elements = (E[])new Object[capacity]; 参考：ArrayList 源码中声明： Object[] elementData ，而非泛型参数类型数组。

8）父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

子类不保留父类的泛型：按需实现

>没有类型擦除

>具体类型

子类保留父类的泛型：泛型子类

>全部保留

>部分保留

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

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

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}

2、泛型方法

>方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型 方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。

> 泛型方法的格式：

[ 访问权限 ] < 泛型 > 返回类型方法名 ([ 泛型标识参数名称 ]) 抛出的异常

>泛型方法声明泛型时也可以指定上限

public class DAO {
public <E> E get(int id, E e) {
E result = null;
return result; } }

public static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
for (T o : a) {
c.add(o);
} }
public static void main(String[] args) {
Object[] ao = new Object[100];
Collection<Object> co = new ArrayList<Object>();
fromArrayToCollection(ao, co);
String[] sa = new String[20];
Collection<String> cs = new ArrayList<>();
fromArrayToCollection(sa, cs);
Collection<Double> cd = new ArrayList<>();
// 下面代码中T是Double类，但sa是String类型，编译错误。
// fromArrayToCollection(sa, cd);
// 下面代码中T是Object类型，sa是String类型，可以赋值成功。
fromArrayToCollection(sa, co);
}

3、泛型在继承上的体现

public void testGenericAndSubClass() {
Person[] persons = null;
Man[] mans = null;
// 而 Person[] 是 Man[] 的父类.
persons = mans;
Person p = mans[0];
// 在泛型的集合上
List<Person> personList = null;
List<Man> manList = null;
// personList = manList;(报错) }

4、通配符的使用

4.1、通配符

1）. 使用类型 通配符：？

比如： List<?> ， Map<?,?> ，List<?>是 List<String> 、 List<Object> 等各种泛型 List 的父类。

2）. 读取 List<?> 的对象 list 中的元素时，永远是安全的，因为不管 list 的真实类型是什么，它包含的都是Object 。

3）. 不能为 list<?>类型的对象添加元素（因为是未知数据类型）。

>唯一的例外是 null ，它是所有类型的成员。

//注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){
}
//注意点2：编译错误：不能用在泛型类的声明上
class GenericTypeClass<?>{
}
//注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();

4.2、有限制的通配符

 <?>

允许所有泛型的引用调用

 通配符指定上限

上限 extends ：使用时指定的类型必须是继承某个类，或者实现某个接口，即 <=

 通配符指定下限

下限 super ：使用时指定的类型不能小于操作的类，即 >=

 举例：

<? extends Number>

只允许泛型为Number 及 Number 子类的引用调用

<? super Number>

只允许泛型为Number 及 Number 父类的引用调用

<? extends Comparable>

只允许泛型为实现Comparable 接口的实现类的引用调用

18、泛型