**Lecture 4**: Review Wrap-up (last updated Wed Jan 20)

This is supposed to be a wrap up for the A201 review. The "review" has
included many new things, such as object and class terminology and the
use of the `BreezyGUI`

package.

By the end of today's lecture
we hope to have covered: arrays, `do-while`

, `break`

,
`continue`

, `switch`

, the `Math`

functions
`random`

and the cast operator.

There should be no mistery left about these things at the end of the lecture.

At the same time we will forge ahead at the object oriented simulations that are supposed to give you a good idea of how classes and objects behave.

**1.** Random numbers

For our simulations we will use random numbers. Let's get back to the line
we wrote in lecture 3 that was intended to give use random numbers between
`1`

and `6`

(integers only, including `1`

and `6`

):

wheredice = (int)Math.round(Math.random() * 6 + 1);

`dice`

is an `int`

.
Since `Math.random()`

produces numbers in `[0, 1)`

then

will produce numbers inMath.random() * 6

`[0, 6)`

and if you add `1`

to this it
means that will produce numbers in the intervalMath.random() * 6 + 1

`[1, 7)`

.
Now the news: completely *forget* the rounding operation.

As Schmalensee put it recently in the Microsoft antitrust trial,

``My immediate reaction is, what could I have been thinking?''

He was talking about a different thing, but if we
`floor`

the interval `[1, 7)`

we end up with the following set of integer numbers:

and that's what we wanted.{ 1, 2, 3, 4, 5, 6}

Taking the integer part of a `double`

can be done with
the cast operator:

returns the integer part of the(int)aDouble

`aDouble`

variable (that
is a number with decimals in our example).
So if we eliminate the `round`

part altogether in our line
we end up with what we wanted in the first place, that is for the integer
numbers `1`

through `6`

to come up with equal
probability.

In other words, like throwing a dice (and a fair one at that).

As noted by Joel Mason (e-mail communication) the dice needs to be fair.
Not because we want the objects of our `Hoosier`

class to cheer
uniformly in one of the three ways we were designing them to cheer, but
because we want to make sure that if we need to use this dice again we can
safely rely on it being unbiased.

You're right, Joel, using `round`

makes a biased dice.

Fortunately using `(int)`

restores the fairness since casting
to an `int`

is equivalent to taking the floor of the number.

**2.** Taking advantage of it

The good part of all this is that we can now write a better definition
for the class `Hoosier`

that we used in our second play, that
is, `Hoosiers(.java)`

.

We take the original code:

and turn it into:class Hoosier { void cheer() { int dice; dice = (int)(Math.random() * 6 + 1); switch (dice) { case 1: case 2: System.out.println("I-N-D-I-A-N-A!"); break; case 3: case 4: System.out.println("Go IU Beat Purdue!"); break; case 5: case 6: System.out.println("Hoosiers! Hoosiers!"); break; } } }

where all the changes have been marked in blue.class Hoosier { void cheer() { int dice; dice = random(1, 6); switch (dice) { case 1: case 2: System.out.println("I-N-D-I-A-N-A!"); break; case 3: case 4: System.out.println("Go IU Beat Purdue!"); break; case 5: case 6: System.out.println("Hoosiers! Hoosiers!"); break; } } int random(int start, int stop) { return (int)(Math.random() * stop + start); } }

**3.** Arrays

This example throws a fair dice 10 times and fills an array with
`int`

s and then calculates their product. It illustrates arrays,
`for`

loops, `break`

and `continue`

.

More detailed explanation ofpublic class Arrays { public static void main(String[] args) { int[] myArray = new int[10]; for (int i=0; i < myArray.length; i++) myArray[i] = random(1, 6); int product = 1; for (int i=0; i < myArray.length; i++) { System.out.println(i + ": " + myArray[i]); if (myArray[i] == 0) { product = 0;break; } else if (myArray[i] == 1) {continue; } else { product *= myArray[i]; } } System.out.println(product); } static int random(int start, int stop) { return (int)(Math.random() * stop + start); } }

`break`

and
`continue`

will be given in class, although a
few things will have to be said here. [...]
We've been carrying our own definition of `random`

around.
In later examples we may simply use the line without first coding it
into a definition for an instance method, `random`

. But note
that `random`

needs to be `static`

here.

**4.** `switch`

revisited

**5.** Arrays of `Hoosier`

s

* to be continued... *

I will update this with the code we wrote in class and a few other notes before Saturday.