**## 3.1** **泛型概述**
在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
大家观察下面代码：
~~~java
public class GenericDemo {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("abc");
        coll.add("itcast");
        coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
        Iterator it = coll.iterator();
        while(it.hasNext()){
            //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
            String str = (String) it.next();
            System.out.println(str.length());
        }
    }
}
~~~
程序在运行时发生了问题****java.lang.ClassCastException****。 为什么会发生类型转换异常呢？ 我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢？ Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后，新增了********泛型********(****Generic****)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

* ********泛型********：可以在类或方法中预支地使用未知的类型。
\> tips:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

**## 3.2** **使用泛型的好处**
上一节只是讲解了泛型的引入，那么泛型带来了哪些好处呢？
* 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
* 避免了类型强转的麻烦。
通过我们如下代码体验一下：
~~~java
public class GenericDemo2 {
    public static void main(String[] args) {
Collection\<String\> list = new ArrayList\<String\>();
list.add("abc");
list.add("itcast");
// list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
Iterator\<String\> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator\<String\>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
    }
}
~~~
\> tips:泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

**## 3.3** **泛型的定义与使用**
我们在集合中会大量使用到泛型，这里来完整地学习泛型知识。
泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
**###** **定义和使用含有泛型的类**
定义格式：
~~~
修饰符 class 类名\<代表泛型的变量\> { }
~~~
例如，API中的ArrayList集合：
~~~java
class ArrayList\<E\>{
public boolean add(E e){ }
public E get(int index){ }
 ....
}
~~~
使用泛型： 即什么时候确定泛型。

**在创建对象的时候确定泛型**
例如，`ArrayList\<String\> list = new ArrayList\<String\>();`
此时，变量E的值就是String类型,那么我们的类型就可以理解为：
~~~java
class ArrayList\<String\>{
public boolean add(String e){ }
public String get(int index){ }
...
}
~~~
再例如，`ArrayList\<Integer\> list = new ArrayList\<Integer\>();`
此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：
~~~java
class ArrayList\<Integer\> {
public boolean add(Integer e) { }
public Integer get(int index) { }
...
}
~~~
举例自定义泛型类
~~~java
public class MyGenericClass\<MVP\> {
    //没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    private MVP mvp;
public void setMVP(MVP mvp) {
this.mvp = mvp;
}
public MVP getMVP() {
return mvp;
}
}
~~~
使用:
~~~java
public class GenericClassDemo {
  public static void main(String[] args) {        
// 创建一个泛型为String的类
MyGenericClass\<String\> my = new MyGenericClass\<String\>();   
// 调用setMVP
my.setMVP("大胡子登登");
// 调用getMVP
String mvp = my.getMVP();
System.out.println(mvp);
//创建一个泛型为Integer的类
MyGenericClass\<Integer\> my2 = new MyGenericClass\<Integer\>();
my2.setMVP(123);     
Integer mvp2 = my2.getMVP();
}
}

~~~
**###** **含有泛型的方法**
定义格式：
~~~
修饰符 \<代表泛型的变量\> 返回值类型 方法名(参数){ }
~~~
例如，
~~~java
public class MyGenericMethod {  
public \<MVP\> void show(MVP mvp) {
    System.out.println(mvp.getClass());
}
public \<MVP\> MVP show2(MVP mvp) {   
    return mvp;
}
}
~~~
使用格式：********调用方法时，确定泛型的类型********
~~~java
public class GenericMethodDemo {
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
mm.show(12.45);
}
}
~~~
**###** **含有泛型的接口**
定义格式：
~~~
修饰符 interface接口名\<代表泛型的变量\> { }
~~~
例如，
~~~java
public interface MyGenericInterface\<E\>{
    public abstract void add(E e);
    
    public abstract E getE();
}
~~~
使用格式：
****1****、定义类时确定泛型的类型********
例如
~~~java
public class MyImp1 implements MyGenericInterface\<String\> {
    @Override
public void add(String e) {
// 省略...
}
    @Override
    public String getE() {
        return null;
    }
}
~~~
此时，泛型E的值就是String类型。
****2****、始终不确定泛型的类型，直到创建对象时，确定泛型的类型********
例如
~~~java
public class MyImp2\<E\> implements MyGenericInterface\<E\> {
    @Override
    public void add(E e) {
  // 省略...
    }
    @Override
    public E getE() {
        return null;
    }
}
~~~
确定泛型：
~~~java
/*
* 使用
*/
public class GenericInterface {
public static void main(String[] args) {
MyImp2\<String\> my = new MyImp2\<String\>();
my.add("aa");
}
}
~~~

