模拟鬥地主抓牌的程式整理JAVA集合知識點

文章目錄

• ​​一、需求​​
• ​​二、分析​​
• ​​三、程式結構​​
• ​​四、代碼解析​​

• ​​1、單隻牌的類​​
• ​​2、常量定義​​
• ​​3、撲克牌類​​
• ​​4、玩家類​​
• ​​5、抓牌主程式​​
• ​​6、程式輸出​​

一、需求

用模拟鬥地主抓牌的程式整理JAVA集合知識，程式需求如下：

1、生成一副54張的撲克牌，并通過洗牌打亂牌的順序；

2、三個人玩鬥地主：玩家1，玩家2為農民，玩家3為地主；

3、三位玩家分别抓牌，留3隻底牌給地主，并展示三位玩家分别拿到的牌。

二、分析

• 生成一副54張的撲克牌

  -需建立撲克牌的類，類中需建立集合類型的成員變量，放置54張牌，每張牌有花色和數字（例如黑桃2，紅桃K，大王等）。

• 并通過洗牌打亂牌的花色和順序
• 在撲克牌類中需提供洗牌的成員方法，調用此成員方法實作打亂牌的順序。

• 三個人玩鬥地主

  需建立玩家類，玩家有成員變量姓名、玩家類型等；玩家類需建立集合類型的成員變量，放置抓到的牌。

• 三位玩家分别抓牌，留3隻底牌給地主

  玩家類需建立抓牌的成員方法；并周遊撲克牌對象，農民抓17隻牌，地主再多抓最後3隻底牌。

• 展示三位玩家分别拿到的牌

  玩家類需提供顯示抓到的牌的成員方法。

三、程式結構

四、代碼解析

1、單隻牌的類

單隻牌的類中定義了花色（黑桃、紅心等）和數字（2，10，K等）

/**
 * 單隻牌
 *
 * @author zhuhuix
 * @date 2020-04-27
 */
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;
    }
}      

2、常量定義

常量類中定義了花色，數字的數組，及大小王。

/**
 * 常量
 *
 * @author zhuhuix
 * @date 2020-04-27
 */
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="小王";
}      

3、撲克牌類

撲克牌類中定義了集合類型的成員變量，存放54隻牌（單隻牌對象），及整副牌的數量。

定義shuffle成員方法，利用Collections工具類的靜态方法shuffle随機打亂牌的順序。

通過重寫toString方法，進行撲克牌的周遊輸出。

/**
 * 整副撲克牌
 *
 * @author zhuhuix
 * @date 2020-04-27
 */
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;
    }
}      

4、玩家類

玩家類中定義了成員變量name與type，定并義集合類型的成員變量存放玩家抓到的牌。

定義draw成員方法，将抓到的牌放入成員變量cards中。

通過重寫toString方法，進行玩家手上抓到的牌的周遊輸出。

/**
 * 玩家
 *
 * @author zhuhuix
 * @date 2020-04-27
 */
public class Player {

    /**
     * 玩家姓名
     */
    private String name;

    /**
     * 玩家類型：農民/地主
     */
    private String type;

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

    /**
     * 抓牌
     *
     * @param card 單隻牌
     */
    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;
    }
}      

5、抓牌主程式

1. 生成一副新的撲克牌
2. 洗牌
3. 生成三個玩家：兩個農民，一個地主
4. 輪流抓牌，直到剩餘三隻底牌
5. 地主抓底牌
6. 分别展示三個玩家手上抓到的牌

/**
 * 用鬥地主發牌程式演練集合執行個體
 *
 * @author zhuhuix
 * @date 2020-4-27
 */
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());

    }

}      

6、程式輸出