Java 21点程序将卡片返回为空？

主要类别：

公营21点{

static Deck D;
static Hand P;
public static void main(String[] args) {
    init();
}

private static void init() {
    D=new Deck();
    P=new Hand(D);
    startGame();
}

private static void startGame() {
    System.out.print("Your cards are: "+P.H.get(0)+", "+P.H.get(1));
}

}

手工课：

import java.util.ArrayList;
import java.util.Random;


public class Hand {
ArrayList<String> H;
Random R;
public Hand(Deck D){
    R=new Random();
    H=new ArrayList<String>();
    int C=R.nextInt(D.getP().length);
    H.add(D.getP()[C]);
    D.removeFromDeck(C);
    int E=R.nextInt(D.getP().length);
    H.add(D.getP()[E]);
    D.removeFromDeck(E);
}

import java.util.ArrayList；
导入java.util.Random；
公务生{
ArrayList H；
随机R；
人手（D组）{
R=新随机数（）；
H=新的ArrayList（）；
int C=R.nextInt（D.getP（）.length）；
H.add（D.getP（）[C]）；
D.从甲板上拆除（C）；
int E=R.nextInt（D.getP（）.length）；
H.add（D.getP（）[E]）；
D.从甲板上拆除（E）；
}

}

甲板级

public class Deck {
String[] P;
public Deck(){
    P=new String[52];
    String Suit="Default";
    int C=0;
    for(int A=1;A<=4;A++){
        switch(A){
        case 1:
            Suit="Hearts";
            break;
        case 2:
            Suit="Diamonds";
            break;
        case 3:
            Suit="Clubs";
            break;
        case 4:
            Suit="Spades";
            break;
        }
        for(int B=1;B<=13;B++){
            if(B>10){
                switch(B){
                case 11: P[C]="Joker of "+Suit; 
                break;
                case 12: P[C]="Queen of "+Suit;
                break;
                case 13: P[C]="King of "+Suit;
                break;
                }
            }else{
                P[C]=B+" of "+Suit;
            }
        }
    }
}
public void setP(String[] p) {
    P = p;
}
public String[] getP() {
    return P;
}
public void removeFromDeck(int C){
    System.arraycopy(P, C + 1, P, C,
            P.length - C - 1);
}

公共类甲板{
字符串[]P；
公共甲板（）{
P=新字符串[52]；
String Suit=“默认”；
int C=0；
对于（int A=1；A两个循环的条件都是错误的：

for(int A=1;A>=4;A++)

   ...
   for(int B=1;B>=13;B++)

这两者都不会执行任何迭代。它们应该是：

for(int A=1;A<=4;A++)

   ...
   for(int B=1;B<=13;B++)

背面有52张牌，而不是51张

编辑：正如评论中所指出的，你总是会对发布的代码感到满意，因为你选择套装的switch语句没有任何中断。我本以为这会导致编译时警告。你真的应该注意警告。你可以像这样添加中断语句：

switch(A) {
    case 1:
        S = "Hearts";
        break;
    case 2:
        S = "Diamonds";
        break;
    case 3:
        S = "Clubs";
        break;
    case 4:
        S = "Spades";
        break;
}

最后，我强烈建议您使用更有意义的变量名，最好遵循Java命名约定。（实际上，我会对您的代码进行各种其他更改，但从这些更改开始。）
您的两个循环都有错误的条件：

for(int A=1;A>=4;A++)

   ...
   for(int B=1;B>=13;B++)

这两者都不会执行任何迭代。它们应该是：

for(int A=1;A<=4;A++)

   ...
   for(int B=1;B<=13;B++)

背面有52张牌，而不是51张

编辑：正如评论中所指出的，你总是会对发布的代码感到满意，因为你选择套装的switch语句没有任何中断。我本以为这会导致编译时警告。你真的应该注意警告。你可以像这样添加中断语句：

switch(A) {
    case 1:
        S = "Hearts";
        break;
    case 2:
        S = "Diamonds";
        break;
    case 3:
        S = "Clubs";
        break;
    case 4:
        S = "Spades";
        break;
}

最后，我强烈建议您使用更有意义的变量名，最好遵循Java命名约定。（实际上，我会对您的代码进行各种其他更改，但从这些更改开始。）
乍一看，问题似乎在这里：
for（inta=1；a>=4；a++）{
和here
for（intb=1；B>=13；B++）{
。这些循环将永远不会执行，因为在第一个循环中，在第一次迭代中，A将是1，因此小于4，这意味着它打破了第一个循环的条件，第二个循环也是如此。用
替换
乍一看，问题似乎如下：
for（int A=1；A>=4；A++）{
和这里的
用于（intb=1；B>=13；B++）{
。这些循环永远不会执行，因为在第一个循环中，在第一次迭代中，A将是1，因此小于4，这意味着它打破了第一个循环的条件，第二个循环也是如此。将
替换为
我很困惑，为什么还没有封装
卡
类这将使卡片的实例化更容易。此外，您可以将套装抽象到它自己的类或枚举中

无论如何，我可能为你做了太多的设计工作，但这里有一些事情可以让你开始：

public enum Suit {
    Spade,
    Heart,
    Diamond,
    Club;

    public static Suit getSuit(int suit) {
        switch (suit) {
            case 3: 
                return Suit.Spade;
            case 2:
                return Suit.Heart;
            case 1:
                return Suit.Diamond;
            case 0:
            default:
                return Suit.Club;
        }
    }
}

public class DeckFactory {

    public static List<Card> BuildDeck() {
        List<Card> cards = new ArrayList<Card>();

        for (int value = 1; value <= 13; ++value) {
            for (int suit = 0; suit < 4; ++suit) {
                cards.add(new Card(value, suit));
            }
        }

        return cards;
    }

}

这里有一个简单的
卡片
类，使用这套套装

public class Card {

    private Suit suit;
    private int value;

    public Card(Suit suit, int value) {
        this.suit = suit;
        this.value = value;
    }

    public Card(int suit, int value) {
        this(Suit.getSuit(suit), value);
    }

    public int getValue() { return value; }
    public Suit getSuit() { return suit; }

}

创建甲板很简单。下面是一个简单的工厂，让您开始：

public enum Suit {
    Spade,
    Heart,
    Diamond,
    Club;

    public static Suit getSuit(int suit) {
        switch (suit) {
            case 3: 
                return Suit.Spade;
            case 2:
                return Suit.Heart;
            case 1:
                return Suit.Diamond;
            case 0:
            default:
                return Suit.Club;
        }
    }
}

public class DeckFactory {

    public static List<Card> BuildDeck() {
        List<Card> cards = new ArrayList<Card>();

        for (int value = 1; value <= 13; ++value) {
            for (int suit = 0; suit < 4; ++suit) {
                cards.add(new Card(value, suit));
            }
        }

        return cards;
    }

}

希望这能有所帮助。
我不明白为什么您还没有封装
Card
类，因为这样可以更容易地实例化Card。此外，您可以将suit抽象到自己的类或枚举中

无论如何，我可能为你做了太多的设计工作，但这里有一些事情可以让你开始：

public enum Suit {
    Spade,
    Heart,
    Diamond,
    Club;

    public static Suit getSuit(int suit) {
        switch (suit) {
            case 3: 
                return Suit.Spade;
            case 2:
                return Suit.Heart;
            case 1:
                return Suit.Diamond;
            case 0:
            default:
                return Suit.Club;
        }
    }
}

public class DeckFactory {

    public static List<Card> BuildDeck() {
        List<Card> cards = new ArrayList<Card>();

        for (int value = 1; value <= 13; ++value) {
            for (int suit = 0; suit < 4; ++suit) {
                cards.add(new Card(value, suit));
            }
        }

        return cards;
    }

}

这里有一个简单的
卡片
类，使用这套套装

public class Card {

    private Suit suit;
    private int value;

    public Card(Suit suit, int value) {
        this.suit = suit;
        this.value = value;
    }

    public Card(int suit, int value) {
        this(Suit.getSuit(suit), value);
    }

    public int getValue() { return value; }
    public Suit getSuit() { return suit; }

}

创建甲板很简单。下面是一个简单的工厂，让您开始：

public enum Suit {
    Spade,
    Heart,
    Diamond,
    Club;

    public static Suit getSuit(int suit) {
        switch (suit) {
            case 3: 
                return Suit.Spade;
            case 2:
                return Suit.Heart;
            case 1:
                return Suit.Diamond;
            case 0:
            default:
                return Suit.Club;
        }
    }
}

public class DeckFactory {

    public static List<Card> BuildDeck() {
        List<Card> cards = new ArrayList<Card>();

        for (int value = 1; value <= 13; ++value) {
            for (int suit = 0; suit < 4; ++suit) {
                cards.add(new Card(value, suit));
            }
        }

        return cards;
    }

}

希望这能有所帮助。
这在switch语句中给了我一个arrayindexoutofbounds错误。而且，你几乎立即回答了我所有的问题，这就像你跟踪我一样。D：好吧，现在它只返回黑桃，这真的很混乱，因为C变量应该阻止它这样做that@user1357527：您没有
中断
语句。您没有收到警告吗？@user1357527常见的约定是从零（0）开始。for循环从零开始编写，然后您只需执行以下操作"@user1357527:那么我怀疑你把它们添加到了错误的地方。现在是学习一些诊断技能的好时机——添加日志记录，在调试器中运行代码。这会在switch语句中给我一个arrayindexoutofbounds错误。而且，你几乎立即回答了我所有的问题，就像你跟踪我一样。D：好的，现在它只是返回黑桃，这确实令人困惑，因为C变量应该阻止它这样做that@user1357527：您在任何切换条件下都没有
break
语句。您没有收到警告吗？@user1357527常见的约定是从零开始（0）。for循环从零开始编写，然后只需执行“@user1357527:那么我怀疑您将它们添加到了错误的位置。现在是学习一些诊断技能的好时机-添加日志记录，在调试器中运行代码。顺便说一句。J是为Jack而不是为Joker编写的。：-）我不明白为什么您没有封装
Card
类，因为这样可以简化卡的实例化。
Card
类可以覆盖toString方法来显示它是“Jack，Queen还是King”“。此外，您可以将suit值抽象到它自己的类或enum中。顺便说一句，J是为Jack而不是为Joker.：-）我不明白为什么您没有封装
Card
类，因为这样可以简化卡的实例化。
Card
类可以覆盖toString方法以显示它是“Jack，Queen还是King”。此外，您可以将suit值抽象到其自己的类或枚举中。