CS401 Lab 3: Using and Writing Methods

Introduction

In order to understand classes and objects better and to get used to using them in programs, it is a good idea to practice with them. Soon we will build our own classes, but for now we will just work with some predefined classes in Java and write some static methods.

Background

Java has many predefined classes that we can use in our programs in two ways:

1. Call helpful static utility methods that we otherwise would have to write ourselves. Recall from the lecture notes that static methods are associated with an entire class rather than with individual objects (which is why they are also called class methods). Recall also that static methods are invoked through the class directly, so we would call them by ClassName.methodName(). For example, the Math class contains a number of static methods to calculate common functions such as Math.abs(), Math.pow() and Math.sin().
2. Create objects that we can also use in our programs. We have already seen an example of this with the Scanner class -- we used a Scanner object to read tokens from the input stream in a logical way.

Random Class

The Random class in Java is a predefined class that enables the programmer to generate pseudo-random numbers. These are useful for simulations and scientific experiments. The methods in the Random Class are instance methods, not static methods.  Thus, to use it we must first create a Random object, then use that object to generate our random numbers. Look up the Random class in the Java API and note that many of the methods have the same name as those we saw in the Scanner class. This is because in a way they are similar -- objects of both Scanner and Random produce sequences of values, but the Scanner class obtains them from the input stream while the Random class generates them using an algorithm.

Program

Write a Java program that will simulate rolling 2 six-sided dice, and keep track of how many times each possible result (2, 3, ... 12) occurs.

First "roll" the dice 100 times and calculate the fraction of the "rolls" that resulted in each of the values (2, 3, ... 12). Compare these fractions with the probabilistic values for each number:

Next "roll" the dice 100000 times and calculate the fractions again. Again compare them to the probabilistic values. Do they match up better with the values this time? Make sure you understand why.

Details

Complete your program in the following way:

Write a static void method called RollDice that has two parameters: an int and a Random. The int parameter determines how many times to roll the dice and the Random is used to generate the actual values (note: we could make the Random variable local to the method, but that would create a new object with each call, which is not necessary). Think carefully about which method in Random to call and how to appropriately generate the actual roll values. In the method do the "rolls" and count how many times each number comes up. Then print out the number of times each number comes up and its fraction out of all of the rolls.

In the main program create the Random object, then enter a conditional loop. At each iteration of the loop ask the user to enter the number of rolls desired and call RollDice with the appropriate parameters. Then ask the user if he/she wants to continue. If so, repeat the process; if not terminate the program.