基于Java实现炸金花扑克游戏

炸金花的牌型有6种，从大到小依次为：

1.豹子。也就是三张完全一样的牌，其中三个A是最大的，三个2是最小的。

2.同花顺。指的是三张牌，上面的点数是连续排列的，而且花色相同。最大的牌型是AKQ，最小的牌型是A23.

3.同花。指的是三张牌，花色完全相同。其中牌型最大的是AKQ，最小的是352。

4.顺子。指的是三张牌牌面上的点数是连续的，但是花色不同。其中AKQ最大，A23最小。

5.对子。指的是三张牌中有两张牌是一对，也就是点数相同。盘面最大的是AAK，最小的是223。

6.单张牌。出现单张牌的情况下，最大的牌是AKJ，最小的是352。

了解炸金花的牌型后，我们先创建扑克牌Card.java，代码如下：

//扑克牌
public class Card {
    private int color;
    private int number;

    public Card() {
    }

    public Card(int color, int number) {
        this.color = color;
        this.number = number;
    }

    public int getColor() {
        return color;
    }

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

    public int getNumber() {
        return number;
    }

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

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

//对花色进行字符化，黑桃最大，方块最小，
    private String colorToString(int i){
        String flower = null;
        switch (i){
            case 1:
                flower = "方块";
                break;
            case 2:
                flower = "梅花";
                break;
            case 3:
                flower = "红心";
                break;
            case 4:
                flower = "黑桃";
                break;
        }
        return flower;
    }
//对扑克牌的JQKA进行字符化，A为14，K为13，Q为12，J为11
    private String numberToString(int i){
        String num = null;
        switch (i){
            case 11:
                num = "J";
                break;
            case 12:
                num = "Q";
                break;
            case 13:
                num = "K";
                break;
            case 14:
                num = "A";
                break;
            default:
                if (i >= 2 && i <= 10) {
                    num = new Integer(i).toString();
                }else
                    num = "3";
        }
        return num;
    }
}

创建扑克牌后，创建Cards.java，我们就要把52张扑克牌初始化出来，然后加入到集合当中，代码如下所示：

import java.util.*;

//扑克牌
public class Cards {
    public List<Card> initCards(){                      //将52张牌创建并加入List集合中
        List<Card> list = new ArrayList<>();            //创建List集合
        for (int i = 1; i < 5; i++) {                   //i对应为花色
            for (int j = 2; j < 15; j++) {              //j对应为数字
                Card card = new Card();                 //在循环中创建扑克牌对象，该代码执行4*13=52次
                card.setColor(i);                       //设置扑克牌花色
                card.setNumber(j);                      //设置扑克牌数字
                list.add(card);                         //将扑克牌加入List集合
            }
        }
        return list;
    }
}

然后将52张牌进行洗牌（打乱），代码如下：

  //洗牌
    public List<Card> shuffle(List<Card> list){
        List<Card> slist = new ArrayList<>();            //创建List集合,保存洗牌后的扑克
        Random random = new Random();
        while (list.size() > 0){
            int r = random.nextInt(list.size());        //生成正整型的随机数
            Card card = list.remove(r);                 //返回list中，随机数位置的元素并且移除对应位置的元素
            slist.add(card);
        }
        return slist;
    }

洗完牌后，对牌进行排序，代码如下：

  //对手牌进行排序
    public List<Card> playListSort(List<Card> playList){
        playList.sort(new Comparator<Card>() {
            @Override
            public int compare(Card c1, Card c2) {
                return c1.getNumber() - c2.getNumber();
            }
        });
        return playList;
    }

接下来就要对牌型进行判断，判断牌型是否为豹子，代码如下：

