0x00　　簡述

使用列舉型別對一副撲克牌（52張牌，不包括大小王）建模：
一副撲克牌有四種花色（Suit）：HEART,SPADE,DIAMOND,CLUB；
有十三種等級(Rank)：ACE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE,TEN,JACK,QUEEN,KING;
建立2個列舉型別包含這兩類例項。
每張撲克牌（Card）物件都會有這兩個屬性，建立一個帶有這兩個列舉型別屬性的類Card。

0x01　　為每個花色及大小建模

建立一個Poker類，為花色和大小分別建立兩個列舉集。

public class Poker {
    enum Suit{HEART("♥",1),SPADE("♠",2),DIAMOND("♦",3),CLUB("♣",4);

        public String s;
        public int i;

        Suit(String s,int i) {
            this.s=s;
            this.i=i;
        }

        public String getS() {
            return s;
        }

        public int getI() {
            return i;
        }
    }
    enum Rank{TWO("2",2),THREE("3",3),FOUR("4",4),FIVE("5",5),SIX("6",6),SEVEN("7",7),EIGHT("8",8),NINE("9",9),TEN("10",10),JACK("J",11),QUEEN("Q",12),KING("K",13),ACE("A",14);

        public String r;
        public int i;

        Rank(String r,int i) {
            this.r=r;
            this.i=i;
        }

        public String getR() {
            return r;
        }

        public int getI() {
            return i;
        }
    }
}



 

這樣，我們就有了建立一張牌的介面。

0x02　　建立一張單牌

建立一個Card類，用來表明和獲取一張牌的花色大小。

public class Card {
    public  Poker.Rank rank;
    public  Poker.Suit suit;
    public Card(Poker.Suit suit,Poker.Rank rank){
        this.rank=rank;
        this.suit=suit;
    }

    public Poker.Rank getRank() {
        return rank;
    }

    public Poker.Suit getSuit() {
        return suit;
    }

    @Override
    public String toString() {
        return suit.getS()+rank.getR();
    }

}

 

在上述程式碼中，使用toString()方法即可獲得該卡的資訊。

0x03　　判斷五張牌組成的套牌大小

根據德州撲克的玩法介紹，五張牌的花色大小決定這套牌的大小，所以我們寫一個方法為每套牌計算權重。

import java.util.Arrays;
import java.util.Comparator;

class CardSet implements Comparable {

    public Card[] cards = new Card[5];

    public CardSet(Card[] cards) {
        this.cards = cards;
        Arrays.sort(cards, new cmp());
    }

    public String getCard() {
        for(int i=0;i<5;i++) {
            System.out.print(cards[i].getSuit().s + cards[i].getRank().r+",");
        }
        return (" ");
    }

    public int getHigh() {
        int max = 0;
        for (Card c : cards) {
            if (c.getRank().getI() > max)
                max = c.getRank().getI();
            if (c.getRank().getI() == 1)
                max = 14;
        }
        return max;
    }

    public int getPair() {
        int res = 0;
        for(int i=0;i<5;i++){
            for(int j=i+1;j<5;j++){
                if(cards[i].getRank()==cards[j].getRank())
                    res++;
            }
        }
        return res;
    }

    public boolean isThree() {
        return (getPair()==3);
    }

    public int isStraight() {
        int a = cards[4].getRank().getI() - cards[3].getRank().getI();
        int b = cards[3].getRank().getI() - cards[2].getRank().getI();
        int c = cards[2].getRank().getI() - cards[1].getRank().getI();
        int d = cards[1].getRank().getI() - cards[0].getRank().getI();
        if (a == b && b == c && c == d) {
            return 1;
        } else if (a == b && b == c && d == 0) {
            return 2;
        }
        return 0;
    }

    public boolean isFlush() {
        for (int i = 0; i < 4; i++) {
            if (cards[i].getSuit() != cards[i + 1].getSuit())
                return false;
        }
        return true;
    }

    public boolean isFullHouse() {
        return (getPair() == 4);
    }

    public boolean isFour() {
        return (getPair()==6);
    }

    public boolean isStraightFlush() {
        return (isStraight() == 1) && isFlush();
    }

    public boolean isRoyal() {
        return (isStraight() == 2) && isFlush();
    }

    public int getPoints() {
        if (isRoyal())
            return 23;
        else if (isStraightFlush())
            return 22;
        else if (isFour())
            return 21;
        else if (isFullHouse())
            return 20;
        else if (isFlush())
            return 19;
        else if (isStraight() != 0)
            return 18;
        else if (isThree())
            return 17;
        else if (getPair() == 2)
            return 16;
        else if (getPair() == 1)
            return 15;
        else
            return getHigh();
    }

    public String getName() {
        if (isRoyal())
            return "皇家同花順";
        else if (isStraightFlush())
            return "同花順";
        else if (isFour())
            return "四條";
        else if (isFullHouse())
            return "葫蘆";
        else if (isFlush())
            return "同花";
        else if (isStraight() != 0)
            return "順子";
        else if (isThree())
            return "三條";
        else if (getPair() == 2)
            return "兩對";
        else if (getPair() == 1)
            return "一對";
        else
            return "散牌";

    }

