如何使用javax.swing.Timer暫停GUI程序

Question

在問這個問題之前，我已經進行了研究，並嘗試了幾件事，但似乎沒有任何效果。

下面，我包括了代碼的簡化版本。

我有一個程序，基本上可以在國際象棋桌上移動棋子。 該表是使用類JTable實現的。 我試圖做到的是創建每次移動之間的延遲幾秒鍾。

該表是擴展JTable的類。 構造函數在桌子上創建一個棋子。

public Table (int rows, int columns)
{
    ChessPiece piece = new ChessPiece();
}

桌子上有一個菜單，可移動棋子。 此選項將棋子前進通過調用方法moveForward移動（）。

JMenuBar menuBar = new JMenuBar();
JMenu menu       = new JMenu("Menu");
JMenuItem item   = new JMenuItem("Move Chess Piece");
menu.add(item);
menuBar.add(menu);
item.addActionListener(new ActionListener()
                       {
                           public void actionPerformed(ActionEvent event)
                           {
                               piece.moveForward();
                           }
                       });
setJMenuBar(menuBar);

要啟動該程序，請執行以下操作：

Table table = new Table();
javax.swing.SwingUtilities.invokeLater( new Runnable()
                                        { public void run()
                                          {
                                              table.setVisible(true);
                                          }
                                        } );

因此，為了建立一個連接的延遲秒，我第一次嘗試以下操作：

public void moveForward()
{
    // Sleep for a couple of seconds before moving.
    try { Thread.sleep(SLEEP_TIME);}
    catch(InterruptedException ex) { Thread.currentThread().interrupt(); }

    .....<code to move the chess piece forward>....
}

當我單擊“移動棋子”選項時，這將導致整個GUI凍結。 對我來說，尚不清楚為什么程序會如此運行。 如果有人能用簡單的英語給我解釋，我將不勝感激！

我環顧四周，被告知，我應該使用java.swing.Timer。 所以我將代碼更改為以下內容：

public void moveForward()
{
    ActionListener taskPerformer = new ActionListener() {
                                       public void actionPerformed(ActionEvent evt)
                                       {
                                           System.out.println("Hello!");

                                       }
                                     };
    javax.swing.Timer t = new javax.swing.Timer(10000, taskPerformer);
    t.setRepeats(false);
    t.start();

    .....<code to move the chess piece forward>....
}

當我單擊“移動棋子”選項時，GUI不再凍結，但是它什么也沒做。 我沒有期望有10秒鍾的延遲。

請告知這里有什么問題！

提前致謝。

Answer 1

這看起來很完美，可以將棋子從起始位置逐個移動到棋盤中心的前面。

為了盡快獲得更好的幫助，請發布行為不同的“ 最小完整測試和可讀示例” （如此代碼）。 此MCTRE基於制作強大的，可調整大小的Swing Chess GUI中可見的代碼。

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import javax.swing.*;
import javax.swing.border.*;
import java.net.URL;
import javax.imageio.ImageIO;

public class AnimatedChessGui {

    private final JPanel gui = new JPanel(new BorderLayout(3, 3));
    private JButton[][] chessBoardSquares = new JButton[8][8];
    private Image[][] chessPieceImages = new Image[2][6];
    private JPanel chessBoard;
    private final JLabel message = new JLabel(
            "Chess Champ is ready to play!");
    private static final String COLS = "ABCDEFGH";
    public static final int QUEEN = 0, KING = 1,
            ROOK = 2, KNIGHT = 3, BISHOP = 4, PAWN = 5;
    public static final int[] STARTING_ROW = {
        ROOK, KNIGHT, BISHOP, KING, QUEEN, BISHOP, KNIGHT, ROOK
    };
    public static final int BLACK = 0, WHITE = 1;
    private Timer timer;

    AnimatedChessGui() {
        initializeGui();
    }

    public void animateChessPieces() {
        timer = new Timer(1000, new ActionListener() {

            int count = 0;

            @Override
            public void actionPerformed(ActionEvent e) {
                if (count % 2 == 0) {
                    chessBoardSquares[count/2][1].setIcon(null);
                    chessBoardSquares[count/2][3].setIcon(new ImageIcon(
                            chessPieceImages[BLACK][PAWN]));
                } else {
                    chessBoardSquares[count/2][6].setIcon(null);
                    chessBoardSquares[count/2][4].setIcon(new ImageIcon(
                            chessPieceImages[WHITE][PAWN]));
                }
                count++;
                if (count == 16) {
                    timer.stop();
                }
            }
        });
        timer.start();
    }

