Chapter 6 Objects and

Classes
 Using the RandomGenerator Class

• Before you start to write classes of your own, it

helps to look more closely at how to use classes
that have been developed by others.
• Introduce a class called RandomGenerator.
• It makes it possible to write programs that
simulate random processes such as flipping a
coin or rolling a die.
 Random number generator

• Deterministic program: Its output is predictable

with any given set of input values.
• Nondeterministic program: Its output is
unpredictable, such as casino games.
• Nondeterministic behavior is essential to many
applications: Computer games, simulations,
computer security, and algorithmic research.
 Random number generator

• The core at any nondeterministic program is often a

random number generator.
• A true random number generator is hard, if not
impossible, to implement on a computer. A
computer executes its instructions in a precise and
predictable way. If you give a computer program the
same inputs, it will generate the same outputs every
time, which is not you want in a nondeterministic
program.
• The solution is a pseudorandom number generator.
(D. Knuth)
 Pseudorandom
• RandomGenerator must simulate randomness
by carrying out a deterministic process that
satisfies the following criteria:
1. The values generated by that process should be
difficult for human observers to predict.
2. Those values should appear to be random, in the
sense that they should pass statistical test for
randomness.
• Because the process is not truly random, the
values generated by RandomGenerator are said
to be pseudorandom
 Pseudorandom number generator

• Can be viewed as a black box that generates a

sequence of values
1749940626, 892128508, 155629808, ...
• The pseudorandom number generator generates
seemingly random values by applying a function to the
previous value. The starting point for this sequence of
values is called the seed.
• Java initializes the seed for its pseudorandom number
generator to a value based on the system clock, which
changes very quickly on a human time scale.
Using the RandomGenerator class
• Create a single shared instance of the class
RandomGenerator
import acm.util
private RandomGenerator rgen = RandomGenerator.getInstance();
• Notice the difference? Using new is not
appropriate for RandomGenerator because
there should be only one random generator in
an application. What you want to do instead is to
ask the RandomGenerator class for a common
instance that can be shared throughout all
classes in your program.
 Class hierarchy
• The RandomGenerator class is actually implemented as
a subclass of a class called Random.
• Some methods that you call to produce random values
are defined in RandomGenerator class itself; others are
inherited from the Random class.
• RandomGenerator class is defined in the package
acm.util, which is part of the ACM Java Libraries.
• Random class is part of java.util package, which is a
collection of general utility classes.
• When you use the RandomGenerator class, you do not
need to import the java.util package (unless you use it
for some other purpose).
 Why new is not appropriate?

• Computers run much faster than the internal

clock can register. If you create two
RandomGenerator instances in a single
program, it is likely that both will be initialized
with the same seed and therefore generate the
same sequence of values. This fact explains
why it is important to create only one
RandomGenerator instance in an application.
 Debugging and random behavior
• Unpredictability often makes debugging extermely
difficult. Because the program runs in a different way
each time, there is no way to ensure that a bug that turns
up the first you run a program will happen again the
second time around.
• To get around this problem, it is often useful to have your
programs run deterministically during the debugging
phase. To do so, you can use:
rgen.setSeed(1)
• This call sets the random number seed to 1 so that the
internal random number sequence will always begin at
the same point. The value 1 is arbitrary.
Using the RandomGenerator class

private RandomGenerator rgen = RandomGenerator.getInstance();

• This declaration usually appears outside of any

method and is therefore an example of an
instance variable.
• The key word private indicates that this variable
can be used from any method within this class
but is not accessible to other classes.
 Methods to generate random values

int nextInt(int low, int high)

Returns a random int between low and high inclusive.
int nextInt(int n)
Returns a random int between 0 and n-1.
double nextDouble(double low, double high)
Returns a random double in the range [low, high]
double nextDouble()
Returns a random double in the range [0, 1.0)
boolean nextBoolean()
Returns a random boolean value, which is true 50% of the time
boolean nextBoolean(double p)
Returns a random boolean, which is true with probability p, where
0<=p<=1.
Color nextColor()
Returns a random color.
 Call method

Send a message to the generator in rgen(receiver)

int die = rgen.nextInt(1, 6)

Returns an integer between 1 and 6 inclusive.
(Rolling a die)

String coinFlip = rgen.nextBoolean() ? “Heads” :

