Chapter 10 Review Exercise Solutions
R10.1
SavingsAccount b = new SavingsAccount(10); // balance is 0
b.deposit(5000); // balance is 5000
b.withdraw(b.getBalance() / 2); // balance is 2500
b.addInterest(); // balance is 2750
R10.2
The SavingsAccount has one constructor, SavingsAccount(double), which constructs a bank account with a given interest rate.
It inherits the following methods from the BankAccount class:
•	void deposit(double)
•	void withdraw(double)
•	double getBalance()
•	void transfer(double, BankAccount)
The method
void addInterest()
is added to the SavingsAccount class.
R10.3
You can convert a subclass reference to a superclass reference. Therefore, a reference to a SavingsAccount object can be converted to a BankAccount reference.

SavingsAccount collegeFund = new SavingsAccount(10);
BankAccount anAccount = collegeFund;

Furthermore, all references can be converted to the type Object.

Object anObject = collegeFund;

Very occasionally, you need to carry out the opposite conversion, from a superclass reference to a subclass reference. For example, you may have a variable of type Object, and you know that it actually holds a BankAccount reference. In that case, you can use a cast to convert the type:

BankAccount anAccount = (BankAccount) anObject;

However, this cast is somewhat dangerous. If you are wrong, and anObject actually refers to an object of an unrelated type, then an exception is thrown.
R10.4
a. Manager is a subclass of the superclass Employee
b. Triangle is a subclass of the superclass Polygon
c. GraduateStudent is a subclass of the superclass Student
d. Student is a subclass of Person
e. no relation between Employee and GraduateStudent
f. CheckingAccount is a subclass of the superclass BankAccount
g. Car is a subclass of the superclass Vehicle
h. Minivan is a subclass of the superclass Vehicle
i. Minivan is a subclass of the superclass Car
j. Truck is a subclass of the superclass Vehicle
R10.5
Sandwich x = new Sandwich(); 
Sub y = new Sub();
x = y; // legal
y = x; // not legal
y = new Sandwich(); // not legal
x = new Sub(); // legal
R10.6

R10.7

R10.8
Student is a Person
Employee is a Person
Professor is an Employee
TeachingAssistant is an Employee
Secretary is an Employee
DepartmentChair is a Professor
Janitor is an Employee
SeminarSpeaker is a Person
Seminar is a Course
Lecture is a Course
CompuerLab is a Course
R10.9
r instanceof Rectangle: true
r instanceof Point: false
r instanceof Rectangle2D.Double: false
r instanceof RectangularShape: true
r instanceof Object: true
r instanceof Shape: true
R10.10
super has two meanings:
1.	to invoke the superclass constructor, e.g. super(initialBalance);
2.	to invoke a superclass method, e.g. super.deposit(amount);
this has two meanings:
1.	to invoke another constructor of the same class, e.g. this(0);
2.	to denote the implicit parameter of a method
The first meanings of super and this are related, because they both are ways of invoking another constructor.
R10.11
The first call
this.g();
is an example of polymorphism. For example, if another class E extends D, and that class redefines the method g(). and f is called on an E object, then this.g() calls E.g.
The second call
super.g();
is not. No matter what the actual type of this, the exact same method is always called (namely the closest definition of g in the inheritance chain.)
R10.12
The endOfMonth calls are resolved at compile time because there is no implicit object–there are two static methods with the same name but different parameters, and the compiler merely picks the appropriate one. 
The call to getBalance is resolved by dynamic method invocation because the selection of which account's balance is displayed does not take place until the program runs.
R10.13
A shallow copy only copies numbers and object references to an object. A deep copy makes copies of all objects on which an object depends.
R10.14
We recommend that all variables (both instance and static variables) have private access. However, constants (static final variables) can have public access.
R10.15
Methods should generally be public or private. We recommend avoiding the use of package-visible methods. Public methods are the norm, and private methods should be for used implementation-dependent tasks that should be carried out only by methods of the same class. Static methods should have public access because they do not operate on an implicit parameter, so it is very likely that they will be called from an object that does not belong to the same class.
R10.16
The System.in and System.out static variables are final, so you cannot assign new values to them.
You can change them with the setIn and setOut methods.
(You may wonder how the setIn and setOut methods are implemented–how can these methods change a final variable? They call native methods setIn0 and setOut0 that are able to circumvent this language restriction.)
R10.17
Public instance variables are dangerous because any instruction in a (potentially large) program can change their value. Public static variables are, if anything, even more dangerous because not even an object reference is required to change the value.