Question

我正在制作一副扑克牌（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.

我现在能够做到这一点，但是对于Jack，Queen，King和Ace这样的面部卡有问题。目前我使用数字代表他们。因此，不是打印杰克俱乐部，而是显示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() + " "); 
        }
    }
}

Answer 1

您的卡片建模存在缺陷，您的问题突显了这一点。 Rank不是数字，不应该是'int'。您可能希望使用enum作为排名。

你可能想要给你的等级一个整数值，但这可能不是一个好主意。该值通常由您正在玩的游戏定义，而不是由卡片组定义。例如在扑克中，国王的排名高于杰克，但在二十一点中，他们的排名相同。

Answer 2

将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
    }
}

Answer 3

可能是下面显示的源代码可以帮助您：

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;

}

Answer 4

您可以删除已有的枚举 Faces ，并将以下方法添加到类卡中：

   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()); 
}

这将完成工作; - ）

Answer 5

一张牌由RANK和SUIT组成。常见的扑克软件惯例是将卡片表示为SUIT + RANK Strings，如3c为3俱乐部，Kd为钻石之王。（参见pokerstove或大多数手工历史制作者和消费者）

你需要扩展面部之外的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/

Answer 6

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

诉讼的枚举是：

 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("");
            }

        }
}

希望这有帮助。

如何使用枚举仅仅针对卡片中的某些部分（面部卡片）

6 个答案: