Java 碰撞游戏错误和计时器

在我的比赛中，我有两个问题。首先，我遇到了一些我不知道如何解决的错误。其次，我这个项目的目标是每30秒增加一个球。不过，我尝试了几种方法（计时器和for循环）。然而，这些方法导致图形不出现，但其他功能工作（一个看不见的球）。如果有人能帮我解决这些问题，我将不胜感激

import java.awt.*;
import java.lang.*;
import java.awt.event.KeyEvent;
import java.util.Formatter;
import javax.swing.*;
import java.awt.event.*;
import java.awt.Polygon;
import java.awt.geom.Area;
public class  Man  implements KeyListener {

private static final int BOX_WIDTH = 640;
private static final int BOX_HEIGHT = 480;
private float ballSpeedX3 = 7;
private float ballSpeedY3 = 7;
private double ball3Radius = 20;
private double ball3X = 320 ;
private double ball3Y = 120 ;
private float ballSpeedX4 = -10;
private float ballSpeedY4 = 10;
private double ball4Radius = 15;
private double ball4X = 600 ;
private double ball4Y = 300 ;
private float ballSpeedX = 0;
private float ballSpeedY = 0;
private double ballRadius = 20;
private double ballX = 120;
private double ballY = 140;
private float ballSpeed1X = 10;
private float ballSpeed1Y = -10;
private double ballRadius1 = 20;
private double ball1X = 320;
private double ball1Y = 340;
private float ballSpeed2X = -3;
private float ballSpeed2Y = -3;
private double ballRadius2 = 50;
private double ball2X = 50;
private double ball2Y = 400;

private static final int UPDATE_RATE = 30;

public Man() {
    this.setPreferredSize(new Dimension(BOX_WIDTH, BOX_HEIGHT));
    Thread gameThread = new Thread() {
        public void run() {
while(true){             

              if ( Math.sqrt(    (Math.pow((ballX- ball1X), 2))    +    Math.pow((ballY-ball1Y), 2)) <= (ballRadius1 + ballRadius)) {
    System.exit(0);}
              if ( Math.sqrt(    (Math.pow((ball4X- ballX), 2))    +    Math.pow((ball4Y-ballY), 2)) <= (ball4Radius + ballRadius)) {
                    System.exit(0);}
              if ( Math.sqrt(    (Math.pow((ball2X- ballX), 2))    +    Math.pow((ball2Y-ballY), 2)) <= (ballRadius2 + ballRadius)) {
                System.exit(0);}        

                  ball4X += ballSpeedX4;
                  ball4Y += ballSpeedY4;
                  if (ball4X - ball4Radius < 0) {
                      ballSpeedX4 = -ballSpeedX4;
                      ball4X = ball4Radius;
                  } else if (ball4X + ball4Radius > BOX_WIDTH) {
                      ballSpeedX4 = -ballSpeedX4;
                      ball4X = BOX_WIDTH - ball4Radius;
                  }
                  if (ball4Y - ball4Radius < 0) {
                      ballSpeedY4 = -ballSpeedY4;
                      ball4Y = ball4Radius;
                  } else if (ball4Y + ball4Radius > BOX_HEIGHT) {
                      ballSpeedY4 = -ballSpeedY4;
                      ball4Y = BOX_HEIGHT - ball4Radius;
                  }

              if ( Math.sqrt(    (Math.pow((ball3X- ballX), 2))    +           Math.pow((ball3Y-ballY), 2)) <= (ball3Radius + ballRadius)) {
                System.exit(0);}


                ball3X += ballSpeedX3;
                ball3Y += ballSpeedY3;
                if (ball3X - ball3Radius < 0) {
                    ballSpeedX3 = -ballSpeedX3;
                    ball3X = ball3Radius;
                } else if (ball3X + ball3Radius > BOX_WIDTH) {
                    ballSpeedX3 = -ballSpeedX3;
                    ball3X = BOX_WIDTH - ball3Radius;
                }
                if (ball3Y - ball3Radius < 0) {
                    ballSpeedY3 = -ballSpeedY3;
                    ball3Y = ball3Radius;
                } else if (ball3Y + ball3Radius > BOX_HEIGHT) {
                    ballSpeedY3 = -ballSpeedY3;
                    ball3Y = BOX_HEIGHT - ball3Radius;
                }

                ballX += ballSpeedX;

                ballY += ballSpeedY;


                if (ballX - ballRadius < 0) {

                    ballX = ballRadius;
                } else if (ballX + ballRadius > BOX_WIDTH) {

                    ballX = BOX_WIDTH - ballRadius;
                }

                if (ballY - ballRadius < 0) {

                    ballY = ballRadius;
                } else if (ballY + ballRadius > BOX_HEIGHT) {

                    ballY = BOX_HEIGHT - ballRadius;
                }

                ball1X += ballSpeed1X;
                ball1Y += ballSpeed1Y;
                if (ball1X - ballRadius1 < 0) {
                    ballSpeed1X = -ballSpeed1X;
                    ball1X = ballRadius1;
                } else if (ball1X + ballRadius1 > BOX_WIDTH) {
                    ballSpeed1X = -ballSpeed1X;
                    ball1X = BOX_WIDTH - ballRadius1;
                }

                if (ball1Y - ballRadius1 < 0) {
                    ballSpeed1Y = -ballSpeed1Y;
                    ball1Y = ballRadius1;
                } else if (ball1Y + ballRadius1 > BOX_HEIGHT) {
                    ballSpeed1Y = -ballSpeed1Y;
                    ball1Y = BOX_HEIGHT - ballRadius1;
                }
                ball2X += ballSpeed2X;
                ball2Y += ballSpeed2Y;
                if (ball2X - ballRadius2 < 0) {
                    ballSpeed2X = -ballSpeed2X;
                    ball2X = ballRadius2;
                } else if (ball2X + ballRadius2 > BOX_WIDTH) {
                    ballSpeed2X = -ballSpeed2X;
                    ball2X = BOX_WIDTH - ballRadius2;
                }

                if (ball2Y - ballRadius2 < 0) {
                    ballSpeed2Y = -ballSpeed2Y;
                    ball2Y = ballRadius2;
                } else if (ball2Y + ballRadius2 > BOX_HEIGHT) {
                    ballSpeed2Y = -ballSpeed2Y;
                    ball2Y = BOX_HEIGHT - ballRadius2;
                }

                repaint();
                try {
                    Thread.sleep(1000 / UPDATE_RATE);

                } catch (InterruptedException ex) { }
            }
        }  
    };
    gameThread.start();

}
@Override
public void paintComponent(Graphics g) {
    super.paintComponent(g);
    g.setColor(Color.BLACK);
    g.fillRect(0, 0, BOX_WIDTH, BOX_HEIGHT);
    g.setColor(Color.BLUE);
    g.fillOval((int) (ballX - ballRadius), (int) (ballY - ballRadius),
               (int)(2 * ballRadius), (int)(2 * ballRadius));
    g.setColor(Color.RED);
    g.fillOval((int) (ball1X - ballRadius1), (int) (ball1Y - ballRadius1),
               (int)(2 * ballRadius1), (int)(2 * ballRadius1));    
    g.setColor(Color.PINK);
    g.fillOval((int) (ball2X - ballRadius2), (int) (ball2Y - ballRadius2),
               (int)(2 * ballRadius2), (int)(2 * ballRadius2));   
           g.setColor(Color.GREEN);
    g.fillOval((int) (ball3X - ball3Radius), (int) (ball3Y - ball3Radius),
                           (int)(2 * ball3Radius), (int)(2 * ball3Radius));
    g.setColor(Color.YELLOW);
    g.fillOval((int) (ball4X - ball4Radius), (int) (ball4Y - ball4Radius),
                           (int)(2 * ball4Radius), (int)(2 * ball4Radius));


}

public void keyPressed(KeyEvent e) {
    if (e.getKeyCode() == KeyEvent.VK_RIGHT ) {
        ballSpeedX = 5;
    }
    else if (e.getKeyCode() == KeyEvent.VK_LEFT ) {
        ballSpeedX = -5;
    }
    else if (e.getKeyCode() == KeyEvent.VK_UP ) {
        ballSpeedY = -5;
    }
    else if (e.getKeyCode() == KeyEvent.VK_DOWN ) {
        ballSpeedY = 5;
    }
}

public void keyReleased(KeyEvent e) {
     if (e.getKeyCode() == KeyEvent.VK_RIGHT ) {
         ballSpeedX = 0;
     }
     else if (e.getKeyCode() == KeyEvent.VK_LEFT ) {
         ballSpeedX = 0;
     }
     else if (e.getKeyCode() == KeyEvent.VK_UP ) {
         ballSpeedY = 0;
     }
     else if (e.getKeyCode() == KeyEvent.VK_DOWN ) {
         ballSpeedY = 0;

     }  
}
public void keyTyped(KeyEvent e) { }

public static void main(String[] args) {
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            JFrame frame = new JFrame("Collision");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            Man man = new Man();
            frame.setContentPane(man);
            frame.pack();
            frame.addKeyListener(man);
            frame.setVisible(true);
        }
    });
}
}

