Lecture Notes – Inheritance and Polymorphism (Ch 9-10)

Yonglei Tao

Inheritance An “is a” relationship between classes

Generalization and specialization Software reuse

Employee

ManagerWorker

Extending a Class public class Employee {

protected String name;protected double basePay;

public double getBasePay () { return basePay; }public void setBasePay ( doule amt ) { basePay =

amt; }public String toString () { return “Name:

“+name+“\nPay: “+basePay; } } 

public class Worker extends Employee {private double hours;

public double getHours() { return hours; }public void setHours( double hrs ) { hours = hrs; }

public String toString () { return super.toString()+“\nHours: “+hours; } }

Constructors // in class Employee

public Employee () { }

public Employee (String name, double pay) {this.name = name;basePay = pay;

}  // in class Worker public Worker (String name, double pay, double hours) {

super (name, pay);this.hours = hours;

}

Overloading vs. Overriding Method overloading

An overloaded method has a different header Static binding

Method overriding An overriding method has the same header

although may have its own access modifier Dynamic binding

Polymorphic References

Worker w = new Worker(“Ed”, 9.25, 25); System.out.println (“Base Pay: “ + w.getBasePay());

System.out.println (w);

Employee p; // a polymorphic reference p = new Worker(“Tom”, 7.95, 40); System.out.println (p); p = new Manager(“John”, 36000); System.out.println (p);

A super class reference can refer to an object of any subclass

Inheritance Hierarchies

Multiple Inheritance

1-8

Abstract Classes

public abstract class Employee {

protected String name;protected double basePay;…public abstract double calcBiweeklyPay (); …

}

Represent an abstract concept Cannot be instantiated A derived class must define all of its parent’s

abstract methods or itself is an abstract class

Polymorphism A reference of a super class can refer to an

object of any descendent class Allowing objects of different classes to respond

to the same method call in different ways Benefits

No need to use conditional logic Simplify the client code

Extensible

An Example // in class Employeepublic abstract double calcBiWeeklyPay ();

// in class Workerpublic double calcBiWeeklyPay () { return hours * basePay; } 

// in class Managerpublic double calcBiWeeklyPay () { return basePay / 26; } 

// in client codeEmployee list[] = new Employee[30];List [0] = new Worker (“Tom”, 12.5);List [1] = new Manager (“John”, 36000);List [2] = new Worker (“Ed”, 11.25);…for (int i = 0; i < list.length; i++) { System.out.print ( list[i] ); System.out.println ( list[i].calcBiWeeklyPay () );}

Dynamic Binding Employee p; Worker w = new Worker(“Tom”, 7.95, 40); Manager m = new Manager(“John”, 36000);

… // either p = w or p = m

w.calcBinweeklyPay(); // static/early binding m.calcBinweeklyPay();

p.calcBiweeklyPay(); // dynamic/late binding

The binding of a method call to its definition is performed at runtime for a polymorphic reference

Final Classes and Methods

public final class A {... // cannot be extended

} 

public class B {final void f () { ... } // cannot be

overridden....

}

Improve security and optimization

Visibility Private members are inherited by the child

class, but cannot be referenced by name Invisible to members defined in the child class

However, they may be used indirectly through a public method of the super class

Interfaces

public interface Doable{ public void doThis(); public int doThat(); public void doThis2 (float value, char ch); public boolean doTheOther (int num);}

interface is a reserved wordNone of the methods inan interface are given

a definition (body)

A semicolon immediatelyfollows each method header

Interfaces

