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

1. Lecture Notes – Inheritance and Polymorphism (Ch 9-10) Yonglei Tao

2. Inheritance • An “is a” relationship between classes • Generalization and specialization • Software reuse Employee Worker Manager

3. Extending a Class public class Employee { protected String name; protecteddouble basePay; public double getBasePay () { return basePay; } public void setBasePay ( douleamt ) { 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; } }

4. 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; }

5. 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

6. 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

7. Inheritance Hierarchies

8. Multiple Inheritance

9. 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

10. 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

11. An Example // in class Employee public abstract double calcBiWeeklyPay(); // in class Worker public double calcBiWeeklyPay () { return hours * basePay; } // in class Manager public double calcBiWeeklyPay () { return basePay / 26; } // in client code Employee 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 () ); }

12. 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

13. Final Classes and Methods publicfinal class A { ... // cannot be extended } publicclass B { final void f () { ... } // cannot be overridden .... } • Improve security and optimization

14. 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

15. interfaceis a reserved word A semicolon immediately follows each method header Interfaces None of the methods in an interface are given a definition (body) public interface Doable { public void doThis(); public intdoThat(); public void doThis2 (float value, char ch); public booleandoTheOther (intnum); }

16. implementsis a reserved word Each method listed inDoableis given a definition Interfaces public class CanDo implements Doable { public void doThis () { // whatever } public void doThat () { // whatever } // etc. }

17. Interfaces

18. Interface and Its Implementation public 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 BankAccountimplements Measurable { private double balance; public double getMeasure() { return balance; } … }

19. DataSet for Measurable Objects public 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 MeasurablegetMaximum() { return max; }} A reference of an interface can refer to an object of any implementation class

20. publicclassDataSetTester{ publicstaticvoid main(String[] args) { DataSetbankData = newDataSet(); bankData.add(newBankAccount(0)); bankData.add(newBankAccount(10000)); bankData.add(newBankAccount(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"); DataSetcoinData = newDataSet(); coinData.add(newCoin(0.25, "quarter")); coinData.add(newCoin(0.1, "dime")); coinData.add(newCoin(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"); } }

21. 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

22. The Object Class • All classes extend Object, directly or indirectly, explicitly or implicitly, and therefore inherit its methods

23. Methods of Object • String toString() • boolean equals (Object other) • inthashCode() • Object clone() • Class getClass() • Redefine a method if the default definition is not appropriate for a derived class

24. Type Conversion • Implicit conversion intVar = charExpr; floatVar = intExpr; doubleVar = floatExpr; Worker w = new Worker (); Employee p = w; • Explicit conversion char ch = (char) anInt; // anInt = 65 long num = (long) aDouble; // aDouble = 7.99

25. Explicit Conversion Employee p; Worker w = new Worker(“Tom”, 7.95, 40); Manager m = new Manager(“John”, 36000); … // either p = w or p = m w = p; ?  public void aMethod ( Employee p ) { if ( p instanceof Worker ) Worker w = (Worker) p; … } }

26. Class Shape public abstract class Shape { private String name; public abstract double area (); public Shape( String shapeName ) { name = shapeName; } final public booleanlessThan ( Shape other) { return area() < other.area(); } final public String toString () { return name + " of area " + area(); } }

27. 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; } }

28. 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; } }

29. Class Square public class Square extends Rectangle { public Square ( double side ) { super ( side, side ); } }

30. public class ShapeTest { final static intMaxSize = 50; public static void main ( String[] args ) { Shape[] shapeList = new Shape [ MaxSize ]; intsize = 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; } }

31. // 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?