10
One Ring to rule them all, One Ring to find them, One Ring to bring them all and in the darkness bind them.
—John Ronald Reuel Tolkien

Object-Oriented Programming: Polymorphism
OBJECTIVES In this chapter you will learn:
■ ■ ■ ■ ■

General propositions do not decide concrete cases.
—Oliver Wendell Holmes

A philosopher of imposing stature doesn’t think in a vacuum. Even his most abstract ideas are, to some extent, conditioned by what is or is not known in the time when he lives.
—Alfred North Whitehead

The concept of polymorphism. To use overridden methods to effect polymorphism. To distinguish between abstract and concrete classes. To declare abstract methods to create abstract classes. How polymorphism makes systems extensible and maintainable. To determine an object’s type at execution time. To declare and implement interfaces.

Why art thou cast down, O my soul?
—Psalms 42:5

■ ■

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

307

Assignment Checklist
Name: Section: Date:

Exercises

Assigned: Circle assignments

Date Due

Prelab Activities
Matching Fill in the Blank Short Answer Programming Output Correct the Code YES YES YES YES YES YES 1 NO NO 1 YES NO NO NO NO NO NO

Lab Exercises
Exercise 1 — Payroll System Modification Follow-Up Question and Activity Follow-Up Question and Activity Debugging

Exercise 2 — Accounts Payable System Modification YES

Labs Provided by Instructor
1. 2. 3.

Postlab Activities
Coding Exercises Programming Challenges 1, 2, 3, 4, 5, 6, 7, 8 1, 2

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

309

Prelab Activities
Matching
Name: Section: After reading Chapter 10 of Java How to Program: Seventh Edition, answer the given questions. The questions are intended to test and reinforce your understanding of key concepts. You may answer the questions before or during the lab. For each term in the left column, write the letter for the description from the right column that best matches the term.
Term Description

Date:

1. 2. 3.

abstract getClass

method method keyword

a) Can be used in place of an abstract class when there is no default implementation to inherit. b) Indicates that a method cannot be overridden or that a class cannot be a superclass. c)
Class method which returns the name of the class associated with the Class object.

implements

4. type-wrapper classes 5. downcasting 6. concrete class 7. polymorphism 8. 9. 10. 11. instanceof final getName

d) An operator that returns true if its left operand (a variable of a reference type) has the is-a relationship with its right operand (a class or interface name). e) Uses superclass references to manipulate sets of subclass objects in a generic manner. f) Casting a superclass reference to a subclass reference. g) Cannot be instantiated; used primarily for inheritance. h) Indicates that a class will declare each method in an interface with the signature specified in the interface declaration. i) j) Must be overridden in a subclass; otherwise, the subclass must be declared abstract. Returns an object that can be used to determine information about the object’s class. Classes in the java.lang package that are used to create objects containing values of primitive types.

method class

abstract

12. interface

k) A class that can be used to create objects. l)

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

311

Prelab Activities Fill in the Blank
Fill in the Blank

Name:

Name: Section:

Date:

Fill in the blanks for each of the following statements: 13. With , it becomes possible to design and implement systems that are more extensible. of abstract su-

14. Although we cannot instantiate objects of abstract superclasses, we can declare perclass types. 15. It is a syntax error if a class with one or more abstract methods is not explicitly declared 16. It is possible to assign a superclass reference to a subclass variable by type. 17. A(n)

.

the reference to the subclass

may contain a set of public abstract methods and/or public static final fields.

18. When a method is invoked through a superclass reference to a subclass object, Java executes the version of the method found in the . 19. The operator determines whether the type of the object to which its left operand refers has an isa relationship with the type specified as its right operand. 20. To use an interface, a class must specify that it the interface and must declare every method in the interface with the signatures specified in the interface declaration. 21. When a class implements an interface, it establishes an relationship with the interface type.

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

313

Prelab Activities Short Answer
Short Answer

Name:

Name: Section:

Date:

In the space provided, answer each of the given questions. Your answers should be concise; aim for two or three sentences. 22. Describe the concept of polymorphism.

23. Define what it means to declare a method final and what it means to declare a class final.

