Major Lag with my Application and a 2D Ball collision question

Question

Well, check it. Basically I'm running an application that looks something like this:
public class Gameextends Canvas implements KeyListener,MouseInputListener{
     /*-------Variable Declarations-------*/
     //GameApp Objects
     BufferStrategy strategy;
     JFrame gameWindow;
     Graphics g;     
     public Game(){
          version=2.0; //see update history for details
          debug=false;     
          //all basic variable setups
          stage=1;
          fps=0;
          gridSize=10;
          numCols=80;
          numRows=60;
          WIDTH=numCols*gridSize;
          HEIGHT=numRows*gridSize;
          //sets all booleans related to game states
          isPaused=false;
          isFinished=false;     
          //Behind the scenes settings
          //maxFPS=80;
          initObjects();
          //Setup gamewindow
          gameWindow = new JFrame("SnakeSoccer v"+version);
        JPanel panel = (JPanel)gameWindow.getContentPane();
        setBounds(0,0,WIDTH,HEIGHT);
        panel.setPreferredSize(new Dimension(WIDTH,HEIGHT));
        panel.setLayout(null);
        panel.setBackground(Color.white);
        panel.add(this);
          gameWindow.setResizable(false);
          gameWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          gameWindow.pack();
          //makes the buffer work
          createBufferStrategy(2);
          strategy = this.getBufferStrategy();
          //sets up all listeners
          addMouseListener(this);
          addMouseMotionListener(this);
          addKeyListener(this);
          this.requestFocus();
          gameWindow.setVisible(true);
     public void initObjects(){
     public void run(){
          tm=System.currentTimeMillis();
          while(!isFinished){
               if(!isPaused){
                    g=strategy.getDrawGraphics();
                    switch(stage){
                         case 1: //Draw Title Screen
                              drawTitleScreen(g);
                              stage=2; //This must be taken out once KeyListener works
                              break;
                         case 2: //Main Game loop
                              checkWorld();
                              updateWorld();
                              drawWorld(g);
                              break;     
                    strategy.show();               
               if(debug)
                    if(System.currentTimeMillis()-tm>1000)
                              drawFPS(g);
          System.exit(0);
     }Basically, you should be able to tell what's going on. I can limit the FPS by putting an if statement in the beginning of 'case 2' by making it look like this:
case 2: //Main Game loop
if(fps<maxFPS)
                              checkWorld();
                              updateWorld();
                              drawWorld(g);
                              break;     basically, in the drawWorld method it does if(debug)fps++;
Then in the drawFPS it resets the FPS and all that jazz.
Anyways, that's the game loop and everything. It does it's thing, but I noticed weird FPS output. Anywhere from 30 all the way up to 3k+ when I didn't limit it. It also is extremely laggy on my PC (good specs, shouldn't be a problem) whether it's capped or uncapped. Any advice would be awesome.
Also, ball collision... check it:
Ball class is basically this:
int x,y,size;
x,y are the top left points of the ball, and the size is the diameter. I'm trying to have it bounce of two moving objects and all the walls. The obvious thing for this is:
if(ball.x<0) ball.invertX(); //inverts the movement of the ball along the X axis. Does not affect the velocity.
or something to that nature. But I guess the real question is what happens if the velocity would land it on the other side of the wall. IE: it's at 5,5 and it moves 8 up and 8 over every time. So it would appear slightly outside the screen. How would I solve this? Sorry it's kinda choppy, but any help would be awesome. I'm programming as we speak, so I will be checking every 5min. My AIM is SAOniKami if you guys wanna chat.
Let me know if you need anymore info. Thanks.

Answer 1

Ok, so a few questions:
1. With the sleeper stuff, why should I use my current thread? My application starts like this:
public class Runner{
     public static void main(String[] args){
          SnakeSoccer app = new SnakeSoccer();
          app.run();
}I actually never reference a thread, so it should be all on one thread. Is this bad? When you mentioned that other sleep method it just got me thinking.
Also, about the collisions: I'm not quite sure what you're saying. Right now I have this in my ball class:
public class Ball extends GameObject{
     //Data Fields
     private int x,y,vY,vX,radius;
     private boolean isVisible,isXMoveable,isYMoveable;
     private Color ballColor;
     private Image ballImage;
     Ball(){
          x=50;
          y=50;
          vX=3;
          vY=3;
          radius=5;
          ballImage = new ImageIcon("images/ballPic.gif").getImage();
          isXMoveable=true;
          isYMoveable=true;
     Ball(int x,int y,int vX,int vY,int size,Color c){
          this.x=x;
          this.y=y;
          this.vX=vX;
          this.vY=vY;
          this.radius=radius;
          ballColor=c;
          isXMoveable=true;
          isYMoveable=true;
     Ball(int x,int y,int vX,int vY,int size,Image i){
          this.x=x;
          this.y=y;
          this.vX=vX;
          this.vY=vY;
          this.radius=radius;
          ballImage=i;
          isXMoveable=true;
          isYMoveable=true;
     public int getX(){ return x; }
     public int getY(){ return y; }
     public int getVX(){ return vY; }
     public int getVY(){ return vY; }
     public int getRadius(){ return radius; }
     public boolean isVisible(){ return isVisible; }
     public boolean isXMoveable(){ return isXMoveable; }
     public boolean isYMoveable(){ return isYMoveable; }
     public void setX(int n){ x=n; }
     public void setY(int n){ y=n; }
     public void setVX(int n){ vX=n; }
     public void setVY(int n){ vY=n; }
     public void setVisible(boolean b){ isVisible=b; }
     public void setXMoveable(boolean b){ isXMoveable=b; }
     public void setYMoveable(boolean b){ isYMoveable=b; }
     public void inverseX(){ vX*=-1; }
     public void inverseY(){ vY*=-1; }
     public void tick(){
          if(isXMoveable)
               x+=vX;
          if(isYMoveable)
               y+=vY;
     public void draw(Graphics g){
          if(ballImage==null){
               g.setColor(ballColor);
               g.fillOval(x-radius,y-radius,radius*2,radius*2);     
          else
               g.drawImage(ballImage,x-radius,y-radius,null);
}Basically, vX and vY are how many pixels it moves everytime it's updated. Then I just call invertX or invertY to just times it by -1. Unfortunately, this is a very simple collision engine, but it seems to serve it's purpose.
How I detect them is something like this:
          //check for wall collisions
          if(ballX-radius-1<=0) //left wall
               ball.inverseX();
          else if(ballX+radius+1>=numCols*gridSize) //right wall
               ball.inverseX();
          if(ballY-radius-1<=0) //top wall
               ball.inverseY();
          else if(ballY+radius+1>=(numRows-10)*gridSize) //bottom wall
               ball.inverseY();gridSize is the size of a grid in my program. While, there are no 'grids', I just use that to scale the program. IE: If I change the gridSize from 10 to 20, the window will be twice as big, and everything else will work fine also.
Anyways, let me know if you see anything wrong with that.