Java Swing--没有错误或异常，但程序没有'；我好像不工作

在我开始之前，我已经仔细检查了我的代码4个小时，直到我再也找不到了，来到这里是最后的选择，我不想浪费任何人的时间在愚蠢的问题上，但是，无论如何；在我的simon游戏中帮助我自学Java，还有几个问题。首先，showPattern方法似乎都不可靠。值得注意的是，它似乎并没有按照预期每次显示一种新颜色的相同图案。此外，单击正确的按钮时，当前/高分不会更新。到目前为止，我只发现了这些错误，可能还有其他错误

我只是发布整个程序，以便您可以复制和测试它。对不起，如果有点长。我真的很感激任何帮助，请不要像其他人一样愤世嫉俗

package simon;

import java.util.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.Color.*;
import javax.swing.Timer;


/**
 *  Main Class
 * @author Chris Mailloux
 */
class Simon
{


    public static void main (String[] args)
    {

        window.setBackground(Color.BLACK); 
        window.setVisible(true);
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    // Static object creations.
    public static GameWindow window = new GameWindow();

    // Variable declarations.
    public static final String[] colors = {"Green", "Red", "Yellow", "Blue"};
    public static ArrayList<String> pattern = new ArrayList<String>();
    public static int currentScore = 0;
    public static int iterator = 0;
    public static boolean isPlayerTurn = false;
    public static int highScore = 0; // TEMPORARY
}

/**
 * Class for main game window.
 * @author Chris
 */
class GameWindow extends JFrame
{
    GameWindow()
    {
        // Set basic properties of frame.
        setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
        setTitle("Simon");
        setResizable(true);
        setLocation(DEFAULT_HORIZONTAL_LOCATION, DEFAULT_VERTICAL_LOCATION);
        // PLACEHOLDER FOR IMAGE ICON

        // Adding Border layout helper panel.
        BorderPanel borderPanel = new BorderPanel();
        add(borderPanel);
    }

    // Declaring window positioning constants.
    public static final int DEFAULT_WIDTH = 800;
    public static final int DEFAULT_HEIGHT = 800;

    // TEMPORARY PLACEHOLDER FOR SCREENSIZE CALCULATIONS
    public static final int DEFAULT_HORIZONTAL_LOCATION = 0;
    public static final int DEFAULT_VERTICAL_LOCATION = 0;
}

/**
 * Class to hold the buttonsPanel
 * @author Chris
 */
class ButtonsPanel extends JPanel
{

    // Creating JButtons for gameplay.
    public static JButton greenButton = new JButton();
    public static JButton redButton = new JButton();
    public static JButton yellowButton = new JButton();
    public static JButton blueButton = new JButton();

    ButtonsPanel()
    {

       setBackground(Color.BLACK); 

       // Setting grid layout (with spaces)
       setLayout(new GridLayout(2, 2, 20, 20)); 

       // Setting background color of buttons.
       greenButton.setBackground(Color.GREEN);  // NEED COLOR CONSTANTS
       redButton.setBackground(Color.RED);  
       yellowButton.setBackground(Color.YELLOW);    
       blueButton.setBackground(Color.BLUE);

       // Add buttons to panel. (In order)
        add(greenButton);
        add(redButton);
        add(yellowButton);
        add(blueButton);

       // Creating ActionListeners for 4 main buttons.
        ActionListener greenAction = new ActionListener()
        {
            public void actionPerformed(ActionEvent event)
            {
                greenClicked();
            }
        };

        ActionListener redAction = new ActionListener()
        {
            public void actionPerformed(ActionEvent event)
            {
                redClicked();
            }
        };

        ActionListener yellowAction = new ActionListener()
        {
            public void actionPerformed(ActionEvent event)
            {
                yellowClicked();
            }
        };

        ActionListener blueAction = new ActionListener()
        {
            public void actionPerformed(ActionEvent event)
            {
                blueClicked();
            }
        };

            // Associate actions with buttons.
        greenButton.addActionListener(greenAction);
        redButton.addActionListener(redAction);
        yellowButton.addActionListener(yellowAction);
        blueButton.addActionListener(blueAction);
    }

