如何仅对一副纸牌中的某些部分(面卡)使用枚举进行循环

我正在创建一副扑克牌（52张牌）。我希望能够打印出来，例如：

2 of Club, 3 of Club...... 
2 of Diamond, 3 of Diamond.... 
Queen of Diamond, King of Diamond 
and so on for the 52 cards.

我现在能够做到这一点，但是当涉及到杰克，女王，国王和王牌的面卡时遇到问题。目前我正在使用数字来表示它们。所以它不是打印俱乐部杰克，而是显示为 11 个俱乐部，这是错误的。我试图将面卡存储在一个enum中，并试图循环它们，但无法真正做到这一点。

我能否获得一些关于如何获得面卡而不是将它们表示为数字的建议。我已经附上了我的主要方法和下面的类。感谢您的帮助。

//Card Class
import java.util.Objects;
public class Card {
    public enum Suits{
        CLUBS, DIAMONDS, HEARTS, SPADES;  
    }
    public enum Faces{
        JACK, QUEEN, KING, ACE;  
    }
    private int rank;
    private String suit; 
    public Card(int rank, String suit){ 
        this.rank = rank;
        this.suit = suit;
    }
    public int getRank(){
        return rank; 
    }
    public String getSuit(){
        return suit;
    }
    public String format(){
        return String.format("%d of %s, ", getRank(), getSuit()); 
    }
}
//Main method
public class CardTester {
    public static void main(String[] args) {
        Card[] cards = new Card[52];  
        int i = 0;
        for (Card.Suits suit : Card.Suits.values()) { 
            for (int y = 2; y < 15; y++) {
                cards[i] = new Card(y, suit.name());  
                i++; 
            }
        }      
        for(Card p : cards){ 
            System.out.print(p.format() + " "); 
        }
    }
}

将format()方法更改为：

public String format(){
    if (getRank() < 11) {
        return String.format("%d of %s, ", getRank(), getSuit());
    }
    else {
        Faces face = Faces.values()[getRank() - 11];
        return String.format("%s of %s, ", face, getSuit());
    }
}

或者，这里有一个更好的Card实现：

import java.util.Objects;
public class Card {
    public enum Suit {
        CLUBS, DIAMONDS, HEARTS, SPADES;
    }
    public enum Rank {
        TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, 
        JACK, QUEEN, KING, ACE;
    }
    private final Suit suit;
    private final Rank rank;
    public Card(Suit suit, Rank rank) {
        this.suit = suit;
        this.rank = rank;
    }
    public Suit getSuit(){
        return suit;
    }
    public Rank getRank(){
        return rank; 
    }
    @Override
    public String toString() {
        return rank + " of " + suit;
    }
    @Override
    public int hashCode() {
        int hash = 5;
        hash = 97 * hash + Objects.hashCode(this.suit);
        hash = 97 * hash + Objects.hashCode(this.rank);
        return hash;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Card other = (Card) obj;
        if (this.suit != other.suit) {
            return false;
        }
        if (this.rank != other.rank) {
            return false;
        }
        return true;
    }
}

你可以像这样使用它：

import java.util.ArrayList;
import java.util.List;
public class CardTester {
    public static void main(String[] args) {
        List<Card> cardList = new ArrayList<>();
        Card lastCard = new Card(Card.Suit.SPADES, Card.Rank.ACE);
        for (Card.Suit suit : Card.Suit.values()) { 
            for (Card.Rank rank : Card.Rank.values()) {
                Card card = new Card(suit, rank);
                cardList.add(card);
                if (!card.equals(lastCard)) {
                    System.out.print(card + ", ");
                }
                else {
                    System.out.print(card);
                }
            }
        }
        // use cardList
    }
}

你的卡片建模是有缺陷的，你的问题突出了这一点。排名不是数字，不应该是"整数"。您可能希望对排名使用枚举。

您可能很想为您的排名提供一个整数值，但这可能不是一个好主意。该值通常由您正在玩的游戏定义，而不是由一副纸牌定义。例如，在扑克中，国王的排名高于杰克，但在二十一点中，它们的排名相同。

