11.3 (Composition vs. Inheritance) Many apps written with inheritance could be written with composition instead, and vice versa. Rewrite class BasePlusCommissionEmployee
(Fig. 11.11) of the CommissionEmployee
–BasePlusCommissionEmployee
hierarchy to use composition rather than inheritance.
11.4 (Inheritance and Software Reuse) Discuss the ways in which inheritance promotes software reuse, saves time during app development and helps prevent errors.
11.5 (Student
Inheritance Hierarchy) Draw a UML class diagram for an inheritance hierarchy for students at a university similar to the hierarchy shown in Fig. 11.2. Use Student
as the base class of the hierarchy, then extend Student
with classes UndergraduateStudent
and GraduateStudent
. Continue to extend the hierarchy as deeply (i.e., as many levels) as possible. For example, Freshman
, Sophomore
, Junior
and Senior
might extend UndergraduateStudent
, and DoctoralStudent
and MastersStudent
might be derived classes of GraduateStudent
. After drawing the hierarchy, discuss the relationships that exist between the classes. [Note: You do not need to write any code for this exercise.]
11.6 (Shape
Inheritance Hierarchy) The world of shapes is much richer than the shapes included in the inheritance hierarchy of Fig. 11.3. Write down all the shapes you can think of—both two-dimensional and three-dimensional—and form them into a more complete Shape
hierarchy with as many levels as possible. Your hierarchy should have class Shape
at the top. Class TwoDimensionalShape
and class ThreeDimensionalShape
should extend Shape
. Add additional derived classes, such as Quadrilateral
and Sphere
, at their correct locations in the hierarchy as necessary.
11.7 (Protected
vs. Private
Access) Some programmers prefer not to use protected
access, because they believe it breaks the encapsulation of the base class. Discuss the relative merits of using protected
access vs. using private
access in base classes.
11.8 (Quadrilateral
Inheritance Hierarchy) Write an inheritance hierarchy for classes Quadrilateral
, Trapezoid
, Parallelogram
, Rectangle
and Square
. Use Quadrilateral
as the base class of the hierarchy. Make the hierarchy as deep (i.e., as many levels) as possible. Specify the instance variables, properties and methods for each class. The private
instance variables of Quadrilateral
should be the x–y coordinate pairs for the four endpoints of the Quadrilateral
. Write an app that instantiates objects of your classes and outputs each object’s area (except Quadrilateral
).
11.9 (Account
Inheritance Hierarchy) Create an inheritance hierarchy that a bank might use to represent customers’ bank accounts. All customers at this bank can deposit (i.e., credit) money into their accounts and withdraw (i.e., debit) money from their accounts. More specific types of accounts also exist. Savings accounts, for instance, earn interest on the money they hold. Checking accounts, on the other hand, charge a fee per transaction.
Create base class Account
and derived classes SavingsAccount
and CheckingAccount
that inherit from class Account
. Base class Account
should include one private
instance variable of type decimal
to represent the account balance. The class should provide a constructor that receives an initial balance and uses it to initialize the instance variable with a public
property. The property should validate the initial balance to ensure that it’s greater than or equal to 0.0
; if not, throw an exception. The class should provide two public
methods. Method Credit
should add an amount to the current balance. Method Debit
should withdraw money from the Account
and ensure that the debit amount does not exceed the Account
’s balance. If it does, the balance should be left unchanged, and the method should display the message "Debit amount exceeded account balance."
The class should also provide a get
accessor in property Balance
that returns the current balance.
Derived class SavingsAccount
should inherit the functionality of an Account
, but also include a decimal
instance variable indicating the interest rate (percentage) assigned to the Account
. SavingsAccount
’s constructor should receive the initial balance, as well as an initial value for the interest rate. SavingsAccount
should provide public
method CalculateInterest
that returns a decimal
indicating the amount of interest earned by an account. Method CalculateInterest
should determine this amount by multiplying the interest rate by the account balance. [Note: SavingsAccount
should inherit methods Credit
and Debit
without redefining them.]
Derived class CheckingAccount
should inherit from base class Account
and include a decimal
instance variable that represents the fee charged per transaction. CheckingAccount
’s constructor should receive the initial balance, as well as a parameter indicating a fee amount. Class Checking-Account
should redefine methods Credit
and Debit
so that they subtract the fee from the account balance whenever either transaction is performed successfully. CheckingAccount
’s versions of these methods should invoke the base-class Account
version to perform the updates to an account balance. CheckingAccount
’s Debit
method should charge a fee only if money is actually withdrawn (i.e., the debit amount does not exceed the account balance). [Hint: Define Account
’s Debit
method so that it returns a bool
indicating whether money was withdrawn. Then use the return value to determine whether a fee should be charged.]
After defining the classes in this hierarchy, write an app that creates objects of each class and tests their methods. Add interest to the SavingsAccount
object by first invoking its CalculateInterest
method, then passing the returned interest amount to the object’s Credit
method.