Chapter 3 Review Exercise Solutions

Chapter 3 Review Exercise Solutions


R3.1

The public interface of the Counter in Section 3.1 consists of the click,
getValue, and reset methods. The public interface specifies the
functionality supported by the class but does not disclose any details of
how the functionality is implemented. In contrast, the implementation of a
class is the code that accomplishes the tasks to support the class's
functionality.



R3.2

Encapsulation is the process of hiding implementation details while
publishing an interface for programmers to use. If you hide the
implementation details, you can diagnose errors and make changes and
improvements to the implementation of a class without disrupting the work
of programmers who use the class.

R3.3

The private reserved word prevents a programmer using the class from
manipulating instance variables except through the methods of that class. A
programmer must use the public interface-the public methods that access or
modify the instance variables-to change them. As such, the instance
variables are hidden from methods outside of the class.

R3.4

private String grade;
or a numeric value that corresponds to the letter grade to simplify gpa
calculations
private double grade;

R3.5

Represent the time as one entire string value, example "8:35 a.m."
private String value;
or as individual components
private int hour;
private int minute;
private String meridian;







R3.6

The programmers using the Time class do not have to do anything. The code
that uses the Time class is written based on the public interface and, as
such, it need not change unless the public interface changes. That is the
purpose of encapsulation and using a public interface.

R3.7

No, there should not be a setValue method. The Counter class, as the
original example indicates, models a device that can be used to count
people. The tally increases by one for each person counted. The required
functionality does not dictate the need to begin a tally at a value other
than zero.
If there is a need to begin a count at a value other than zero, then a
constructor should be added to support such functionality. A mutator such
as setValue should only be added if there is a need to support
functionality to reset an existing counter to a value other than zero.

R3.8

(a) If BankAccount(double initialBalance) did not exist, we could use the
default constructor to create a BankAccount and then use the deposit method
to increase the balance.
BankAccount account = new BankAccount();
account.deposit(1500);

is equivalent to

BankAccount account = new BankAccount(1500);

(b) (The previously provided answer does not address the question asked.)

If the BankAccount() constructor is removed from the BankAccount class,
then creating an object of the BankAccount class would require using the
BankAccount(double initialBalance) constructor. This constructor allows
the specification of an initialBalance which can be 0.

BankAccount account = new BankAccount(0);

is equivalent to (with the no-argument constructor available)

BankAccount account = new BankAccount();


R3.9

A reset method effectively empties the account without any accountability.
It would be best to create a new object if you want to delete an account
and start with a new one. Otherwise, use the withdraw method to reduce the
balance down to zero, which is how a real bank account should work.

R3.10

The account will have a negative balance. There are no checks to detect or
stop this from happening.

R3.11

The this reference is used to refer to the implicit parameter of a method.
It can be used to clarify the code, to explicitly access instance variables
and methods in the object referenced by the implicit parameter, and to call
another constructor of the same class.

R3.12

The method transfers an amount from the account passed as the implicit
parameter to the account that is given as an explicit parameter.
Here is a sample call:
BankAccount harrysChecking = new BankAccount();
BankAccount momsSavings = new BankAccount(10000);
momsSavings.mystery(harrysChecking, 1000);

R3.13

public class TimeDepositAccount
{
private double balance;
private double interestRate;
// Constructor
public TimeDepositAccount(
double initialBalance, double interestRate)
{
this.balance = initialBalance;
this.interestRate = interestRate;
}
// Methods
public void withdrawAll()
{
balance = 0.0;
}
public double getBalance()
{
return balance;
}

public void addInterest()
{
balance = balance + balance * interestRate;
}
}

R3.14

Instance variables are initialized when the object is created. In this
case, area would be initialized to zero and wouldn't get calculated with
the correct value until getArea is called. If another method were added to
this class that used area, it would incorrectly use the value zero if
getArea had not been called first to calculate the correct value. As is,
area is used in only a single method, getArea, and does not hold a value
that must exist across method calls. This suggests that area is a
candidate for being turned into a variable local to getArea