24. What happens when a class specifies that it implements an interface, but does not provide declarations of all the methods in the interface?

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

314

Object-Oriented Programming: Polymorphism

Chapter10

Prelab Activities Short Answer
25. Describe how to determine the class name of an object’s class.

Name:

26. Distinguish between an abstract class and a concrete class.

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

315

Prelab Activities Programming Output
Programming Output

Name:

Name: Section:

Date:

For each of the given program segments, read the code and write the output in the space provided below each program. [Note: Do not execute these programs on a computer.]

Use the class definitions in Fig. L 10.1–Fig. L 10.3 when answering Programming Output Exercises 27–30.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
// Employee.java // Employee abstract superclass. public abstract class Employee { private String firstName; private String lastName; private String socialSecurityNumber; // three-argument constructor public Employee( String first, String last, String ssn ) { firstName = first; lastName = last; socialSecurityNumber = ssn; } // end three-argument Employee constructor // set first name public void setFirstName( String first ) { firstName = first; } // end method setFirstName // return first name public String getFirstName() { return firstName; } // end method getFirstName // set last name public void setLastName( String last ) { lastName = last; } // end method setLastName // return last name public String getLastName() { return lastName; } // end method getLastName

Fig. L 10.1

| Employee

abstract superclass. (Part 1 of 2.)

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

316

Object-Oriented Programming: Polymorphism

Chapter10

Prelab Activities Programming Output

Name:

42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

// set social security number public void setSocialSecurityNumber( String ssn ) { socialSecurityNumber = ssn; // should validate } // end method setSocialSecurityNumber // return social security number public String getSocialSecurityNumber() { return socialSecurityNumber; } // end method getSocialSecurityNumber // return String representation of Employee object public String toString() { return String.format( "%s %s\nsocial security number: %s", getFirstName(), getLastName(), getSocialSecurityNumber() ); } // end method toString // abstract method overridden by subclasses public abstract double earnings(); // no implementation here } // end abstract class Employee | Employee

Fig. L 10.1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

abstract superclass. (Part 2 of 2.)

// SalariedEmployee.java // SalariedEmployee class extends Employee. public class SalariedEmployee extends Employee { private double weeklySalary; // four-argument constructor public SalariedEmployee( String first, String last, String ssn, double salary ) { super( first, last, ssn ); // pass to Employee constructor setWeeklySalary( salary ); // validate and store salary } // end four-argument SalariedEmployee constructor // set salary public void setWeeklySalary( double salary ) { weeklySalary = salary < 0.0 ? 0.0 : salary; } // end method setWeeklySalary // return salary public double getWeeklySalary() { return weeklySalary; } // end method getWeeklySalary // calculate earnings; override abstract method earnings in Employee public double earnings() { | SalariedEmployee

Fig. L 10.2

class derived from Employee. (Part 1 of 2.)

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

317

Prelab Activities Programming Output

Name:

31 32 33 34 35 36 37 38 39 40

return getWeeklySalary(); } // end method earnings // return String representation of SalariedEmployee object public String toString() { return String.format( "salaried employee: %s\n%s: $%,.2f", super.toString(), "weekly salary", getWeeklySalary() ); } // end method toString } // end class SalariedEmployee | SalariedEmployee

Fig. L 10.2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

class derived from Employee. (Part 2 of 2.)

// CommissionEmployee.java // CommissionEmployee class extends Employee. public class CommissionEmployee extends Employee { private double grossSales; // gross weekly sales private double commissionRate; // commission percentage // five-argument constructor public CommissionEmployee( String first, String last, String ssn, double sales, double rate ) { super( first, last, ssn ); setGrossSales( sales ); setCommissionRate( rate ); } // end five-argument CommissionEmployee constructor // set commission rate public void setCommissionRate( double rate ) { commissionRate = ( rate > 0.0 && rate < 1.0 ) ? rate : 0.0; } // end method setCommissionRate // return commission rate public double getCommissionRate() { return commissionRate; } // end method getCommissionRate // set gross sales amount public void setGrossSales( double sales ) { grossSales = ( sales < 0.0 ) ? 0.0 : sales; } // end method setGrossSales // return gross sales amount public double getGrossSales() { return grossSales; } // end method getGrossSales