**## 3.4** **泛型通配符**
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符\<?\>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
**####** **通配符基本使用**
泛型的通配符:********不知道使用什么类型来接收的时候****,****此时可以使用****?,?****表示未知通配符。********
此时只能接受数据,不能往该集合中存储数据。
~~~java
public static void main(String[] args) {
Collection\<Intger\> list1 = new ArrayList\<Integer\>();
getElement(list1);
Collection\<String\> list2 = new ArrayList\<String\>();
getElement(list2);
}
public static void getElement(Collection\<?\> coll){}
//？代表可以接收任意类型
~~~
\> tips:泛型不存在继承关系 Collection\<Object\> list = new ArrayList\<String\>();这种是错误的。

**####** **通配符高级使用****----****受限泛型**
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的********上限********和********下限********。
********泛型的上限********：
* ********格式********： `类型名称 \<? extends 类 \> 对象名称`
* ********意义********： `只能接收该类型及其子类`
********泛型的下限********：
- ********格式********： `类型名称 \<? super 类 \> 对象名称`
- ********意义********： `只能接收该类型及其父类型`
比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类
~~~java
public static void main(String[] args) {
Collection\<Integer\> list1 = new ArrayList\<Integer\>();
Collection\<String\> list2 = new ArrayList\<String\>();
Collection\<Number\> list3 = new ArrayList\<Number\>();
Collection\<Object\> list4 = new ArrayList\<Object\>();
getElement(list1);
getElement(list2);//报错
getElement(list3);
getElement(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection\<? extends Number\> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection\<? super Number\> coll){}
~~~

**#** **第四章** **集合综合案例**
**## 4.1** **案例介绍**
按照斗地主的规则，完成洗牌发牌的动作。
具体规则：
使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
**## 4.2** **案例分析**
* 准备牌：
牌可以设计为一个ArrayList\<String\>,每个字符串为一张牌。
每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
牌由Collections类的shuffle方法进行随机排序。
* 发牌
将每个人以及底牌设计为ArrayList\<String\>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

* 看牌
直接打印每个集合。
**## 4.3** **代码实现**
~~~java
import java.util.ArrayList;
import java.util.Collections;
public class Poker {
public static void main(String[] args) {
/*
* 1: 准备牌操作
*/
//1.1 创建牌盒 将来存储牌面的
ArrayList\<String\> pokerBox = new ArrayList\<String\>();
//1.2 创建花色集合
ArrayList\<String\> colors = new ArrayList\<String\>();
//1.3 创建数字集合
ArrayList\<String\> numbers = new ArrayList\<String\>();
//1.4 分别给花色 以及 数字集合添加元素
colors.add("♥");
colors.add("♦");
colors.add("♠");
colors.add("♣");
for(int i = 2;i\<=10;i++){
numbers.add(i+"");
}
numbers.add("J");
numbers.add("Q");
numbers.add("K");
numbers.add("A");
//1.5 创造牌 拼接牌操作
// 拿出每一个花色 然后跟每一个数字 进行结合 存储到牌盒中
for (String color : colors) {
//color每一个花色
//遍历数字集合
for(String number : numbers){
//结合
String card = color+number;
//存储到牌盒中
pokerBox.add(card);
}
}
//1.6大王小王
pokerBox.add("小☺");
pokerBox.add("大☠"); 
// System.out.println(pokerBox);
//洗牌 是不是就是将 牌盒中 牌的索引打乱
// Collections类 工具类 都是 静态方法
// shuffer方法
/*
* static void shuffle(List\<?\> list)
* 使用默认随机源对指定列表进行置换。
*/
//2:洗牌
Collections.shuffle(pokerBox);
//3 发牌
//3.1 创建 三个 玩家集合 创建一个底牌集合
ArrayList\<String\> player1 = new ArrayList\<String\>();
ArrayList\<String\> player2 = new ArrayList\<String\>();
ArrayList\<String\> player3 = new ArrayList\<String\>();
ArrayList\<String\> dipai = new ArrayList\<String\>();  
//遍历 牌盒 必须知道索引
for(int i = 0;i\<pokerBox.size();i++){
//获取 牌面
String card = pokerBox.get(i);
//留出三张底牌 存到 底牌集合中
if(i\>=51){//存到底牌集合中
dipai.add(card);
} else {
//玩家1 %3 ==0
if(i%3==0){
  player1.add(card);
}else if(i%3==1){//玩家2
  player2.add(card);
}else{//玩家3
  player3.add(card);
}
}
}
//看看
System.out.println("令狐冲："+player1);
System.out.println("田伯光："+player2);
System.out.println("绿竹翁："+player3);
System.out.println("底牌："+dipai);
    }
}
~~~