//判断牌型是否为豹子（三张牌的数字都是一致的）
    public boolean isTheSameNumber(List<Card> playList){
        if (playList != null && playList.size() == 3){
            if (playList.get(0).getNumber() == playList.get(1).getNumber()
            && playList.get(1).getNumber() == playList.get(2).getNumber()){
                return true;
            }else{
                return false;
            }
        }else {
            System.err.println("手牌不符合规则");
            throw new RuntimeException("手牌不符合规则");
        }
    }

判断牌型是否为同花，代码如下：

  //判断牌型是否为同花（三张牌的牌色都是一致的）
    public boolean isFlushColor(List<Card> playList) {
        if (playList != null && playList.size() == 3){
            if (playList.get(0).getColor() == playList.get(1).getColor()
                    && playList.get(1).getColor() == playList.get(2).getColor()){
                return true;
            }else{
                return false;
            }
        }else {
            System.err.println("手牌不符合规则");
            throw new RuntimeException("手牌不符合规则");
        }
    }

判断牌型是否为顺子，代码如下：

//判断牌型是否为顺子（三张牌的数字是连续的） （2 3 A）也为顺子
    public boolean isStraight(List<Card> playList) {
        if (playList != null && playList.size() == 3){
            if ((playList.get(0).getNumber() + 1 == playList.get(1).getNumber()
                    && playList.get(1).getNumber() + 1 == playList.get(2).getNumber())
            || (playList.get(2).getNumber() == 14 && playList.get(0).getNumber() == 2 && playList.get(1).getNumber() == 3)){
                return true;
            }else{
                return false;
            }
        }else {
            System.err.println("手牌不符合规则");
            throw new RuntimeException("手牌不符合规则");
        }
    }

判断是否为对子，代码如下：

//判断牌型是否为对子（三张牌中有两张牌为相同）
    public boolean isPair(List<Card> playList){
        if (playList != null && playList.size() == 3){
            if (playList.get(0).getNumber() == playList.get(1).getNumber()
                    && playList.get(1).getNumber() == playList.get(2).getNumber()){
                return false;
            }else {
                if (playList.get(0).getNumber() == playList.get(1).getNumber()
                || playList.get(1).getNumber() == playList.get(2).getNumber()){
                    return true;
                }
                return false;
            }
        }
        else {
            System.err.println("手牌不符合规则");
            throw new RuntimeException("手牌不符合规则");
        }
    }

紧接着创建玩家类Player.java，代码如下：

import java.util.*;

//玩家
public class Player {
    private String name;                    //玩家姓名
    private List<Card> handCards;           //玩家手牌
    private int grade;                      //牌型等级

    public Player() {
    }