Fig. L 10.3

| CommissionEmployee

class derived from Employee. (Part 1 of 2.)

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

318

Object-Oriented Programming: Polymorphism

Chapter10

Prelab Activities Programming Output

Name:

42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

// calculate earnings; override abstract method earnings in Employee public double earnings() { return getCommissionRate() * getGrossSales(); } // end method earnings // return String representation of CommissionEmployee object public String toString() { return String.format( "%s: %s\n%s: $%,.2f; %s: %.2f", "commission employee", super.toString(), "gross sales", getGrossSales(), "commission rate", getCommissionRate() ); } // end method toString } // end class CommissionEmployee | CommissionEmployee

Fig. L 10.3

class derived from Employee. (Part 2 of 2.)

27. What is output by the following code segment? Assume that the code appears in the main method of an application.
1 2 3 4 5 6 7 8
SalariedEmployee employee1 = new SalariedEmployee( "June", "Bug", "123-45-6789", 1000.00 ); CommissionEmployee employee2 = new CommissionEmployee( "Archie", "Tic", "987-65-4321", 15000.00, 0.10 ); System.out.printf( "Employee 1:\n%s\n\n", employee1 ); System.out.printf( "Employee 2:\n%s\n\n", employee2 );

Your answer:

28. What is output by the following code segment? Assume that the code appears in the main method of an application.
1 2 3 4 5 6 7 8
Employee firstEmployee = new SalariedEmployee( "June", "Bug", "123-45-6789", 1000.00 ); Employee secondEmployee = new CommissionEmployee( "Archie", "Tic", "987-65-4321", 15000.00, 0.10 ); System.out.printf( "Employee 1:\n%s\n\n", firstEmployee ); System.out.printf( "Employee 2:\n%s\n\n", secondEmployee );

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

319

Prelab Activities Programming Output
Your answer:

Name:

29. What is output by the following code segment? Assume that the code follows the statements in Programming Output Exercise 28.
1 2
SalariedEmployee salaried = ( SalariedEmployee ) firstEmployee; System.out.printf( "salaried:\n%s\n", salaried );

Your answer:

30. What is output by the following code segment? Assume that the code follows the statements in Programming Output Exercise 29.
1 2
CommissionEmployee commission = ( CommissionEmployee ) firstEmployee; System.out.println( "commission:\n%s\n", commission );

Your answer:

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

321

Prelab Activities Correct the Code
Correct the Code

Name:

Name: Section:

Date:

Determine if there is an error in each of the following program segments. If there is an error, specify whether it is a logic error or a syntax error, circle the error in the program and write the corrected code in the space provided after each problem. If the code does not contain an error, write “no error.” [Note: There may be more than one error in a program segment.] For questions 31–33 assume the following definition of abstract class Employee.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
// Employee abstract superclass. public abstract class Employee { private String firstName; private String lastName; // three-argument constructor public Employee( String first, String last ) { firstName = first; lastName = last; } // end three-argument Employee constructor // return first name public String getFirstName() { return firstName; } // end method getFirstName // return last name public String getLastName() { return lastName; } // end method getLastName // return String representation of Employee object public String toString() { return String.format( "%s %s", getFirstName(), getLastName() ); } // end method toString // abstract method overridden by subclasses public abstract double earnings(); // no implementation here } // end abstract class Employee

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

322

Object-Oriented Programming: Polymorphism

Chapter10

Prelab Activities Correct the Code

Name:

31. The following concrete class should inherit from abstract class Employee. A TipWorker is paid by the hour plus their tips for the week.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
// TipWorker.java public final class TipWorker extends Employee { private double wage; // wage per hour private double hours; // hours worked for week private double tips; // tips for the week public TipWorker( String first, String last, double wagePerHour, double hoursWorked, double tipsEarned ) { super( first, last ); // call superclass constructor setWage ( wagePerHour ); setHours( hoursWorked ); setTips( tipsEarned ); } // set the wage public void setWage( double wagePerHour ) { wage = ( wagePerHour < 0 ? 0 : wagePerHour ); } // set the hours worked public void setHours( double hoursWorked ) { hours = ( hoursWorked >= 0 && hoursWorked < 168 ? hoursWorked : 0 ); } // set the tips public void setTips( double tipsEarned ) { tips = ( tipsEarned < 0 ? 0 : tipsEarned ); } } // end class TipWorker

