Java学习日志(四): 泛型(Generic),斗地主发牌综合案例(无序模式)

JavaEE学习日志持续更新----> 必看！JavaEE学习路线（文章总汇）

泛型(Generic)

泛型的概述

泛型(Generic):是一种未知的数据类型,当我们不知道什么类型的时候,就可以使用泛型

泛型也可以看成一个变量,用来接收数据类型

• E:element 元素 T:type 类型

集合在定义的时候,并不知道要存储什么类型的元素,使用了泛型
如ArrayList源码：

public class ArrayList<E>{
   public boolean add(E e){}
   public E get(int index){}
 }

创建集合对象的时候,确定集合泛型的类型

ArrayList<Integer> list = new ArrayList<Integer>();
public class ArrayList<Integer>{
  public boolean add(Integer e){}
  public Integer get(int index){}
}

泛型的好处与弊端

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

• 好处:集合的类型为默认的Object类型,可以存储任意对象
• 弊端:不安全,不能使用元素特有的方法

private static void show01() {
    ArrayList list = new ArrayList();
    list.add("aaa");
    list.add(1);
    //使用迭代器遍历集合
    Iterator it = list.iterator();
    while(it.hasNext()){
        //取出集合中元素,Object类型
        Object next = it.next();
        System.out.println(next);
        //想使用字符串特有的方法length
        //不能使用!!!!需向下转型
        //Object obj = "abc";多态
        String s = (String)next;
        System.out.println(s);//ClassCastException
    }
}

创建集合对象,使用泛型

• 好处:想使用元素特有的方法时,避免了类型转换的麻烦把运行时异常,提升到编译时期
• 弊端:只能存储对应类型的数据

private static void show02() {
    ArrayList<String> list = new ArrayList<String>();
    list.add("abc");
    //list.add(1);  编译时期的异常
    //增强for遍历list
    for(String s :list){
        System.out.println(s+":"+s.length());
    }
}

泛型的定义

定义含有泛型的类

什么时候使用泛型:当我们不知道使用什么类型时,可以使用泛型
什么时候确定泛型的数据类型:创建对象的时候

public class GenericClass<E> {
    private E a;

    public E getA() {
        return a;
    }

    public void setA(E a) {
        this.a = a;
    }
}

public class Demo01GenericClass {
    public static void main(String[] args) {
        //创建GenericClass对象,泛型使用Integer
        GenericClass<Integer> gc1 = new GenericClass<>();
        gc1.setA(123);
        Integer a = gc1.getA();
        System.out.println(a);
        //创建GenericClass对象,泛型使用Boolean
        GenericClass<Boolean> gc2 = new GenericClass<>();
        gc2.setA(true);
        Boolean a1 = gc2.getA();
        System.out.println(a1);
    }
}

定义含有泛型的方法(重点)

泛型定义在修饰符和返回值类型之间
格式:

修饰符 <泛型> 返回值类型 方法名(参数列表<使用泛型>){
	方法体;
}

public class GenericMethod {
    //定义一个含有泛型的方法
    public <M> void show(M m){
        System.out.println(m);
    }
    //定义一个含有泛型的静态方法
    public static <S> void show02(S s){
        System.out.println(s);
    }
}

调用方法时确定泛型的数据类型,传递什么类型的参数,泛型就是什么类型

public class Demo01 {
    public static void main(String[] args) {
        //创建GenericMethod对象
        GenericMethod gm = new GenericMethod();
        //调用含有泛型的show方法
        gm.show(1); //泛型就是Integer
        gm.show("123"); //泛型就是String
        gm.show(true);//泛型就是Boolean
        gm.show(2.2);//泛型就是Double

        //调用静态方法
        GenericMethod.show02(1);//泛型就是Integer
        GenericMethod.show02("123");//泛型就是String
    }
}

定义含有泛型的接口

public interface GenericInterface<I> {
    //定义一个抽象方法
    public abstract void show(I i);
}

定义含有泛型接口GenericInterface实现类对象

第一张使用方式:类实现接口的同时,指定接口泛型的数据类型,这样数据类型就确定下来了

public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

第二种使用方式:类实现含有泛型的接口,接口使用什么类型,类就使用什么类型,类跟着接口走,相当于定义了一个含有泛型的类

public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void show(I i) {
        System.out.println(i);
    }
}

public class Demo01 {
    public static void main(String[] args) {
        //创建含有泛型接口GenericInterface实现类GenericInterfaceImpl1的对象
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.show("abc");
        //创建含有泛型接口GenericInterface实现类GenericInterfaceImpl2的对象
        //在创建对象的同时,指定泛型的类型
        GenericInterfaceImpl2<Double> gi2 = new GenericInterfaceImpl2();
        gi2.show(2.2);
        GenericInterfaceImpl2<Integer> gi3 = new GenericInterfaceImpl2();
        gi3.show(3);
    }
}

