Java Frame fillRect setColor不工作

我可以打开java应用程序，但我没有看到任何颜色或我创建的4个矩形，我没有看到任何错误，任何帮助都将不胜感激。提前谢谢。我试着去探究它为什么不创造它们，但我看不出它为什么不创造它们。是否应该创建fillRect，或者我在这里遗漏了什么

simon.java

public class Simon implements ActionListener
{

public static Simon simon;

public Renderer renderer;

public static final int WIDTH = 800, HEIGHT = 800;

public Simon()
{
    JFrame frame = new JFrame("Simon");
    Timer timer = new Timer(20, this);

    renderer = new Renderer();

    frame.setSize(WIDTH + 15, HEIGHT + 38);
    frame.setVisible(true);
    frame.add(renderer);
    frame.setResizable(false);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    timer.start();

}

public static void main(String[] args)
{
    simon = new Simon();
}

@Override
public void actionPerformed(ActionEvent e) 
{

    renderer.repaint();

}

public void paint(Graphics2D g) 
{

    g.setColor(Color.GRAY);
    g.fillRect(0, 0, WIDTH + 15, HEIGHT + 35);

    g.setColor(Color.GREEN);
    g.fillRect(0, 0, WIDTH / 2, HEIGHT / 2);

    g.setColor(Color.RED);
    g.fillRect(WIDTH / 2, 0, WIDTH / 2, HEIGHT / 2);

    g.setColor(Color.ORANGE);
    g.fillRect(0, HEIGHT / 2, WIDTH / 2, HEIGHT / 2);

    g.setColor(Color.BLUE);
    g.fillRect(WIDTH / 2, HEIGHT / 2, WIDTH / 2, HEIGHT / 2);




}

}

Renderer.java

package Simon;

import java.awt.Graphics;
import java.awt.Graphics2D;
import javax.swing.JPanel;

@SuppressWarnings("serial")
public class Renderer extends JPanel
{
@Override
protected void paintComponent(Graphics g)
{
    super.paintComponent(g);

    if(Simon.simon !=null)
    {   
        Simon.simon.paint((Graphics2D) g);
    }

}

}

---

您的方法是不可扩展的

这是一个西蒙说的图形用户界面，我把它放在一起。它显示前10个计算机序列，一次显示一个

首先，我创建GUI。我在扩展的JPanel上绘制圆段。我在游戏模型中创建并保存有关游戏的信息。通过将模型与视图和控制器分离，我可以一次专注于游戏的一部分

这是代码。我将所有的类放在一起，以便于粘贴代码。您应该将这些类分离到它们自己的文件中

package com.ggl.testing;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.Arc2D;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class SimonShape implements Runnable {

    private GameModel gameModel;

    private JFrame frame;

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new SimonShape());
    }

    public SimonShape() {
        this.gameModel = new GameModel();
    }

    @Override
    public void run() {
        frame = new JFrame("Simon Says");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        DrawingPanel drawingPanel = new DrawingPanel();
        frame.add(drawingPanel);

        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);

        GameRunnable runnable = new GameRunnable(drawingPanel, gameModel);
        new Thread(runnable).start();
    }

    public class DrawingPanel extends JPanel {

        private static final long serialVersionUID = 70146219705119575L;

        private List<ArcModel> segments;

        public DrawingPanel() {
            this.segments = new ArrayList<ArcModel>();

            int margin = 50;
            int diameter = 300;
            Rectangle r = new Rectangle(margin, margin, diameter, diameter);

            segments.add(new ArcModel(Color.GREEN, r, 180, 90, Arc2D.PIE));
            segments.add(new ArcModel(Color.BLUE, r, 270, 90, Arc2D.PIE));
            segments.add(new ArcModel(Color.RED, r, 360, 90, Arc2D.PIE));
            segments.add(new ArcModel(Color.YELLOW, r, 90, 90, Arc2D.PIE));

            int width = diameter + margin + margin;
            this.setPreferredSize(new Dimension(width, width));
        }

        public void brighterArcModelColor(int index) {
            segments.get(index).brighterColor();
            repaint();
        }

        public void darkerArcModelColor(int index) {
            segments.get(index).darkerColor();
            repaint();
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);

            Graphics2D g2d = (Graphics2D) g;

            for (ArcModel arcModel : segments) {
                g2d.setPaint(arcModel.getColor());
                Rectangle r = arcModel.getRectangle();
                g2d.fill(new Arc2D.Double(r.getX(), r.getY(), r.getWidth(), r
                        .getHeight(), arcModel.getStartingAngle(), arcModel
                        .getExtent(), arcModel.getClosureType()));
            }
        }

    }

    public class ArcModel {

        private final int closureType;

        private final double startingAngle;
        private final double extent;

        private Color color;
        private final Color originalColor;

        private final Rectangle rectangle;

        public ArcModel(Color color, Rectangle rectangle, double startingAngle,
                double extent, int closureType) {
            this.color = color;
            this.originalColor = color;
            this.rectangle = rectangle;
            this.startingAngle = startingAngle;
            this.extent = extent;
            this.closureType = closureType;
        }

        public int getClosureType() {
            return closureType;
        }

        public double getStartingAngle() {
            return startingAngle;
        }

        public double getExtent() {
            return extent;
        }

        public Rectangle getRectangle() {
            return rectangle;
        }

        public Color getColor() {
            return color;
        }

        public void brighterColor() {
            this.color = Color.WHITE;
        }

        public void darkerColor() {
            this.color = originalColor;
        }

    }

    public class GameModel {

        private List<Integer> computerSequence;
        private List<Integer> playerSequence;

        private Random random;

        public GameModel() {
            this.computerSequence = new ArrayList<Integer>();
            this.playerSequence = new ArrayList<Integer>();
            this.random = new Random();
        }

        public void addToComputerSequence() {
            computerSequence.add(Integer.valueOf(random.nextInt(4)));
        }

        public void clearComputerSequence() {
            computerSequence.clear();
        }

        public List<Integer> getComputerSequence() {
            return computerSequence;
        }

        public void clearPlayerSequence() {
            playerSequence.clear();
        }

        public void addToPlayerSequence(int number) {
            playerSequence.add(Integer.valueOf(number));
        }

        public boolean doSequencesMatch() {
            if (computerSequence.size() == playerSequence.size()) {
                for (int i = 0; i < computerSequence.size(); i++) {
                    int computer = computerSequence.get(i);
                    int player = playerSequence.get(i);
                    if (computer != player) {
                        return false;
                    }
                }

                return true;
            }

            return false;
        }

    }

    public class GameRunnable implements Runnable {

        private volatile boolean running;

        private DrawingPanel drawingPanel;

        private GameModel gameModel;

        public GameRunnable(DrawingPanel drawingPanel, GameModel gameModel) {
            this.drawingPanel = drawingPanel;
            this.gameModel = gameModel;
        }

        @Override
        public void run() {
            running = true;
            while (running && gameModel.getComputerSequence().size() < 10) {
                generateComputerSequence();
                sleep(1800L);
            }
        }

        private void generateComputerSequence() {

            gameModel.addToComputerSequence();
            for (Integer index : gameModel.getComputerSequence()) {
                drawingPanel.brighterArcModelColor(index);
                sleep(1000L);
                drawingPanel.darkerArcModelColor(index);
                sleep(200L);
            }

        }

        private void sleep(long duration) {
            try {
                Thread.sleep(duration);
            } catch (InterruptedException e) {

            }
        }

        public synchronized void setRunning(boolean running) {
            this.running = running;
        }

    }

}

