CS100A, 5 Sept. 1998

1
CS100A, 5 Sept. 1998

• This lecture continues the discussion of classes.
  The important new concept of this lecture is
  inheritance. This will require to introduce
  constructors and to use the Java keywords
  extends, this, and super.
• Inheritance is motivated by extending class
  Employee of the previous lecture to distin-guish
  between kinds of employees VIPs (the CEO and
  other major officers), salaried em-ployees, and
  regular employees. Each kind of employee requires
  different information in their record, and there
  is different processing for each. Placing the
  information for all three kinds of employees in
  class Employee wastes space and causes
  complications in the code using classes that are
  extensions of class Employee eliminates these
  problems.

2
CS100A, 15 September 1998

• Concepts for this lecture
• Inheritance a subclass B of a class A inherits
  fields and methods from class A. A is a
  super-class of B. In Java, keyword extends is
  used to define a subclass.
• Using the constructor of a super class.
• Access modifier protected
• Overriding methods
• Method toString() for every class
• Reading Holmes --look in index and try to find
  appropriate pages to read

3

• Method toString
• // Yield a String containing the data for
• // the person
• public String toString()
• return name " "
• salary " "
• hireDate
• Convention Every class implements method
  toString!
• In ltStringgt B
• (catenation), if B is not a String, method
  B.toString() is automatically used to convert it
  to a String.

4
Our old class Employee

• // An instance of Employee contains a person's
  name,
• // salary, and year hired. It has a constructor
  and
• // methods for raising the salary, printing the
  data, and
• // retrieving the person's name and the year
  hired.
• public class Employee
• public String name // The person's name
• public double pay // The person's yearly salary
• public int hireDate // The year hired
• // Constructor a person with name n, salary s,
  and
• // year d hired
• public Employee(String n, double s, int d)
• name n
• pay s
• hireDate d

5
// Raise the salary by p percent public void
raiseSalary(double p) pay pay (1
p/100.0) // Yield the year the person was
hired public int hireYear() return
hireDate // Yield the person's name public
String getName() return name // Yield a
String containing the data for the person public
String toString() return name " "
pay " "
hireDate (old class Employee)
6
Our task today

• Modify class Employees to take into account three
  different kinds
• VIPS (e.g. CEO, president, vice president) Need
  a field bonus, since VIPS get (big) bonuses. Get
  a yearly salary.
• Salaried Expected to work overtime whenever
  necessary, without extra pay.
• Regular Time cards! Have an hourly wage instead
  of a yearly salary. (Need also to record the
  number of hours worked on each day, but well
  forego that here and assume 40 hours per week.

7

• How to implement?
• Add fields
• int employeeKind // 1 VIP, 2 salaried,
• // 3 regular
• double bonus // bonus for VIP (only)
• double hourlyWage // (for regular
• // employees only
• // Set bonus to b (if employee is a VIP)
• public setBonus(double b)
• if (employeeKind 1)
• bonus b
• A lot of other changes are required.

8

• Problems with this approach
• Each employees record has a field for a bonus
  and for an hourly wage, even though it may not
  need it.
• Within the methods of class Employee that deal
  with salary and wages and hours, tests will have
  to be made to determine which kind of employee is
  being processed. This makes the code longer, less
  well-structured, and confusing.
• If a new kind of employee were to be added that
  required a different processing for pay, all the
  code that deals with pay would have to be
  changed.
• Instead, use a different approach
  inheritance.

9

• // An instance of VIP contains a VIP's data
• public class VIP extends Employee
• private double bonus // The VIP's bonus
• // Constructor a person with name n, year d
  hired,
• // yearly pay s, and bonus b
• public VIP(String n, int d, double s, double b)
• super (n,d)
• pay s bonus b
• // Yield a String containing the data for the
  person
• public String toString()
• return VIP " name " " pay "
  "
• " " bonus " "
  hireDate
• // Change the bonus to p
• public void changeBonus(double p)
• bonues p

10

• An instance of class VIP has every field and
  method that an instance of class Employee does,
  plus the ones VIP declares.

Employee x x new Employee(Gries,
1969) Employee y new VIP(Cardie,1994,
90000,1000)
VIP
y
Name Cardie pay 90000 hireDate 1994
Employee, hireYear, getName, toString bonus
1000 VIP changeBonus
11

• Use of super
• For an instance of VIP. A constructor of super
  class Employee should be called to initialize the
  fields declared within Employee. This is as the
  first statement in a constructor for VIP
• super (n,d)
• Use of protected
• If fields of Employee are public, they can be
  referenced from anywhere.
• If they are private, they can be referenced only
  from instances of Employee.
• If they are protected, they can be referenced
  only in same package --concept discussed
• much later!!!

12

• Referencing methods
• VIP y
• y new VIP(Perkins, 1983, 90000, 1000)
• y.getName() refers to method getName of its
  superclass, Employee. This is because getName is
  not defined in VIP.
• y.getBonus() refers to method getBonus of VIP.
  This is because getBonus is defined in VIP.
• y.toString() refers to method toString of VIP.
  This is because toString is defined in VIP.
• Method toString of superclass Employee has been
  overridden in class VIP.