    @Override
    public int compareTo(Object o) {
        if (this.getPoints() != ((CardSet) o).getPoints()) {
            if (this.getPoints() > ((CardSet) o).getPoints())
                return 1;
            else
                return -1;
        } else
            return 0;
    }

    class cmp implements Comparator {
        @Override
        public int compare(Object o1, Object o2) {
            Card c1 = (Card) o1;
            Card c2 = (Card) o2;
            if (c1.getRank().getR() != c2.getRank().getR())
                return c1.getRank().getI() > c2.getRank().getI() ? 1 : -1;
            else
                return 0;
        }
    }
}

 

其中散牌的權重為2-14依據其中最大單牌決定，而一對到皇家同花順的權重從15依次加到23。

0x04　　建立不同的幾套牌進行比對

public class Main {
    public static void main(String[] args) {
        Card[] c1={new Card(Poker.Suit.DIAMOND,Poker.Rank.ACE ),new Card(Poker.Suit.DIAMOND,Poker.Rank.JACK ),new Card(Poker.Suit.DIAMOND,Poker.Rank.KING),
                new Card(Poker.Suit.DIAMOND,Poker.Rank.TEN ),new Card(Poker.Suit.DIAMOND,Poker.Rank.QUEEN )};
        Card[] c2={new Card(Poker.Suit.SPADE,Poker.Rank.JACK ),new Card(Poker.Suit.HEART,Poker.Rank.JACK ),new Card(Poker.Suit.CLUB,Poker.Rank.JACK),
                new Card(Poker.Suit.CLUB,Poker.Rank.FIVE ),new Card(Poker.Suit.SPADE,Poker.Rank.TWO )};
        Card[] c3={new Card(Poker.Suit.DIAMOND,Poker.Rank.ACE ),new Card(Poker.Suit.DIAMOND ,Poker.Rank.FOUR ),new Card(Poker.Suit.DIAMOND,Poker.Rank.THREE),
                new Card(Poker.Suit.CLUB,Poker.Rank.NINE ),new Card(Poker.Suit.SPADE,Poker.Rank.SIX )};
        Card[] c4={new Card(Poker.Suit.HEART,Poker.Rank.KING ),new Card(Poker.Suit.HEART,Poker.Rank.EIGHT ),new Card(Poker.Suit.DIAMOND,Poker.Rank.THREE ),
                new Card(Poker.Suit.CLUB,Poker.Rank.SEVEN ),new Card(Poker.Suit.SPADE,Poker.Rank.SEVEN )};
        Card[] c5={new Card(Poker.Suit.HEART,Poker.Rank.QUEEN ),new Card(Poker.Suit.HEART,Poker.Rank.TWO ),new Card(Poker.Suit.SPADE,Poker.Rank.THREE ),
                new Card(Poker.Suit.HEART,Poker.Rank.SEVEN ),new Card(Poker.Suit.DIAMOND,Poker.Rank.SEVEN )};

        CardSet deck1 = new CardSet(c1);
        CardSet deck2 = new CardSet(c2);
        CardSet deck3 = new CardSet(c3);
        CardSet deck4 = new CardSet(c4);
        CardSet deck5 = new CardSet(c5);
        System.out.print("套牌一為：");
        System.out.println(deck1.getCard() + "種類是： " + deck1.getName());
        System.out.print("套牌二為：");
        System.out.println(deck2.getCard() + "種類是： " + deck2.getName());
        System.out.print("套牌三為：");
        System.out.println(deck3.getCard() + "種類是： " + deck3.getName());
        System.out.print("套牌四為：");
        System.out.println(deck4.getCard() + "種類是： " + deck4.getName());
        System.out.print("套牌五為：");
        System.out.println(deck5.getCard() + "種類是： " + deck5.getName());
        System.out.println("套牌一是否比套牌二大："+deck1.compareTo(deck2));
        System.out.println("套牌二是否比套牌三大："+deck2.compareTo(deck3));
        System.out.println("套牌三是否比套牌一大："+deck3.compareTo(deck1));
        System.out.println("套牌三是否比套牌四大："+deck3.compareTo(deck4));
        System.out.println("套牌五是否比套牌二大："+deck5.compareTo(deck2));
        System.out.println("套牌五是否比套牌四大："+deck5.compareTo(deck4));
    }
}

執行後如圖所示

0x05　　小結

列舉類通常用於一個類的物件是有限且固定的時候。對於撲克牌大小比較這塊，還是借鑑肖大佬許多部分，實屬慚愧。這次程式碼的比較部分還有許多缺陷，如在兩套牌牌型一致，但最大單牌不同時，程式仍會把兩套牌認為大小相同，如上圖套牌4和5。又由於構造套牌方式的問題，無法為這5套牌一併進行大小比對。