Multithreading: bouncing balls problem

[Joe Fett]

I had to find a program that demos a bouncing ball in JPanel and I did that. The next evolution is taking that program and making it add a new ball with each mouse click. I have attempted a few things but now I am totally lost with this project. I was able to get the code to compile but not run.

Anyone have a helpful idea how I can unfunk this code and get it going the right direction? As always, the help is appreciated!

/*
*      Ball.java
*/
 
import java.awt.Dimension;
import java.util.Random;
import java.awt.Color;
 
public class Ball implements Runnable
{
 
    static void init() {
        throw new UnsupportedOperationException("Not yet implemented");
    }
    
    public Dimension getPreferredSize()
   {
      return new Dimension( MAX_X, MAX_Y );
   } // end method getPreferredSize
 
    static void setPreferredSize(Dimension dimension) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
   private boolean xUp, yUp; 
   
   int x, y; // positions of ball
   
   private int xDx; // change in horizontal position of ball
   private int yDy; // change in vertical position of ball
   private final int MAX_X = 200; // horizontal edge of JPanel
   private final int MAX_Y = 200; // vertical edge of JPanel
   private Random generator = new Random();
   private Color color; // color of ball
 
   public Ball( int xPos, int yPos )
   {
      xUp = false;
      yUp = false; 
      xDx = generator.nextInt( 5 ) + 1; 
      yDy = generator.nextInt( 5 ) + 1; 
      x = xPos; 
      y = yPos; 
     // color = new Color( generator.nextInt( 256 ), 
     //    generator.nextInt( 256 ), generator.nextInt( 256 ) ); 
   } // end Ball constructor
 
   
   public void run()
   {
      while ( true ) // infinite loop
      {
         try 
         {
            Thread.sleep( 20 ); // sleep for 20 milliseconds
         } // end try
         
         catch ( InterruptedException exception ) 
         {
            exception.printStackTrace();
         } // end catch
 
         // determine new x position
         if ( xUp == true )
            x += xDx; 
         else
            x -= xDx;
 
         // determine new y position
         if ( yUp == true )
            y += yDy; 
         else
            y -= yDy; 
 
         if ( y <= 0 ) 
            yUp = true; 
         else if ( y >= MAX_Y - 10 ) 
            yUp = false; 
 
         if ( x <= 0 ) 
            xUp = true;
         else if ( x >= MAX_X - 10 ) 
            xUp = false; 
      }  // end while
   } // end method run
 
   
   public int getX()
   {
      return x; 
   } // end method getX
 
   
   public int getY()
   {
      return y; 
   } // end method getY
 
   // get the ball's color
   public Color getColor()
   {
      return color;
   }
} // end class Ball    

 /*
* BouncingBall.java modified from  
* <a href="http://www.shsu.edu/~ucs_mca/java/ball/Ball.java" target="_blank" rel="nofollow">http://www.shsu.edu/~ucs_mca/java/ball/Ball.java</a> 
 */
 
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.applet.*;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// note interface for threads
 
