SwingWorker，Thread.sleep（）或javax.swing.timer？ 我需要“插入暫停”

Question

我正在做一個記憶游戲，所以我想設置它，所以我單擊第一個"card" ，然后單擊第二個卡片；如果它們不相同，則第二個卡片顯示幾秒鍾，然后它們返回"non-flipped"卡片。 "non-flipped"位置。

我嘗試使用SwingWorker ， Thread.sleep和SwingTimer但無法正常工作。 使用Thread.sleep ，如果第二張卡重復，則第二張卡不會"flip" ，它會等待一段時間的睡眠時間並消失。 如果不匹配，它將等待“面朝下”，並且在睡眠計時器之后，第一張卡確實會向后翻轉。 無論我將Thread.sleep放在哪里，都會發生這種情況。

使用Swing Timer ，當我與卡片互動時，它似乎只是“更改計時器”，因此最終在激活之前翻轉了8張卡片。

我在SwingWorker運氣不好，甚至不確定它是否SwingWorker我的需求。

這是我的代碼：

    class ButtonListener implements ActionListener
    {

        public void actionPerformed(ActionEvent e) 
        {
            for(int index = 0; index < arraySize; index++)
            {

                if(button[index] == e.getSource())
                {
                    button[index].setText(String.valueOf(cards.get(index)));
                    button[index].setEnabled(false);

                    number[counter]=cards.get(index);

                    if (counter == 0)
                    {
                        counter++;
                    }
                    else if (counter == 1)
                    {   
                        if (number[0] == number[1])
                        {
                            for(int i = 0; i < arraySize; i++)
                            {
                                if(!button[i].isEnabled())
                                {
                                    button[i].setVisible(false);
                                }
                            }
                        }
                        else
                        {
                            for(int i = 0; i < arraySize; i++)
                            {
                                if(!button[i].isEnabled())
                                {
                                    button[i].setEnabled(true);
                                    button[i].setText("Card");
                                }
                            }
                        }

                        counter = 0;
                    }
                }
            }
        }
    }

基本上，我需要的是在計數器== 1且卡不匹配時執行此代碼：

    button[index].setText(String.valueOf(cards.get(index)));
                    button[index].setEnabled(false);

然后暫停片刻，以使card is revealed在該時間card is revealed ，最后恢復到將卡放回其正面朝下的位置。

這是我用Thread.sleep()嘗試的：

class ButtonListener implements ActionListener
    {

        public void actionPerformed(ActionEvent e) 
        {
            for(int index = 0; index < arraySize; index++)
            {

                if(button[index] == e.getSource())
                {
                    button[index].setText(String.valueOf(cards.get(index)));
                    button[index].setEnabled(false);

                    number[counter]=cards.get(index);

                    if (counter == 0)
                    {
                        counter++;
                    }
                    else if (counter == 1)
                    {   
                        if (number[0] == number[1])
                        {
                            for(int i = 0; i < arraySize; i++)
                            {
                                if(!button[i].isEnabled())
                                {
                                    button[i].setVisible(false);
                                }
                            }
                        }
                        else
                        {
                            try 
                            {
                                Thread.sleep(800);
                            } 
                            catch (InterruptedException e1) 
                            {
                                e1.printStackTrace();
                            }

                            for(int i = 0; i < arraySize; i++)
                            {
                                if(!button[i].isEnabled())
                                {
                                    button[i].setEnabled(true);
                                    button[i].setText("Card");
                                }
                            }
                        }

                        counter = 0;
                    }
                }
            }
        }
    }

預先感謝您的任何建議

Answer 1

使用javax.swing.Timer安排將來的事件來觸發。 這將允許您安全地對UI進行更改，因為計時器是在事件調度線程的上下文中觸發的。

能夠同時翻轉多張卡片的問題更多與您沒有設置阻止用戶翻轉卡片的狀態而不是使用計時器有關。

以下示例基本上只允許每組一次翻轉一張卡。

一旦在兩個組中都翻轉了卡，就啟動計時器。 觸發后，卡將重置。

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.LinearGradientPaint;
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.awt.image.BufferedImage;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.border.LineBorder;

public class FlipCards {

    public static void main(String[] args) {
        new FlipCards();
    }