public class Square
{
private int sideLength;

public Square(int length)
{
sideLength = length;
}

public int getArea ()
{
int area; // local variable

area = sideLength * sideLength;
return area;
}
}

R3.15

If the method grow is called, the value of the instance variable area will
no longer be correct. You should make area a local variable in the getArea
method and remove the calculation from the constructor.
public class Square
{
private int sideLength;

public Square(int length)
{
sideLength = length;
}

public int getArea ()
{
int area; // local variable

area = sideLength * sideLength;
return area;
}

public void grow ()
{
sideLength = 2 * sideLength;
}
}

R3.16

/**
A class to test the Counter class.
*/
public class CounterTester
{
/**
Tests the methods of the Counter class.
@param args not used
*/
public static void main(String[] args)
{
Counter tally = new Counter();
int result = tally.getValue();
System.out.println(result);
System.out.println("Expected 0");

tally.count();
tally.count();
tally.count();
result = tally.getValue();
System.out.println(result);
System.out.println("Expected 3");

tally.reset();
result = tally.getValue();
System.out.println(result);
System.out.println("Expected 0");

}
}



R3.17

/**
A class to test the Car class.
*/
public class CarTester
{
/**
Tests the methods of the Car class.
@param args not used
*/
public static void main(String[] args)
{
Car myHybrid = new Car(50); // 50 miles per gallon
myHybrid.addGas(20); // Fill tank with 20 gallons
myHybrid.drive(100); // Drive 100 miles, use 2 gallons
myHybrid.addGas(10); // Add 10 gallons to tank
myHybrid.drive(200); // Drive 200 miles, use 4 gallons
double gasLeft = myHybrid.getGasInTank();// Gas remaining in tank
System.out.println(gasLeft);
System.out.println("Expected 24");
}
}

R3.18

Card Front: BankAccount harrysChecking
BankAccount
BankAccount(initialBalance)
deposit(amount)
withdraw(amount)
getBalance

Card Back: balance
0
2000
1500



3.19

Card Front: CashRegister register
CashRegister
recordPurchase(amount)
receivePayment(amount)
giveChange

Card Back: purchase payment
0 0
29.50 0
38.75 0
38.75 50
0 0

3.20

Card Front: Menu mainMenu
Menu
addOption(option)
display

Card Back: optionCount menuText
0 ""
1 "1) Open new account\n"
2 "1) Open new account\n2) Log into existing
account\n"
3 "1) Open new account\n2) Log into existing
account\n3) Help\n"
4 "1) Open new account\n2) Log into existing
account\n3) Help\n4) Quit\n"

R3.21

First, we need to add a new instance variable to keep track of the number
of transactions each month. We will add the following instance variable to
the class:

int numTransactions;

This variable should be incremented by one inside the withdraw and deposit
methods. The following line of code could be added to the end of these
methods:

numTransactions++;

And, of course, we should initialize this variable to zero inside both
constructors.

Finally, we need to add a new instance method that will calculate and
deduct the fee ($1 for each transaction over 5) and reset the
numTransactions variable to zero (to start the new month).

public void calculateTransFee()
{
if (numTransactions > 5)
{
balance = balance - (numTransactions - 5);
}

numTransactions = 0;
}

And for the new object trace, let's assume the following method calls are
made over two months

BankAccount harrysAccount(1000);
harrysAccount.deposit(50);
harrysAccount.deposit(500);
harrysAccount.deposit(250);
harrysAccount.withdraw(100);
harrysAccount.deposit(70);
harrysAccount.deposit(80);
harrysAccount.calculateTransFee();
harrysAccount.deposit(150);
harrysAccount.deposit(500);
harrysAccount.deposit(250);
harrysAccount.withdraw(100);
harrysAccount.deposit(70);
harrysAccount.deposit(90);
harrysAccount.deposit(190);
harrysAccount.calculateTransFee );

Here are the updated object cards showing the results of these method
calls:

[pic]

You can see that the numTransactions variable resets whenever the fee is
calculated, and then a fee is subtracted from the balance (one dollar for
every transaction over 5).




R3.22

You need four classes: House, Car, SceneComponent, and Scen