import java.awt.*；
导入java.lang.*；
导入java.awt.event.KeyEvent；
导入java.util.Formatter；
导入javax.swing.*；
导入java.awt.event.*；
导入java.awt.Polygon；
导入java.awt.geom.Area；
公共类Man实现了keylister{
专用静态最终整型框_宽度=640；
专用静态最终整型箱高度=480；
私人浮球速度x3=7；
私人浮球速度y3=7；
私人双球3半径=20；
私人双球3x=320；
私人双球3y=120；
私人浮球速度x4=-10；
私人浮球速度4=10；
私人双球4半径=15；
私人双球4x=600；
私人双球4y=300；
私人浮球速度x=0；
私人浮球=0；
私人双球半径=20；
私人双球X=120；
私人双巴利=140；
私人浮球速度1x=10；
私人浮球速度1y=-10；
专用双球半径1=20；
私人双球1X=320；
私人双球1Y=340；
私人浮球速度2x=-3；
私人浮球速度2y=-3；
专用双球半径2=50；
私人双球2X=50；
私人双球2y=400；
私有静态最终整数更新率=30；
公职人员（）{
此.setPreferredSize（新尺寸（框宽、框高））；
线程gameThread=新线程（）{
公开募捐{
虽然（正确）{
如果（数学sqrt（（数学功率（（ballX-ball1X），2））+数学功率（（ballY-ball1Y，2））箱高）{
ballSpeedY3=-ballSpeedY3；
ball3Y=箱体高度-ball3Y半径；
}
ballX+=ballSpeedX；
ballY+=ballY；
if（球X-球半径<0）{
ballX=球半径；
}否则，如果（球X+球半径>框宽度）{
ballX=盒子宽度-球体半径；
}
如果（球-球半径<0）{
ballY=球半径；
}否则如果（球+球半径>框高）{
ballY=箱体高度-球体半径；
}
ball1X+=ballSpeed1X；
ball1Y+=ball1Y；
如果（ball1X-ballRadius1<0）{
ballSpeed1X=-ballSpeed1X；
ball1X=ballRadius1；
}否则如果（ball1X+ballRadius1>方框宽度）{
ballSpeed1X=-ballSpeed1X；
ball1X=盒子宽度-ballRadius1；
}
if（球1Y-球半径1<0）{
ballSpeed1Y=-ballSpeed1Y；
ball1Y=ballRadius1；
}否则如果（球1Y+球半径1>盒子高度）{
ballSpeed1Y=-ballSpeed1Y；
ball1Y=箱体高度-ballRadius1；
}
ball2X+=ballSpeed2X；
ball2Y+=ball2Y；
如果（ball2X-ballRadius2<0）{
ballSpeed2X=-ballSpeed2X；
ball2X=ballRadius2；
}else if（ball2X+ballRadius2>框宽）{
ballSpeed2X=-ballSpeed2X；
ball2X=盒子宽度-BallRadius 2；
}
if（ball2Y-ballRadius2<0）{
ballSpeed2Y=-ballSpeed2Y；
ball2Y=ballRadius2；
}否则如果（ball2Y+ballRadius2>盒子高度）{
ballSpeed2Y=-ballSpeed2Y；
ball2Y=箱体高度-BallRadius 2；
}
重新油漆（）；
试一试{
线程睡眠（1000/更新率）；
}catch（InterruptedException ex）{}
}
}  
};
gamesthread.start（）；
}
@凌驾
公共组件（图形g）{
超级组件（g）；
g、 设置颜色（颜色为黑色）；
g、 fillRect（0，0，方框宽度，方框高度）；
g、 setColor（Color.BLUE）；
g、 圆角（（int）（圆球x-圆球半径），（int）（圆球y-圆球半径），
（int）（2*球半径），（int）（2*球半径））；
g、 setColor（Color.RED）；
g、 圆角（（内部）（ball1X-ballRadius1），（内部）（ball1Y-ballRadius1），
（int）（2*ballRadius1），（int）（2*ballRadius1））；
g、 setColor（颜色为粉红色）；
g、 圆角（（内部）（ball2X-ballRadius2），（内部）（ball2Y-ballRadius2），
（int）（2*ballRadius2），（int）（2*ballRadius2））；
g、 setColor（Color.GREEN）；
g、 圆角（（int）（ball3X-ball3Radius），（int）（ball3Y-ball3Radius），
（int）（2*Ball3半径），（int）（2*Ball3半径））；
g、 setColor（颜色为黄色）；
g、 圆角（（int）（ball4X-ball4Radius），（int）（ball4Y-ball4Radius），
（int）（2*ball4Radius），（int）（2*ball4Radius））；
}
按下公共无效键（按键事件e）{
如果（如getKeyCode（）==KeyEvent.VK_RIGHT）{
ballSpeedX=5；
}
else if（e.getKeyCode（）==KeyEvent.VK_左）{
ballSpeedX=-5；
}
else if（e.getKeyCode（）==KeyEvent.VK_UP）{
平均值=-5；
}
else if（e.getKeyCode（）==KeyEvent.VK_DOWN）{
b=5；
}
}
公共无效密钥已释放（密钥事件e）{
如果（如getKeyCode（）==KeyEvent.VK_RIGHT）{
ballSpeedX=0；
}
else if（e.getKeyCode（）==KeyEvent.VK_左）{
ballSpeedX=0；
}
else if（e.getKeyCode（）==KeyEvent.VK_UP）{
ball=0；
}
else if（e.getKeyCode（）==KeyEvent.VK_DOWN）{
ball=0；
}  
}
公钥
public class  Man  extends JComponent implements KeyListener {

package com.ggl.testing;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.List;

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

public class CollisionGame {

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

    private static final int BOX_WIDTH = 640;
    private static final int BOX_HEIGHT = 480;

    public CollisionGame() {
        GameModel gameModel = new GameModel();

        JFrame frame = new JFrame("Collision");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        DrawingPanel drawingPanel = new DrawingPanel(gameModel, BOX_WIDTH,
                BOX_HEIGHT);
        frame.add(drawingPanel);
        frame.pack();
        frame.setVisible(true);

        Animation animation = new Animation(drawingPanel, gameModel, BOX_WIDTH,
                BOX_HEIGHT);
        new Thread(animation).start();
    }

    public class DrawingPanel extends JPanel {
        private static final long serialVersionUID = -8219208002512324440L;

        private int width;
        private int height;

        private GameModel gameModel;

        public DrawingPanel(GameModel gameModel, int width, int height) {
            this.gameModel = gameModel;
            this.width = width;
            this.height = height;

            this.setFocusable(true);
            this.requestFocusInWindow();
            this.addKeyListener(new GameKeyListener(gameModel.getPlayer()));
            this.setPreferredSize(new Dimension(width, height));
        }

        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            g.setColor(Color.BLACK);
            g.fillRect(0, 0, width, height);

            Player player = gameModel.getPlayer();
            g.setColor(player.getColor());
            double playerRadius = player.getRadius();
            double playerDiameter = playerRadius + playerRadius;
            g.fillOval((int) (player.getPositionX() - playerRadius),
                    (int) (player.getPositionY() - playerRadius),
                    (int) (playerDiameter), (int) (playerDiameter));

            for (Ball ball : gameModel.getBalls()) {
                g.setColor(ball.getColor());
                double ballRadius = ball.getRadius();
                double ballDiameter = ballRadius + ballRadius;
                g.fillOval((int) (ball.getPositionX() - ballRadius),
                        (int) (ball.getPositionY() - ballRadius),
                        (int) (ballDiameter), (int) (ballDiameter));
            }
        }
    }

    public class Animation implements Runnable {
        private static final long UPDATE_RATE = 30;

        private boolean running;

        private double width;
        private double height;

        private DrawingPanel drawingPanel;

        private GameModel gameModel;

        public Animation(DrawingPanel drawingPanel, GameModel gameModel,
                double width, double height) {
            this.drawingPanel = drawingPanel;
            this.gameModel = gameModel;
            this.width = width;
            this.height = height;
            this.running = true;
        }

        @Override
        public void run() {
            sleep(1000L);
            long ballTime = System.currentTimeMillis();
            long nextBallTime = 30000L;
            gameModel.addBall();

            while (running) {
                long elapsedTime = System.currentTimeMillis() - ballTime;
                if (elapsedTime >= nextBallTime) {
                    gameModel.addBall();
                    ballTime += nextBallTime;
                }

                movePlayer(gameModel.getPlayer());
                for (Ball ball : gameModel.getBalls()) {
                    moveBall(ball);
                }

                repaint();

                if (isPlayerHit()) {
                    running = false;
                } else {
                    sleep(1000L / UPDATE_RATE);
                }
            }
        }

        private void movePlayer(Player player) {
            player.setPositionX(player.getPositionX() + player.getSpeedX());
            player.setPositionY(player.getPositionY() + player.getSpeedY());

            double radius = player.getRadius();
            if (player.getPositionX() - radius < 0) {
                player.setSpeedX(-player.getSpeedX());
                player.setPositionX(radius);
            } else if (player.getPositionX() + radius > width) {
                player.setSpeedX(-player.getSpeedX());
                player.setPositionX(width - radius);
            }

            if (player.getPositionY() - radius < 0) {
                player.setSpeedY(-player.getSpeedY());
                player.setPositionY(radius);
            } else if (player.getPositionY() + radius > height) {
                player.setSpeedY(-player.getSpeedY());
                player.setPositionY(height - radius);
            }
        }

        private void moveBall(Ball ball) {
            ball.setPositionX(ball.getPositionX() + ball.getSpeedX());
            ball.setPositionY(ball.getPositionY() + ball.getSpeedY());

            double radius = ball.getRadius();
            if (ball.getPositionX() - radius < 0) {
                ball.setSpeedX(-ball.getSpeedX());
                ball.setPositionX(radius);
            } else if (ball.getPositionX() + radius > width) {
                ball.setSpeedX(-ball.getSpeedX());
                ball.setPositionX(width - radius);
            }

            if (ball.getPositionY() - radius < 0) {
                ball.setSpeedY(-ball.getSpeedY());
                ball.setPositionY(radius);
            } else if (ball.getPositionY() + radius > height) {
                ball.setSpeedY(-ball.getSpeedY());
                ball.setPositionY(height - radius);
            }
        }

        private boolean isPlayerHit() {
            Player player = gameModel.getPlayer();
            for (Ball ball : gameModel.getBalls()) {
                double radiusSquared = Math.pow(
                        ball.getRadius() + player.getRadius(), 2D);
                double distanceSquared = Math.pow(
                        (ball.getPositionX() - player.getPositionX()), 2D)
                        + Math.pow(ball.getPositionY() - player.getPositionY(),
                                2D);
                if (distanceSquared <= radiusSquared) {
                    return true;
                }
            }

            return false;
        }

        private void repaint() {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    drawingPanel.repaint();
                }
            });
        }

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

            }
        }
    }

    public class GameKeyListener implements KeyListener {
        private float playerSpeedX;
        private float playerSpeedY;

        private Player player;

        public GameKeyListener(Player player) {
            this.player = player;
        }

        @Override
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
                playerSpeedX = 5;
            } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
                playerSpeedX = -5;
            } else if (e.getKeyCode() == KeyEvent.VK_UP) {
                playerSpeedY = -5;
            } else if (e.getKeyCode() == KeyEvent.VK_DOWN) {
                playerSpeedY = 5;
            }

            updatePlayer();
        }

        @Override
        public void keyReleased(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
                playerSpeedX = 0;
            } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
                playerSpeedX = 0;
            } else if (e.getKeyCode() == KeyEvent.VK_UP) {
                playerSpeedY = 0;
            } else if (e.getKeyCode() == KeyEvent.VK_DOWN) {
                playerSpeedY = 0;
            }

            updatePlayer();
        }

        @Override
        public void keyTyped(KeyEvent e) {
        }

        private void updatePlayer() {
            player.setSpeedX(playerSpeedX);
            player.setSpeedY(playerSpeedY);
        }

    }

    public class GameModel {
        private List<Ball> balls;
        private List<Ball> newBalls;

        private Player player;

        public GameModel() {
            this.balls = new ArrayList<>();
            this.newBalls = createBalls();
            this.player = new Player(Color.PINK, 120, 140, 20, 0, 0);
        }

        private List<Ball> createBalls() {
            List<Ball> balls = new ArrayList<>();
            balls.add(new Ball(Color.BLUE, 320, 120, 20, 7, 7));
            balls.add(new Ball(Color.RED, 600, 300, 15, -10, 10));
            balls.add(new Ball(Color.GREEN, 320, 340, 20, 10, -10));
            balls.add(new Ball(Color.YELLOW, 50, 400, 50, -3, -3));

            return balls;
        }

        public void addBall() {
            if (!newBalls.isEmpty()) {
                balls.add(newBalls.get(0));
                newBalls.remove(0);
            }
        }

        public List<Ball> getBalls() {
            return balls;
        }

        public Player getPlayer() {
            return player;
        }

    }

    public class Player {
        private float speedX;
        private float speedY;
        private double radius;
        private double positionX;
        private double positionY;
        private Color color;

        public Player(Color color, double positionX, double positionY,
                double radius, float speedX, float speedY) {
            this.color = color;
            this.positionX = positionX;
            this.positionY = positionY;
            this.radius = radius;
            this.speedX = speedX;
            this.speedY = speedY;
        }

        public float getSpeedX() {
            return speedX;
        }

        public void setSpeedX(float speedX) {
            this.speedX = speedX;
        }

        public float getSpeedY() {
            return speedY;
        }

        public void setSpeedY(float speedY) {
            this.speedY = speedY;
        }

        public double getRadius() {
            return radius;
        }

        public double getPositionX() {
            return positionX;
        }

        public void setPositionX(double positionX) {
            this.positionX = positionX;
        }

        public double getPositionY() {
            return positionY;
        }

        public void setPositionY(double positionY) {
            this.positionY = positionY;
        }

        public Color getColor() {
            return color;
        }
    }

    public class Ball {
        private float speedX;
        private float speedY;
        private double radius;
        private double positionX;
        private double positionY;
        private Color color;

        public Ball(Color color, double positionX, double positionY,
                double radius, float speedX, float speedY) {
            this.color = color;
            this.positionX = positionX;
            this.positionY = positionY;
            this.radius = radius;
            this.speedX = speedX;
            this.speedY = speedY;
        }

        public float getSpeedX() {
            return speedX;
        }

        public void setSpeedX(float speedX) {
            this.speedX = speedX;
        }

        public float getSpeedY() {
            return speedY;
        }

        public void setSpeedY(float speedY) {
            this.speedY = speedY;
        }

        public double getRadius() {
            return radius;
        }

        public double getPositionX() {
            return positionX;
        }

        public void setPositionX(double positionX) {
            this.positionX = positionX;
        }

        public double getPositionY() {
            return positionY;
        }

        public void setPositionY(double positionY) {
            this.positionY = positionY;
        }

        public Color getColor() {
            return color;
        }

    }
}