2021-10-14 模拟斗地主(集合的应用)

目录

需求

思路

程序

一张牌Card类

花色，数字，大小王的常量定义Constant类

扑克牌Poker类

玩家Player类

抓牌主程序

流程：

输出结果

---

需求

用模拟斗地主抓牌的程序整理JAVA集合知识，程序需求如下：

1、生成一副54张的扑克牌，并通过洗牌打乱牌的顺序；
2、三个人玩斗地主：玩家1，玩家2为农民，玩家3为地主；
3、三位玩家分别抓牌，留3只底牌给地主，并展示三位玩家分别拿到的牌。

思路

• 生成54张扑克牌要创建扑克牌的类，类中要创建集合类型的成员变量，放置54张牌。数字有1-13；花色有黑桃，红桃，梅花，方片，大小王。
• 洗牌打乱花色和顺序，要在扑克牌类中提供洗牌的成员方法，调用此成员方法实现大陆安排的顺序。
• 三个玩家的成员变量有姓名，玩家类型等；玩家类需创建集合类型的成员变量，保存玩家拥有的牌。
• 三位玩家抓牌时，要留三张牌给地主，要求玩家类创建抓牌的成员方法，遍历扑克牌对象，农民17张，地主20张。
• 展示三位玩家分别拿到的牌，玩家类里创建显示抓到的牌的成员方法。

程序

一张牌Card类

定义花色和数字

public class Card {

    //花色
    private String color;

    //数字
    private String number = "";

    public Card() {

    }
    
    public Card(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return this.color + this.number;
    }
}

花色，数字，大小王的常量定义Constant类

定义了花色，数字的数组，及大小王

public class Constant {

     //纸牌花色：黑桃，红心，梅花，方块
     static String[] COLORS={"♠","♡","♣","♢"};

     //纸牌数字
     static String[] NUMBERS={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

     static String RED_JOKER="大王";
     static String BLACK_JOKER="小王";
}

扑克牌Poker类

定义了集合类型的成员变量，存放54只牌（单只牌对象），及整副牌的数量。

定义shuffle成员方法，利用Collections工具类的静态方法shuffle随机打乱牌的顺序。

通过重写toString方法，进行扑克牌的遍历输出。

public class Poker {

    private List<Card> cards;

    private Integer cardCount;

    //洗牌
    public void shuffle() {
        Collections.shuffle(this.cards);
    }

    public Poker() {

        List<Card> cardList = new ArrayList<>();
        for (int i = 0; i < Constant.COLORS.length; i++) {
            for (int j = 0; j < Constant.NUMBERS.length; j++) {
                Card card = new Card();
                card.setColor(Constant.COLORS[i]);
                card.setNumber(Constant.NUMBERS[j]);
                cardList.add(card);
            }
        }
        cardList.add(new Card(Constant.RED_JOKER));
        cardList.add(new Card(Constant.BLACK_JOKER));
        this.cards = cardList;
        this.cardCount = cardList.size();
    }

    public List<Card> getCards() {
        return cards;
    }

    public void setCards(List<Card> cards) {
        this.cards = cards;
    }

    public Integer getCardCount() {
        return cardCount;
    }

    @Override
    public String toString() {
        String poker = "[";
        Iterator<Card> iterator = this.cards.iterator();
        while (iterator.hasNext()) {
            poker += iterator.next().toString()+",";
        }
        poker += "]";
        return poker;
    }
}

玩家Player类

定义了成员变量name与type，定并义集合类型的成员变量存放玩家抓到的牌。

定义draw成员方法，将抓到的牌放入成员变量cards中。

通过重写toString方法，进行玩家手上抓到的牌的遍历输出。

public class Player {

    // 玩家姓名
    private String name;

    // 玩家类型：农民/地主
    private String type;

    //抓到的牌
    private List<Card> cards;

    //抓牌
    public void draw(Card card) {
        this.cards.add(card);
    }

    public Player(String name, String type) {
        this.name = name;
        this.type = type;
        this.cards = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public List<Card> getCards() {
        return cards;
    }

    public void setCards(List<Card> cards) {
        this.cards = cards;
    }

    @Override
    public String toString() {
        String poker = "[";
        Iterator<Card> iterator = this.cards.iterator();
        while (iterator.hasNext()) {
            poker += iterator.next().toString() + ",";
        }
        poker += "]";
        return this.getType() + ":" + this.getName() + "抓到" + this.cards.size() + "牌：" + poker;
    }
}

抓牌主程序

流程：

1. 生成一副新的扑克牌
2. 洗牌
3. 生成三个玩家：两个农民，一个地主
4. 轮流抓牌，直到剩余三只底牌
5. 地主抓底牌
6. 分别展示三个玩家手上抓到的牌

public class PlayDemo {

    public static void main(String[] args) {

        //生成一副扑克牌并洗好牌
        Poker poker = new Poker();
        poker.shuffle();
        System.out.println("扑克牌共" + poker.getCardCount() + "只:" + poker.toString());

        //生成三个玩家，并设定两人为农民，一个为地主
        int playCount = 3;
        Player player1 = new Player("玩家1", "农民");
        Player player2 = new Player("玩家2", "农民");
        Player player3 = new Player("玩家2", "地主");

        //三个玩家按顺序抓牌
        int i;
        for (i = 0; i < poker.getCardCount() - playCount; i++) {
            if (i % playCount == 0) {
                player1.draw(poker.getCards().get(i));
            } else if (i % playCount == 1) {
                player2.draw(poker.getCards().get(i));
            } else if (i % playCount == 2) {
                player3.draw(poker.getCards().get(i));
            }
        }

        //地主拿剩余底牌
        while (i < poker.getCardCount()) {
            player3.draw(poker.getCards().get(i));
            i++;
        }

        //展示三个玩家拿到的牌
        System.out.println(player1.toString());
        System.out.println(player2.toString());
        System.out.println(player3.toString());

    }

}