        public static final int delay = 400;

        // Handling button activations.
        public static void greenClicked()
        {
            // Handling button Coloring/timing.
            greenButton.setBackground(Color.WHITE);
            greenButton.repaint();

            ActionListener taskPerformer = new ActionListener() 
            {
                public void actionPerformed(ActionEvent evt) 
                {
                greenButton.setBackground(Color.GREEN);
                }
            };

            Timer timer = new Timer(delay, taskPerformer);
            timer.setRepeats(false);
            timer.start();

            // Handling button Action
            if(Game.isPlayerTurn == true)
            {
                Game.check("Green");
            }
        }

        public static void redClicked()
        {
            // Handling button color and timing.
            redButton.setBackground(Color.WHITE);
            redButton.repaint();

            ActionListener taskPerformer = new ActionListener() 
            {
                public void actionPerformed(ActionEvent evt) 
                {
                    redButton.setBackground(Color.RED);
                }
            };

            Timer timer = new Timer(delay, taskPerformer);
            timer.setRepeats(false);
            timer.start();

            // Handling button actions.
            if(Game.isPlayerTurn == true)
            {
                Game.check("Red");
            }
        }

        public static void yellowClicked()
        {

            // Handling button color and timing.
            yellowButton.setBackground(Color.WHITE);
            yellowButton.repaint();

            ActionListener taskPerformer = new ActionListener() 
            {
                public void actionPerformed(ActionEvent evt) 
                {
                    yellowButton.setBackground(Color.YELLOW);
                }
            };

            Timer timer = new Timer(delay, taskPerformer);
            timer.setRepeats(false);
            timer.start();

            // Handling button actions.
            if(Game.isPlayerTurn == true)
            {
                Game.check("Yellow");
            }
        }

        public static void blueClicked()
        { 
            // Handling button color and timing.
            blueButton.setBackground(Color.WHITE);
            blueButton.repaint();

            ActionListener taskPerformer = new ActionListener() 
            {
                public void actionPerformed(ActionEvent evt) 
                {
                    blueButton.setBackground(Color.BLUE);
                }
            };

            Timer timer = new Timer(delay, taskPerformer);
            timer.setRepeats(false);
            timer.start();

            // Handling button actions.
            if(Game.isPlayerTurn == true)
            {
                Game.check("Blue");  
            }
        }

}
/**
 * Menu buttons panel.
 * @author Chris Mailloux
 */
class MenuPanel extends JPanel    
{    

    static JButton startButton;
    static JButton scoreDisplay;
    static JButton highScoreDisplay;

    public MenuPanel()
    {
        setBackground(Color.BLACK);

        // Menu panel buttons.
        startButton = new JButton("Start");
        scoreDisplay = new JButton(String.valueOf(Simon.currentScore));
        highScoreDisplay = new JButton(String.valueOf(Simon.highScore));

        // Adding Buttons
        add(startButton);
        add(scoreDisplay);
        add(highScoreDisplay);

        // Setting background colors
        scoreDisplay.setBackground(Color.BLACK);
        highScoreDisplay.setBackground(Color.BLACK);
        startButton.setBackground(Color.BLUE);

        // Disabling displays
        scoreDisplay.setEnabled(false);
        highScoreDisplay.setEnabled(false);

        // ActionListeners for menu buttons.
        ActionListener startButtonAction = new ActionListener()
        {
            public void actionPerformed(ActionEvent event)
            {
                Game.startGame();
            }
        };
        startButton.addActionListener(startButtonAction);

        startButton.setFocusable(false);
    }
 }

/**
 * Border Panel support class.
 * @author Chris Mailloux
 */
class BorderPanel extends JPanel
{

    BorderPanel()
    {
        setLayout(new BorderLayout());
        add(new MenuPanel(), BorderLayout.NORTH);
        add(new ButtonsPanel(), BorderLayout.CENTER);

    }
}
/**
* Main game logic class.
* @author Chris
*/
class Game extends Simon
{   

// Resets variables for new game.
public static void startGame()
{
    isPlayerTurn = false;
    pattern.clear();
    currentScore = 0;
    iterator = 0;

    gamePlay(); // Should Start game
}

public static void gamePlay()
{
    if (isPlayerTurn == false)
    {
        computerTurn();
    }
    else
    {
        playerTurn();
    }
}

public static void computerTurn()
{
    // Isn't working.
    ButtonsPanel.greenButton.setEnabled(false);
    ButtonsPanel.redButton.setEnabled(false);
    ButtonsPanel.yellowButton.setEnabled(false);
    ButtonsPanel.blueButton.setEnabled(false);

    iterator = 0; // So CPU can use iterator to show pattern.
    Random generator = new Random();
    int randInt = generator.nextInt(4);
    String randColor = colors[randInt];
    System.out.println(randColor); // For testing.
    pattern.add(new String(randColor));
    showPattern();
}

public static void playerTurn()
{
    iterator = 0;
    ButtonsPanel.greenButton.setEnabled(true);
    ButtonsPanel.redButton.setEnabled(true);
    ButtonsPanel.yellowButton.setEnabled(true);
    ButtonsPanel.blueButton.setEnabled(true);
}

/**
 * Handles scoring and checks inputs for correctness.
 * @author Chris Mailloux
 */
public static void check(String lastInput)
{
    if (lastInput.equals(pattern.get(iterator)))
    {
        iterator++;
        if(iterator > currentScore)
        {
            currentScore++;
            MenuPanel.scoreDisplay.repaint();
            if(currentScore > highScore)
            {
                highScore++;
                // PLACEHOLDER TO WRITE HIGHSCORE TO FILE.
            }
        }
        if (iterator == pattern.size());
        {
            isPlayerTurn = false;
            computerTurn();
        }
    }
    else
    {
        gameOver();
    }
}

public static void showPattern()
{
    int j = 0;
    while (j < pattern.size())
    {
        String showerHelper = pattern.get(j); // Helper variable.
        switch (showerHelper)
        {
            case "Green" : ButtonsPanel.greenClicked();
            case "Red" : ButtonsPanel.redClicked();
            case "Yellow" : ButtonsPanel.yellowClicked();
            case "Blue" : ButtonsPanel.blueClicked();
            break; // Fallthrough handler.
            default: System.out.println("Error: Invalid value for pattern"
                    + " ArrayList, or improper storage of variable in the"
                    + " showerHelper variable.");
        }
        j++;
    }
    isPlayerTurn = true;
    gamePlay();
}

public static void gameOver()
{
    System.out.println("YOU LOSE!");
    // PLACEHOLDER TO PLAY GAMEOVER SOUND
}

} // End of game class.

package；
导入java.util.*；
导入javax.swing.*；
导入java.awt.*；
导入java.awt.event.*；
导入java.awt.Color.*；
导入javax.swing.Timer；
/**
*主类
*@作者Chris Mailloux
*/
西蒙班
{
公共静态void main（字符串[]args）
{
窗户。背景（颜色。黑色）；
window.setVisible（true）；
window.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
}
//静态对象创建。
公共静态游戏窗口=新建游戏窗口（）；
//变量声明。
公共静态最终字符串[]颜色={“绿色”、“红色”、“黄色”、“蓝色”}；
公共静态ArrayList模式=新建ArrayList（）；
公共静态int currentScore=0；
公共静态int迭代器=0；
公共静态布尔值isPlayerTurn=false；
public static int highScore=0；//临时
}
/**
*类用于主游戏窗口。
*@作者克里斯
*/
类GameWindow扩展了JFrame
{
游戏窗口（）
{
//设置框架的基本属性。
设置大小（默认宽度、默认高度）；
片名（“西蒙”）；
可设置大小（真）；
设置位置（默认水平位置、默认垂直位置）；
//图像图标的占位符
//添加边框布局辅助面板。
BorderPanel BorderPanel=新的BorderPanel（）；
添加（边框面板）；
}
//声明窗口定位常量。
公共静态最终整数默认值_宽度=800；
公共静态最终int默认值_高度=800；
//屏幕大小计算的临时占位符
公共静态最终整数默认水平位置=0；
公共静态最终整数默认值垂直位置=0；
}
/**
*类来按住按钮面板
*@作者克里斯
*/
类按钮面板扩展了JPanel
{
//为游戏性创建JButtons。
公共静态JButton greenButton=新JButton（）；
公共静态JButton redButton=新JButton（）；
公共静态JButton yellowButton=新JButton（）；
公共静态JButton blueButton=新JButton（）；
按钮板（）
{
挫折背景（颜色：黑色）；
//设置栅格布局（带空间）
setLayout（新的GridLayout（2,2,20,20））；
//设置按钮的背景色。
greenButton.setBackground（Color.GREEN）；//需要颜色常量
红色按钮。背景（颜色。红色）；
黄色按钮。背景（颜色。黄色）；
蓝色按钮。挫折背景（颜色。蓝色）；
//将按钮添加到面板。（按顺序）
添加（绿色按钮）；
添加（红色按钮）；
添加（黄色按钮）；
添加（蓝色按钮）；
//为4个主按钮创建ActionListeners。
ActionListener greenAction=新建ActionListener（）
{
已执行的公共无效操作（操作事件）
{
绿色点击（）；
}
};
ActionListener编校=新建ActionListener（）
{
已执行的公共无效操作（操作事件）
{
单击鼠标右键（）；
}
};
ActionListener yellowAction=新建ActionListener（）
{
已执行的公共无效操作（操作事件）
{
黄色点击（）；
}
};
ActionListener blueAction=新建ActionListener（）
{
已执行的公共无效操作（操作事件）
{
蓝色点击（）；
}
};
//将操作与按钮关联。
greenButton.addActionListener（greenAction）；
redButton.addActionListener（编校）；
yellowButton.addActionListener（yellowAction）；
addActionListener（blueAction）；
}
公共静态最终整数延迟=400；
//处理按钮激活。
公共静态无效（）
{
//处理按钮着色/计时。
绿色按钮。背景（颜色。白色）；
greenButton.repaint（）；
ActionListener taskPerformer=新建ActionListener（）
{
已执行的公共无效操作（操作事件evt）
{
绿色按钮。背景（颜色。绿色）；
}
};
计时器=新计时器（延迟、任务执行者）；
timer.setRepeats（假）；
timer.start（）；
//操纵按钮动作
如果（Game.isPlayerTurn==true）
{
游戏。检查（“绿色”）；
}
}
公共静态void redClicked（）
{
//处理按钮颜色和时间。
红色按钮。背景（颜色。白色）；
redButton.repaint（）；
ActionListener taskPerformer=新建ActionListener（）
{
已执行的公共无效操作（操作事件evt）
{
红色按钮。背景（颜色。红色）；
}
};
计时器=新计时器（延迟、任务执行者）；
timer.setRepeats（假）；
timer.start（）；
//处理按钮操作。
如果（Game.isPlayerTurn==true）
{
    try
    {
        Thread.sleep(400);
    }
    catch(InterruptedException e)
    {    
    }
    blueButton.setBackground(Color.BLUE);

            int delay = 400; //milliseconds
            ActionListener taskPerformer = new ActionListener() {
                public void actionPerformed(ActionEvent evt) {
                    //...Perform a task...
                    blueButton.setBackground(Color.BLUE);
                }
            };
            Timer timer = new Timer(delay, taskPerformer);
            timer.setRepeats(false);
            timer.start();