Why aren't the Balls Bouncing ? HELP !

Question

Dear Java People,
In doing a program that should have balls bouncing, I can see no balls bouncing !
Below is the BallDemo class that has the bounce() method and the BouncingBall class that has the characteristics of a bouncing ball.
There are no compilation errors which makes it a little bit
difficult to find the error.
Thank you in advance
Stan
import java.awt.*;
//(d)
import java.awt.Color;
import java.util.Random;
import java.awt.geom.*;
//ex5.50 (a)
import java.util.*;
import java.io.*;
* Class BallDemo - provides two short demonstrations showing how to use the
* Canvas class.
//(a) Change the bounce() method in the BallDemo class to let the user
//choose how many balls should be bouncing
//(b) Use a collection to store the balls
//(c) Place the balls in a row along the top of the canvas.
public class BallDemo
    private Canvas myCanvas;
    FormattedInput input;
     * Create a BallDemo object. Creates a fresh canvas and makes it visible.
    public BallDemo()
        myCanvas = new Canvas("Ball Demo", 600, 500);
        input = new FormattedInput();
        myCanvas.setVisible(true);
     * This method demonstrates some of the drawing operations that are
     * available on a Canvas object.
    public void drawDemo()
        myCanvas.setFont(new Font("helvetica", Font.BOLD, 14));
        myCanvas.setForegroundColor(Color.red);
        myCanvas.drawString("We can draw text, ...", 20, 50);
        myCanvas.wait(1000);
        myCanvas.setForegroundColor(Color.black);
        myCanvas.drawString("...draw lines...", 60, 70);
        myCanvas.wait(500);
        myCanvas.setForegroundColor(Color.blue);
        myCanvas.drawLine(200, 20, 300, 450);
        myCanvas.wait(500);
        myCanvas.setForegroundColor(Color.blue);
        myCanvas.drawLine(220, 100, 570, 260);
        myCanvas.wait(500);
        myCanvas.setForegroundColor(Color.green);
        myCanvas.drawLine(290, 10, 620, 220);
        myCanvas.wait(1000);
        myCanvas.setForegroundColor(Color.white);
        myCanvas.drawString("...and shapes!", 110, 90);
        myCanvas.setForegroundColor(Color.red);
                // the shape to draw and move
        int xPos = 10;
        Rectangle rect = new Rectangle(xPos, 150, 30, 20);
        // move the rectangle across the screen
        for(int i = 0; i < 200; i ++) {
            myCanvas.fill(rect);
            myCanvas.wait(10);
            myCanvas.erase(rect);
            xPos++;
            rect.setLocation(xPos, 150);
        // at the end of the move, draw once more so that it remains visible
        myCanvas.fill(rect);
       //ex 5.48
       public void drawFrame()
         Dimension myDimension =new Dimension( myCanvas.getSize());
         //Rectangle rectangle = new Rectangle(10,10,myDimension.width,  myDimension.height);
         //page 136
        Rectangle rectangle = new Rectangle(10,10,580,480);
         myCanvas.fill(rectangle);
     * Simulates two bouncing balls
    public void bounce()
        int ground = 400;   // position of the ground line
        int numberOfBalls = 0;
        myCanvas.setVisible(true);
        ArrayList balls = new ArrayList();
        // draw the ground
        myCanvas.drawLine(50, ground, 550, ground);
        //ex 5.50 (a)
        System.out.println("Type in the number of balls you would like to see bouncing and hit enter");
          numberOfBalls = input.readInt();
         //(b)
         for(int i = 0; i < numberOfBalls; i++)
           //(c) (d)
        Random rg = new Random(255);
         BouncingBall newBall =  new BouncingBall(i + 100, 0, 16, new Color(rg.nextInt(255),rg.nextInt(255),rg.nextInt(255)), ground, myCanvas);
         //add the ball to the ArrayList object
        balls.add(newBall);
       for(int i = 0; i < numberOfBalls; i++)
              BouncingBall ball = (BouncingBall)balls.get(i);
              ball.draw();
          // make the balls bounce
          boolean finished =  false;
          while(!finished) {
           myCanvas.wait(50);           // small delay
           ball.move();
            // stop once ball has travelled a certain distance on x axis
            if(ball.getXPosition() >= 550 )
                finished = true;
        }//move loop
              ball.erase();
      }//for loop
    }//bounce method
}//endof class
===================================================================
import java.awt.*;
import java.awt.geom.*;
* Class BouncingBall - a graphical ball that observes the effect of gravity. The ball
* has the ability to move. Details of movement are determined by the ball itself. It
* will fall downwards, accelerating with time due to the effect of gravity, and bounce
* upward again when hitting the ground.
* This movement can be initiated by repeated calls to the "move" method.
public class BouncingBall
    private static final int gravity = 3;  // effect of gravity
    private int ballDegradation = 2;
    private Ellipse2D.Double circle;
    private Color color;
    private int diameter;
    private int xPosition;
    private int yPosition;
    private final int groundPosition;      // y position of ground
    private Canvas canvas;
    private int ySpeed = 1;                // initial downward speed
     * Constructor for objects of class BouncingBall
     * @param xPos  the horizontal coordinate of the ball
     * @param yPos  the vertical coordinate of the ball
     * @param ballDiameter  the diameter (in pixels) of the ball
     * @param ballColor  the color of the ball
     * @param groundPos  the position of the ground (where the wall will bounce)
     * @param drawingCanvas  the canvas to draw this ball on
    public BouncingBall(int xPos, int yPos, int ballDiameter, Color ballColor,
                        int groundPos, Canvas drawingCanvas)
        xPosition = xPos;
        yPosition = yPos;
        color = ballColor;
        diameter = ballDiameter;
        groundPosition = groundPos;
        canvas = drawingCanvas;
     * Draw this ball at its current position onto the canvas.
    public void draw()
        canvas.setForegroundColor(color);
        canvas.fillCircle(xPosition, yPosition, diameter);
     * Erase this ball at its current position.
    public void erase()
        canvas.eraseCircle(xPosition, yPosition, diameter);
     * Move this ball according to its position and speed and redraw.
    public void move()
        // remove from canvas at the current position
        erase();
        // compute new position
        ySpeed += gravity;
        yPosition += ySpeed;
        xPosition +=2;
        // check if it has hit the ground
        if(yPosition >= (groundPosition - diameter) && ySpeed > 0) {
            yPosition = (int)(groundPosition - diameter);
            ySpeed = -ySpeed + ballDegradation;
        // draw again at new position
        draw();
     * return the horizontal position of this ball
    public int getXPosition()
        return xPosition;
     * return the vertical position of this ball
    public int getYPosition()
        return yPosition;
}

