Well that's definitely not good for business, ha.
When you removed the loop from Ball's paint method, did you also change it so it wasn't doing any ball stuff? There wouldn't need to be any array stuff in there.
And you kept the loop in game's paint method?

I wanna reiterate since I am throwing up different issues kind of all at once. Remember to take one issue and work on solving it (small steps). So don't try to change and update and add 3 or 4 things all at once.

For the thread code you added, I wanna say I think adding threads is only going to make this more complex, harder to maintain and harder to understand what's going wrong when something does. But if you insist on diving into threads, We'll need to see the code where you start or schedule that thread to run. For the code you posted, if (t == 5) would never be true. You have a for loop that runs from 0 through 9 and quits when t equals 10 so t will equal 10 when that loop is exited. If it were to ever be true, the line of code inside just generates a random number but doesn't do anything with it or put it anywhere so that you can use it (assuming the randomNumber method is the same as before).

Excellent. Now that's a solid little Ball class. Does that leave you now working on getting them appearing every 10 seconds?

I wish I could say that after you've used Threads a little, they become easy. But they never do... Most programmers reach a point where they can write good threaded code, but still not actually correct.. just that it's correct enough that it doesn't bite them in the ass all that often.

Alright, a couple of things:

1. Right now you're generating a new random number every time you do one of those drawString statements. That is just like it sounds like, a random number with no particular meaning or relation to anything. It's random. It looks like you're wanting to treat those statements like debugging kind of statements that tell you where each ball actually is. For that information, you'd want to look at the variables the ball has (like ball[0].x, ball[0].y, etc).

2. The reason your whole program "stops" for 5 seconds is you tell this program's thread to sleep for 5 seconds (Thread.sleep(5000). So for 5 seconds this thread isn't responding or updating or drawing or anything. What you want probably isn't to do NOTHING for 5 seconds.. just that you have something you DO want to happen every 5 seconds. For help on that, I think you'll need to post all of your code, as this will be a time where I need to take in what you're doing on the various threads and to try to see what you might be doing that you don't mean to be doing on the various threads.

I think if you're gonna stick with Threads so heavily, you'll need to go read up on some concurrency (http://docs.oracle.com/javase/tutorial/essential/concurrency/) to get a good idea of what goes on and what you want to go on.

I'll also write a more lengthy post about a good to do what you want to w/o threads.. it'll be an hour or so though probably before I can do that.

Alright, sorry but I needed to support my gaming habit for a while. I just put this together and I did confirm that it runs. If you have any questions about why I did something, please do feel free to ask because I can't/won't say that everything is the best approach to a problem. I put it together to show you things being done based on time but not centered around running several threads within my program.

[source lang="java"]import java.applet.Applet;
import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

public class GameWithTime extends Applet implements Runnable
{
//Sets NEW_DOT_FREQUENCY as 3 seconds
private static long NEW_DOT_FREQUENCY = TimeUnit.SECONDS.toMillis(3);
private static final int SCREEN_WIDTH = 400;
private static final int SCREEN_HEIGHT = 400;

//Stores what the time was when updateGame last ran
private long lastUpdateTime = 0;
//Tracks how much time has passed since the last new dot was added
private long timeSinceLastNewDot = 0;
//List of all the enemy dots
private ArrayList<Dot> enemyDots;

private Thread animator;
private boolean isRunning;

//Initialize things for the game
public void init()
{
debugPrint("Initializing values.");
//Put 4 dots in the list initially
enemyDots = new ArrayList<Dot>();
enemyDots.add(new Dot(randomValue(), randomValue(), 10, 10));
enemyDots.add(new Dot(randomValue(), randomValue(), 10, 20));
enemyDots.add(new Dot(randomValue(), randomValue(), 20, 10));
enemyDots.add(new Dot(randomValue(), randomValue(), 20, 20));
}

public void start()
{
lastUpdateTime = System.currentTimeMillis();
isRunning = true;

animator = new Thread(this);
animator.start();
}

public void stop()
{
isRunning = false;
}

//Applet is closing, clean up
public void destroy()
{

}

public void run()
{
while (isRunning)
{
repaint();
try
{
Thread.sleep(15);
} catch (InterruptedException e)
{
}
}
}

//This update and paint approach is an alternative to double buffering to avoid flickering
public void update(Graphics g)
{
//Update variables
updateGame();

//Draw things to the screen
//Clear the screen
g.setColor(Color.BLACK);
g.fillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);

g.setColor(Color.cyan);
//Draw each dot in the list
for (Dot dot : enemyDots)
{
dot.draw(g);
}
}

//This update and paint approach is an alternative to double buffering to avoid flickering
public void paint(Graphics g)
{
update(g);
}

private void updateGame()
{
//Get the current time
long currentTime = System.currentTimeMillis();
//Calculate how much time has passed since the last update
long elapsedTime = currentTime - lastUpdateTime;
//Store this as the most recent update time
lastUpdateTime = currentTime;

//Process inputs
updateVariablesBasedOnUserInput();

//Create a new dot if enough time has passed
//Update the time since last new dot was drawn
timeSinceLastNewDot += elapsedTime;
//See if enough time has passed to create a new dot
debugPrint(Long.toString(timeSinceLastNewDot));

if (timeSinceLastNewDot >= NEW_DOT_FREQUENCY)
{
//Generate random x and y values for new dot
int newX = randomValue();
int newY = randomValue();

//Add a new dot to the collection of dots
debugPrint("New dot created at x:" + newX + ", y:" + newY + ".");
enemyDots.add(new Dot(newX, newY, 20, 20));

//Reset time since a new dot was created
timeSinceLastNewDot = 0;
}
}

private void updateVariablesBasedOnUserInput()
{
//Set speeds/velocities based on user inputs
}

//Returns a new random value each time a call is made
private int randomValue()
{
return (int) (Math.random() * 400);
}

//Prints passed value to the console
private void debugPrint(String value)
{
System.out.println(value);
}

private class Dot extends Ellipse2D.Float
{
public Dot(int xValue, int yValue, int width, int height)
{
this.x = xValue;
this.y = yValue;
this.width = width;
this.height = height;
}

public void draw(Graphics graphics)
{
graphics.drawOval((int) x, (int) y, (int) width, (int) height);
}
}
}
[/source]