public class BouncingBall extends JFrame 
implements Runnable, MouseListener //, MouseMotionListener
{
 
   
//Thread runner;
private ExecutorService threadExecutor;     
private Thread blueBall;
private boolean xUp, yUp, bouncing;
private ArrayList< BouncingBall > balls = new ArrayList< BouncingBall >(20);
private JFrame parentWindow;
private final int MAX_X = 200; 
private final int MAX_Y = 200;
// Image offscreen;
// Graphics goffscreen;
// Color  color[]=new Color[7];
private Color color;
// int v,w ; //index to color
// state of balls
int x,y,dx,dy;
int dh, dv;
 
public BouncingBall()
{
    pack(); 
    setVisible( true );
    
    
}
 
    private BouncingBall(int a, int b) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
//    @Override
public void init() 
{
    threadExecutor = Executors.newCachedThreadPool();
    
      // applet listens to its own mouse events
   //   addMouseListener( this ); // old
      
      addMouseListener( 
         new MouseAdapter() 
         {
            @Override
            public void mousePressed( MouseEvent e ) 
            {
               createBall( e ); 
       //        RepaintTimer timer = new RepaintTimer( parentWindow );
       //        threadExecutor.execute( timer );
            } // end method mousePressed
         } 
      ); // end call to addMouseListener
    
      
//      addMouseMotionListener( this );
//w=6;
//color[0]=Color.pink;
//color[1]=Color.red;
//color[2]=Color.blue;
//color[3]=Color.orange;
//color[4]=Color.green;
//color[5]=Color.yellow;
//color[6]=Color.black;
// create offscreen drawing buffer
dh = getSize().width;
dv = getSize().height;
 
//offscreen = createImage(dh, dv);
//goffscreen = offscreen.getGraphics();
 
// set initial position and step size
x = y = 0;
dx = 5 + (int) Math.floor(Math.random() * 20);
dy = 5 + (int) Math.floor(Math.random() * 20);
}
 

// create a thread
//    @Override
public void start()
{
if (blueBall == null)
{blueBall = new Thread(this);
blueBall.start();
}
}
 
// kill the thread
//    @Override
public void stop()
{
if (blueBall != null)
{blueBall.stop();
blueBall = null;
}
}
 
public void run()
{
int oldx,oldy;
 
oldx=x;
oldy=y;
while (true)
{
// Pause between displays to slow speed
try { Thread.sleep(100); }
catch (InterruptedException e) {}

// reflect balls from walls
x += dx; //increment to next x by step size
if (x > dh) //if off right side then bounce
{x = dh - (x - dh); // (max -(cur - max))
dx = -dx; //clear step size, x will be new steping
}
if (x < 0)//if off left side then bounce
{x = -x;
dx = -dx; //clear dx
}
y += dy; //increment to next y
if (y > dv)//if off bottom then bounce
{y = dv - (y - dv);
dy = -dy;//clear dy
}
if (y < 0)//if off top then bounce
{y = -y;
dy = -dy; //clear dy
}
//System.out.println("x>" + x + "y>" + y);
repaint();

}//end while
}
 
    @Override
public void paint(Graphics g)
{
        if ( bouncing ) {
         g.setColor( Color.blue );
         g.fillOval( x, y, 10, 10 );
      }
// Repaint screen to erase last ball
//goffscreen.setColor(color[w]);
//goffscreen.fillRect(0, 0, dh, dv);
 
//Set color and draw ball at new location
//goffscreen.setColor(Color.blue);
//goffscreen.setColor(color[v]);
//goffscreen.fillOval(x - 5, y - 5, 10, 10);
// draw to ball to screen
//g.drawImage(offscreen, 0, 0, this);
}
 
// overload for no erase
    @Override
public void update(Graphics g)
{
paint(g);
}
    
    @Override
public int getX()
   {
      return x; // return x value
   } // end method getX
 
   
    @Override
   public int getY()
   {
      return y; // return y value
   } // end method getY    
    
private void createBall( MouseEvent e )
   {
      int a = e.getX(); 
      int b = e.getY();
      BouncingBall ball = new BouncingBall( a, b ); // creates new ball
      threadExecutor.execute( ball ); // set ball in motion
      balls.add( ball ); // place new Ball in the ArrayList
   } // end method createBall    
 
//   }
 
   // MouseListener event handlers
/*   public void mouseClicked( MouseEvent e )
      { }
 
   public void mousePressed( MouseEvent e )
      { 
v++;
if (v > 5)
v=1;
 
}
 
   public void mouseReleased( MouseEvent e ) { }
 
   public void mouseEntered( MouseEvent e )
      { 
v++;
if (v > 5)
v=1;
 
}
 
   public void mouseExited( MouseEvent e )
      { 
if (v == 0)
v=5;
else
v--;
}
 
   // MouseMotionListener event handlers
   public void mouseDragged( MouseEvent e ) { }
 
   public void mouseMoved( MouseEvent e )   { }
*/    
  public static void main(String[] args)
    {
        BouncingBall application = new BouncingBall();
 //       BouncingBall.run();
//        Ball.setPreferredSize(new Dimension(200, 200));
 //       JFrame frame = new JFrame("Ball");
 //       frame.setContentPane( Ball );
 //       frame.pack();
 //       frame.setResizable( false );
 //       frame.setLocationRelativeTo( null );
 //       frame.setVisible( true ); 
//        application.setDefaultCloseOperation( EXIT_ON_CLOSE );
   }
 
    public void mouseClicked(MouseEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 
    public void mousePressed(MouseEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 
    public void mouseReleased(MouseEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 
    public void mouseEntered(MouseEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 
    public void mouseExited(MouseEvent e) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
 

 } // end class BouncingBall  

[Ulf Dittmer]

What's with all the UnsupportedOperationExceptions? Does the code run if you remove those? If so, what does it do, and where are you stuck making progress?

[Joe Fett]

Originally posted by Ulf Dittmer:
What's with all the UnsupportedOperationExceptions? Does the code run if you remove those? If so, what does it do, and where are you stuck making progress?

As I was going through and resolving the issues, I let NetBeans resolve them so I could get it to compile. The result was all that unsupported nonsense which just added to my misery.

I'm stuck at getting the full JPanel or JFrame to show. As it runs now only the title bar of it displays.

[Ulf Dittmer]

I don't see code that would add a JPanel (or anything, actually) to the JFrame. That the JFrame is sized to essentially nothing is because of the "pack" call - if a frame is empty, then there's no need for it to take up space.

[Campbell Ritchie]

If you create a method and don't write anything in it, NetBeans will write "throw new UnsupportedOperationException();" which is useful for method which you intend to implement later. When you have interfaces and wish to leave some of the methods blank, as you have found the hard way ( ) it doesn't help.