    public Player(String name, List<Card> handCards, int grade) {
        this.name = name;
        this.handCards = handCards;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

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

    public List<Card> getHandCards() {
        return handCards;
    }

    public void setHandCards(List<Card> handCards) {
        this.handCards = handCards;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    @Override
    public String toString() {
        String h = "";
        for (int i = 0; i < this.handCards.size(); i++) {
            h += this.handCards.get(i).toString();
        }
        return this.name + ":" + h;
    }
}

紧接着来编写扑克牌游戏类PokerGame.java,代码如下：

import java.util.*;

public class PokerGame {
    private Player p1;                                  //玩家1
    private Player p2;                                  //玩家2

    public void startPlayingCards(){                    //开始游戏

        p1 = new Player();                              //创建玩家
        p1.setName("Liu");

        p2 = new Player();                              //创建玩家
        p2.setName("Li");

        Cards cards = new Cards();                      //创建扑克牌
        List<Card> list = cards.initCards();

        List<Card> slist = cards.shuffle(list);         //洗牌

        List<Card> playlist1 = new ArrayList<>();        //发牌
        for (int i = 0; i < 3; i++) {
            Card card = slist.remove(0);
            playlist1.add(card);
            p1.setHandCards(playlist1);
        }

        List<Card> playlist2 = new ArrayList<>();        //发牌
        for (int i = 0; i < 3; i++) {
            Card card = slist.remove(0);
            playlist2.add(card);
            p2.setHandCards(playlist2);
        }

        List<Card> card1 = cards.playListSort(p1.getHandCards());       //手牌排序
        p1.setHandCards(card1);

        List<Card> card2 = cards.playListSort(p2.getHandCards());       //手牌排序
        p2.setHandCards(card2);
    }

    //查看玩家手中的牌
    public void showPlayer(){
        String cardType1 = this.getCardType(p1);
        String cardType2 = this.getCardType(p2);

        System.out.println(p1.toString() + " 牌型为:" + cardType1);
        System.out.println(p2.toString() + " 牌型为:" + cardType2);
    }

    //判断手中牌型
    private String getCardType(Player p){
        List<Card> cardList = p .getHandCards();
        Cards cards = new Cards();
        String cardType = "单张";

        if (cards.isTheSameNumber(cardList)){
            cardType = "豹子";
            p.setGrade(6);
            return cardType;
        }

        if (cards.isFlushColor(cardList)){
            if (cards.isStraight(cardList)){
                cardType = "同花顺";
                p.setGrade(5);
                return cardType;
            }else {
                cardType = "同花";
                p.setGrade(4);
                return cardType;
            }
        }else {
            if (cards.isStraight(cardList)){
                cardType = "顺子";
                p.setGrade(3);
                return cardType;
            }
        }

        if (cards.isPair(cardList)){
            cardType = "对子";
            p.setGrade(2);
            return cardType;
        }

        p.setGrade(1);
        return cardType;
    }

    //判断手牌大小
    public Player getWinner(){
        int grade1 = p1.getGrade();
        int grade2 = p2.getGrade();

        Player winner = grade1 > grade2 ? p1 : p2;
        if (grade1 != grade2){
            return grade1 > grade2 ? p1 : p2;
        }
        switch (grade1){
            case 6:                     //豹子
                winner =  p1.getHandCards().get(0).getNumber() > p2.getHandCards().get(0).getNumber() ? p1 : p2;
                break;
            case 5:                    //同花顺
            case 3:                    //顺子
                winner =  p1.getHandCards().get(0).getNumber() > p2.getHandCards().get(0).getNumber() ? p1 : p2;
                break;
            case 4:                    //同花
            case 1:                    //单张
             if (p1.getHandCards().get(2).getNumber() > p2.getHandCards().get(2).getNumber()){
                 winner = p1;
             }else if (p1.getHandCards().get(2).getNumber() == p2.getHandCards().get(2).getNumber()){
                 if (p1.getHandCards().get(1).getNumber() > p2.getHandCards().get(1).getNumber()){
                     winner = p1;
                 }else if (p1.getHandCards().get(1).getNumber() == p2.getHandCards().get(1).getNumber()){
                     if (p1.getHandCards().get(0).getNumber() > p2.getHandCards().get(0).getNumber()){
                         winner = p1;
                     }else if (p1.getHandCards().get(0).getNumber() == p2.getHandCards().get(0).getNumber()){
                         winner = p2;
                     }else {winner = p2;}
                 }else {winner = p2;}
             }else {winner = p2;}
             break;
            case 2:                 //对子
                winner =  p1.getHandCards().get(1).getNumber() > p2.getHandCards().get(1).getNumber() ? p1 : p2;
                break;
        }

        return winner;
    }
}

最后编写Test.java，代码如下：

public class Test {
    public static void main(String[] args) {
      PokerGame pokerGame = new PokerGame();
      pokerGame.startPlayingCards();
      pokerGame.showPlayer();

      Player winner = pokerGame.getWinner();
        System.out.println("获胜者为:"+ winner.getName());
    }
}

效果图，如下

编写该实例，可以能够更好的学习到面向对象属性封装、对象数组创建、对象数组排序、对象根据属性大小比较等功能，能够更好的提升语法熟练度，以及思维能力。

源码：https://github.com/shijian08/FriedGoldenFlower