Your answer:

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

323

Prelab Activities Correct the Code

Name:

32. The following code should define method toString of class TipWorker in Correct the Code Exercise 31.
1 2 3 4 5 6 7
// return a string representation of a TipWorker public String toString() { return String.format( "Tip worker: %s\n%s: $%,.2f; %s: %.2f; %s: $%,.2f\n", toString(), "hourly wage", wage, "hours worked", hours, "tips earned", tips ); }

Your answer:

33. The following code should input information about five TipWorkers from the user and then print that information and all the TipWorkers’ calculated earnings.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
// Test2.java import java.util.Scanner; public class Test2 { public static void main( String args[] ) { Employee employee[]; Scanner input = new Scanner( System.in ); for ( int i = 0; i < employee.length; i++ ) { System.out.print( "Input first name: " ); String firstName = input.nextLine(); System.out.print( "Input last name: " ); String lastName = input.nextLine(); System.out.print( "Input hours worked: " ); double hours = input.nextDouble(); System.out.print( "Input tips earned: " ); double tips = input.nextDouble(); employee[ i ] = new Employee( firstName, lastName, 2.63, hours, tips ); System.out.printf( "%s %s earned $%.2f\n", employee[ i ].getFirstName(), employee[ i ].getLastName(), employee[ i ].earnings() ); input.nextLine(); // clear any remaining characters in the input stream } // end for } // end main } // end class Test2

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

324

Object-Oriented Programming: Polymorphism

Chapter10

Prelab Activities Correct the Code
Your answer:

Name:

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

325

Lab Exercises
Lab Exercise 1 — Payroll System Modification
Name: Section: This problem is intended to be solved in a closed-lab session with a teaching assistant or instructor present. The problem is divided into six parts: 1. Lab Objectives 2. Description of the Problem 3. Sample Output 4. Program Template (Fig. L 10.4–Fig. L 10.5) 5. Problem-Solving Tips 6. Follow-Up Question and Activity The program template represents a complete working Java program, with one or more key lines of code replaced with comments. Read the problem description and examine the sample output; then study the template code. Using the problem-solving tips as a guide, replace the /* */ comments with Java code. Compile and execute the program. Compare your output with the sample output provided. Then answer the follow-up questions. The source code for the template is available at www.deitel.com/books/jhtp7/ and www.prenhall.com/deitel. Date:

Lab Objectives
• • •

This lab was designed to reinforce programming concepts from Chapter 10 of Java How to Program: Seventh Edition. In this lab, you will practice: Creating a new class and adding it to an existing class hierarchy. Using the updated class hierarchy in a polymorphic application. Understanding polymorphism.

The follow-up question and activity also will give you practice:

(Payroll System Modification) Modify the payroll system of Figs. 10.4–10.9 to include an additional Employee subclass PieceWorker that represents an employee whose pay is based on the number of pieces of merchandise produced. Class PieceWorker should contain private instance variables wage (to store the employee’s wage per piece) and pieces (to store the number of pieces produced). Provide a concrete implementation of method earnings in class PieceWorker that calculates the employee’s earnings by multiplying the number of pieces produced by the wage per piece. Create an array of Employee variables to store references to objects of each concrete class in the new Employee hierarchy. For each Employee, display its string representation and earnings.

Description of the Problem

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

326

Object-Oriented Programming: Polymorphism

Chapter10

Lab Exercises

Name:

Lab Exercise 1 — Payroll System Modification
Sample Output
Employees processed polymorphically: salaried employee: John Smith social security number: 111-11-1111 weekly salary: $800.00 earned $800.00 hourly social hourly earned employee: Karen Price security number: 222-22-2222 wage: $16.75; hours worked: 40.00 $670.00

