Fatal编程技术网
  • java/
  • Java 一副纸牌

Java 一副纸牌

java

Java 一副纸牌,java,Java,我已经创建了一副牌，可以处理每一张牌和一套衣服，直到没有剩余的牌为止。对于我的项目，我需要将其分为3个类，其中包括一个驱动程序类。我首先创建了一个包含所有内容的类，因此我知道如何使所有内容都工作 public class DeckOfCards2 { public static void main(String[] args) { int[] deck = new int[52]; String[] suits = {"Spades", "Hearts", "Diamonds

我已经创建了一副牌，可以处理每一张牌和一套衣服，直到没有剩余的牌为止。对于我的项目，我需要将其分为3个类，其中包括一个驱动程序类。我首先创建了一个包含所有内容的类，因此我知道如何使所有内容都工作

public class DeckOfCards2 {
  public static void main(String[] args) {
    int[] deck = new int[52];
    String[] suits = {"Spades", "Hearts", "Diamonds", "Clubs"};
    String[] ranks = {"Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"};

    // Initialize cards
    for (int i = 0; i < deck.length; i++) {
      deck[i] = i;
    }

    // Shuffle the cards
    for (int i = 0; i < deck.length; i++) {
      int index = (int)(Math.random() * deck.length);
      int temp = deck[i];
      deck[i] = deck[index];
      deck[index] = temp;
    }

    // Display the all the cards
    for (int i = 0; i < 52; i++) {
      String suit = suits[deck[i] / 13];
      String rank = ranks[deck[i] % 13];
      System.out.println( rank + " of " + suit);
    }
  }
}
首先，您的类有一个架构问题。您将属性
卡片组
移动到了类
卡片
中。但当然，它是卡片组的一个属性，因此必须在类
DeckOfCards
中。然后，初始化循环不应该在
卡的构造函数中，而应该在您的deck类中。此外，当前的牌组是
int
的数组，但应该是
卡的数组

第二，在方法
Deal
中，您应该将
suits
称为
Card.suits
，并将此成员设为最终成员。与
等级相同


最后，请遵守命名约定。方法名称总是以小写字母开头，即
shuffle
而不是
shuffle
您的设计有问题。试着让你的类代表真实世界的事物。例如：


private List<Card> cards = new ArrayList<Card>();

//Building the Deck...

//...

public void shuffle() {
    Collections.shuffle(this.cards); 
}



    

  • 班级卡应代表一张卡，即“卡”的性质。卡片类不需要了解甲板
    • 

  • 牌组类应该包含52个牌对象（加上小丑？）

您的代码中有许多错误，例如，您只是在
Shuffle
方法中键入
deck
，而不是真正调用您的deck。您只能通过键入
card.deck

我已更改您的洗牌方法：


public void Shuffle(){
    for (int i = 0; i < theCard.deck.length; i++) {
        int index = (int)(Math.random()*theCard.deck.length );
        int temp = theCard.deck[i];
        theCard.deck[i] = theCard.deck[index];
        theCard.deck[index] = temp;
        remainingCards--;
    }
}



public void Shuffle（）{
for（int i=0；i


还有，据说你有结构性问题。你应该按照你在现实生活中的理解命名类，例如，当你说卡片时，它只是一张卡片，当你说卡片时，它应该是52+2张卡片。这样你的代码就更容易理解了。
正如其他人所说，你的设计不是很清晰，也不是面向对象的

最明显的错误是，在你的设计中，一张牌知道一副牌。卡片组应该了解卡片并在其构造函数中实例化对象。例如：


public class DeckOfCards {
    private Card cards[];

    public DeckOfCards() {
        this.cards = new Card[52];
        for (int i = 0; i < ; i++) {
            Card card = new Card(...); //Instantiate a Card
            this.cards[i] = card; //Adding card to the Deck
        }
     }



public class SpecialDeck extends DeckOfCards {
   ....



/* Creating all possible cards... */
for (Suits s : Suits.values()) {
    for (Ranks r : Ranks.values()) {
         Card c = new Card(s,r);
    }  
}


我要改变的另一件事是使用字符串数组来表示西服和军衔。自Java1.5以来，该语言支持枚举，这非常适合此类问题。例如：


public enum Suits {
    SPADES, 
    HEARTS, 
    DIAMONDS,
    CLUBS;  
}


使用Enum，您可以获得一些好处，例如：


private List<Card> cards = new ArrayList<Card>();

//Building the Deck...

//...

public void shuffle() {
    Collections.shuffle(this.cards); 
}


1） Enum是类型安全的。除了预定义的Enum常量，您不能为Enum变量分配任何其他内容。例如，您可以按照以下方式编写卡的构造函数：


public class Card {

   private Suits suit;
   private Ranks rank;

public Card(Suits suit, Ranks rank) {
    this.suit = suit;
    this.rank = rank;
}


这样，您就可以确保构建只接受值的一致卡片​​您的枚举

2） 您可以在Java内部的Switch语句中使用Enum，比如int或char基元数据类型（这里我们不得不说，因为Java 1.7 Switch语句也可以用于字符串）

3） 在Java中的Enum上添加新常量很容易，您可以在不破坏现有代码的情况下添加新常量

4） 您可以迭代枚举，这在实例化卡片时非常有用。例如：


public class DeckOfCards {
    private Card cards[];

    public DeckOfCards() {
        this.cards = new Card[52];
        for (int i = 0; i < ; i++) {
            Card card = new Card(...); //Instantiate a Card
            this.cards[i] = card; //Adding card to the Deck
        }
     }



public class SpecialDeck extends DeckOfCards {
   ....



/* Creating all possible cards... */
for (Suits s : Suits.values()) {
    for (Ranks r : Ranks.values()) {
         Card c = new Card(s,r);
    }  
}


为了避免再次发明轮子，我还将改变将卡片从数组保存到Java集合的方式，通过这种方式，您可以在牌组上使用许多强大的方法，但最重要的是，您可以使用来洗牌牌组。例如：


private List<Card> cards = new ArrayList<Card>();

//Building the Deck...

//...

public void shuffle() {
    Collections.shuffle(this.cards); 
}



private List cards=new ArrayList（）；
//建造甲板。。。
//...
公开无效洗牌（）{
收集。洗牌（这张牌）；
}

您的程序中有很多错误


  • 指数的计算。我想应该是
    Math.random（）%deck.length
    • 

  • 在卡片的展示中。根据我的说法，你应该制作一个等级适合的卡片类别，并制作该类别类型的数组
    • 

    如果你愿意，我可以给你完整的结构，但最好是你自己做
    这里有一些代码。它使用两个类（Card.java和Deck.java）来完成这个问题，并且在创建Deck对象时，它会自动为您排序。：）
    

    import java.util.*；
公共课2{
ArrayList cards=新的ArrayList（）；
字符串[]值={“A”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“10”、“J”、“Q”、“K”}；
字符串[]套装={“俱乐部”、“黑桃”、“钻石”、“心脏”}；
静态布尔值firstThread=true；
公众谘询委员会2(){

    对于（int i=0；i我认为解决方案与此一样简单：
    

    Card temp = deck[cardAindex];
deck[cardAIndex]=deck[cardBIndex]; 
deck[cardBIndex]=temp;

    

    这是我的实现：
    

    public class CardsDeck {
    private ArrayList<Card> mCards;
    private ArrayList<Card> mPulledCards;
    private Random mRandom;

public enum Suit {
    SPADES,
    HEARTS,
    DIAMONDS,
    CLUBS;
}

public enum Rank {
    TWO,
    THREE,
    FOUR,
    FIVE,
    SIX,
    SEVEN,
    EIGHT,
    NINE,
    TEN,
    JACK,
    QUEEN,
    KING,
    ACE;
}

public CardsDeck() {
    mRandom = new Random();
    mPulledCards = new ArrayList<Card>();
    mCards = new ArrayList<Card>(Suit.values().length * Rank.values().length);
    reset();
}

public void reset() {
    mPulledCards.clear();
    mCards.clear();
    /* Creating all possible cards... */
    for (Suit s : Suit.values()) {
        for (Rank r : Rank.values()) {
            Card c = new Card(s, r);
            mCards.add(c);
        }
    }
}


public static class Card {

    private Suit mSuit;
    private Rank mRank;

    public Card(Suit suit, Rank rank) {
        this.mSuit = suit;
        this.mRank = rank;
    }

    public Suit getSuit() {
        return mSuit;
    }

    public Rank getRank() {
        return mRank;
    }

    public int getValue() {
        return mRank.ordinal() + 2;
    }

    @Override
    public boolean equals(Object o) {
        return (o != null && o instanceof Card && ((Card) o).mRank == mRank && ((Card) o).mSuit == mSuit);
    }


}

/**
 * get a random card, removing it from the pack
 * @return
 */
public Card pullRandom() {
    if (mCards.isEmpty())
        return null;

    Card res = mCards.remove(randInt(0, mCards.size() - 1));
    if (res != null)
        mPulledCards.add(res);
    return res;
}

/**
 * Get a random cards, leaves it inside the pack 
 * @return
 */
public Card getRandom() {
    if (mCards.isEmpty())
        return null;

    Card res = mCards.get(randInt(0, mCards.size() - 1));
    return res;
}

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public int randInt(int min, int max) {
    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = mRandom.nextInt((max - min) + 1) + min;
    return randomNum;
}


public boolean isEmpty(){
    return mCards.isEmpty();
}
}

    

    公共类shuffleCards{
公共静态void main（字符串[]args）{
String[]cardsType={“俱乐部”、“黑桃”、“心脏”、“钻石”}；
字符串[]cardValue={“Ace”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“10”、“国王”、“女王”、“杰克”}；
列表卡=新的ArrayList（）；
对于（inti=0；i
    import java.util.List；
导入java.util.ArrayList；
导入静态java.lang.System.out；
进口龙目织机；
进口龙目吸气剂；
导入java.awt.Color；
公务舱甲板{
私有静态@Getter List deck=null；
最终国际诉讼数量=4；
最终整数值_计数=13；
公共甲板（）{
deck=newarraylist（）；
卡片=空；
int suiteindex=0，valueIndex=0；
while（suiteindeximport java.util.List;
import java.util.ArrayList;
import static java.lang.System.out;
import lombok.Setter;
import lombok.Getter;
import java.awt.Color;


public class Deck {

private static @Getter List<Card> deck = null;

final int SUIT_COUNT = 4;
final int VALUE_COUNT = 13;

public Deck() {
    deck = new ArrayList<>();
    Card card = null;
    int suitIndex = 0, valueIndex = 0;
    while (suitIndex < SUIT_COUNT) {
        while (valueIndex < VALUE_COUNT) {
            card = new Card(Suit.values()[suitIndex], FaceValue.values()[valueIndex]);
            valueIndex++;
            deck.add(card);
        }
        valueIndex = 0;
        suitIndex++;
    }
}

private enum Suit{CLUBS("Clubs", Color.BLACK), DIAMONDS("Diamonds", Color.RED),HEARTS("Hearts", Color.RED), SPADES("Spades", Color.BLACK);

    private @Getter String name = null;
    private @Getter Color color = null;

    Suit(String name) {
        this.name = name;
    }

    Suit(String name, Color color) {
        this.name = name;
        this.color = color;
    }
}

private enum FaceValue{ACE(1), TWO(2), THREE(3),
    FOUR(4), FIVE(5), SIX(6), SEVEN(7), EIGHT (8), NINE(9), TEN(10),
    JACK(11), QUEEN(12), KING(13);

    private @Getter int cardValue = 0;

    FaceValue(int value) {
        this.cardValue = value;
    }
}

private class Card {

    private @Getter @Setter Suit suit = null;

    private @Getter @Setter FaceValue faceValue = null;

    Card(Suit suit, FaceValue value) {
        this.suit = suit;
        this.faceValue = value;
    }

    public String toString() {
        return getSuit() + " " + getFaceValue();
    }

    public String properties() {
        return getSuit().getName() + " " + getFaceValue().getCardValue();
    }

}

public static void main(String...inputs) {
    Deck deck = new Deck();
    List<Card> cards = deck.getDeck();
    cards.stream().filter(card -> card.getSuit().getColor() != Color.RED && card.getFaceValue().getCardValue() > 4).map(card -> card.toString() + " " + card.properties()).forEach(out::println);   
}