    public final void initializeGui() {
        // create the images for the chess pieces
        createImages();

        // set up the main GUI
        gui.setBorder(new EmptyBorder(5, 5, 5, 5));
        JToolBar tools = new JToolBar();
        tools.setFloatable(false);
        gui.add(tools, BorderLayout.PAGE_START);
        Action newGameAction = new AbstractAction("New") {

            @Override
            public void actionPerformed(ActionEvent e) {
                setupNewGame();
            }
        };
        tools.add(newGameAction);
        tools.add(new JButton("Save")); // TODO - add functionality!
        tools.add(new JButton("Restore")); // TODO - add functionality!
        tools.addSeparator();
        tools.add(new JButton("Resign")); // TODO - add functionality!
        tools.addSeparator();
        tools.add(message);

        gui.add(new JLabel("?"), BorderLayout.LINE_START);

        chessBoard = new JPanel(new GridLayout(0, 9)) {

            /**
             * Override the preferred size to return the largest it can, in a
             * square shape. Must (must, must) be added to a GridBagLayout as
             * the only component (it uses the parent as a guide to size) with
             * no GridBagConstaint (so it is centered).
             */
            @Override
            public final Dimension getPreferredSize() {
                Dimension d = super.getPreferredSize();
                Dimension prefSize = null;
                Component c = getParent();
                if (c == null) {
                    prefSize = new Dimension(
                            (int) d.getWidth(), (int) d.getHeight());
                } else if (c != null
                        && c.getWidth() > d.getWidth()
                        && c.getHeight() > d.getHeight()) {
                    prefSize = c.getSize();
                } else {
                    prefSize = d;
                }
                int w = (int) prefSize.getWidth();
                int h = (int) prefSize.getHeight();
                // the smaller of the two sizes
                int s = (w > h ? h : w);
                return new Dimension(s, s);
            }
        };
        chessBoard.setBorder(new CompoundBorder(
                new EmptyBorder(8, 8, 8, 8),
                new LineBorder(Color.BLACK)));
        // Set the BG to be ochre
        Color ochre = new Color(204, 119, 34);
        chessBoard.setBackground(ochre);
        JPanel boardConstrain = new JPanel(new GridBagLayout());
        boardConstrain.setBackground(ochre);
        boardConstrain.add(chessBoard);
        gui.add(boardConstrain);

        // create the chess board squares
        Insets buttonMargin = new Insets(0, 0, 0, 0);
        for (int ii = 0; ii < chessBoardSquares.length; ii++) {
            for (int jj = 0; jj < chessBoardSquares[ii].length; jj++) {
                JButton b = new JButton();
                b.setMargin(buttonMargin);
                // our chess pieces are 64x64 px in size, so we'll
                // 'fill this in' using a transparent icon..
                ImageIcon icon = new ImageIcon(
                        new BufferedImage(64, 64, BufferedImage.TYPE_INT_ARGB));
                b.setIcon(icon);
                if ((jj % 2 == 1 && ii % 2 == 1)
                        //) {
                        || (jj % 2 == 0 && ii % 2 == 0)) {
                    b.setBackground(Color.WHITE);
                } else {
                    b.setBackground(Color.BLACK);
                }
                chessBoardSquares[jj][ii] = b;
            }
        }

        /*
         * fill the chess board
         */
        chessBoard.add(new JLabel(""));
        // fill the top row
        for (int ii = 0; ii < 8; ii++) {
            chessBoard.add(
                    new JLabel(COLS.substring(ii, ii + 1),
                    SwingConstants.CENTER));
        }
        // fill the black non-pawn piece row
        for (int ii = 0; ii < 8; ii++) {
            for (int jj = 0; jj < 8; jj++) {
                switch (jj) {
                    case 0:
                        chessBoard.add(new JLabel("" + (9 - (ii + 1)),
                                SwingConstants.CENTER));
                    default:
                        chessBoard.add(chessBoardSquares[jj][ii]);
                }
            }
        }
    }

    public final JComponent getGui() {
        return gui;
    }

    private final void createImages() {
        try {
            URL url = new URL("http://i.stack.imgur.com/memI0.png");
            BufferedImage bi = ImageIO.read(url);
            for (int ii = 0; ii < 2; ii++) {
                for (int jj = 0; jj < 6; jj++) {
                    chessPieceImages[ii][jj] = bi.getSubimage(
                            jj * 64, ii * 64, 64, 64);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    /**
     * Initializes the icons of the initial chess board piece places
     */
    private final void setupNewGame() {
        message.setText("Make your move!");
        // set up the black pieces
        for (int ii = 0; ii < STARTING_ROW.length; ii++) {
            chessBoardSquares[ii][0].setIcon(new ImageIcon(
                    chessPieceImages[BLACK][STARTING_ROW[ii]]));
        }
        for (int ii = 0; ii < STARTING_ROW.length; ii++) {
            chessBoardSquares[ii][1].setIcon(new ImageIcon(
                    chessPieceImages[BLACK][PAWN]));
        }
        // set up the white pieces
        for (int ii = 0; ii < STARTING_ROW.length; ii++) {
            chessBoardSquares[ii][6].setIcon(new ImageIcon(
                    chessPieceImages[WHITE][PAWN]));
        }
        for (int ii = 0; ii < STARTING_ROW.length; ii++) {
            chessBoardSquares[ii][7].setIcon(new ImageIcon(
                    chessPieceImages[WHITE][STARTING_ROW[ii]]));
        }
    }

    public static void main(String[] args) {
        Runnable r = new Runnable() {

            @Override
            public void run() {
                AnimatedChessGui acg = new AnimatedChessGui();

                JFrame f = new JFrame("ChessChamp");
                f.add(acg.getGui());
                // Ensures JVM closes after frame(s) closed and
                // all non-daemon threads are finished
                f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                // See https://stackoverflow.com/a/7143398/418556 for demo.
                f.setLocationByPlatform(true);

                // ensures the frame is the minimum size it needs to be
                // in order display the components within it
                f.pack();
                // ensures the minimum size is enforced.
                f.setMinimumSize(f.getSize());
                f.setVisible(true);
                acg.setupNewGame();
                acg.animateChessPieces();
            }
        };
        // Swing GUIs should be created and updated on the EDT
        // http://docs.oracle.com/javase/tutorial/uiswing/concurrency
        SwingUtilities.invokeLater(r);
    }
}