commission employee: Sue Jones social security number: 333-33-3333 gross sales: $10,000.00; commission rate: 0.06 earned $600.00 base-salaried commission employee: Bob Lewis social security number: 444-44-4444 gross sales: $5,000.00; commission rate: 0.04; base salary: $300.00 earned $500.00 piece worker: Rick Bridges social security number: 555-55-5555 wage per piece: $2.25; pieces produced: 400 earned $900.00

Program Template
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// Lab Exercise 1: PieceWorker.java // PieceWorker class extends Employee. public class PieceWorker extends Employee { /* declare instance variable wage */ /* declare instance variable pieces */ // five-argument constructor public PieceWorker( String first, String last, String ssn, double wagePerPiece, int piecesProduced ) { /* write code to initialize a PieceWorker */ } // end five-argument PieceWorker constructor // set wage /* write a set method that validates and sets the PieceWorker's wage */ // return wage /* write a get method that returns the PieceWorker's wage */ // set pieces produced /* write a set method that validates and sets the number of pieces produced */

Fig. L 10.4 |

PieceWorker.java.

(Part 1 of 2.)

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

327

Lab Exercises

Name:

Lab Exercise 1 — Payroll System Modification

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// return pieces produced /* write a get method that returns the number of pieces produced */ // calculate earnings; override abstract method earnings in Employee public double earnings() { /* write code to return the earnings for a PieceWorker */ } // end method earnings // return String representation of PieceWorker object public String toString() { /* write code to return a string representation of a PieceWorker */ } // end method toString } // end class PieceWorker PieceWorker.java.

Fig. L 10.4 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

(Part 2 of 2.)

// Lab Exercise 1: PayrollSystemTest.java // Employee hierarchy test program. public class PayrollSystemTest { public static void main( String args[] ) { // create five-element Employee array Employee employees[] = new Employee[ 5 ]; // initialize array with Employees employees[ 0 ] = new SalariedEmployee( "John", "Smith", "111-11-1111", 800.00 ); employees[ 1 ] = new HourlyEmployee( "Karen", "Price", "222-22-2222", 16.75, 40 ); employees[ 2 ] = new CommissionEmployee( "Sue", "Jones", "333-33-3333", 10000, .06 ); employees[ 3 ] = new BasePlusCommissionEmployee( "Bob", "Lewis", "444-44-4444", 5000, .04, 300 ); /* create a PieceWoker object and assign it to employees[ 4 ] */ System.out.println( "Employees processed polymorphically:\n" ); // generically process each element in array employees for ( Employee currentEmployee : employees ) { System.out.println( currentEmployee ); // invokes toString System.out.printf( "earned $%,.2f\n\n", currentEmployee.earnings() ); } // end for } // end main } // end class PayrollSystemTest PayrollSystemTest.java

Fig. L 10.5 |

Problem-Solving Tips
1. The PieceWorker constructor should call the superclass Employee constructor to initialize the employee’s name.

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

328

Object-Oriented Programming: Polymorphism

Chapter10

Lab Exercises

Name:

Lab Exercise 1 — Payroll System Modification
2. The number of pieces produced should be greater than or equal to 0. Place this logic in the set method for the pieces variable. 3. The wage should be greater than or equal to 0. Place this logic in the set method for the wage variable. 4. The main method must explicitly create a new PieceWorker object and assign it to an element of the employees array. 5. If you have any questions as you proceed, ask your lab instructor for assistance.

Follow-Up Question and Activity
1. Explain the line of code in your PayrollSystemTest’s main method that calls method earnings. Why can that line invoke method earnings on every element of the employees array?

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

329

Lab Exercises

Name:

Lab Exercise 2 — Accounts Payable System Modification
Lab Exercise 2 — Accounts Payable System Modification

Name: Section:

Date:

This problem is intended to be solved in a closed-lab session with a teaching assistant or instructor present. The problem is divided into six parts: 1. Lab Objectives 2. Description of the Problem 3. Sample Output 4. Program Template (Fig. L 10.6–Fig. L 10.9) 5. Problem-Solving Tips 6. Follow-Up Question and Activity The program template represents a complete working Java program, with one or more key lines of code replaced with comments. Read the problem description and examine the sample output; then study the template code. Using the problem-solving tips as a guide, replace the /* */ comments with Java code. Compile and execute the program. Compare your output with the sample output provided. Then answer the follow-up question. The source code for the template is available at www.deitel.com/books/jhtp7/ and www.prenhall.com/deitel.

