Lab: Gaining Experience Designing Classes
Instructions:
Answer the following questions one at a time. After answering each question,
check your answer (by clicking on the check-mark icon if it is available)
before proceeding to the next question.
Getting Ready:
Before going any further, you should:
-
Depending on your development environment, create either a
directory or a project for this lab.
1. A Class of Immutable Objects:
This part of the lab will give you some experience designing a
simple class of immutable objects. The textual description of this
class follows:
A fraction is a quotient of one integer divided by another (often
indicated by a/b).
The dividend a is called the numerator and the divisor
b is called the denominator. One can add a fraction to,
subtract a fraction from, multiply a fraction by, and divide a
fraction by another fraction. The result of each of these
operations is another fraction.
-
What are the important noun phrases in this textual description?
-
What data type would you use for each?
numerator int
denominator int
-
What are the important verb phrases in this textual description.
add a fraction to
subtract a fraction from
multiply a fraction by
divide a fraction by
-
What parameters are required by each?
A fraction.
-
What is the return type of each?
A fraction.
-
Given the analysis above, what would your initial encapsulation be?
(Do not include any constructors at this point.)
public class Fraction
{
private int denominator, numerator;
public Fraction add(Fraction other);
public Fraction divide(Fraction other);
public Fraction multiply(Fraction other);
public Fraction subtract(Fraction other);
}
-
To add and subtract two fractions you must first find a common
denominator and convert each to an equivalent fraction with that
denominator. Given this observation, what private method
would you add?
private int commonDenominator(Fraction other);
-
All classes should have a
toString()
method
that returns a String
representation of
an instance. For this class, how should the String
be formatted? (Note: Remember to think about the sign of the
fraction.)
A '-' or a '' depending on the sign, the numerator (in the narrowest
possible field), a '/', and the denominator (in the narrowest possible
field).
-
Given that
Fraction
objects are supposed to be immutable,
should this class have "set" methods?
No, since a user could then change a Fraction
object.
-
Should this class have accessor (i.e., "get") methods for the
numerator and/or denominator?
No. A fraction is a coherent whole; the internal details
should be hidden.
-
Given the discussion of the
toString()
method above,
it would clearly be useful to always use positive integers for
the numerator and the denominator and keep a sign attribute.
What type should the sign attribute be and what values should
it take on? (Hint: Think about how it will be used in the
various methods.)
There are three obvious possibilities, a
boolean
, a
char
(either '-' or ' '), or an
int
(either -1 or 1). To decide which is best, you need to think
about the different methods that it will be used in.
For the toString()
method it's probably best to use
a char
. However, a char
will be very awkward
for all of the arithmetic operations.
For the arithmetic operations it's probably best to use
a char
. This will create a little more work
for the toString()
method, but not much.
The boolean
, the most obvious of the three since
it can take on two values as needed, is probably the worst choice.
So, I'd use an int
that can take the value -1 or 1.
-
What operation is very similar to addition?
Subtraction
-
How would you use the
add()
method to
perform this other operation?
Negate the other fraction and then call add()
.
-
What operation is very similar to multiplication?
Division
-
How would you use the
multiply()
method to
perform this other operation?
Invert the other fraction and then call multiply()
.
-
What explicit value constructor should this class certainly
contain?
public Fraction(int numerator, int denominator)
-
Do you think this class should contain a default constructor?
Why or why not?
No. Since Fraction
objects are immutable,
it doesn't make sense to have a default constructor.
2. A Class of Mutable Objects:
This part of the lab will give you some experience designing
a simple class of mutable objects. The textual description of
this class follows:
An "Esketcher" is a simple electronic drawing toy (like the
famous Etch A Sketch from The Ohio Art
Company
).
You can shake an "Esketcher",
you can turn the horizontal drawing dial clockwise,
you can turn the horizontal drawing dial counter-clockwise,
you can turn the vertical drawing dial clockwise, and
you can turn the vertical drawing dial counter-clockwise.
-
What are the important noun phrases in this textual description.
horizontal drawing dial
vertical drawing dial
-
What are the important verb phrases in this textual description?
shake
turn the horizontal drawing dial clockwise
turn the horizontal drawing dial counter-clockwise
turn the vertical drawing dial clockwise
turn the vertical drawing dial counter-clockwise
-
What parameters are required by each?
The distance/amount/size of the turn which is probably an
int
.
One could, alternatively, think about
either percentages of the horizontal/vertical distance or
percentages of a "turn" (measured in either degrees or radians).
-
What is the return type of each?
void
-
Since the noun phrases are part of the verb phrases it may not
be necessary to have any attributes. Assuming that this is the
case, what would your initial encapsulation be? (Do not include
any constructors at this point.)
public class Esketcher
{
public void shake();
public void turnHorizontalDialClockwise(int amount);
public void turnHorizontalDialCounterClockwise(int amount);
public void turnVerticalDialClockwise(int amount);
public void turnVerticalDialCounterClockwise(int amount);
}
-
Though it isn't mentioned in the textual description, an
"Esketcher" has a "virtual pen" that does the drawing.
What important information about the "virtual pen"
must be maintained?
The position of the virtual pen (i.e., its horizontal and vertical
position, both of which are probably int
values).
-
Though it isn't mentioned in the textual description, when the
"virtual pen" gets to the right or left edge
turning the horizontal dial in the offending direction has no
effect. Similarly, when the
"virtual pen" gets to the top or bottom edge
turning the horizontal dial in the offending direction has no
effect. What important information must be maintained to support this
behavior?
The size of the drawing area (probably two int
attributes).
-
How could you combine the two "turn horizontal dial" methods
into one?
public void turnHorizontalDial(int direction, int amount);
-
How could you combine the two "turn vertical dial" methods
into one?
public void turnVerticalDial(int direction, int amount);
-
It is probably not a good idea to combine the public
"turn vertical dial" and "turn horizontal dial" methods.
Why not?
The "real world" object being modeled actually has two dials.
Hence, combining them would make this class more difficult
to understand.