Random Number Generation in Java

This program opens a window divided into a grid of colored squares. It paints every square a random color, and then it lets a single point of interest wander across the grid, repainting each square it lands on. The walk never stops until you close the window, so the final picture is a mosaic whose colors depend on where the walk happened to go.

The best way to read a program like this is to watch it run and then ask what each part of the code must have done to produce what you saw. Keep one question in mind throughout: if the window ever shows something you did not expect, which subroutine would be responsible for it?

The first real work the main program hands off is the fill step. The fillWithRandomColors subroutine uses two nested loops. The outer loop counts rows from 0 up to 15, and the inner loop counts columns from 0 up to 19. Together they visit every square of the 16 by 20 grid exactly once. For each square, the subroutine calls changeToRandomColor with that square's row and column.

The nested loops are a simple way to guarantee coverage. The count of 16 rows and 20 columns appears as literal numbers in the code. The source passes these values directly rather than defining named constants, so the same numbers must be kept consistent by hand in every place they are used.

The color itself is produced inside changeToRandomColor. It needs three numbers, one each for red, green, and blue, and each number comes from the same expression pattern. Math.random() produces a double in the range from 0.0 up to, but not including, 1.0. Multiplying that by 256 stretches the range to roughly 0 up to 256. The cast to int then drops the fractional part, leaving whole numbers from 0 to 255. Those are exactly the values a color component can take.

The three values are then passed to Mosaic.setColor along with the row and column. The direction is picked with the same idea but a different multiplier. The expression (int)(4*Math.random()) produces a whole number from 0 to 3, and the program stores that number in directionNum.

The program keeps track of the disturbance with two class-level variables, currentRow and currentColumn. They are declared with the static keyword outside any method. A reasonable first guess is that these should be local variables inside main. The source explains why that would not work: several different subroutines need each of these variables. main sets their starting values, and randomMove reads and updates them on every step of the walk.

A local variable exists only while the method that declares it is running, and each method has its own separate copy of its locals. If currentRow were local to main, randomMove would have no access to it. Making the variables static members of the class gives every static method in the class a shared place to read and write the current position. That shared place is what lets one subroutine move the disturbance and another subroutine repaint the square the disturbance is standing on.

The randomMove subroutine performs exactly one step of the walk each time it is called. It begins by choosing a direction, and a switch statement then looks at directionNum and runs one of four cases. Case 0 moves up, case 1 moves right, case 2 moves down, and case 3 moves left. The direction numbers are chosen arbitrarily; any four distinct numbers would work, provided the switch matched them correctly.

Exactly one of the four branches runs for each call. Every branch changes only one of the two position variables, by one. After that, all four paths meet at the same edge check, and that shared check keeps the disturbance inside the grid no matter which direction was chosen.

The rule stated in the subroutine's documentation is that a neighboring position outside the grid is replaced by the position on the opposite edge. The four cases implement this rule with specific numbers. Moving up from row 0 sets the row to 15. Moving down from row 15 sets it to 0. Moving right from column 19 sets the column to 0. Moving left from column 0 sets the column to 19.

The column rule works the same way along the horizontal edges. Moving left from column 0 lands on column 19, and moving right from column 19 lands on column 0. Note that the wrap is only about the edge check: randomMove still changes exactly one position variable by one before the check runs.

The main program does its setup once: it fills the grid with random colors and sets the starting position. After that, a while loop runs while the window is open. Each pass repaints the square at the current position with a new random color, and then calls randomMove to choose the next position. The loop does not stop on its own; it ends only when the window closes.

Use the rules from this article to trace the walk. Start with currentRow = 15 and currentColumn = 0. Apply these direction numbers in order: 2, 3, 0. After each step, state the new position and say which edge rule (if any) was used. Remember that the main loop repaints the current square before each call to randomMove.