Lab Objectives
• •

This lab was designed to reinforce programming concepts from Chapter 10 of Java How to Program: Seventh Edition. In this lab you will practice: Provide additional polymorphic processing capabilities to an inheritance hierarchy by implementing an interface. Using the instanceof operator to determine whether a variable refers to an object that has an is-a relationship with a particular class. Comparing interfaces and abstract classes.

The follow-up question and activity will also give you practice: •

(Accounts Payable System Modification) In this exercise, we modify the accounts payable application of Figs. 10.11–10.15 to include the complete functionality of the payroll application. The application should still process two Invoice objects, but now should process one object of each of the four Employee subclasses (Figs. 10.5–10.8). If the object currently being processed is a BasePlusCommissionEmployee, the application should increase the BasePlusCommissionEmployee’s base salary by 10%. Finally, the application should output the payment amount for each object. Complete the following steps to create the new application: a) Modify classes HourlyEmployee and CommissionEmployee to place them in the Payable hierarchy as subclasses of the version of Employee that implements Payable (Fig. 10.13). [Hint: Change the name of method earnings to getPaymentAmount in each subclass so that the class satisfies its inherited contract with interface Payable.] b) Modify class BasePlusCommissionEmployee such that it extends the version of class CommissionEmployee created in Part a.

Description of the Problem

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

330

Object-Oriented Programming: Polymorphism

Chapter10

Lab Exercises

Name:

Lab Exercise 2 — Accounts Payable System Modification
c) Modify
PayableInterfaceTest to polymorphically process two Invoices, one SalariedEmployee, one HourlyEmployee, one CommissionEmployee and one BasePlusCommissionEmployee. First output a string representation of each Payable object. Next, if an object is a BasePlusCommissionEmployee, increase its base salary by 10%. Finally, output the payment amount for each Payable object.

Sample Output
Invoices and Employees processed polymorphically: invoice: part number: 01234 (seat) quantity: 2 price per item: $375.00 payment due: $750.00 invoice: part number: 56789 (tire) quantity: 4 price per item: $79.95 payment due: $319.80 salaried employee: John Smith social security number: 111-11-1111 weekly salary: $800.00 payment due: $800.00 hourly employee: Karen Price social security number: 222-22-2222 hourly wage: $16.75; hours worked: 40.00 payment due: $670.00 commission employee: Sue Jones social security number: 333-33-3333 gross sales: $10,000.00; commission rate: 0.06 payment due: $600.00 base-salaried commission employee: Bob Lewis social security number: 444-44-4444 gross sales: $5,000.00; commission rate: 0.04; base salary: $300.00 new base salary with 10% increase is: $330.00 payment due: $530.00

Program Template
1 2 3 4 5 6 7 8
// Lab Exercise 2: HourlyEmployee.java // HourlyEmployee class extends Employee, which implements Payable. public class HourlyEmployee extends Employee { private double wage; // wage per hour private double hours; // hours worked for week

Fig. L 10.6 |

HourlyEmployee.java.

(Part 1 of 2.)

© Copyright 1992-2007 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved.

Chapter 10

Object-Oriented Programming: Polymorphism

331

Lab Exercises

Name:

Lab Exercise 2 — Accounts Payable System Modification

9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

// five-argument constructor public HourlyEmployee( String first, String last, String ssn, double hourlyWage, double hoursWorked ) { super( first, last, ssn ); setWage( hourlyWage ); // validate and store hourly wage setHours( hoursWorked ); // validate and store hours worked } // end five-argument HourlyEmployee constructor // set wage public void setWage( double hourlyWage ) { wage = ( hourlyWage < 0.0 ) ? 0.0 : hourlyWage; } // end method setWage // return wage public double getWage() { return wage; } // end method getWage // set hours worked public void setHours( double hoursWorked ) { hours = ( ( hoursWorked >= 0.0 ) && ( hoursWorked