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.
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.
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.
private String grade;
or a numeric value that corresponds to the letter grade to simplify gpa calculations
private double grade;
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;
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.
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.
(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();
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.
The account will have a negative balance. There are no checks to detect or stop this from happening.
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.
Mutator Methods
recordPurchase
receivePayment
Accessor Method
giveChange
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);
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;
}
}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;
}
}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;
}
}/**
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");
}
}/**
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");
}
}Card Front:
BankAccount harrysChecking BankAccount BankAccount(initialBalance) deposit(amount) withdraw(amount) getBalance
Card Back:
balance020001500
Card Front:
CashRegister register CashRegister recordPurchase(amount) receivePayment(amount) giveChange
Card Back:
| purchase | payment |
| 0 | 0 |
Card Front:
Menu mainMenu addOption(option) display
Card Back:
optionCount menuText0“”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”
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:
You can see that thenumTransactionsvariable resets whenever the fee is calculated, and then a fee is subtracted from the balance (one dollar for every transaction over 5).
You need four classes: House, Car, SceneComponent, and SceneViewer.
The methods have the same implicit parameter as the paintComponent method. We could have written the calls as this.getHeight() and this.getWidth(). They are accessor methods so they don't need an explicit parameter; the instance variables of the object are all they need to do their work.
Add width and height fields to the Car class, initialize them in the Car constructor, and use them in the draw method to determine the dimensions of the body, tires, and windshield