public class CanDo implements Doable{ public void doThis () { // whatever }

public void doThat () { // whatever }

// etc.}

implements is areserved word

Each method listedin Doable is

given a definition

Interfaces

Interface and Its Implementationpublic interface Measurable { double getMeasure(); }

public class Coin implements Measurable { private double value; private String name; public double getMeasure() { return value; } public String getName() { … } ...}

public class BankAccount implements Measurable { private double balance;

public double getMeasure() { return balance; }

…}

DataSet for Measurable Objectspublic class DataSet { private double sum; private Measurable max; private int count; ... public void add(Measurable x) { sum = sum + x.getMeasure(); if (count==0 || max.getMeasure()< x.getMeasure()) max = x; count++; }

public double getAverage() { return sum/count; }

public Measurable getMaximum() { return max; }}

A reference of an interface can refer to an object of any implementation class

public class DataSetTester {

public static void main(String[] args) {

DataSet bankData = new DataSet();

bankData.add(new BankAccount(0)); bankData.add(new BankAccount(10000)); bankData.add(new BankAccount(2000));

System.out.println("Average balance: " + bankData.getAverage()); System.out.println("Expected: 4000"); Measurable max = bankData.getMaximum(); System.out.println("Highest balance: " + max.getMeasure()); System.out.println("Expected: 10000");

DataSet coinData = new DataSet();

coinData.add(new Coin(0.25, "quarter")); coinData.add(new Coin(0.1, "dime")); coinData.add(new Coin(0.05, "nickel"));

System.out.println("Average coin value: “ + coinData.getAverage()); System.out.println("Expected: 0.133"); max = coinData.getMaximum(); System.out.println("Highest coin value: " + max.getMeasure()); System.out.println("Expected: 0.25"); }}

Interfaces vs. Classes An interface is similar to a class, but there

are several important differences: • All methods in an interface are abstract; they

don’t have an implementation

• All methods in an interface are automatically public

• Instance variables in an interface are always static or final

A class may implement multiple interfaces

The Object Class

All classes extend Object, directly or indirectly, explicitly or implicitly, and therefore inherit its methods

Methods of Object String toString() boolean equals (Object other) int hashCode() Object clone() Class getClass()

Redefine a method if the default definition is not appropriate for a derived class

Type Conversion Implicit conversion

intVar = charExpr;floatVar = intExpr;doubleVar = floatExpr;

Worker w = new Worker ();Employee p = w;

Explicit conversionchar ch = (char) anInt; // anInt = 65long num = (long) aDouble; // aDouble = 7.99

Explicit Conversion Employee p; Worker w = new Worker(“Tom”, 7.95, 40); Manager m = new Manager(“John”, 36000);

… // either p = w or p = mw = p; ? 

public void aMethod ( Employee p ) {if ( p instanceof Worker )

Worker w = (Worker) p;…

}}

Class Shapepublic abstract class Shape {

private String name;

public abstract double area ();

public Shape( String shapeName ) { name = shapeName; }

final public boolean lessThan ( Shape other ) { return area() < other.area(); }

final public String toString () { return name + " of area " + area(); }}

Circle Rectangle

public class Rectangle extends Shape {

private double length, width;

public Rectangle ( double len, double wid ) {

super ( "rectangle" );

length = len;

width = wid;

}

public double area () {

return length * width;

}

}

Class Circle

public class Circle extends Shape {

private double radius;

public Circle( double radius ) { super ( "circle" ); this.radius = radius; }

public double area () { return Math.PI * radius * radius; } }

Class Square

public class Square extends Rectangle {

public Square ( double side ) { super ( side, side ); }

}

public class ShapeTest {

final static int MaxSize = 50;

public static void main ( String[] args ) { Shape[] shapeList = new Shape [ MaxSize ]; int size = 0, choice;

for ( int i = 0; i < 15; i++ ) { // object construction choice = (int) ( Math.random() * 3 ); switch ( choice ) { case 0: shapeList[size++] = new Circle( size*1.25 ); break; case 1: shapeList[size++] = new Rectangle( size+2.5, size*7.0 ); break; case 2: shapeList[size++] = new Square ( size*5.0 ); break; } }

// processing of objects

for ( int i = 0; i < size; i++ ) { System.out.println( shapeList[i] ); }

double total = 0; for ( int i = 0; i < size; i++ ) { total += shapeList[i].area(); } System.out.println( "The total are is " + total ); }

}

What needs to be done if a new subclass is added?