“Tails”;
Returns “Heads” or “Tails” in equal probability.
(Flipping a coin)
 Exercises
1. Set the variable total to the sum of two dice.
int d1 = rgen.nextInt(1, 6);
int d2 = rgen.nextInt(1,6);
int total = d1 + d2;
What’s wrong with int total = rgen.nextInt(2,12)?
2. Flip a weighted coin that comes up heads 60%
of the time.
String flip = rgen.nextBoolean(0.6) ? “Heads” : “Tails”;
3. Fill color of rect to some randomly chosen color
rect.setFillColor(rgen.nextColor())
 Simulating the game of Craps
public void run() {
int total = rollTwoDice();
if (total == 7 || total == 11) {
println(“That’s a natural. You win.”);
} else if (total == 2 || total == 3 || total == 12) {
println(“That’s craps. You lose.”);
} else {
int point = total;
println(“Your point is “ + point + “.”);
while (true) . . .
}
}
• Trace the program
 rollTwoDice() method

private int rollTwoDice() {

int d1 = rgen.nextInt(1, 6);
int d2 = rgen.nextInt(1, 6);
int total = d1 + d2;
println(“Rolling dice: “ + d1 + “ + “ + d2 + “ = “
+ total);
return total;
}
 The while loop

while (true) {
total = rollTwoDice();
if (total == point) {
println(“You made your point. You win.”;
break;
} else if (total == 7) {
println(“That’s a 7. You lose.”);
break;
}
 The javadoc documentation system
• Unlike earlier languages that appeared before WWW,
Java was designed to operate in web-based
environment.
• One of the most important ways in which Java works
together with web is the design of its documentation
system, called javadoc.
• The Javadoc application reads Java source files and
generates documentation for each class.
• You can see the complete documentation for the ACM
Java Libraries from
http://jtf.acm.org/javadoc/student/
 Sample javadoc pages
acm.util
Class RandomGenerator

public class RandomGenerator extends Random

This class implements a simple random number generator that allows clients to
generate pseudorandom integers, doubles, booleans, and colors. To use it,
the first step is to declare an instance variable to hold the random generator
as follows:

private RandomGenerator rgen =

RandomGenerator.getInstance();
 Sample javadoc pages
Constructor Summary
RandomGenerator()
Create a new random generator.

Method Summary
RandomGenerator getInstance()
Returns a RandomGenerator instance that . . .
boolean nextBoolean(double p)
Returns a random boolean value with specified . . .

Inherited Mehod Summary

boolean nextBoolean()
Returns a random boolean that is true 50 percent of the time.
double nextDouble()
Returns a random double in [0, 1)
 Sample javadoc pages
Constructor Detail
public RandomGenerator()
Create a new random generator. Most clients will not use the constructor directly but
will instead call getInstance to obtain a RandomGenerator object that is shared by
all classes in the application.

Usage: RandomGenerator rgen = new RandomGenerator();

Method Detail
public RandomGenerator()
Returns a RandomGenerator instance that can be shared among several classes.

Usage: RandomGenerator rgen = RandomGenerator.getInstance();

Returns: A shared RandomGenerator object
 Writing javadoc comments
• To make javadoc work with your own programs, you
need to specially formatted comments to your code.
• A javadoc comment begins with /** and extends up to */
just as a regular comment does. The javadoc application
reads through them to find the information it needs to
create the documentation.
• Although javadoc comments may consists of simple text,
they may also contain formatting information written in
HTML used to create web pages. The javadoc
comments also often contain @param and @return tags
to describe parameters and results.
 An example of javadoc comments
The javadoc comment
/**
* Returns the next random integer between 0 and
* <code>n</code>-1, inclusive.
* @param n The number of integers in the range
* @return A random integer between 0 and <code>n</code>-1
*/
public int nextInt(int n)
Produces the following entry in “Method Detail” section of the web page
---------------------------------------------------------------------------------------
public int nextInt(int n)
Returns the next random integer between 0 and n-1, inclusive
Parameter: n The number of integers in the range
Return: A random integer between 0 and n-1
-------------------------------------------------------------------------------------------------
 Defining your own classes
Defining a class by extending an existing class
public class name extends super {
class body
}
name: The name of the new class. Must be the same as
the name of the source file.
super: The name of the super class. If the extends clause
is missing, the new class becomes a direct subclass of
Object, which is the root of Java’s class hierarchy.
class body: A sequence of definitions that typically includes
constructors, methods, named constants, and instance
variables. Generally called entries.
 Controlling access to entries
• public: All classes in the program have access to any public
entry. The public entries in a class are said to be exported by
that class.
• private: Access to entries declared as private is limited to the
class itself, making that entry completely invisible outside the
class.
• protected: Protected entries are restricted to the class that
defines them, along with any of its subclasses or any classes
in the same package.
• (no keyword): If the access keyword is missing, the entry is
visible only to classes in the same package. Such entries are
called package-private.
• The text uses only public and private. All entries are marked
as private unless there is a compelling reason to export them.
 A student information system
• Class definition
public class Student {
}
No clause extends, it is a direct subclass of the
Java built-in Object class.
• It is used to keep track of the following information
– The name of the student
– The student’s six-digit identification number
– The number of credits the student has earned (which may
include a decimal fraction to account for half- and quater-
credit courses)
– A flag indicating whether the student has paid all university
fees
 Private instance variables

Each of these values is stored in an instance

variable of the appropriate type.

private String studentName;

private int studentID;
private double creditsEarned = 0.0;
private boolean paidUp = false;

• Vary from object to object, cannot be directly

accessed by clients.
 Constructor
/**
* Creates a new Student object with the specified name
* and ID.
* @param name The student’s name as a String
* @param id The student’s ID number as an int
*/

public Student(String name, int id) {

studentName = name;
studentID = id;
}
Different names for the formal parameters and the instance
variables.
 Methods
/**
* Gets the name of this student.
* @return The name of this student
*/
public String getName() {
return studentName;
}

• Clients can only reach names throught methods, cannot

directly access studentName (private instance variable).
 Methods
/**
* Sets whether the student is paid up.
* @param flag The value indicating paid-up status
*/
public void setPaidUp(boolean flag) {
paidUp = flag;
}

/**
* Returns whether the student is paid up.
* @return Whether the student is paid up
*/
public boolean isPaidUp() {
return paidUp;
}
 Overriding
Overriding toString defined in Object class
public String toString() {
return studentName + “ (#” + studentID + “)”;
}
• toString, which converts the value of an object into
string, is used by println.
• The + operator automatically converts int to String.
• By redefining (overriding) toString, println can print the
value of an object Student in more readable form, such
as
Hermione Granger (#314159)
 Using the Student class

• Once you have defined the Student class, you can then
use its constructor to create instances of that class. For
example, you could use the following code to create two
Student objects
Student choseOne = new Student(“Harry Potter”, 123456);
Student topStudent = new Student(“Hermione Granger”, 314159);
• You can then use the standard receiver syntax to call
methods on these objects.
topStudent.setCredits(97);
choseStudent.getName();
 Rational numbers

• A more elaborate example of class definition.

• Rational numbers can be useful in cases in which you
need exact calculation with fractions. The floating-point
0.1 is not exactly represented internally (binary). The
rational number 1/10 is exact (the quotient of two
integers).
• Standard arithmetic operations:
a/b + c/d = (ad + bc)/(bd)
a/b – c/d = (ad – bc)/(bd)
a/b * c/d = (ac)/(bd)
(a/b) / (c/d) = (ad) / (bc)
 Implementing the Rational class
Section 6.5, p. 198.
• Constructors are overloaded.
– No argument: initialize to 0;
– One argument: initialize to that integer;
– Two arguments: initialize to a fraction.
• Invariant properties (remain in force)
– The numerator and denominator are reduced to lowest terms;
– The denominator is positive.
• The add, subtract, multiply, and divide methods are written so
that one of the operands is the receiver (signified by the key
word this) and the other is passed as an argument. For
example
r1.add(r2)
• Immutable: Classes whose internal state cannot be changed
by clients, even through method calls. (Private instance
variables num and den.)
 The Rational class constructor
/**
* The Rational class is used to represent rational numbers, which
* are defined to be the quotient of two integers.
*/
public class Rational {
/** Creates a new Rational initialized to zero. */
public Rational() {
this(0);
}

/**
* Creates a new Rational from the integer argument.
* @param n The initial value
*/
public Rational(int n) {
this(n, 1);
}
 The Rational class constructor
/**
* Creates a new Rational with the value x/y.
* @param x The numerator of the rational number
* @param y The denominator of the rational number
*/
public Rational(int x, int y) {
int g = gcd(Math.abs(x), Math.abs(y) {
num = x / g;
den = Math.abs(y) / g;
if (y < 0) num = -num;
}

/** Private instance variables */

private int num; /* The numerator of this Rational */
private int den; /* The denominator of this Rational */
}
 The Rational add method

/**
* Adds the rational number r to this one and returns the sum.
* @param r The rational number to be added
* @return The sum of the current number and r
*/
public Rational add(Rational r) {
return new Rational(this.num * r.den + r.num * this.den,
this.den * r.den);
}

Note: This method has access to the components of r.

 Overriding toString
/**
* Creates a string representation of this rational number.
* @return The string representation of this rational number
*/
public String toString() {
if (den == 1) {
return “” + num;
else
return num + “/” + den;
}
}
• The + (concatenation) operator automatically converts int into
String. When printing num (int), a forced + operator is introduced
into “” + num to convert int into String.
 The Rational class
/**
* Calculates the greatest common divisor using Euclid’s algorithm.
* @param x First integer
* @param y Second integer
* @return The greatest common divisor of x and y
*/
public int gcd(int x, int y) {
int r = x % y;
while (r != 0) {
x = y;
y = r;
r = x % y;
}
 Simulating rational calculation

A simple program that adds three rational numbers:

1/2 + 1/3 + 1/6

public void run() {

Rational a = new Rational(1, 2);
Rational b = new Rational(1, 3);
Rational c = new Rational(1, 6);
Rational sum = a.add(b).add(c);
println(a + “ = “ + b “ + “ + “ + “ c + “ = “ + sum);
}

• Trace the program.

 Extending existing classes
• Extend an existing class to create a new class that
inherits most of its behavior from its superclass but
makes some small extensions or changes.
• Example: Define a new class called FilledRect that is
similar to the Grect class, except that it is filled rather
than outlined by default. It makes sense to pass color to
the constructor. Calling
add(new FilledRect(10, 10, 100, 75, Color.RED));
for example, should create a 100x75 rectangle solidly
filled in red and then add it to the canvas at the position
(10,10)
 The FilledRect class
/**
* This class is a Gobject subclass that is almost identical to GRect except that
* it starts out filled instead of outlined.
*/
public class FilledRect extends GRect {

/** Create a new FilledRect with the specified bounds. */

public FilledRect(double x, double y, double width, double height) {
super(x, y, width, height);
setFilled(true);
}

/** Create a new FilledRect with the specified bounds and color. */
public FilledRect(double x, double y, double width, double height, Color color) {
this(x, y, width, height);
setColor(color);
}
 Rules for inherited constructors

• When creating an object of an extended class, Java must call some

constructor for the superclass object to ensure that its structure is
correctly initialized.
• If the superclass does not define any explicit constructors, Java
automatically provides a default constructor with an empty body.
• Java invokes the superclass in one of the following ways:
– Classes that begin with an explicit call to this invoke one of the other
constructors for this class, delegating responsibility to that constructor for making
sure that the superclass constructor gets called.
– Classes that begin with a call to super invoke the constructor in the superclass
that matches the argument list provided.
– Classes that begin with no call to either super or this invoke the default
superclass constructor with no arguments.
 Rules for inherited constructors

• When one class extends another, the subclass is

allowed to override method definitions in its superclass.
Whenever you invoke that method on an instance of the
extended class, Java chooses the new version of the
method.
• The decision about which version of a method to use is
always made on the basis of what the object in fact is.
• If you need to invoke the original version of a method,
you need to use the keyword super as a receiver, for
example, supper.init(), where init method is the original
method specified by the superclass.
 Programming guideline
• Avoid writing the same code in more than one part of a
program. Duplicated code often can lead to serious
maintenance problems, since it is easy for a maintainer
to change one copy of the code without updating the
others.
• Be careful whenever you override a method in an
existing class because your new definition can violate
assumptions made by the original class. As a general
rule, it makes sense to override methods only when the
documentation for those methods specifically invites you
to do so. (For example, toString in Object class.)