Java-使用ArrayList创建对象，构造函数跳过了第一次迭代

我正在为21点游戏编写程序。到目前为止，我可以创建一个对象，其中包含一个suit、value和一个值作为字符串。我正在试验在游戏中实现我的类的不同方法。不幸的是，当我使用循环在ArrayList中创建多个对象时，当列表中的第一个对象用其字段实例化时，构造函数会重复两次。这是一个问题，因为检查重复卡的数组依赖于每个对象只调用构造函数一次。这仅在使用ArrayList时发生；使用单个对象可以正常工作。下面是我的两个类，驱动程序和示例输出。请忽略大部分评论，这是直接复制的，大部分是我自己的笔记

那么为什么它会重复呢？如何解决这个问题？蒂亚

卡类

public class Card 
{
    private final String[] SUITS = {"Clubs", "Diamonds", "Hearts", "Spades"};
    private final int[] VALUES = {2,3,4,5,6,7,8,9,10};

    public String getSuits(int num) 
    {
        return SUITS[num];
    }
    public int getValues(int num) 
    {
        return VALUES[num];
    }
}

import java.util.Random;
//import java.util.Arrays;

public class Deck extends Card
{
    private String suit, valueString;
    private int value, valueNum, suitNum;
    private static int tot = 0;
    private static boolean[][] duplicateCheck = new boolean[4][13];//to see if suit/value pair has been used yet    //only fills up to 50 cards
    static int times = 0;
    Random rand = new Random();
    Card transfer = new Card();

    public Deck()//can the constructor just be a super() of the parent?
    {
        //System.out.println(Arrays.deepToString(duplicateCheck));
        do
        {
            suitNum = rand.nextInt((3 - 0) + 1) + 0;
            suit = transfer.getSuits(suitNum);
            valueNum = rand.nextInt((12 - 0) + 1) + 0;
           // System.out.println("CARD BELOW");
        }
        while(duplicateCheck[suitNum][valueNum] );

        duplicateCheck[suitNum][valueNum] = true;
        //System.out.println(duplicateCheck[suitNum][valueNum] + ", "+valueNum + " "+suitNum);
        if(valueNum >= 9 && valueNum <= 11)
        {
            value = 11;
            switch(valueNum)
            {
                case 9:
                    valueString = "Jack";
                    break;
                case 10:
                    valueString = "King";
                    break;
                case 11:
                    valueString = "Queen";
                    break;
                default:
                    valueString = Integer.toString(valueNum);//not really needed
                    break;
            }
        }
        else if(valueNum == 12)
        {
            if(tot + 11 > 21)
                value = 1;
            else
                value = 11;
            valueString = "Ace";
        }
        else
        {
            value = transfer.getValues(valueNum);
            valueString = Integer.toString(transfer.getValues(valueNum));
        }
        tot += value;
        System.out.println(valueString + ", " + suit + ", " + ++times);
    }
    public String getSuit()
    {
        return suit;
    }
    public int getValue()
    {
        return value;
    }
    public String getValueString()
    {
        return valueString;
    }
    //put into place a method that plays a new deck after each hand
}

甲板等级

public class Card 
{
    private final String[] SUITS = {"Clubs", "Diamonds", "Hearts", "Spades"};
    private final int[] VALUES = {2,3,4,5,6,7,8,9,10};

    public String getSuits(int num) 
    {
        return SUITS[num];
    }
    public int getValues(int num) 
    {
        return VALUES[num];
    }
}

import java.util.Random;
//import java.util.Arrays;

public class Deck extends Card
{
    private String suit, valueString;
    private int value, valueNum, suitNum;
    private static int tot = 0;
    private static boolean[][] duplicateCheck = new boolean[4][13];//to see if suit/value pair has been used yet    //only fills up to 50 cards
    static int times = 0;
    Random rand = new Random();
    Card transfer = new Card();

    public Deck()//can the constructor just be a super() of the parent?
    {
        //System.out.println(Arrays.deepToString(duplicateCheck));
        do
        {
            suitNum = rand.nextInt((3 - 0) + 1) + 0;
            suit = transfer.getSuits(suitNum);
            valueNum = rand.nextInt((12 - 0) + 1) + 0;
           // System.out.println("CARD BELOW");
        }
        while(duplicateCheck[suitNum][valueNum] );

        duplicateCheck[suitNum][valueNum] = true;
        //System.out.println(duplicateCheck[suitNum][valueNum] + ", "+valueNum + " "+suitNum);
        if(valueNum >= 9 && valueNum <= 11)
        {
            value = 11;
            switch(valueNum)
            {
                case 9:
                    valueString = "Jack";
                    break;
                case 10:
                    valueString = "King";
                    break;
                case 11:
                    valueString = "Queen";
                    break;
                default:
                    valueString = Integer.toString(valueNum);//not really needed
                    break;
            }
        }
        else if(valueNum == 12)
        {
            if(tot + 11 > 21)
                value = 1;
            else
                value = 11;
            valueString = "Ace";
        }
        else
        {
            value = transfer.getValues(valueNum);
            valueString = Integer.toString(transfer.getValues(valueNum));
        }
        tot += value;
        System.out.println(valueString + ", " + suit + ", " + ++times);
    }
    public String getSuit()
    {
        return suit;
    }
    public int getValue()
    {
        return value;
    }
    public String getValueString()
    {
        return valueString;
    }
    //put into place a method that plays a new deck after each hand
}

您的输出是正确的： 打印的第一行来自Deck temp=new Deck（） 构造函数在打印时执行 System.out.println（valueString+“，“+suit+”，“+++次）

这张照片来自两个构造器 在每个文件和打印系统上。out.println（t.get（x.getValueString（）+） 表示“+t.get（x）.getSuit（）+”+x）；在for循环中

King, Clubs, 2  
King of Clubs
4, Diamonds, 3
4 of Diamonds
9, Clubs, 4
9 of Clubs
9, Spades, 5
9 of Spades
4, Hearts, 6
4 of Hearts

---

现在请注意，每次创建一个对象时，构造函数只执行一次，它不会执行两次。您的输出打印误导了您。

哇，我真的很愚蠢，没有意识到这一点。谢谢。没必要对自己太苛刻了，你的纸牌游戏表明你走得很好。我只是提出一个建议，如果您想检查是否有重复的卡在deck类之外执行此检查，那么将此检查留在构造函数中是毫无意义的，因为每个对象都不知道其他对象的任何信息，并且数组从每个对象的新开始。，使用在驱动程序中创建的数组，您可以将此数组作为参数传递给deck类的构造函数，这样该类只创建以前未创建的卡片；一副牌不是一张牌。但看起来你的牌组类实际上是一张牌，而你的牌类只是一个助手。卡没有任何状态。所有东西都可以是静态的，不需要Deck来扩展（它们可以被重命名）。你有一个A等于1或11的逻辑。您可能应该首先关注简单地创建一副牌，然后在21点类中使用该逻辑。

King, Clubs, 2  
King of Clubs
4, Diamonds, 3
4 of Diamonds
9, Clubs, 4
9 of Clubs
9, Spades, 5
9 of Spades
4, Hearts, 6
4 of Hearts