0x00 泛型

1.概述

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。

泛型也可以看出是一个变量，用来接收数据类型

E e:Element 元素

T t:Type 类型

例如：ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型。

E：未知的数据类型

创建集合对象的时候，就会确定泛型的数据类型

2.使用泛型的好处

package day23;

import java.util.ArrayList;

import java.util.Iterator;

public class Demo01 {

public static void main(String[] args) {

}

/*

创建集合对象，不使用泛型

好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。

弊端：不安全，会引发异常。

*/

private static void show1(){

ArrayList list = new ArrayList();

list.add("adb");

list.add(1);

//使用迭代器遍历list集合

Iterator it = list.iterator();

while (it.hasNext()) {

Object obj = it.next();

System.out.println(obj);

//想要使用String类特有的方法，length获取字符串长度，需要向下转型。

//而在这时，会抛出类型转换一场，不能把Integer类型转换成String类型。

String s = (String)obj;

System.out.println(s.length());

}

}

/*

创建集合对象，使用泛型

好处：

1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。

2.把运行期异常(代码运行之后会抛出的异常)，提升到了编译器(写代码的时候会报错)。

弊端：

泛型是什么类型，只能存储什么类型的数据。

*/

private static void show2(){

ArrayList list = new ArrayList<>();

list.add("abc");

//使用迭代器遍历list集合

Iterator it = list.iterator();

while(it.hasNext()){

}

}

3.泛型的定义和使用

定义含有泛型的方法：泛型定义在方法和修饰符和返回值类型之间

格式：

修饰符 返回值类型 方法名(参数列表(使用泛型))｛

方法体；

｝

含有泛型的方法，在调用方法的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型。

4.含有泛型的接口的定义和使用

含有泛型的接口第一种使用方式：定义接口的实现类，视线接口，指定接口的泛型。

public interface Iterator{

E next();

}

Scanner类视线了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String

public final class Scanner implements Iterator{

public String next() { }

}

含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走。

public interface list{

boolean add(E e);

E get(int index);

}

public class ArrayListimplements List{

public boolean add(E e) {}

public E get(int index) {}

}

5.泛型通配符

泛型的通配符：

？：代表任意的数据类型

使用方式：

不能创建对象使用

只能作为方法的参数使用

使用环境

定义一个方法，能遍历所有类型的ArrayList集合。

这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符?来接受数据类型。

注意：泛型没有继承概念

0x01 斗地主案例

斗地主综合案例要求：

以斗地主的规则，完成洗牌和发牌的动作。

案例完成思路

准备牌：54张牌，存储到一个集合中。

特殊牌：大王，小王

其他52张牌：

定义一个数组/集合，存储四种花色：黑桃、红桃、梅花、方块。

定义一个数组/集合，存储13个序号A，2，3...K。

循环嵌套遍历两个数组/集合，组装52张牌。

洗牌

使用集合工具类Collection的方法

static void shuffle(List>list)使用指定的随即元对指定列表进行置换。

会随机的打乱集合中元素的顺序。

发牌

要求：1人17张牌，剩余3张作为底牌，一人一张轮流发牌：集合的索引(0-53)%3

定义4个集合，存储3个玩家的牌和底牌

索引%2，有两个值(0，1)0%2=0 1%2=1 2 2%2=0 3%2=1。

索引%3，有三个值(0，1，2)0%3=0 1%3=1 2%3=2 3%3=0。

索引>=51，该底牌发牌。

看牌

直接打印集合，遍历存储玩家和底牌的集合。

代码实现

package day23;

/*

斗地主综合案例：

1. 准备牌

2. 洗牌

3. 发牌

4. 看牌

*/

import javafx.print.Collation;

import javax.lang.model.element.NestingKind;

import java.util.ArrayList;

import java.util.Collections;

public class doudizhu01 {

public static void main(String[] args) {

// 1.准备牌

//定义一个存储54张牌的ArrayList集合，泛型使用String

ArrayList poker = new ArrayList<>();

// 定义一个数组，一个数组存储牌的花色，一个数组存储牌的序号。

String[] colors = {"♠","♥","♣","♦"};

String[] numbers = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

//先把大王和小王存储到poker集合中

poker.add("大王");

poker.add("小王");

//循环嵌套遍历两个数组，组装52张牌

for (String number:numbers){

for (String color : colors){

// System.out.println(color+number);

poker.add(color+number);

}

}

// 2.洗牌

//使用集合的工具类Collections种的方法

//static void shuffle(list> list)使用默认随机源对指定列表进行置换。

Collections.shuffle(poker);

// 3.发牌

//定义四个集合，存储玩家的牌和底牌。

ArrayList player1 = new ArrayList<>();

ArrayList player2 = new ArrayList<>();

ArrayList player3 = new ArrayList<>();

ArrayList dipai = new ArrayList<>();

/*

遍历poker集合，获取每一张牌

使用poker集合的索引%3给3个玩家轮流发牌

剩余3张牌给底牌

注意：

首先判断底牌是不是大于51张，否则就没有底牌了、

*/

for (int i = 0; i < poker.size(); i++) {

//获取每一张牌

String p = poker.get(i);

//设置发牌循环

if (i>=51){

dipai.add(p);

} else if (i%3 == 1){

player1.add(p);

} else if (i%3 == 2){

player2.add(p);

} else {

player3.add(p);

}

}

// 4.看牌

System.out.println("玩家1的牌："+player1);

System.out.println("玩家2的牌："+player2);

System.out.println("玩家3的牌："+player3);

System.out.println("底牌："+dipai);

}

}