泛型的通配符

?:代表任意的数据类型
使用方式:

1. 不用创建对象的时候作为泛型使用
2. 作为方法的参数的泛型使用

public class Demo01 {
    public static void main(String[] args) {
        //不能创建对象的时候作为泛型使用
        /*ArrayList<?> list = new ArrayList<>();
        list.add(1);*/

        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);
        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");

        printArrayList(list01);
        printArrayList(list02);
    }
    /*
    * 定义一个方法,对ArrayList集合进行遍历
    * 要求:可以遍历任意数据类型的ArrayList集合
    * */
    public static void printArrayList(ArrayList<?> list){
        //使用迭代器遍历集合,迭代器的泛型和集合一样
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            //取出元素,Object类型
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

泛型的上限与下限的限定:

• 泛型上限限定: ? extends E 代表使用的泛型只要是E类型的子类/本身即可
• 泛型下限限定: ? super E 代表使用的泛型只要是E类型的父类/本身即可

类与类之间的继承关系:

• Integer extends Number extends Object
• String extends Object

public class Demo02 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();

        getElement1(list1);
        //getElement1(list2);//报错   String和Number没有关系
        getElement1(list3);
        //getElement1(list4);//报错   Number的父类无法传递

        //getElement2(list1);//报错   Number的子类无法传递
        //getElement2(list2);//报错   String和Number没有关系
        getElement2(list3);
        getElement2(list4);
    }
    //泛型的上限:此时的泛型?,必须是Number类型或Number类型的子类
    private static void getElement1(Collection<? extends Number> coll) {}
    //泛型的下限:此时的泛型?,必须是Number类型或Number类型的父类
    private static void getElement2(Collection<? super Number> coll) {}
}

斗地主发牌综合案例(无序模式)

1 案例介绍
按照斗地主的规则，完成洗牌发牌的动作。 具体规则： 使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，后三张留作底牌。

2 案例分析
(1) 准备牌: 牌可以设计为一个ArrayList,每个字符串为一张牌。 每张牌由花色数字两部分组成，我们可以使用花色 集合与数字集合嵌套迭代完成每张牌的组装。
(2) 洗牌: 牌由Collections类的shuffle方法进行随机排序。
(3) 发牌: 将每个人以及底牌设计为ArrayList,将后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
(4) 看牌: 直接打印每个集合。

import java.util.ArrayList;
import java.util.Collections;

/*
* 斗地主综合案例
*   1.准备牌
*   2.洗牌
*   3.发牌
*   4.看牌
*
* */
public class DouDiZhu {
    public static void main(String[] args) {
        //1.准备牌
        //定义一个集合,存储54张牌
        ArrayList<String> poker = new ArrayList<String>();
        //先存储大王小王
        poker.add("大王");
        poker.add("小王");
        //定义两个数组,一个存储花色,一个存储序号
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        //循环嵌套遍历两个数组,组装52张牌
        for (String number : numbers) {
            for (String color : colors) {
                //System.out.println(color+number);
                //把组装好的牌放到集合中
                poker.add(color+number);
            }
        }
        //System.out.println(poker);
        /*
        * 2.洗牌
        * 使用Collection集合工具类中的方法
        *   static void shuffle(list<?> list)   使用默认随机源对指定列表进行置换
        *
        * */
        Collections.shuffle(poker);
        //System.out.println(poker);
        /*
        * 3.发牌
        * 定义4个集合,存储玩家的牌和底牌
        * */
        ArrayList<String> player01 = new ArrayList<>();
        ArrayList<String> player02 = new ArrayList<>();
        ArrayList<String> player03 = new ArrayList<>();
        ArrayList<String> diPai = new ArrayList<>();
        //遍历poker集合,获取每一张牌
        for (int i = 0; i < poker.size(); i++) {
            String pai = poker.get(i);
            //先判断底牌,否则就发没有了
            if(i>=51){
                //给底牌发牌
                diPai.add(pai);
            }else if(i%3==0){
                //给玩家1发牌
                player01.add(pai);
            }else if(i%3==1){
                //给玩家2发牌
                player02.add(pai);
            }else if(i%3==2){
                //给玩家3发牌
                player03.add(pai);
            }
        }
        /*
        * 4.看牌
        * */
        System.out.println("玩家一:"+player01);
        System.out.println("玩家二:"+player02);
        System.out.println("玩家三:"+player03);
        System.out.println("底牌:"+diPai);
    }
}