Question

我可以打开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);
    }

}

}

Answer 1

您的方法无法延长。

这是一张西蒙说的GUI，我把它放在一起。它显示前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;
        }

    }

}

帧fillRect setColor无法正常工作

1 个答案: