Почему мой JFrame пуст в моей игре в секцию?

Question

Так что я новичок в java и мне нужна помощь с моей игрой в секцию Мой JFrame просто пуст, и я не знаю, как это исправить?

Итак, у меня есть класс мяча, класс весла, класс холста и класс кирпича, а также основной класс. В моем классе холста я устанавливаю все функции, которые есть у мяча, весла, кирпича и т. Д. В классе кирпича я рисую кубики. И в моем основном я делаю JFrame, но это пусто

Основной класс:

public class Main {
    public static void main(String[] args){
        JFrame frame = new JFrame();
        Canvas c = new Canvas();

        frame.add(c);
        frame.pack();
        frame.setResizable(false);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

Я ожидаю, что JFrame покажет игру вместо просто пустого окна

package breakout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import javax.swing.JPanel;
import javax.swing.Timer;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.KeyEvent;


import breakout.Bricks.Type;

public class Canvas extends JPanel implements ActionListener, MouseMotionListener, MouseListener, KeyListener {
    /**
     * 
     */
        private static final long serialVersionUID = 1L;
        private static final int HEIGHT = 600;
        public static final int WIDTH = 720;

        private int horizontalCount;
        private BufferedImage image;
        private Graphics2D bufferedGraphics;
        private Timer time;
        private static final Font endFont = new Font(Font.SANS_SERIF, Font.BOLD, 20);
        private static final Font scoreFont = new Font(Font.SANS_SERIF, Font.BOLD, 15);

        private Paddle player;
        private Ball ball;
        ArrayList<ArrayList<Bricks>> bricks;


    public Canvas() {
        super();
        setPreferredSize( new Dimension(WIDTH, HEIGHT));
        image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
        bufferedGraphics = image.createGraphics();
        time = new Timer (15, this);
        player = new Paddle((WIDTH/2)-(Paddle.PADDLE_WIDTH/2));
        ball = new Ball (((player.getX() + (Paddle.PADDLE_WIDTH / 2 )) - (Ball.DIAMETER / 2)), (Paddle.Y_POS - (Ball.DIAMETER + 10 )), -5, -5);

        bricks = new ArrayList<ArrayList<Bricks>>();
        horizontalCount = WIDTH / Bricks.BRICK_WIDTH;
        for(int i = 0; i < 8; ++i) {
            ArrayList<Bricks> temp = new ArrayList<Bricks>();
            @SuppressWarnings("unused")
            Type rowColor = null;
            switch(i) {
            case 0 :
            case 2:
                rowColor = Type.LOW;
                break;
            case 1 :
            case 3 :
            case 5 :
                rowColor = Type.MEDIUM;
                break;
            case 4 :
            case 6 :
                rowColor = Type.HIGH;
                break;
            case 7 :
                default :
                    rowColor = Type.ULTRA;
                    break;

            }
            for(int j = 0; j < horizontalCount; ++j) {
                Bricks tempBrick = new Bricks();
                temp.add(tempBrick);
            }
            bricks.add(temp);
            addMouseMotionListener(this);
            addMouseListener(this);
            addKeyListener(this);
            requestFocus();

        }
    }

    public void actionPerformed(ActionEvent e) {
        checkCollisions();
        ball.Move();
        for(int i = 0; i < bricks.size(); ++i) {
            ArrayList<Bricks> al = bricks.get(i);
            for(int j = 0; j < al.size(); ++j) {
                Bricks b = al.get(j);
                if(b.dead()) {
                    al.remove(b);

                }
            }
        }
        repaint();
    }

    private void checkCollisions() {
        if(player.hitPaddle(ball)) {
            ball.setDY(ball.getDY() * -1);
            return;
        }
        if(ball.getX() >= (WIDTH - Ball.DIAMETER) || ball.getX() <= 0) {
            ball.setDX(ball.getDX() * -1);
        }
        if(ball.getY() > (Paddle.Y_POS + Paddle.PADDLE_HEIGHT + 10)) {
            resetBall();
        }
        if(ball.getY() <= 0) {
            ball.setDY(ball.getDY() * -1);
        }
        int brickRowActive = 0;
        for(ArrayList<Bricks> alb : bricks) {
            if(alb.size() == horizontalCount) {
                ++brickRowActive;
            }
        }

        for(int i = (brickRowActive==0) ? 0 : (brickRowActive - 1); i < bricks.size(); ++i) {
            for(Bricks b : bricks.get(i)) {
                if(b.hitBy(ball)) {
                    player.setScore(player.getScore() + b.getBrickType().getPoints());
                    b.decrementType();
                }
            }
        }
    }

    private void resetBall() {
        if(gameOver()) {
            time.stop();
            return;
        }
        ball.setX(WIDTH/2);
        ball.setDY((HEIGHT/2) + 80);
        player.setLives(player.getLives() -1);
        player.setScore(player.getScore() <= 1);

    }

    private boolean gameOver() {
        if(player.getLives() <= 1) {
            return true;
        }
        return false; 
    }


    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        bufferedGraphics.clearRect(0, 0, WIDTH, HEIGHT);
        player.drawPaddle(bufferedGraphics);
        player.drawBall(bufferedGraphics);
        for(ArrayList<Bricks> row : bricks) {
        for(Bricks b : row) {
            b.drawBrick(bufferedGraphics);
        }
        }

        bufferedGraphics.setFont(scoreFont);
        bufferedGraphics.drawString("Score: " + player.getScore(), 10, 25);
        if(gameOver() && ball.getY() >= HEIGHT) {
            bufferedGraphics.setColor(Color.black);
            bufferedGraphics.setFont(endFont);
            bufferedGraphics.drawString("Game Over Score: " + player.getScore(), (WIDTH /2) -85, (HEIGHT/2));

        }
        if(empty()) {
            bufferedGraphics.setColor(Color.black);
            bufferedGraphics.setFont(endFont);
            bufferedGraphics.drawString("You won. Score: " + player.getScore(), (WIDTH /2) -85, (HEIGHT /2));
            time.stop();
        }
        g.drawImage(image, 0, 0, this);
        Toolkit.getDefaultToolkit().sync();
    }

    private boolean empty() {
        for(ArrayList<Bricks> al : bricks) {
            if(al.size() != 0) {
                return false;
            }
        }
        return true;
    }


    @Override
    public void mouseMoved(MouseEvent e) {
        player.setX(e.getX() - (Paddle.PADDLE_WIDTH / 2));
    }

    @Override
    public void mouseClicked(MouseEvent e) {
        if(time.isRunning()) {
            return;
        }
        time.start();
    }
    @Override
    public void mouseDragged(MouseEvent e) { }

    @Override
    public void mouseEntered(MouseEvent arg0) {}

    @Override
    public void mouseExited(MouseEvent arg0) {}

    @Override
    public void mousePressed(MouseEvent arg0) {}

    @Override
    public void mouseReleased(MouseEvent arg0) {}

    @Override
    public void keyPressed(KeyEvent arg0) {}

    @Override
    public void keyReleased(KeyEvent arg0) {}

    @Override
    public void keyTyped(KeyEvent arg0) {}  
}

Answer 1

Подготовка MCVE , как требуется для SO, не только облегчает помощь.Во многих случаях во время подготовки вы, вероятно, найдете проблему, поэтому это хороший инструмент для отладки.Чтобы ответить "почему мой JFrame пуст?"Вы можете создать минимальный пример кода, подобный следующему (скопируйте и вставьте весь код в GameBoard.java и запустите):

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class GameBoard extends JPanel {

        static final int HEIGHT = 600, WIDTH = 720, BRICK_ROWS = 8;
        private final int horizontalCount;
        private static final Font scoreFont = new Font(Font.SANS_SERIF, Font.BOLD, 15);
        private final Paddle player;
        private final Ball ball;
        ArrayList<ArrayList<Brick>> bricks;

    public GameBoard() {
        super();
        setPreferredSize( new Dimension(WIDTH, HEIGHT));

        player = new Paddle(WIDTH/2-Paddle.PADDLE_WIDTH/2);
        ball = new Ball (player.getX() + Paddle.PADDLE_WIDTH / 2 - Ball.DIAMETER / 2,
                                                        Paddle.Y_POS - (Ball.DIAMETER + 10 ));
        bricks = new ArrayList<>();
        horizontalCount = WIDTH / Brick.BRICK_WIDTH;
        for(int i = 0; i < BRICK_ROWS; ++i) {

            ArrayList<Brick> temp = new ArrayList<>();
            for(int j = 0; j < horizontalCount; ++j) {
                Brick tempBrick = new Brick(j*Brick.BRICK_WIDTH , Brick.BRICK_YPOS + i*Brick.BRICK_HEIGHT);
                temp.add(tempBrick);
            }
            bricks.add(temp);
        }
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2D = (Graphics2D)g;
        g2D.clearRect(0, 0, WIDTH, HEIGHT);
        player.drawPaddle(g2D);
        ball.drawBall(g2D);
        for(ArrayList<Brick> row : bricks) {
            for(Brick b : row) {
                b.drawBrick(g2D);
            }
        }
        g2D.setFont(scoreFont);
        g2D.drawString("Score: " + player.getScore(), 10, 25);
    }
}

class Paddle{

    public final static int PADDLE_WIDTH = 100, PADDLE_HEIGHT= 30, Y_POS = GameBoard.HEIGHT - 2* PADDLE_HEIGHT;
    private int xPos, score;

    Paddle(int xPos) {
        this.xPos = xPos;
    }

    void setX(int xPos) {this.xPos = xPos;}

    int getX() {return xPos;}

    String getScore() {
        return String.valueOf(score);
    }

    void drawPaddle(Graphics2D g2D) {
        g2D.setColor(Color.GREEN);
        g2D.fillRect(xPos, Y_POS, PADDLE_WIDTH, PADDLE_HEIGHT);
    }

    public static void main(String[] args) {

        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLocation(400,250);
        frame.add(new GameBoard());
        frame.pack();
        frame.setResizable(false);
        frame.setVisible(true);
    }
}

class Brick{

    final static int BRICK_WIDTH = 80, BRICK_HEIGHT = 15, BRICK_YPOS = 50;
    int xPos, yPos;

    Brick(int xPos, int yPos) {
        this.xPos = xPos;
        this.yPos = yPos;
    }

    void drawBrick(Graphics2D g2D) {
        g2D.setColor(Color.RED);
        g2D.fillRect(xPos, yPos, BRICK_WIDTH, BRICK_HEIGHT);
        g2D.setColor(Color.BLACK);
        g2D.drawRect(xPos, yPos, BRICK_WIDTH, BRICK_HEIGHT);
    }
}

class Ball{

    final static int DIAMETER = 40;
    int xPos, yPos;

    Ball(int xPos, int yPos) {
        this.xPos = xPos;
        this.yPos = yPos;
    }

    void drawBall(Graphics2D g2D) {
        g2D.setColor(Color.BLUE);
        g2D.fillOval(xPos, yPos, DIAMETER, DIAMETER);
    }
}

Это дает следующий результат, который, как я считаю, может послужить основой дляВы хотели достичь:

Теперь начните добавлять недостающую функциональность и посмотрите, что ее нарушает.

Answer 2

Я также довольно новичок, поэтому не знаю точно, почему это сработало для меня, но я использую Canvas c = new yourClass();, а также extends canvas в классе, который вы вызываете из