package com.ggl.testing；
导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.Rectangle；
导入java.awt.geom.Arc2D；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Random；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.SwingUtilities；
公共类SimonShape实现可运行{
私人博弈模型；
私有JFrame；
公共静态void main（字符串[]args）{
调用器（新SimonShape（））；
}
公共SimonShape（）{
this.gameModel=新的gameModel（）；
}
@凌驾
公开募捐{
frame=新的JFrame（“西蒙说”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
DrawingPanel DrawingPanel=新建DrawingPanel（）；
添加框架（drawingPanel）；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
GameRunnable runnable=新的GameRunnable（drawingPanel，gameModel）；
新线程（runnable.start（）；
}
公共类DrawingPanel扩展了JPanel{
私有静态最终长serialVersionUID=70146219705119575L；
私人名单部分；
公共绘图面板（）{
this.segments=新的ArrayList（）；
整数裕度=50；
内径=300；
矩形r=新矩形（边距、边距、直径、直径）；
添加（新的ArcModel（Color.GREEN、r、180、90、Arc2D.PIE））；
添加（新的ArcModel（Color.BLUE，r，270，90，Arc2D.PIE））；
添加（新的ArcModel（Color.RED、r、360、90、Arc2D.PIE））；
添加（新的ArcModel（Color.YELLOW，r，90，90，Arc2D.PIE））；
内部宽度=直径+边距+边距；
此.setPreferredSize（新尺寸（宽度、宽度））；
}
public void brighterArcModelColor（int索引）{
segments.get（index.brighterColor（）；
重新油漆（）；
}
公共空间暗RARCMODELCOLOR（整数索引）{
segments.get（index.darkerColor（）；
重新油漆（）；
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
Graphics2D g2d=（Graphics2D）g；
用于（ArcModel ArcModel:段）{
setPaint（arcModel.getColor（））；
矩形r=arcModel.getRectangle（）；
填充（新的Arc2D.Double（r.getX（），r.getY（），r.getWidth（），r
.getHeight（），arcModel.getStartingAngle（），arcModel
.getExtent（），arcModel.getClosureType（））；
}
}
}
公共类模型{
私有最终int closureType；
私人最终双起动角；
私人最终双重范围；
私人色彩；
私人最终颜色原色；
私有最终矩形；
公共ArcModel（彩色、矩形、双起始角、，
双数据块，int closureType）{
这个颜色=颜色；
本原颜色=颜色；
this.rectangle=矩形；
this.startingAngle=启动角度；
这个范围=范围；
this.closureType=closureType；
}
public int getClosureType（）{
返回闭合式；
}
公共双getStartingAngle（）{
返回起始角；
}
公共双getExtent（）{
返回范围；
}
公共矩形getRectangle（）{
返回矩形；
}
公共颜色getColor（）{
返回颜色；
}
公共空白亮颜色（）{
this.color=color.WHITE；
}
公共空间深颜色（）{
this.color=原色；
}
}
公共类博弈模型{
私有列表序列；
私有列表播放序列；
私有随机；
公共游戏模型（）{
this.computerSequence=new ArrayList（）；
this.playerSequence=新的ArrayList（）；
this.random=新的random（）；
}
public void addToComputerSequence（）{
computerSequence.add（Integer.valueOf（random.nextInt（4））；
}
公共无效clearComputerSequence（）{
computerSequence.clear（）；
}
公共列表getComputerSequence（）{
返回顺序；
}
公共无效clearPlayerSequence（）{
playerSequence.clear（）；
}
公共无效addToPlayerSequence（整数）{
playerSequence.add（Integer.valueOf（number））；
}
公共布尔值doSequencesMatch（）{
if（computerSequence.size（）==playerSequence.size（））{
对于（int i=0；i