Answer 1

I'm not reading all of that. what do you see? here, try this out.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.awt.geom.*;
public class BallRoom extends Applet implements Runnable, MouseListener, ActionListener {
     Thread thread;
     Rectangle border;
     Ball[] theBalls;
     int numberOfBalls = 10;
     Image bufferedScreen;
     Graphics2D bufferedG;
     double xSpeed=3.0, ySpeed=0.0;
     double gravity=1.2;
     int bounds=600;
     int speed=50;
     Button fastBut=new Button("Faster"), slowBut=new Button("Slower");
     Panel controlPanel = new Panel();
     public void init() {
          fastBut.addActionListener(this);
          slowBut.addActionListener(this);
          controlPanel.setLayout(new GridLayout(1,2));
          controlPanel.add(fastBut);
          controlPanel.add(slowBut);
          this.add(controlPanel);
          addMouseListener(this);
          theBalls = new Ball[numberOfBalls];
          setSize(bounds,bounds);
          border = new Rectangle(0,0,getSize().width,getSize().height);
          setBackground(Color.white);
          for(int a=0;a<numberOfBalls;a++){
               theBalls[a]=new Ball(Math.random()*bounds,Math.random()*bounds,Math.random()*40+5,new Color((int)(Math.random()*255),(int)(Math.random()*255),(int)(Math.random()*255)),border,gravity);
     public void start() {
          thread = new Thread(this);
          thread.start();
     public void run() {
          Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
          for(int a=0;a<numberOfBalls;a++){
               theBalls[a].moveIt((int)(10-Math.random()*20),(int)(10-Math.random()*20));
          while(true){
               for(int a=0;a<numberOfBalls;a++){
                    theBalls[a].moveIt();
                    for(int b=a+1;b<numberOfBalls;b++){
                         if(theBalls[a].intersects(theBalls)){
                              swapSpeeds(theBalls[a],theBalls[b]);
               repaint();
               try{
                    thread.sleep(speed);
               }catch(InterruptedException ex){
     public void swapSpeeds(Ball one, Ball two){
          double xVone=one.getxV();
          double yVone=one.getyV();
          double xVtwo=two.getxV();
          double yVtwo=two.getyV();
          one.setSpeeds(xVtwo,yVtwo);
          two.setSpeeds(xVone,yVone);
               one.moveIt();
               two.moveIt();
     public void paint(Graphics g) {
          g.setColor(Color.black);
          for(int a=0;a<numberOfBalls;a++){
               theBalls[a].drawBall(g);
          Point2D.Double pointa=theBalls[0].getCenter();
          Point2D.Double pointb=theBalls[1].getCenter();
          double distance = pointa.distance(pointb);
          double deltaX = pointa.getX()-pointb.getX();
          double xSpot=theBalls[2].getX();
          double ySpot=theBalls[2].getY();
          g.drawString("X :"+String.valueOf(xSpot),20,20);
          g.drawString("Y :"+String.valueOf(ySpot),20,30);
          g.drawString("speed :"+String.valueOf(speed),20,40);
     public void update(Graphics g) {
          if(bufferedScreen==null){
               bufferedScreen=createImage(getSize().width,getSize().height);
          bufferedG=(Graphics2D)(bufferedScreen.getGraphics());
          bufferedG.setColor(getBackground());
          bufferedG.fillRect(0,0,getSize().width,getSize().height);
          paint(bufferedG);
          g.drawImage(bufferedScreen,0,0,this);
public void actionPerformed(ActionEvent e) {
          java.awt.Toolkit.getDefaultToolkit().beep();
          Button source = (Button)e.getSource();
          if(source==fastBut){
               speed=speed-5;
               if(speed<0){speed=0;}
          if(source==slowBut){
               speed=speed+5;
     public void mousePressed(MouseEvent m){
          for (int a=0;a<numberOfBalls;a++){
               if (theBalls[a].contains(m.getPoint())){
                    theBalls[a].setSpeeds( (5-(int)(Math.random()*10)),(int)(-40*(Math.random())) );
     public void mouseEntered(MouseEvent m){mousePressed(m);}
     public void mouseReleased(MouseEvent m){mousePressed(m);}
     public void mouseClicked(MouseEvent m){}
     public void mouseExited(MouseEvent m){}
and this..
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
public class Ball extends Rectangle2D.Double {
     double a;                              //acceleration
     double yV=0, yVi=0, xV=0, xVi=0;     //velocity and initial velocity
     double t=1;                                       //time
     double roomWidth, roomHeight;
     double x_pos, y_pos;
     double ballDiam;
     double spring=.9;
     Rectangle room;
     Color color;
     Point2D.Double center;
     Ball(double x, double y, double diameter, Color color, Rectangle walls, double gravity) {
          a=gravity;
          room=walls;
          roomWidth=room.getSize().width;
          roomHeight=room.getSize().height;
          ballDiam=diameter;
          x_pos=x;
          y_pos=y;
          setRect(x,y,ballDiam,ballDiam);
          this.color=color;
          center = new Point2D.Double(x,y);
     public void moveIt() {
          setRect(xMove(),yMove(),ballDiam,ballDiam);
     public void moveIt(double x, double y) {
          setRect(xMove(x),yMove(y),ballDiam,ballDiam);
     public double xMove(double currentSpeed) {
          x_pos=getX();
          xV=currentSpeed;
          x_pos=x_pos+xV*t;
          return x_pos;
     public double xMove() {
          x_pos=getX();
          x_pos=x_pos+xV*t;
          if((x_pos<0) & ( xV<0  ) | ((x_pos>(roomWidth-ballDiam)) & ( xV>0  ))){
               xV*= (-spring);
          return x_pos;
     public double yMove(double currentSpeed) {
          y_pos=getY();
          yVi=currentSpeed;
          yV=yVi+a*t;
          y_pos=y_pos+yV*t+.5*a*t*t;
          return y_pos;
     public double yMove() {
          double grav=a;
          if((y_pos>(roomHeight-(ballDiam+1)))|(y_pos<0)){ //negates gravity during impact
               a=0;
               if (y_pos<1 & y_pos>-.6){
                    yV=0;
          y_pos=getY();
          yVi=yV;
          yV=yVi+a*t;
          y_pos=y_pos+yV*t+.5*a*t*t;
          if((y_pos>(roomHeight-ballDiam)) & ( yV>0  )){
               y_pos=roomHeight-ballDiam;
               yV*= (-spring);
          if (y_pos<0 &  yV<0){
               yV*= (-spring);
          a=grav;
          return y_pos;
     public void drawBall(Graphics g) {
          g.setColor(color);
          g.fillOval((int)getX(),(int)getY(),(int)ballDiam,(int)ballDiam);
          g.setColor(Color.black);
          g.drawOval((int)getX(),(int)getY(),(int)ballDiam,(int)ballDiam);
          g.drawString(String.valueOf(yV),(int)x_pos,(int)y_pos);
     public Point2D.Double getCenter(){
          center.setLocation(x_pos+.5*ballDiam,y_pos+.5*ballDiam);
          return center;
     public double getxV(){
          return xV;
     public double getyV() {
          return yV;
     public void setSpeeds(double x,double y){
          xV=x;
          yV=y;