Java 为什么我的卡片是空白的？

我已经用java创建了一个Soitaire游戏，但是当我编译应用程序（没有错误）时，由于某种原因，卡最终是空的

下面是包含图形的部分代码

在Card.java中

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.geom.RoundRectangle2D;
import javax.swing.JPanel;

public class Card extends JPanel {
  /**
 * defines all values of rank a card can achieve
 */
public enum Rank {
    Ace, One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King
}

/**
 * defines all values of color a card can achieve
 */
public enum Suit {
    HEARTS, DIAMONDS, CLUBS, SPADES
}

private Rank cardRank; ///< will store the rank of our card
private Suit cardColor; ///< will store the color of our card
private boolean faceUp; ///< determines which side the card is facing
private Point location; ///< location of our card on board, has to be stored individually
private Point where; ///< location of Card to others

/// @2DD coordinates
private int x = 0;
private int y = 0;

/// offsets for cards
private final int x_offset = 10;
private final int y_offset = 20;
private final int new_x_offset = x_offset + (CARD_WIDTH - 30);
/// constants for card graphical view
final static public int CARD_WIDTH = 100;
final static public int CARD_HEIGHT = 150;
final static public int ANGLE = 25;

  /**
     *  Defines a sample card object that specifies it's parameters
     *
     * @param defRank - pre-defined rank
     * @param defColor - pre-defined color
     */
    public Card(Rank defRank, Suit defColor){
        cardRank = defRank;
        cardColor = defColor;
        faceUp = false;
        location = new Point();
        x = 0;
        y = 0;
        location.x = x;
        location.y = y;
        where = new Point();
    }



/*  Function for drawing out a card Color
 *
 * @param defColor - defines which card color (symbol we want)
 * @param defColorCode - defines which actual color code should be used for the symbol
 */
private void drawSuit(Graphics2D g, String defColor, Color defColorCode)
{
    g.setColor(defColorCode);
    g.drawString(defColor, location.x + x_offset, location.y + y_offset);
    g.drawString(defColor, location.x + x_offset, location.y + CARD_HEIGHT - 5);
}

/**
 *  similar as color, but instead of symbol we draw the value
 * @see drawColor for more info
 */
private void drawRank(Graphics2D g, String defRank){
    g.drawString(defRank, location.x + new_x_offset, location.y + y_offset);
    g.drawString(defRank, location.x + new_x_offset, location.y + y_offset + CARD_HEIGHT - 25);
}

/**
     *  basically acts as a main for the Card. Creates  card with graphical display
     *
     * @param g2d - utilizes java graphic library to draw compotents of our defined functions
     */
    public void createCard(Graphics g2d){
        Graphics2D g = (Graphics2D) g2d; ///< konvertujeme do 2d grafiky
        RoundRectangle2D rect = new RoundRectangle2D.Double(location.x, location.y, CARD_WIDTH, CARD_HEIGHT, ANGLE, ANGLE);
        g.setColor(Color.WHITE);
        g.fill(rect);
        g.setColor(Color.BLACK);
        g.draw(rect);

        if (faceUp == true){
            switch(cardColor){
                case HEARTS:
                    drawSuit(g, "Hearts", Color.RED);
                    break;
                case DIAMONDS:
                    drawSuit(g, "Diamonds", Color.RED);
                    break;
                case CLUBS:
                    drawSuit(g, "Clubs", Color.BLACK);
                    break;
                case SPADES:
                    drawSuit(g, "Spades", Color.BLACK);
                    break;
            }

            int new_x_offset = x_offset + (CARD_WIDTH - 30);
            switch (cardRank){
                case Ace:
                    drawRank(g, "Ace (A)");
                    break;
                case Two:
                    drawRank(g, "Two (2)");
                    break;
                case Three:
                    drawRank(g, "Three (3)");
                    break;
                case Four:
                    drawRank(g, "Four (4)");
                    break;
                case Six:
                    drawRank(g, "Six (5)");
                    break;
                case Five:
                    drawRank(g, "Five (6)");
                    break;
                case Seven:
                    drawRank(g, "Seven (7)");
                    break;
                case Eight:
                    drawRank(g, "Eight (8)");
                    break;
                case Nine:
                    drawRank(g, "Nine (9)");
                    break;
                case Ten:
                    drawRank(g, "Ten (10)");
                    break;
                case Jack:
                    drawRank(g, "Jack (J)");
                    break;
                case Queen:
                    drawRank(g, "Queen (Q)");
                    break;
                case King:
                    drawRank(g, "King (K)");
                    break;
            }
        } // end of if

        else { ///< ked je karta otocena spodkom
            RoundRectangle2D rect2D = new RoundRectangle2D.Double(location.x, location.y, CARD_WIDTH, CARD_HEIGHT, ANGLE, ANGLE);
            g.setColor(Color.LIGHT_GRAY);
            g.fill(rect2D);
            g.setColor(Color.BLACK);
            g.draw(rect2D);
        } // end of else
    } // end of function


} // end of file (class Card.java)

