Java Chapter 04 - Writing Classes: part 2

Chapter 4
Writing Classes
– Part 2
Java Software Solutions
Foundations of Program Design
9th Edition
John Lewis
William Loftus

Outline
Anatomy of a Class
Encapsulation
Anatomy of a Method

Key Concept
• The heart of object-oriented
programming is defining classes that
represent objects with well-defined
state and behavior.

Writing
Classes
The programs we’ve written in previous
examples have used classes defined in the Java
API
Now we will begin to design programs that rely
on classes that we write ourselves
The class that contains the main method is just
the starting point of a program
True object-oriented programming is based on
defining classes that represent objects with
well-defined characteristics and functionality

Classes and
Objects
Recall from our overview of objects in Chapter 1 that
an object has state and behavior
Consider a six-sided die
(singular of dice)
Its state can be defined as
which face is showing
Its primary behavior is that it
can be rolled
We represent a die by
designing a class called Die
that models this state and
behavior
The class serves as the
blueprint for a die object
We can then instantiate as many die objects as we
need for any particular program

Classes
• A class can contain data declarations and method
declarations
int size, weight;
char category;
Data declarations
Method declarations

Classes
The values of the data define the state of
an object created from the class
The functionality of the methods define
the behaviors of the object
For our Die class, we might declare an
integer called faceValue that represents
the current value showing on the face
One of the methods would “roll” the die
by setting faceValue to a random number
between one and six

Classes
We’ll want to design the Die class so that
it is a versatile and reusable resource
Any given program will probably not use
all operations of a given class
See RollingDice.java
See Die.java

//********************************************************************
// RollingDice.java Author: Lewis/Loftus
//
// Demonstrates the creation and use of a user-defined class.
//********************************************************************
public class RollingDice
{
//-----------------------------------------------------------------
// Creates two Die objects and rolls them several times.
//-----------------------------------------------------------------
public static void main(String[] args)
{
Die die1, die2;
int sum;
die1 = new Die();
die2 = new Die();
die1.roll();
die2.roll();
System.out.println("Die One: " + die1 + ", Die Two: " + die2);
continue

continue
die1.roll();
die2.setFaceValue(4);
sum = die1.getFaceValue() + die2.getFaceValue();
System.out.println("Sum: " + sum);
sum = die1.roll() + die2.roll();
System.out.println("New sum: " + sum);
}
}

continue
die1.roll();
die2.setFaceValue(4);
sum = die1.getFaceValue() + die2.getFaceValue();
System.out.println("Sum: " + sum);
sum = die1.roll() + die2.roll();
System.out.println("New sum: " + sum);
}
}
Sample Run
Die One: 5, Die Two: 2
Sum: 5
New sum: 6

//********************************************************************
// Die.java Author: Lewis/Loftus
//
// Represents one die (singular of dice) with faces showing values
// between 1 and 6.
//********************************************************************
public class Die
{
private final int MAX = 6; // maximum face value
private int faceValue; // current value showing on the die
//-----------------------------------------------------------------
// Constructor: Sets the initial face value.
//-----------------------------------------------------------------
public Die()
{
faceValue = 1;
}
continue

continue
//-----------------------------------------------------------------
// Rolls the die and returns the result.
//-----------------------------------------------------------------
public int roll()
{
faceValue = (int)(Math.random() * MAX) + 1;
return faceValue;
}
//-----------------------------------------------------------------
// Face value mutator.
//-----------------------------------------------------------------
public void setFaceValue(int value)
{
faceValue = value;
}
//-----------------------------------------------------------------
// Face value accessor.
//-----------------------------------------------------------------
public int getFaceValue()
{
return faceValue;
}
continue

continue
//-----------------------------------------------------------------
// Returns a string representation of this die.
//-----------------------------------------------------------------
public String toString()
{
String result = Integer.toString(faceValue);
return result;
}
}

The Die Class
The Die class
contains two data
values
a constant MAX that
represents the
maximum face value
an integer faceValue
that represents the
current face value
The roll method uses the random
method of the Math class to
determine a new face value
There are also methods to
explicitly set and retrieve the
current face value at any time

The toString
Method
It's good practice to define a
toString method for a class
The toString method returns a
character string that represents
the object in some way
It is called automatically when
an object is concatenated to a
string or when it is passed to
the println method
It's also convenient for
debugging problems

Constructors
As mentioned previously, a constructor is
used to set up an object when it is initially
created
A constructor has the same name as the
class
The Die constructor is used to set the
initial face value of each new die object to
one
We examine constructors in more detail
later in this chapter

Key Concept
• The scope of a variable, which
determines where it can be referenced,
depends on where it is declared.

Data Scope
The scope of data is the area in a program in which that data
can be referenced (used)
Data declared at the class level can be referenced by all
methods in that class
Data declared within a method can be used only in that
method
Data declared within a method is called local data
In the Die class, the variable result is declared inside the
toString method -- it is local to that method and cannot be
referenced anywhere else

Instance Data
A variable declared at the class level (such as
faceValue) is called instance data
Each instance (object) has its own instance variable
A class declares the type of the data, but it does not
reserve memory space for it
Each time a Die object is created, a new faceValue
variable is created as well
The objects of a class share the method definitions,
but each object has its own data space
That's the only way two objects can have different
states

Instance Data
• We can depict the two Die objects from the
RollingDice program as follows:
die1 5faceValue
die2 2faceValue
Each object maintains its own faceValue
variable, and thus its own state

Key Concept
• A UML class diagram helps us visualize
the contents of and relationships
among the classes of a program.

UML
Diagrams
UML stands for the Unified Modeling Language
UML diagrams show relationships among classes and
objects
A UML class diagram consists of one or more classes,
each with sections for the class name, attributes (data),
and operations (methods)
Lines between classes represent associations
A dotted arrow shows that one class uses the other
(calls its methods)

UML Class Diagrams
• A UML class diagram for the RollingDice program:
RollingDice
main (args : String[]) : void
Die
faceValue : int
roll() : int
setFaceValue (int value) : void
getFaceValue() : int
toString() : String

Java Chapter 04 - Writing Classes: part 2

Recommended

More Related Content

What's hot (20)

Similar to Java Chapter 04 - Writing Classes: part 2 (20)

More from DanWooster1 (20)

Recently uploaded (20)

Java Chapter 04 - Writing Classes: part 2