一、为什么要有泛型(Generic)
二、在集合中使用泛型
三、自定义泛型结构
- 1、泛型声明与实例化
  - 1.1 泛型的声明
  - 1.2 泛型的实例化
- 3、自定义泛型方法
四、泛型在继承上的体现
五、通配符的使用
- 1、有限制的通配符
六、泛型应用举例

一、为什么要有泛型(Generic)

泛型：标签
举例：中药店，每个抽屉外面贴着标签
超市购物架上很多瓶子，每个瓶子装的是什么，有标签
泛型的设计背景：集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就是类型参数，即泛型。

1、泛型的概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。
JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

那么为什么要有泛型呢，直接Object不是也可以存储数据吗？
1、解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
2、解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。

2、在集合中没有泛型时

ArrayList list = new ArrayList();
// 需求：存放学生的成绩
list.add(78);
list.add(76);
list.add(89);
list.add(88);
// 问题一：类型不安全
// list.add("Tom");
for(Object score : list){
    //问题二：强转时，可能出现ClassCastException
    int stuScore = (Integer) score;
    System.out.println(stuScore);
}

3、在集合中有泛型时

ArrayList<Integer> list =  new ArrayList<Integer>();
list.add(78);
list.add(87);
list.add(99);
list.add(65);
// 编译时，就会进行类型检查，保证数据的安全
// list.add("Tom");
// 方式一：
//for(Integer score : list){
//  // 避免了强转操作
//    int stuScore = score;
//    System.out.println(stuScore);
//}
// 方式二：
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
    int stuScore = iterator.next();
    System.out.println(stuScore);
}

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

二、在集合中使用泛型

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

// Map<String,Integer> map = new HashMap<String,Integer>();
// jdk7新特性：类型推断
Map<String,Integer> map = new HashMap<>();
map.put("Tom",87);
map.put("Jerry",87);
map.put("Jack",67);
// map.put(123,"ABC");
// 泛型的嵌套
Set<Map.Entry<String,Integer>> entry = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
while(iterator.hasNext()){
    Map.Entry<String, Integer> e = iterator.next();
    String key = e.getKey();
    Integer value = e.getValue();
    System.out.println(key + "----" + value);
}

总结：
① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
② 在实例化集合类时，可以指明具体的泛型类型
③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
比如：add(E e) —->实例化以后：add(Integer e)
④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

三、自定义泛型结构

1、泛型声明与实例化

1.1 泛型的声明

interface List 和 class GenTest
其中，T, K, V不代表值，而是表示类型。这里使用任意字母都可以。常用T表示，是Type的缩写。

1.2 泛型的实例化

一定要在类名后面指定类型参数的值（类型）。
如：List strList = new ArrayList();
Iterator iterator = customers.iterator();

T只能是类，不能用基本数据类型填充。但可以使用包装类填充
把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想 ```java // JDK 1.5 之前 Comparable c = new Date(); System.out.println(c.compareTo(“red”));

// JDK 1.5 Comparable c = new Date(); System.out.println(c.compareTo(“red”));

体会：使用泛型的主要优点是能够在编译时而不是在运行时检测错误。
<a name="SEIuZ"></a>
## 2、自定义泛型类、泛型接口
```java
// 自定义泛型类
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;
    }
    // 静态方法中不能使用类的泛型。
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }
    public void show(){
        //编译不通过
//        try{
//        
//        }catch(T t){
//       
//        }
    }
    // 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
    // 换句话说，泛型方法所属的类是不是泛型类都没有关系。
    // 泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    public static <E>  List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }
}

1、泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
2、泛型类的构造器如下：public GenericClass(){}。
而下面是错误的：public GenericClass(){}
3、实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
4、泛型不同的引用不能相互赋值。

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

5、泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
6、如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
7、jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
8、泛型的指定中不能使用基本数据类型，可以使用包装类替换。
9、在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
10、异常类不能是泛型的
11、不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
12、父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

子类不保留父类的泛型：按需实现
- 没有类型：擦除
- 具体类型
子类保留父类的泛型：泛型子类
- 全部保留
- 部分保留

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

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

// 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为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");

// SubOrder：不是泛型类
public class SubOrder extends Order<Integer> {}
SubOrder sub1 = new SubOrder();
// 由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
sub1.setOrderT(1122);
// SubOrder1<T>：仍然是泛型类
public class SubOrder1<T> extends Order<T> {}
SubOrder1<String> sub2 = new SubOrder1<>();
sub2.setOrderT("order2...");

3、自定义泛型方法

1、方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
2、泛型方法的格式：
[访问权限] <泛型> 返回类型方法名([泛型标识参数名称]) 抛出的异常
3、泛型方法声明泛型时也可以指定上限（在第五节讲）

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

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);
}
public static <T> void fromArrayToCollection(T[] a, Collection<T> c) {  
    for (T o : a) {
        c.add(o);
    }
}

class Creature{}
class Person extends Creature{}  
class Man extends Person{}  
class PersonTest {
    public static <T extends Person> void test(T t){
        System.out.println(t);
    }
    public static void main(String[] args) {
        test(new Person());
        test(new Man());
        //The method test(T) in the type PersonTest is not
        //applicable for the arguments (Creature)  
        test(new Creature());
    }
}

四、泛型在继承上的体现

// 请输出如下来两段代码有何不同
public void printCollection(Collection c) {
    Iterator i = c.iterator();
    for (int k = 0; k < c.size(); k++) {
        System.out.println(i.next());
    }
}
public void printCollection(Collection<Object> c) { 
    for (Object e : c) {
        System.out.println(e);
    }
}

如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口，G并不是G的子类型！
比如：String是Object的子类，但是List并不是List

Java 编程

第12章泛型

一、为什么要有泛型(Generic)

1、泛型的概念

2、在集合中没有泛型时

3、在集合中有泛型时

二、在集合中使用泛型

三、自定义泛型结构

1、泛型声明与实例化

1.1 泛型的声明

1.2 泛型的实例化

3、自定义泛型方法

四、泛型在继承上的体现

五、通配符的使用

1、有限制的通配符

六、泛型应用举例

第12章 泛型

一、为什么要有泛型(Generic)

1、泛型的概念

2、在集合中没有泛型时

3、在集合中有泛型时

二、在集合中使用泛型

三、自定义泛型结构

1、泛型声明与实例化

1.1 泛型的声明

1.2 泛型的实例化

3、自定义泛型方法

四、泛型在继承上的体现

五、通配符的使用

1、有限制的通配符

六、泛型应用举例

第12章泛型