导入java.awt.Color；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.Point；
导入java.awt.Rectangle；
导入java.awt.geom.RoundRectangle2D；
导入javax.swing.JPanel；
公共类卡扩展JPanel{
/**
*定义一张卡可以达到的等级的所有值
*/
公共枚举等级{
ACE，一，二，三，四，五，六，七，八，九，十，杰克，皇后，金
}
/**
*定义卡可以实现的所有颜色值
*/
公开枚举诉讼{
红心、钻石、梅花、黑桃
}
private Rank cardRank；//<将存储我们卡的等级
private Suit cardColor；//<将存储我们卡的颜色
private boolean faceUp；//<确定卡面向哪一侧
专用点位置；//<我们卡在板上的位置必须单独存储
私人点；//<向其他人提供卡的位置
///@2DD坐标
私有整数x=0；
私有整数y=0；
///卡的抵消
专用最终整数x_偏移=10；
专用最终整数y_偏移=20；
私有最终整数新的x偏移=x偏移+（卡片宽度-30）；
///卡图形视图的常量
最终静态公共int卡_宽度=100；
最终静态公共int卡_高度=150；
最终静态公共内角=25；
/**
*定义用于指定其参数的示例卡对象
*
*@param defRank-预定义的秩
*@param defColor-预定义颜色
*/
公共卡（等级defRank，套装defColor）{
cardRank=defRank；
cardColor=defColor；
faceUp=false；
位置=新点（）；
x=0；
y=0；
位置x=x；
位置y=y；
其中=新点（）；
}
/*用于绘制卡片颜色的函数
*
*@param defColor-定义所需的卡颜色（符号）
*@param defColorCode-定义符号应使用的实际颜色代码
*/
私人void抽衣（Graphics2D g、String defColor、Color defColorCode）
{
g、 setColor（defColorCode）；
g、 抽绳（defColor，location.x+x_偏移，location.y+y_偏移）；
g、 抽绳（defColor，location.x+x_偏移，location.y+CARD_高度-5）；
}
/**
*与颜色相似，但我们绘制的是值而不是符号
*@有关详细信息，请参阅drawColor
*/
私有void drawRank（Graphics2D g，字符串碎片整理）{
g、 抽绳（defRank，location.x+新的x\u偏移，location.y+y\u偏移）；
g、 抽绳（反存盘，位置.x+新的x\U偏移，位置.y+y\U偏移+卡片高度-25）；
}
/**
*基本上作为卡的主界面。创建带有图形显示的卡
*
*@param g2d-利用java图形库绘制我们定义函数的组件
*/
公共创建卡（图形g2d）{
Graphics2D g=（Graphics2D）g2d；//

在CardStack.java中

import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Color;
import java.awt.Graphics2D;
import java.util.ListIterator;
import java.util.Stack;
import java.util.Collections;
import javax.swing.*;

import java.awt.geom.RoundRectangle2D;
/**
  * We decided to fuse CardDeck with CardStack. CardDeck can contain multiple card stacks
  *
  * @param isDeck - a boolean that checks if we want a deck or only a stack. Deck contains all cards
  */
public CardStack(boolean isDeck) {
    deck = new Stack<Card>();
    this.setLayout(null);
    if(isDeck) {
        for (Card.Suit suit : Card.Suit.values()) {
            for (Card.Rank rank : Card.Rank.values()) {
                deck.push(new Card(rank, suit));
            }
        }
    } else
        playStack = true;
}


/**
      * Paints the entire component, similar to card
      *
      * @see Card
      * @param g - utilizes Graohic library.
      */
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        if (playStack) {
            removeAll();
            ListIterator<Card> iter = deck.listIterator();
            Point prev = new Point(); /// positioning relative to the container
            Point prevWhereAmI = new Point();/// abs positioning on the board
            if (iter.hasNext()) {
                Card c = iter.next();
                //// this origin is point(0,0) inside the cardstack container
                prev = new Point();/// c.getXY(); /// starting deck pos
                add(Solitaire.moveCard(c, prev.x, prev.y));
                /// setting x & y position
                c.setWhere(getXY());
                prevWhereAmI = getXY();
            } else {
                removeAll();
            }

            for (; iter.hasNext(); ) {
                Card c = iter.next();
                c.setXY(new Point(prev.x, prev.y + SPREAD));
                add(Solitaire.moveCard(c, prev.x, prev.y + SPREAD));
                prev = c.getXY();
                /// setting x & y position
                c.setWhere(new Point(prevWhereAmI.x, prevWhereAmI.y + SPREAD));
                prevWhereAmI = c.getWhere();
            }

        }
    }
protected void paintComponent(Graphics g, boolean isFinalStack)
{
    removeAll();
    if (!emptyStack())
    {
        add(Solitaire.moveCard(this.peekLast(), 1, 1));
    } else
    {
        /// draw back of card if empty
        Graphics2D g2d = (Graphics2D) g;
        RoundRectangle2D rect = new RoundRectangle2D.Double(0, 0, Card.CARD_WIDTH, Card.CARD_HEIGHT,
                Card.ANGLE, Card.ANGLE);
        g2d.setColor(Color.LIGHT_GRAY);
        g2d.fill(rect);
        g2d.setColor(Color.black);
        g2d.draw(rect);
    }

}

导入java.awt.Graphics；
导入java.awt.Point；
导入java.awt.Rectangle；
导入java.awt.Color；
导入java.awt.Graphics2D；
导入java.util.ListIterator；
导入java.util.Stack；
导入java.util.Collections；
导入javax.swing.*；
导入java.awt.geom.RoundRectangle2D；
/**
*我们决定将CardDeck与CardStack融合。CardDeck可以包含多个
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JEditorPane;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;

import src.ija.Card;
import src.ija.CardStack;

  /// GUI COMPONENTS (top level)
    private static final JFrame frame = new JFrame("IJA Klondike Solitaire");
    protected static final JPanel table = new JPanel();
    /// other components
    private static JEditorPane gameTitle = new JEditorPane("text/html", "");
    private static JButton showRulesButton = new JButton("Show Rules");
    private static JButton newGameButton = new JButton("New Game");
    private static JButton toggleTimerButton = new JButton("Pause Timer");
    private static JTextField scoreBox = new JTextField();/// displays the score
    private static JTextField timeBox = new JTextField();/// displays the time
    private static JTextField statusBox = new JTextField();/// status messages
    private static final Card newCardButton = new Card();/// reveal waste card

  private static void playNewGame()
    {
        deck = new CardStack(true); /// deal 52 cards
        deck.shuffle();
        table.removeAll();
        /// reset stacks if user starts a new game in the middle of one
        if (playCardStack != null && final_cards != null)
        {
            for (int x = 0; x < NUM_PLAY_DECKS; x++)
            {
                while(!playCardStack[x].emptyStack()){
                    playCardStack[x].popStack();
                }
            }
            for (int x = 0; x < NUM_FINAL_DECKS; x++)
            {
                while(!final_cards[x].emptyStack()){
                    final_cards[x].popStack();
                }
            }
        }
        /// initialize & place final (foundation) decks/stacks
        final_cards = new CardStack[NUM_FINAL_DECKS];
        for (int x = 0; x < NUM_FINAL_DECKS; x++)
        {
            final_cards[x] = new CardStack(false, true);

            final_cards[x].setXY((FINAL_POS.x + (x * Card.CARD_WIDTH)) + 10, FINAL_POS.y, true);
            table.add(final_cards[x]);

        }
        /// place new card distribution button
        table.add(moveCard(newCardButton, DECK_POS.x, DECK_POS.y));
        /// initialize & place play (tableau) decks/stacks
        playCardStack = new CardStack[NUM_PLAY_DECKS];
        for (int x = 0; x < NUM_PLAY_DECKS; x++)
        {
            playCardStack[x] = new CardStack(false);
            playCardStack[x].setXY((DECK_POS.x + (x * (Card.CARD_WIDTH + 10))), PLAY_POS.y);

            table.add(playCardStack[x]);
        }

        /// Dealing new game
        for (int x = 0; x < NUM_PLAY_DECKS; x++)
        {
            int hld = 0;
            Card c = deck.popStack().turnFaceUp();
            playCardStack[x].putFirst(c);

            for (int y = x + 1; y < NUM_PLAY_DECKS; y++)
            {
                playCardStack[y].putFirst(c = deck.popStack());
            }
        }
        /// reset time
        time = 0;
        newGameButton.addActionListener(new NewGameListener());
        newGameButton.setBounds(0, TABLE_HEIGHT - 70, 120, 30);

        showRulesButton.addActionListener(new ShowRulesListener());
        showRulesButton.setBounds(120, TABLE_HEIGHT - 70, 120, 30);

        gameTitle.setText("<b>IJA Solitaire</b> <br>");
        gameTitle.setEditable(false);
        gameTitle.setOpaque(false);
        gameTitle.setBounds(245, 20, 100, 100);

        scoreBox.setBounds(240, TABLE_HEIGHT - 70, 120, 30);
        scoreBox.setText("Score: 0");
        scoreBox.setEditable(false);
        scoreBox.setOpaque(false);

        timeBox.setBounds(360, TABLE_HEIGHT - 70, 120, 30);
        timeBox.setText("Seconds: 0");
        timeBox.setEditable(false);
        timeBox.setOpaque(false);

        startTimer();

        toggleTimerButton.setBounds(480, TABLE_HEIGHT - 70, 125, 30);
        toggleTimerButton.addActionListener(new ToggleTimerListener());

        statusBox.setBounds(605, TABLE_HEIGHT - 70, 180, 30);
        statusBox.setEditable(false);
        statusBox.setOpaque(false);

        table.add(statusBox);
        table.add(toggleTimerButton);
        table.add(gameTitle);
        table.add(timeBox);
        table.add(newGameButton);
        table.add(showRulesButton);
        table.add(scoreBox);
        table.repaint();
    }

  public static void main(String[] args)
    {

        Container contentPane;

        frame.setSize(TABLE_WIDTH, TABLE_HEIGHT);

        table.setLayout(null);
        table.setBackground(new Color(0, 180, 0));

        contentPane = frame.getContentPane();
        contentPane.add(table);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        playNewGame();

        table.addMouseListener(new CardMovementManager());
        table.addMouseMotionListener(new CardMovementManager());

        frame.setVisible(true);

    }
}