Lab OOP

Dated : 5th April 2011

Objective:

To demonstrate Polymorphism in inheritance

What is Polymorphism?

Polymorphism enables us to "program in the general" rather than "program in the specific." In
particular, polymorphism enables us to write programs that process objects that share the same
superclass in a class hierarchy as if they are all objects of the superclass; this can simplify
programming.

Consider the following example of polymorphism. Suppose we create a program that simulates
the movement of several types of animals for a biological study. Classes Fish, Frog and Bird
represent the three types of animals under investigation. Imagine that each of these classes
extends superclass Animal, which contains a method move and maintains an animal's current
location as x-y coordinates. Each subclass implements method move. Our program maintains an
array of references to objects of the various Animal subclasses. To simulate the animals'
movements, the program sends each object the same message once per secondnamely, move.
However, each specific type of Animal responds to a move message in a unique waya Fish
might swim three feet, a Frog might jump five feet and a Bird might fly ten feet. The program
issues the same message (i.e., move) to each animal object generically, but each object knows
how to modify its x-y coordinates appropriately for its specific type of movement. Relying on
each object to know how to "do the right thing" (i.e., do what is appropriate for that type of
object) in response to the same method call is the key concept of polymorphism. The same
message (in this case, move) sent to a variety of objects has "many forms" of resultshence the
term polymorphism

Case Study: Payroll System Using Polymorphism (from Dietel)

A company pays its employees on a weekly basis. The employees are of four types: Salaried
employees are paid a fixed weekly salary regardless of the number of hours worked, hourly
employees are paid by the hour and receive overtime pay for all hours worked in excess of 40
hours, commission employees are paid a percentage of their sales and salaried-commission
employees receive a base salary plus a percentage of their sales. For the current pay period,
the company has decided to reward salaried-commission employees by adding 10% to their
base salaries. The company wants to implement a Java application that performs its payroll
calculations polymorphically.
Employee Abstract Class:

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
 // 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

Concrete Class Salaried 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()
{
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

Concrete Class Hourly Employee

public class HourlyEmployee extends Employee{

private double wage; // wage per hour

private double hours; // hours worked for week
// five-argument constructor
public HourlyEmployee( String first, String last,
String ssn,
double hourlyWage, double hoursWorked )
{
super( first, last, ssn );
setWage( hourlyWage ); // validate hourly wage
setHours( hoursWorked ); // validate 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
<= 168.0 ) ) ?
hoursWorked : 0.0;
} // end method setHours

// return hours worked

public double getHours()
{
return hours;
} // end method getHours

// calculate earnings; override abstract method

earnings in Employee
public double earnings()
{
if ( getHours() <= 40 ) // no overtime
return getWage() * getHours();
else
return 40 * getWage() + ( gethours() - 40 ) *
getWage() * 1.5;
} // end method earnings

// return String representation of HourlyEmployee

object
public String toString()
{
return String.format( "hourly employee: %s\n%s:
$%,.2f; %s: %,.2f",
super.toString(), "hourly wage", getWage(),
"hours worked", getHours() );
} // end method toString

}
Main Class

public class MainClass {

public static void main( String args[] )
{
// create subclass objects
SalariedEmployee salariedEmployee =
new SalariedEmployee( "John", "Smith", "111-11-
1111", 800.00 );
HourlyEmployee hourlyEmployee =
new HourlyEmployee( "Karen", "Price", "222-22-
2222", 16.75, 40 );
// create two-elements Employee array
Employee employees[] = new Employee[ 2];

// initialize array with Employees

employees[ 0 ] = salariedEmployee;
employees[ 1 ] = hourlyEmployee;
System.out.println( "Employees processed
polymorphically:\n" );

for ( Employee currentEmployee : employees )

{
System.out.println( currentEmployee ); //
invokes toString

// get type name of each object in employees

array
for ( int j = 0; j < employees.length; j++ )
System.out.printf( "Employee %d is a %s\n", j,
employees[ j ].getClass().getName() );

}
}}

--------------------------------------------- The End --------------------------------