下面显示的源代码可能会对您有所帮助：

public enum Faces
{
    JACK( 1, "Jack" ), QUEEN( 2, "Queen" ), KING( 3, "King" ), ACE( 4, "Ace" );
    public int GetNumber()
    {
        return m_number;
    }
    public String GetName()
    {
        return m_name;
    }
    private Faces( int number_, String name_ )
    {
        m_number    = number_;
        m_name      = name_;
    }
    private int     m_number;
    private String  m_name;
}

您可以

删除已有的枚举面孔，并将以下方法添加到类 Card 中：

   public String getFace(int rank){
    String result = "";
    switch (rank){
        case 11: result = "Jack"; break;
        case 12: result = "QUEEN"; break;
        case 13: result = "KING"; break;
        case 14: result = "ACE"; break;
        default:{
            result = Integer.toString(rank);
            break;
        }
    }
    return result;
}

并将您的 format（）方法修改为如下所示：

    public String format(){
    return String.format("%s of %s, ", getFace(getRank()), getSuit()); 
}

这将完成这项工作;-）

一张牌由RANK和SUIT组成。常见的扑克软件惯例是将牌表示为SUIT+RANK字符串，如3c表示3个俱乐部，Kd表示钻石之王。（参见扑克炉或大多数手牌历史生产者和消费者）

您需要将 RANK 的概念扩展到面孔之外。我一直在使用Steve Brecher扑克评估库，他的RANK类看起来像这样：

字符串"23456789TJQKA"的简单查找在枚举和 RANK 之间转换。有一个类似的 SUIT 枚举和一个相当合理的 Comparable 类将两者结合起来。

public static enum Rank {
    TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE;
    /**
     * @return the character in {@link #RANK_CHARS} denoting this rank.
     */
    public char toChar() {
        return RANK_CHARS.charAt(this.ordinal());
    }
    /**
     * @param c
     *            a character present in {@link #RANK_CHARS} (case
     *            insensitive)
     * @return the Rank denoted by character.
     * @throws IllegalArgumentException
     *             if c not in {@link #RANK_CHARS}
     */
    public static Rank fromChar(char c) {
        int i = RANK_CHARS.indexOf(Character.toUpperCase(c));
        if (i >= 0)
            return Rank.values()[i];
        throw new IllegalArgumentException("'" + c + "'");
    }
    /**
     * @return the pip value of this Rank, ranging from 2 for a
     *         <code>TWO</code> (deuce) to 14 for an <code>ACE</code>.
     */
    public int pipValue() {
        return this.ordinal() + 2;
    }
    public static final String RANK_CHARS = "23456789TJQKA";
}

你可以在这里找到他的旧图书馆，但仍然可以很好地使用：http://www.brecware.com/Software/software.html 或 http://pokersource.sourceforge.net/

你可以试试这个使用枚举的解决方案。首先，您需要创建两个枚举。一个用于花色，另一个用于卡片。

西装的枚举是：

 public enum suits
     {
     club, diamond,heart,spades
     }

卡片的枚举为：

 public enum cards 
     {
     two(2), three(3), four(4), five(5), six(6), seven(7), eight(8),nine(9),
     ten(10), jack(11), queen(12), king(13),ace(14);
     int number;
     private cards(int number)
     {
         this.number=number;
     }
     public int getNumber()
     {
         return this.number;
     }
     }

在你的主类中，你可以遍历两个枚举来得到你的结果，如下所示：

public class Javaclass
    {
     public static void main(String[] args)
        {
            int count=2;
            for(suits suit:suits.values())
            {
            for(cards card: cards.values())
            {
            if(count<=10)
            System.out.println(card.getNumber()+" of "+suit);
            else
            System.out.println(card+" of "+suit);
            count++;
            }
            count=2;
             System.out.println("");
            }
        }
}

希望这有帮助。

相关内容

最新更新

热门标签：