    public FlipCards() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class Card extends JPanel {

        private BufferedImage image;
        private boolean flipped = false;

        private Dimension prefSize;

        public Card(BufferedImage image, Dimension prefSize) {
            setBorder(new LineBorder(Color.DARK_GRAY));
            this.image = image;
            this.prefSize = prefSize;
        }

        @Override
        public Dimension getPreferredSize() {
            return prefSize;
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            LinearGradientPaint lgp = new LinearGradientPaint(
                    new Point(0, 0),
                    new Point(0, getHeight()),
                    new float[]{0f, 1f},
                    new Color[]{Color.WHITE, Color.GRAY});
            g2d.setPaint(lgp);
            g2d.fill(new Rectangle(0, 0, getWidth(), getHeight()));
            if (flipped && image != null) {
                int x = (getWidth() - image.getWidth()) / 2;
                int y = (getHeight() - image.getHeight()) / 2;
                g2d.drawImage(image, x, y, this);
            }
            g2d.dispose();
        }

        public void setFlipped(boolean flipped) {

            this.flipped = flipped;
            repaint();

        }
    }

    public class CardsPane extends JPanel {

        private Card flippedCard = null;

        public CardsPane(List<BufferedImage> images, Dimension prefSize) {
            setLayout(new GridBagLayout());
            MouseAdapter mouseHandler = new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    if (flippedCard == null) {
                        Card card = (Card) e.getComponent();
                        card.setFlipped(true);
                        flippedCard = card;
                        firePropertyChange("flippedCard", null, card);
                    }
                }
            };
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.insets = new Insets(4, 4, 4, 4);
            gbc.fill = GridBagConstraints.BOTH;
            gbc.weightx = 0.25f;
            for (BufferedImage img : images) {
                Card card = new Card(img, prefSize);
                card.addMouseListener(mouseHandler);
                add(card, gbc);
            }
        }

        public Card getFlippedCard() {
            return flippedCard;
        }

        public void reset() {
            if (flippedCard != null) {
                flippedCard.setFlipped(false);
                flippedCard = null;
            }
        }
    }

    public class TestPane extends JPanel {

        private CardsPane topCards;
        private CardsPane bottomCards;

        private Timer resetTimer;

        public TestPane() {

            resetTimer = new Timer(1000, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    topCards.reset();
                    bottomCards.reset();
                }
            });
            resetTimer.setRepeats(false);
            resetTimer.setCoalesce(true);

            PropertyChangeListener propertyChangeHandler = new PropertyChangeListener() {
                @Override
                public void propertyChange(PropertyChangeEvent evt) {
                    Card top = topCards.getFlippedCard();
                    Card bottom = bottomCards.getFlippedCard();
                    if (top != null && bottom != null) {
                        resetTimer.start();
                    }
                }
            };
            BufferedImage[] images = new BufferedImage[4];
            try {
                images[0] = ImageIO.read(new File("./Card01.png"));
                images[1] = ImageIO.read(new File("./Card02.jpg"));
                images[2] = ImageIO.read(new File("./Card03.jpg"));
                images[3] = ImageIO.read(new File("./Card04.png"));

                Dimension prefSize = getMaxBounds(images);

                List<BufferedImage> topImages = new ArrayList<>(Arrays.asList(images));
                Random rnd = new Random(System.currentTimeMillis());
                int rotate = (int) Math.round((rnd.nextFloat() * 200) - 50);
                Collections.rotate(topImages, rotate);
                topCards = new CardsPane(topImages, prefSize);
                topCards.addPropertyChangeListener("flippedCard", propertyChangeHandler);

                List<BufferedImage> botImages = new ArrayList<>(Arrays.asList(images));

                int botRotate = (int) Math.round((rnd.nextFloat() * 200) - 50);
                Collections.rotate(botImages, botRotate);
                bottomCards = new CardsPane(botImages, prefSize);
                bottomCards.addPropertyChangeListener("flippedCard", propertyChangeHandler);

                setLayout(new GridBagLayout());
                GridBagConstraints gbc = new GridBagConstraints();
                gbc.insets = new Insets(4, 4, 4, 4);
                gbc.gridwidth = GridBagConstraints.REMAINDER;
                add(topCards, gbc);
                add(bottomCards, gbc);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        protected Dimension getMaxBounds(BufferedImage[] images) {
            int width = 0;
            int height = 0;

            for (BufferedImage img : images) {
                width = Math.max(width, img.getWidth());
                height = Math.max(height, img.getHeight());
            }

            return new Dimension(width, height);
        }
    }
}