Object-Oriented Programming Outline Introduction Superclasses and Subclasses protected Members Relationship between Superclass Objects and Subclass Objects

Object-Oriented Programming

OutlineIntroductionSuperclasses and Subclassesprotected MembersRelationship between Superclass Objects and Subclass ObjectsConstructors and Finalizers in SubclassesImplicit Subclass-Object-to-Superclass-Object ConversionSoftware Engineering with InheritanceComposition vs. InheritanceCase Study: Point, Circle, CylinderIntroduction to PolymorphismType Fields and switch StatementsDynamic Method Binding

Chapter 9 - Object-Oriented Programming

Outlinefinal Methods and ClassesAbstract Superclasses and Concrete ClassesPolymorphism ExamplesCase Study: A Payroll System Using PolymorphismNew Classes and Dynamic BindingCase Study: Inheriting Interface and ImplementationCase Study: Creating and Using InterfacesInner Class DefinitionsNotes on Inner Class DefinitionsType-Wrapper Classes for Primitive Types

Introduction

• Object-Oriented Programming (OOP)– Inheritance - form of software reusability

• New classes created from existing ones

• Absorb attributes and behaivors, and add in their own

– Override methods - redefine inherited methods

• Subclass inherits from superclass

– Direct superclass - subclass explicitly inherits

– Indirect superclass - subclass inherits from two or more levels up the class heirarchy

– Polymorphism• Write programs in a general fashion to handle a wide variety

of classes

– Abstraction - seeing the big picture

Introduction

• Object-Oriented Programming– Introduce protected member access

– Relationships• "is a" - inheritance

– Object of subclass "is a" object of the superclass

• "has a" - composition

– Object "has a" object of another class as a member

– Class libraries• New classes can inherit from them

• Someday software may be constructed from standardized, reusable components (like hardware)

• Create more powerful software

Superclasses and Subclasses

• Inheritance example– A rectangle "is a" quadrilateral

• Rectangle is a specific type of quadrilateral

• Quadrilateral is the superclass, rectangle is the subclass

• Incorrect to say quadrilateral "is a" rectangle

– Naming can be confusing because subclass has more features than superclass

• Subclass more specific than superclass

• Every subclass "is an" object of its superclass, but not vice-versa

– Form tree-like hierarchal structures• Create a hierarchy for class Shape (next slide)

Superclasses and Subclasses

• Using inheritance– Use keyword extendsclass TwoDimensionalShape extends Shape{ ... }– private members of superclass not directly accessible to

subclass

– All other variables keep their member access

Shape

TwoDimensionalShape ThreeDimensionalShape

Circle Square Triangle Sphere Cube Tetrahedron

protected Members

• In a superclass– public members

• Accessible anywhere program has a reference to a superclass or subclass type

– private members• Accesible only in methods of the superclass

– protected members• Intermediate protection between private and public• Only accessible by methods of superclass, of subclass, or

classes in the same package

• Subclass methods– Can refer to public or protected members by name

– Overridden methods accessible with super.methodName

Modifiers

Access Levels

Modifier Class Package Subclass World

public Y Y Y Y

protected Y Y Y N

no modifier Y Y N N

private Y N N N

The following table shows the access to members permitted by each modifier:

Relationship between Superclass Objects and Subclass Objects

• Object of subclass– Can be treated as object of superclass

• Reverse not true

– Suppose many classes inherit from one superclass• Can make an array of superclass references• Treat all objects like superclass objects

– Explicit cast• Convert superclass reference to a subclass reference

(downcasting)• Can only be done when superclass reference actually referring

to a subclass object– instanceof operator

• if (p instanceof Circle)• Returns true if the object to which p points "is a" Circle


• Overridding methods– Subclass can redefine superclass methods

• When method mentioned in subclass, subclass version used

• Access original superclass method with super.methodName

– To invoke superclass constructor explicitly• super(); //can pass arguments if needed• If called explicitly, must be first statement

• Every Applet has used these techniques– We have overridden init and paint when we extended Japplet

• Java implicitly uses class Object as superclass for all classes


• Upcoming example

– Every class implicitly inheirts from class Object

– Every constructor must call superclass constructor• Called implicitly by default• If explicit, must be first command

– Inherits from Point

– Explicitly calls superclass (Point) constructor• Must be first statement in Circle constructor• To call default superclass construcor, use super()

4 public class Point {

8 public Point()

41 public class Circle extends Point { // inherits from Point

54 super( a, b ); // call to superclass constructor


– Both Point and Circle override toString• To call class Point's toString in class Circle• super.toString()

– pointRef points to a Circle object• Allowed, because Circle "is a" Point

– pointRef knows it is pointing to a Circle object• Calls the proper toString method

• Example of polymorphism - more later

83 Point pointRef, p; 84 Circle circleRef, c;

88 c = new Circle( 2.7, 120, 89 );

95 pointRef = c; // assign Circle to pointRef

98 pointRef.toString();


– pointRef is pointing to a Circle• Downcast it to a Circle reference, assign to circleRef (explicit cast)

– Operator instanceof• Returns true if object to which p points "is a" Circle• In this case, returns false

102 circleRef = (Circle) pointRef;

87 p = new Point( 30, 50 );

113 if ( p instanceof Circle ) {

1. Point definition

1.1 Data members

1.2 Constructors

1.3 Methods

1 // Fig. 9.4: Point.java

2 // Definition of class Point

3

44 public class Point {

5 protected int x, y; // coordinates of the Point

6

7 // No-argument constructor

88 public Point()

9 {

10 // implicit call to superclass constructor occurs here

11 setPoint( 0, 0 );

12 }

13

14 // Constructor

15 public Point( int a, int b )

16 {

17 // implicit call to superclass constructor occurs here

18 setPoint( a, b );

19 }

20

21 // Set x and y coordinates of Point

22 public void setPoint( int a, int b )

23 {

24 x = a;

25 y = b;

26 }

27

28 // get x coordinate

29 public int getX() { return x; }

Point implicitly inherits from class Object

Notice the default (no argument) constructor. Implicit call to superclass constructor.

1.4 Overridden toString method----------------1. Circle Definition

1.1 extends Point

1.2 Multiple constructors

3031 // get y coordinate32 public int getY() { return y; }3334 // convert the point into a String representation

3535 public String toString()

36 { return "[" + x + ", " + y + "]"; }

37 }

38 // Fig. 9.4: Circle.java39 // Definition of class Circle4041 public class Circle extends Point { // inherits from Point42 protected double radius;4344 // No-argument constructor4545 public Circle()46 {47 // implicit call to superclass constructor occurs here48 setRadius( 0 ); 49 }5051 // Constructor52 public Circle( double r, int a, int b )53 {

5454 super( a, b ); // call to superclass constructor55 setRadius( r ); 56 }5758 // Set radius of Circle59 public void setRadius( double r ) 60 { radius = ( r >= 0.0 ? r : 0.0 ); }

Class Point's method toString overrides the original toString in class Object

Point constructor called implicitly

Point constructor called explicitly, and must be the first statement in the subclass constructor

1.3 Overridden toString method

61

62 // Get radius of Circle

63 public double getRadius() { return radius; }

64

65 // Calculate area of Circle

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

68 // convert the Circle to a String


70 {

71 return "Center = " + "[" + x + ", " + y + "]" +

72 "; Radius = " + radius;

73 }

74 }

1. Initialize objects

2. Refer to a subclass object with a superclass reference

2.1 toString

89

90 output = "Point p: " + p.toString() +

91 "\nCircle c: " + c.toString();

92

93 // use the "is a" relationship to refer to a Circle

94 // with a Point reference

9595 pointRef = c; // assign Circle to pointRef

96

97 output += "\n\nCircle c (via pointRef): " +

9898 pointRef.toString();

75 // Fig. 9.4: Test.java

76 // Demonstrating the "is a" relationship

77 import java.text.DecimalFormat;

78 import javax.swing.JOptionPane;

79

80 public class InheritanceTest {

81 public static void main( String args[] )

82 {

83 Point pointRef, p;

84 Circle circleRef, c;

85 String output;

86

87 p = new Point( 30, 50 );

88 c = new Circle( 2.7, 120, 89 );

Allowed because a subclass object "is a" superclass object

The computer knows that pointRef is actually pointing to a Circle object, so it calls method toString of class Circle. This is an example of polymorphism, more later.

2.2 Downcast

2.3 toString

2.4 area

3. if statement

117 else

118 output += "\n\np does not refer to a Circle";

119

120 JOptionPane.showMessageDialog( null, output,

121 "Demonstrating the \"is a\" relationship",

122 JOptionPane.INFORMATION_MESSAGE );

123

124 System.exit( 0 );

125 }

126}

99

100 // Use downcasting (casting a superclass reference to a

101 // subclass data type) to assign pointRef to circleRef

102102 circleRef = (Circle) pointRef;

103

104 output += "\n\nCircle c (via circleRef): " +

105 circleRef.toString();

106

107 DecimalFormat precision2 = new DecimalFormat( "0.00" );

108 output += "\nArea of c (via circleRef): " +

109 precision2.format( circleRef.area() );

110

111 // Attempt to refer to Point object

112 // with Circle reference

113113 if ( p instanceof Circle ) {

114 circleRef = (Circle) p; // line 40 in Test.java

115 output += "\n\ncast successful";

116 }

Downcast pointRef (which is really pointing to a Circle) to a Circle, and assign it to circleRef

Test if p (class Point) "is a" Circle. It is not.

Program Output

Constructors and Finalizers in Subclasses

• Objects of subclass– Superclass constructor should be called

• Initialize superclass variables

– Default constructor called implicitly• Explicit call (using super) must first command

• If method finalize defined– Subclass finalize should call superclass finalize as

last action

– Should be protected• Only subclasses have access

23 protected void finalize()

1. Class Point

1.1 Constructors

1.2 Finalizer (protected)

1 // Fig. 9.5: Point.java2 // Definition of class Point3 public class Point extends Object {4 protected int x, y; // coordinates of the Point56 // no-argument constructor7 public Point() 8 { 9 x = 0;10 y = 0;11 System.out.println( "Point constructor: " + this );12 }1314 // constructor15 public Point( int a, int b ) 16 { 17 x = a;18 y = b;19 System.out.println( "Point constructor: " + this );20 }2122 // finalizer

2323 protected void finalize() 24 {25 System.out.println( "Point finalizer: " + this );26 }2728 // convert the point into a String representation29 public String toString() 30 { return "[" + x + ", " + y + "]"; }31 }

Only subclass may access protected methods.

1. Class Circle (extends Point)

1.1 Constructors

1.2 Finalizer

32 // Fig. 9.5: Circle.java

33 // Definition of class Circle


35 protected double radius;

36

37 // no-argument constructor

38 public Circle()

39 {

40 // implicit call to superclass constructor here

41 radius = 0;

42 System.out.println( "Circle constructor: " + this );

43 }

44

45 // Constructor

46 public Circle( double r, int a, int b )

47 {

48 super( a, b ); // call the superclass constructor

49 radius = r;

50 System.out.println( "Circle constructor: " + this );

51 }

52

53 // finalizer

5454 protected void finalize()

55 {

56 System.out.println( "Circle finalizer: " + this );

57 super.finalize(); // call superclass finalize method

58 }

59

Circle finalizer calls superclass finalizer (in Point).

1. Class Test

2. main

2.1 Initialize objects

2.2 System.gc



62 {

63 return "Center = " + super.toString() +64 "; Radius = " + radius;65 }66 }67 // Fig. 9.5: Test.java

68 // Demonstrate when superclass and subclass

69 // constructors and finalizers are called.

70 public class Test {


72 {

73 Circle circle1, circle2;

74

75 circle1 = new Circle( 4.5, 72, 29 );

76 circle2 = new Circle( 10, 5, 5 );

77

7878 circle1 = null; // mark for garbage collection

79 circle2 = null; // mark for garbage collection

80

8181 System.gc(); // call the garbage collector

82 }

83 }

Mark objects for garbage collection by setting them to null.

Call garbage collector (static method gc of class System).

Program Output

Point constructor: Center = [72, 29]; Radius = 0.0Circle constructor: Center = [72, 29]; Radius = 4.5Point constructor: Center = [5, 5]; Radius = 0.0Circle constructor: Center = [5, 5]; Radius = 10.0Circle finalizer: Center = [72, 29]; Radius = 4.5Point finalizer: Center = [72, 29]; Radius = 4.5Circle finalizer: Center = [5, 5]; Radius = 10.0Point finalizer: Center = [5, 5]; Radius = 10.0

Implicit Subclass-Object-to-Superclass-Object Conversion

• References to subclass objects– May be implicitly converted to superclass references

• Makes sense - subclass contains members corresponding to those of superclass

– Referring to a subclass object with a superclass reference• Allowed - a subclass object "is a" superclass object

• Can only refer to superclass members

– Referring to a superclass object with a subclass reference• Error

• Must first be cast to a superclass reference

– Need way to use superclass references but call subclass methods

• Discussed later in the chapter

Composition vs. Inheritance

• "is a" relationship– Inheritance

• "has a" relationship– Composition, having other objects as members

• Example Employee “is a” BirthDate; //Wrong!

Employee “has a” Birthdate; //Composition

Case Study: Point, Circle, Cylinder

• Inheritance example– Class Point

• protected variables x, y• Methods: setPoint, getX, getY, toString

– Class Circle (extends Point)• protected variable radius• Methods: setRadius, getRadius, area, override toString

– Class Cylinder (extends Circle)• protected variable height• Methods: setHeight, getHeight, area (surface area), volume, override toString

1. Class Point

1.1 Instance variables

2. Constructors

2.1 Methods

1 // Fig. 9.6: Point.java2 // Definition of class Point3 package com.deitel.jhtp3.ch09;45 public class Point {6 protected int x, y; // coordinates of the Point78 // no-argument constructor9 public Point() { setPoint( 0, 0 ); }1011 // constructor12 public Point( int a, int b ) { setPoint( a, b ); }1314 // Set x and y coordinates of Point15 public void setPoint( int a, int b )16 {17 x = a;18 y = b;19 }2021 // get x coordinate22 public int getX() { return x; } 2324 // get y coordinate25 public int getY() { return y; }2627 // convert the point into a String representation28 public String toString() 29 { return "[" + x + ", " + y + "]"; }30 }


1.1 Instance variable

2. Constructors

2.1 Methods

1 // Fig. 9.7: Circle.java2 // Definition of class Circle3 package com.deitel.jhtp3.ch09;45 public class Circle extends Point { // inherits from Point6 protected double radius;78 // no-argument constructor9 public Circle()10 {11 // implicit call to superclass constructor12 setRadius( 0 ); 13 }1415 // Constructor16 public Circle( double r, int a, int b )17 {18 super( a, b ); // call the superclass constructor19 setRadius( r ); 20 }2122 // Set radius of Circle23 public void setRadius( double r ) 24 { radius = ( r >= 0.0 ? r : 0.0 ); }2526 // Get radius of Circle27 public double getRadius() { return radius; }2829 // Calculate area of Circle30 public double area() 31 { return Math.PI * radius * radius; }

2.1 Methods

32


34 public String toString()35 {36 return "Center = " + super.toString() +37 "; Radius = " + radius;38 }39 }

1. Class Cylinder (extends Circle)


2. Constructors

2.1 Methods

1 // Fig. 9.8: Cylinder.java

2 // Definition of class Cylinder

3 package com.deitel.jhtp3.ch09;

4

5 public class Cylinder extends Circle {

6 protected double height; // height of Cylinder

7

8 // No-argument constructor

9 public Cylinder()

10 {


12 setHeight( 0 );

13 }

14

15 // constructor

16 public Cylinder( double h, double r, int a, int b )

17 {

18 super( r, a, b );

19 setHeight( h );

20 }

21

22 // Set height of Cylinder

23 public void setHeight( double h )

24 { height = ( h >= 0 ? h : 0 ); }

25

26 // Get height of Cylinder

27 public double getHeight() { return height; }

28

2.1 Methods

------------

1. Class Test

2. main

2.1 Initialize object

29 // Calculate area of Cylinder (i.e., surface area)30 public double area() 31 {32 return 2 * super.area() + 33 2 * Math.PI * radius * height;34 }3536 // Calculate volume of Cylinder37 public double volume() { return super.area() * height; }3839 // Convert the Cylinder to a String40 public String toString()41 {42 return super.toString() + "; Height = " + height;43 }44 }45 // Fig. 9.8: Test.java

46 // Application to test class Cylinder

47 import javax.swing.JOptionPane;

48 import java.text.DecimalFormat;

49 import com.deitel.jhtp3.ch09.Cylinder;50

51 public class Test {


53 {

54 Cylinder c = new Cylinder( 5.7, 2.5, 12, 23 );


56 String output;

57

2.2 Method calls

2.3 Set methods

2.4 Display changes

2.5 area and volume

58 output = "X coordinate is " + c.getX() +

59 "\nY coordinate is " + c.getY() +

60 "\nRadius is " + c.getRadius() +

61 "\nHeight is " + c.getHeight();

62

63 c.setHeight( 10 );

64 c.setRadius( 4.25 );

65 c.setPoint( 2, 2 );

66

67 output +=

68 "\n\nThe new location, radius " +

69 "and height of c are\n" + c +

70 "\nArea is " + precision2.format( c.area() ) +

71 "\nVolume is " + precision2.format( c.volume() );

72


74 "Demonstrating Class Cylinder",



77 }

78 }

Program Output

Introduction to Polymorphism

• With polymorphism– Write extensible programs

– Generically process superclass objects

– Easy to add classes to heirarchy • Little or no modification required

• Only parts of program that need direct knowledge of new class must be changed

Type Fields and switch Statements

• switch statements– Can be used to deal with many objects of different types

• Appropriate action based on type

• Problems– Programmer may forget to include a type

– Might forget to test all possible cases

– Every addition/deletion of a class requires all switch statements to be changed

• Tracking all these changes is time consuming and error prone

– Polymorphic programming can eliminate the need for switch logic

• Avoids all these problems automatically

Dynamic Method Binding

• Dynamic Method Binding– At execution time, method calls routed to appropriate

version• Method called for appropriate class

• Example– Triangle, Circle, and Square all subclasses of Shape

• Each has an overridden draw method

– Call draw using superclass references• At execution time, program determines to which class the

reference is actually pointing

• Calls appropriate draw method

final Methods and Classes

• Declaring variables final– Indicates they cannot be modified after declaration

– Must be initialized when declared

• Declaring methods final– Cannot be overridden in a subclass– static and private methods are implicitly final– Program can inline final methods

• Actually inserts method code at method call locations

• Improves program performance

• Declaring classes final– Cannot be a superclass (cannot inherit from it)

– All methods in class are implicitly final

Abstract Superclasses and Concrete Classes

• Abstract classes (abstract superclasses)– Sole purpose is to be a superclass

• Other classes inherit from it

– Cannot instantiate objects of an abstract class• Can still have instance variables and constructors

– Too generic to define real objects– Declare class with keyword abstract

• Concrete class– Can instantiate objects– Provide specifics

• Class heirarchies– Most general classes are usually abstract

• TwoDimensionalShape - too generic to be concrete

Polymorphism Examples

• Class Quadrilateral– Rectangle "is a" Quadrilateral– getPerimeter method can be performed on any subclass

• Square, Parallelogram, Trapezoid• Same method takes on "many forms" - polymorphism

– Have an array of superclass references• Array would point to all the objects

– Call getPerimeter using the references• Appropriate method called for each class

• Adding a new subclass– Simply need to define getPerimeter for that class

– Can refer to it with superclass reference

Polymorphism Examples

• With polymorphism– New classes can be added easily

– One method call can cause different actions to occur, depending on object receiving call

• References– Can create references to abstract classes

• Cannot instantiate objects of abstract classes

• abstract methods– Keyword abstract

• Any class with an abstract method must be abstract

– abstract methods must be overridden in subclass• Otherwise, subclass must be abstract

Case Study: A Payroll System Using Polymorphism

• Example program– abstract superclass Employee

• abstract method earnings– Must be implemented in each subclass

– Classes Boss, CommissionWorker, and PieceWorker, HourlyWorker

• Override methods toString and earnings

– Class Test• Initialize objects

• Use an Employee reference and call toString and earnings

• Through polymorphism, the appropriate class method is called

1. Class Employee (abstract base class)


1.2 Methods

1.3 earnings (abstract method)

1 // Fig. 9.9: Employee.java

2 // Abstract base class Employee

3

44 public abstract class Employee {

5 private String firstName;

6 private String lastName;

7

8 // Constructor

9 public Employee( String first, String last )

10 {

11 firstName = first;

12 lastName = last;

13 }

14

15 // Return the first name

16 public String getFirstName() { return firstName; }

17

18 // Return the last name

19 public String getLastName() { return lastName; }

20


22 { return firstName + ' ' + lastName; }

23

24 // Abstract method that must be implemented for each

25 // derived class of Employee from which objects

26 // are instantiated.

2727 public abstract double earnings();

28 }

Class Employee declared abstract, so no Employee objects can be created.

Employee can still have a constructor, used by its derived classes.

abstract methods must be defined in concrete subclasses.

1. Class Boss (extends Employee)


1.2 Define earnings (required)

1.3 Override toString

29 // Fig. 9.9: Boss.java

30 // Boss class derived from Employee

31

32 public final class Boss extends Employee {

33 private double weeklySalary;

34

35 // Constructor for class Boss

36 public Boss( String first, String last, double s)

37 {

38 super( first, last ); // call superclass constructor

39 setWeeklySalary( s );

40 }

41

42 // Set the Boss's salary

43 public void setWeeklySalary( double s )

44 { weeklySalary = ( s > 0 ? s : 0 ); }

45

46 // Get the Boss's pay

4747 public double earnings() { return weeklySalary; }

48

49 // Print the Boss's name


51 {

52 return "Boss: " + super.toString();

53 }

54 }

Implementing earnings is required because it was declared abstract and Boss is a concrete class.

1. Class CommissionWorker (extends Employee)


1.2 Constructor

55 // Fig. 9.9: CommissionWorker.java56 // CommissionWorker class derived from Employee5758 public final class CommissionWorker extends Employee {59 private double salary; // base salary per week60 private double commission; // amount per item sold61 private int quantity; // total items sold for week6263 // Constructor for class CommissionWorker64 public CommissionWorker( String first, String last,65 double s, double c, int q)66 {67 super( first, last ); // call superclass constructor68 setSalary( s );69 setCommission( c );70 setQuantity( q );71 }72 73 // Set CommissionWorker's weekly base salary74 public void setSalary( double s )75 { salary = ( s > 0 ? s : 0 ); }76 77 // Set CommissionWorker's commission

78 public void setCommission( double c )

79 { commission = ( c > 0 ? c : 0 ); }

80

81 // Set CommissionWorker's quantity sold

82 public void setQuantity( int q )

83 { quantity = ( q > 0 ? q : 0 ); }

84



-----------------

1. Class PieceWorker (extends Employee)

1.1 Constructor

85 // Determine CommissionWorker's earnings86 public double earnings()

87 { return salary + commission * quantity; }

88

89 // Print the CommissionWorker's name


91 {

92 return "Commission worker: " + super.toString();

93 }

94 }

95 // Fig. 9.9: PieceWorker.java96 // PieceWorker class derived from Employee9798 public final class PieceWorker extends Employee {99 private double wagePerPiece; // wage per piece output100 private int quantity; // output for week101102 // Constructor for class PieceWorker103 public PieceWorker( String first, String last,104 double w, int q )105 {106 super( first, last ); // call superclass constructor107 setWage( w );108 setQuantity( q );109 }110 111 // Set the wage112 public void setWage( double w ) 113 { wagePerPiece = ( w > 0 ? w : 0 ); }114



----------------

1. Class HourlyWorker (extends Employee)

1.1 Constructor

115// Set the number of items output116 public void setQuantity( int q ) 117 { quantity = ( q > 0 ? q : 0 ); }118 119 // Determine the PieceWorker's earnings120 public double earnings()121 { return quantity * wagePerPiece; }122 123 public String toString()124 {125 return "Piece worker: " + super.toString();126 } 127}128// Fig. 9.9: HourlyWorker.java

129// Definition of class HourlyWorker

130

131public final class HourlyWorker extends Employee {

132 private double wage; // wage per hour

133 private double hours; // hours worked for week

134

135 // Constructor for class HourlyWorker

136 public HourlyWorker( String first, String last,

137 double w, double h )

138 {

139 super( first, last ); // call superclass constructor

140 setWage( w );

141 setHours( h );

142 }

143



-----------------------

1. Class Test

1.1 Employee reference

144 // Set the wage

145 public void setWage( double w )

146 { wage = ( w > 0 ? w : 0 ); }

147

148 // Set the hours worked

149 public void setHours( double h )

150 { hours = ( h >= 0 && h < 168 ? h : 0 ); }

151

152 // Get the HourlyWorker's pay

153 public double earnings() { return wage * hours; }

154


156 {

157 return "Hourly worker: " + super.toString();

158 }

159}

160// Fig. 9.9: Test.java

161// Driver for Employee hierarchy

162import javax.swing.JOptionPane;

163import java.text.DecimalFormat;

164

165public class Test {


167 {

168168 Employee ref; // superclass reference

169 String output = "";

170

References to abstract classes are allowed.

1.2 Initialize subclass objects

2. Method calls through Employee reference

171 Boss b = new Boss( "John", "Smith", 800.00 );

172 CommissionWorker c =

173 new CommissionWorker( "Sue", "Jones",

174 400.0, 3.0, 150);

175 PieceWorker p =

176 new PieceWorker( "Bob", "Lewis", 2.5, 200 );

177 HourlyWorker h =

178 new HourlyWorker( "Karen", "Price", 13.75, 40 );

179


181

182182 ref = b; // Employee reference to a Boss

183 output += ref.toString() + " earned $" +

184 precision2.format( ref.earnings() ) + "\n" +

185 b.toString() + " earned $" +

186 precision2.format( b.earnings() ) + "\n";

187

188 ref = c; // Employee reference to a CommissionWorker



191 c.toString() + " earned $" +

192 precision2.format( c.earnings() ) + "\n";

193

194 ref = p; // Employee reference to a PieceWorker



197 p.toString() + " earned $" +

198 precision2.format( p.earnings() ) + "\n";

199

Employee reference ref points to Boss object. Through polymorphism, the appropriate Boss versions of toString and earnings are called. To check, they are called through the Boss object as well.

2. Method calls through Employee reference

Program Output

200 ref = h; // Employee reference to an HourlyWorker



203 h.toString() + " earned $" +

204 precision2.format( h.earnings() ) + "\n";

205

206 JOptionPane.showMessageDialog( null, output,207 "Demonstrating Polymorphism",



210 }

211}

New Classes and Dynamic Binding

• Dynamic binding (late binding)– Accomodates new classes

– Object's type does not need to be known at compile time

– At execution time, method call matched with object

Case Study: Inheriting Interface and Implementation

• Polymorphism example– abstract superclass Shape

• Subclasses Point, Circle, Cylinder• abstract method

– getName• non-abstract methods

– area (return 0.0)– volume (return 0.0)

– Class Shape used to define a set of common methods• Interface is the three common methods

• Implementation of area and volume used for first levels of heirarchy

Case Study: Inheriting Interface and Implementation

– Create an array of Shape references• Point to various subclass objects

• Call methods using Shape reference

159 arrayOfShapes[ i ].getName() + ": " +

160 arrayOfShapes[ i ].toString() +

1. Class Shape (abstract superclass)

1.1 getName (abstract method)----------------------

1. Class Point (extends Shape)

1.1 protected data members

1.2 Constructors

1.3 New methods

1 // Fig. 9.10: Shape.java

2 // Definition of abstract base class Shape

3

4 public abstract class Shape extends Object {

55 public double area() { return 0.0; }

6 public double volume() { return 0.0; }

7 public abstract String getName();

8 }

9 // Fig. 9.10: Point.java10 // Definition of class Point1112 public class Point extends Shape {13 protected int x, y; // coordinates of the Point1415 // no-argument constructor16 public Point() { setPoint( 0, 0 ); }1718 // constructor19 public Point( int a, int b ) { setPoint( a, b ); }2021 // Set x and y coordinates of Point22 public void setPoint( int a, int b )23 {24 x = a;25 y = b;26 }2728 // get x coordinate29 public int getX() { return x; }30

Methds area and volume are defined. They will be overridden in the subclasses when necessary.

1.4 Overridden method getName (required)---------------------


1.1 protected data member

1.2 Constructors

1.3 New methods

31 // get y coordinate32 public int getY() { return y; }3334 // convert the point into a String representation35 public String toString() 36 { return "[" + x + ", " + y + "]"; }3738 // return the class name

3939 public String getName() { return "Point"; }40 }41 // Fig. 9.10: Circle.java

42 // Definition of class Circle

43


45 protected double radius;

46


48 public Circle()

49 {


51 setRadius( 0 );

52 }

53

54 // Constructor

55 public Circle( double r, int a, int b )

56 {

57 super( a, b ); // call the superclass constructor

58 setRadius( r ); 59 }60

abstract method getName must be overridden in a concrete subclass.

1.4 Overridden method area

1.5 Overridden method toString

1.6 Overridden method getName (required)---------------------

Class Cylinder (extends Circle)

1.1 protected data member

1.2 Constructors

61 // Set radius of Circle62 public void setRadius( double r )63 { radius = ( r >= 0 ? r : 0 ); }6465 // Get radius of Circle

66 public double getRadius() { return radius; }

67

68 // Calculate area of Circle

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

70



73 { return "Center = " + super.toString() +

74 "; Radius = " + radius; }

75

76 // return the class name

77 public String getName() { return "Circle"; }

78 }

79 // Fig. 9.10: Cylinder.java80 // Definition of class Cylinder8182 public class Cylinder extends Circle {83 protected double height; // height of Cylinder84 85 // no-argument constructor86 public Cylinder() 87 {88 // implicit call to superclass constructor here89 setHeight( 0 );90 }

Circle overrides method area, inherited from Shape. Point did not override area, and has the default implementation (returns 0).

1.2 Constructors

1.3 New methods

1.4 Overridden method area

1.5 Overridden method toString

1.6 Overridden method getName

9192 // constructor93 public Cylinder( double h, double r, int a, int b ) 94 {95 super( r, a, b ); // call superclass constructor96 setHeight( h );97 }9899 // Set height of Cylinder100 public void setHeight( double h )101 { height = ( h >= 0 ? h : 0 ); }102 103 // Get height of Cylinder104 public double getHeight() { return height; }105106 // Calculate area of Cylinder (i.e., surface area)107 public double area()108 {109 return 2 * super.area() +110 2 * Math.PI * radius * height;111 }112 113 // Calculate volume of Cylinder114 public double volume() { return super.area() * height; }115116 // Convert a Cylinder to a String117 public String toString()118 { return super.toString() + "; Height = " + height; }119120 // Return the class name121 public String getName() { return "Cylinder"; }122}

Class Test (driver)

1. import

1.1 Initialize objects

1.2 Create array of Shape references

1.3 Initialize array

2. Call methods using subclass references

123// Fig. 9.10: Test.java124// Driver for point, circle, cylinder hierarchy125import javax.swing.JOptionPane;126import java.text.DecimalFormat;127



130 {

131 Point point = new Point( 7, 11 );

132 Circle circle = new Circle( 3.5, 22, 8 );

133 Cylinder cylinder = new Cylinder( 10, 3.3, 10, 10 );

134

135 Shape arrayOfShapes[];

136

137137 arrayOfShapes = new Shape[ 3 ];

138

139 // aim arrayOfShapes[0] at subclass Point object

140140 arrayOfShapes[ 0 ] = point;

141

142 // aim arrayOfShapes[1] at subclass Circle object

143 arrayOfShapes[ 1 ] = circle;

144

145 // aim arrayOfShapes[2] at subclass Cylinder object

146 arrayOfShapes[ 2 ] = cylinder;

147

148 String output =

149 point.getName() + ": " + point.toString() + "\n" +

150 circle.getName() + ": " + circle.toString() + "\n" +

151 cylinder.getName() + ": " + cylinder.toString();

Create an array of Shape references.

Point the Shape references towards subclass objects.

2.1 Call methods using Shape references

152


154

155 // Loop through arrayOfShapes and print the name,

156 // area, and volume of each object.

157 for ( int i = 0; i < arrayOfShapes.length; i++ ) {

158 output += "\n\n" +



161 "\nArea = " +

162 precision2.format( arrayOfShapes[ i ].area() ) +

163 "\nVolume = " +

164 precision2.format( arrayOfShapes[ i ].volume() );

165 }

166


168 "Demonstrating Polymorphism",


170


172 }

173}

Call methods using superclass references. Appropriate method called because of polymorphism.

Program Output

Case Study: Creating and Using Interfaces

• Interface– Keyword interface– Has set of public abstract methods

– Can contain public final static data

• Using interfaces– Class specifies it uses interface with keyword implements

• Multiple interfaces use comma-separated list

– Class must define all abstract methods in interface• Must use same number of arguments, same return type

– Using interface like signing a contract• "I will define all methods specified in the interface"

– Same "is a" relationship as inheritance


• Using interfaces (continued)– Interfaces used in place of abstract classes

• Used when no default implementation

– Typically public data types• Interface defined in its own .java file

• Interface name same as file name

– Previous interfaces• We have used interface ActionListener• Required to define actionPerformed


• Another use of interfaces– Define a set of constants used by many classespublic interface Constants {

public static final int ONE = 1;

public static final int TWO = 2;

public static final int THREE = 3;

}

• Reexamine previous heirarchy– Replace abstract class Shape with interface Shape

1. Shape interface

1.1 abstract methods-----------------------

1. Class Point(implements Shape)

11 // Fig. 9.11: Shape.java

2 // Definition of interface Shape

3

4 public interface Shape {

5 public abstract double area();

6 public abstract double volume();

7 public abstract String getName();

8 }

9 // Fig. 9.11: Point.java

10 // Definition of class Point

11

1212 public class Point extends Object implements Shape {

13 protected int x, y; // coordinates of the Point

14


16 public Point() { setPoint( 0, 0 ); }

17

18 // constructor

19 public Point( int a, int b ) { setPoint( a, b ); }

20

21 // Set x and y coordinates of Point

22 public void setPoint( int a, int b )

23 {

24 x = a;

25 y = b;

26 }

27

Interface Shape is in its own file, Shape.java

Because Point implements interface Shape, it is required to define the abstract methods in Shape.

1.1 Define method area (required)

1.2 Define method volume (required)

1.3 Define method getName (required)

---------------------

Class Circle and Cylinder defined as before

28 // get x coordinate

29 public int getX() { return x; }

30

31 // get y coordinate

32 public int getY() { return y; }

3334 // convert the point into a String representation


36 { return "[" + x + ", " + y + "]"; }

37

38 // return the area

3939 public double area() { return 0.0; }

40

41 // return the volume

42 public double volume() { return 0.0; }

43

44 // return the class name

45 public String getName() { return "Point"; }

46 }

Point required to define the abstract methods of the interface it implements.

Use same class Test as before

123// Fig. 9.11: Test.java124// Driver for point, circle, cylinder hierarchy125import javax.swing.JOptionPane;126import java.text.DecimalFormat;127



130 {

131 Point point = new Point( 7, 11 );

132 Circle circle = new Circle( 3.5, 22, 8 );

133 Cylinder cylinder = new Cylinder( 10, 3.3, 10, 10 );

134

135 Shape arrayOfShapes[];

136

137 arrayOfShapes = new Shape[ 3 ];

138

139 // aim arrayOfShapes[0] at subclass Point object

140 arrayOfShapes[ 0 ] = point;

141

142 // aim arrayOfShapes[1] at subclass Circle object

143 arrayOfShapes[ 1 ] = circle;

144

145 // aim arrayOfShapes[2] at subclass Cylinder object

146 arrayOfShapes[ 2 ] = cylinder;

147

148 String output =

149 point.getName() + ": " + point.toString() + "\n" +

150 circle.getName() + ": " + circle.toString() + "\n" +

151 cylinder.getName() + ": " + cylinder.toString();

Use same class Test as before

152


154

155 // Loop through arrayOfShapes and print the name,

156 // area, and volume of each object.

157 for ( int i = 0; i < arrayOfShapes.length; i++ ) {

158 output += "\n\n" +



161 "\nArea = " +

162 precision2.format( arrayOfShapes[ i ].area() ) +

163 "\nVolume = " +

164 precision2.format( arrayOfShapes[ i ].volume() );

165 }

166


168 "Demonstrating Polymorphism",


170


172 }

173}

Program Output

Inner Class Definitions

• Inner classes– Till now, all classes defined at file scope (not inside other

classes)

– Inner classes defined inside other classes• Can access all members of outer class

• No special handles needed

– Anonymous inner class• Has no name

– Frequently used with event handling


• Windowed applications– Execute an application in its own window (like an applet)

• Inherit from class JFrame (javax.swing) rather than JApplet

• Call constructor to set title: super( "TitleName" )

– init method replaced by constructor• init not guaranteed to be called (only called for Applets)

• Instead, create GUI components in constructor

• Instantiate object in main (guaranteed to be called)

64 public class TimeTestWindow extends JFrame {

117 TimeTestWindow window = new TimeTestWindow();


• Window

Minimize, maximize, and closeTitle bar


– Event handling– Some class must implement interface ActionListener

• Must define method actionPerformed• Class that implements ActionListener "is an" ActionListener

– Method addActionListener• Takes object of type ActionListener• Pass it instance of the class that implements ActionListener ("is a" relationship)

123 // INNER CLASS DEFINITION FOR EVENT HANDLING

124 private class ActionEventHandler implements ActionListener {

79 // create an instance of the inner class

80 ActionEventHandler handler = new ActionEventHandler();85 hourField.addActionListener( handler );


• Example– We will use the Time class and execute an application in its

own window

– Use event handling to set the time• Define an inner class that implements ActionListener• Use an object of this class as the event handler

1. Time class

1.2 Data members

1.3 Constructors

1.4 Methods

1 // Fig. 9.12: Time.java2 // Time class definition3 import java.text.DecimalFormat; // used for number formatting45 // This class maintains the time in 24-hour format6 public class Time extends Object {7 private int hour; // 0 - 238 private int minute; // 0 - 599 private int second; // 0 - 591011 // Time constructor initializes each instance variable12 // to zero. Ensures that Time object starts in a 13 // consistent state.14 public Time() { setTime( 0, 0, 0 ); }1516 // Set a new time value using universal time. Perform 17 // validity checks on the data. Set invalid values to zero.18 public void setTime( int h, int m, int s )19 {20 setHour( h ); // set the hour21 setMinute( m ); // set the minute22 setSecond( s ); // set the second23 }2425 // set the hour 26 public void setHour( int h ) 27 { hour = ( ( h >= 0 && h < 24 ) ? h : 0 ); }2829 // set the minute 30 public void setMinute( int m ) 31 { minute = ( ( m >= 0 && m < 60 ) ? m : 0 ); }

1.4 Methods

32

33 // set the second

34 public void setSecond( int s ) 35 { second = ( ( s >= 0 && s < 60 ) ? s : 0 ); }3637 // get the hour38 public int getHour() { return hour; }3940 // get the minute41 public int getMinute() { return minute; }4243 // get the second44 public int getSecond() { return second; }4546 // Convert to String in standard-time format


48 {

49 DecimalFormat twoDigits = new DecimalFormat( "00" );

50

51 return ( ( getHour() == 12 || getHour() == 0 ) ?

52 12 : getHour() % 12 ) + ":" +

53 twoDigits.format( getMinute() ) + ":" +

54 twoDigits.format( getSecond() ) +

55 ( getHour() < 12 ? " AM" : " PM" );

56 }

57 }

1. import

1.1 Class TimeTestWindow ( extends JFrame)

1.2 Create GUI components in constructor

1.3 Create instance of class that implements ActionListener

1.4 addActionListener

58 // Fig. 9.12: TimeTestWindow.java59 // Demonstrating the Time class set and get methods60 import java.awt.*;61 import java.awt.event.*;62 import javax.swing.*;6364 public class TimeTestWindow extends JFrame {65 private Time t;66 private JLabel hourLabel, minuteLabel, secondLabel;67 private JTextField hourField, minuteField,68 secondField, display;69 private JButton exitButton;707171 public TimeTestWindow()72 {7373 super( "Inner Class Demonstration" );7475 t = new Time();7677 Container c = getContentPane();7879 // create an instance of the inner class80 ActionEventHandler handler = new ActionEventHandler();8182 c.setLayout( new FlowLayout() );83 hourLabel = new JLabel( "Set Hour" );84 hourField = new JTextField( 10 );8585 hourField.addActionListener( handler );86 c.add( hourLabel );87 c.add( hourField );88

Call to JFrame constructor sets title bar of window.

Object of inner class ActionEventHandler passed as an argument to addActionListener

Set up all GUI components in constructor. In main, create a TimeTestWindow object, which runs the constructor.

1.5 Create GUI components

2. Methods

3. main

3.1 Create object

89 minuteLabel = new JLabel( "Set minute" );

90 minuteField = new JTextField( 10 );

91 minuteField.addActionListener( handler );

92 c.add( minuteLabel );

93 c.add( minuteField );

94

95 secondLabel = new JLabel( "Set Second" );

96 secondField = new JTextField( 10 );

97 secondField.addActionListener( handler );

98 c.add( secondLabel );

99 c.add( secondField );

100

101 display = new JTextField( 30 );

102 display.setEditable( false );

103 c.add( display );

104

105 exitButton = new JButton( "Exit" );

106 exitButton.addActionListener( handler );

107 c.add( exitButton );

108 }

109

110 public void displayTime()

111 {

112 display.setText( "The time is: " + t );

113 }

114

115 public static void main( String args[] )116 {


Create TimeTestWindow object.

4. Inner class ActionEventHandler implements ActionListener

118119 window.setSize( 400, 140 );120 window.show();121 }122123 // INNER CLASS DEFINITION FOR EVENT HANDLING124124 private class ActionEventHandler implements ActionListener {

127 if ( e.getSource() == exitButton )

128 System.exit( 0 ); // terminate the application

129 else if ( e.getSource() == hourField ) {

130 t.setHour(

131 Integer.parseInt( e.getActionCommand() ) );

132 hourField.setText( "" );

133 }

134 else if ( e.getSource() == minuteField ) {

135 t.setMinute(


137 minuteField.setText( "" );

138 }

139 else if ( e.getSource() == secondField ) {

140 t.setSecond(


142 secondField.setText( "" );

143 }

144

145 displayTime();

146 }

147 }

148}

126 {125 public void actionPerformed( ActionEvent e )

Use a named inner class as the event handler. Class implements interface ActionListener, and must define actionPerformed.

Program Output


• Anonymous inner classes– Have no name

– Object created at time class defined

• Event handling with anonymous inner classes– Define the inner class inside the call to addActionListener

• Create an instance of the class inside the method call• addActionListener takes an object of class ActionListener


– new creates an object– ActionListener()

• Begins definition of anonymous class and calls default constructor

• Similar to public class myHandler implements ActionListener– Braces ( {} ) begin and end class defintion

24 hourField.addActionListener(

25 new ActionListener() { // anonymous inner class

26 public void actionPerformed( ActionEvent e )

27 {

28 t.setHour(


30 hourField.setText( "" );31 displayTime();32 }33 }34 );


– Enables use of close box (window closing event)• addWindowListener registers window event listener

• 7 methods need to be defined for interface WindowListener

• Adapter classes - already implement interfaces

– Extend adapter class and override methods want to define

• Adapter class "is a" WindowListener

82 TimeTestWindow window = new TimeTestWindow();84 window.addWindowListener(

85 new WindowAdapter() {86 public void windowClosing( WindowEvent e )

87 {


89 }

90 }

91 );


– new WindowAdapter()• Begins anonymous inner class that extends WindowAdapter• Similar to:

public class myHandler extends WindowAdapter {

82 TimeTestWindow window = new TimeTestWindow();84 window.addWindowListener(

85 new WindowAdapter() {86 public void windowClosing( WindowEvent e )

87 {


89 }

90 }

91 );

1. import

1.1 Class TimeTestWindow (extends JFrame)

1.2 Constructor

1.3 Initialze GUI

2. Event handler ( anonymous inner class)

1 // Fig. 9.13: TimeTestWindow.java2 // Demonstrating the Time class set and get methods3 import java.awt.*;4 import java.awt.event.*;5 import javax.swing.*;67 public class TimeTestWindow extends JFrame {8 private Time t;9 private JLabel hourLabel, minuteLabel, secondLabel;10 private JTextField hourField, minuteField,11 secondField, display;1213 public TimeTestWindow()14 {15 super( "Inner Class Demonstration" );1617 t = new Time();1819 Container c = getContentPane();2021 c.setLayout( new FlowLayout() );22 hourLabel = new JLabel( "Set Hour" );23 hourField = new JTextField( 10 );24 hourField.addActionListener(



27 {

28 t.setHour(


An object of an anonymous inner class is used as the event handler.

2. Event handler ( anonymous inner class)

30 hourField.setText( "" );

31 displayTime();

32 }

33 }

34 );

35 c.add( hourLabel );

36 c.add( hourField );

37

38 minuteLabel = new JLabel( "Set minute" );

39 minuteField = new JTextField( 10 );

40 minuteField.addActionListener(



43 {

44 t.setMinute(


46 minuteField.setText( "" );

47 displayTime();

48 }

49 }

50 );

51 c.add( minuteLabel );

52 c.add( minuteField );

53

54 secondLabel = new JLabel( "Set Second" );

55 secondField = new JTextField( 10 );

56 secondField.addActionListener(



Each button has a separate inner class as an event handler.

3. main

3.1 Create TimeTestWindow object

3.2 addWindowListener

59 {

60 t.setSecond(


62 secondField.setText( "" );

63 displayTime();

64 }

65 }

66 );

67 c.add( secondLabel );

68 c.add( secondField );

69

70 display = new JTextField( 30 );

71 display.setEditable( false );

72 c.add( display );

73 }

74

75 public void displayTime()

76 {

77 display.setText( "The time is: " + t );

78 }

79


81 {


83

84 window.addWindowListener(

85 new WindowAdapter() {

Use an anonymous inner class to handle window events.

Program Output

86 public void windowClosing( WindowEvent e )

87 {


89 }

90 }

91 );

92

93 window.setSize( 400, 120 );

94 window.show();

95 }

96 }

Notes on Inner Class Definitions

• Notes– Every class (including inner classes) have their

own .class file

– Named inner classes can be public, protected, private, or have package access

• Same restrictions as other members of a class

– To access outer class's this reference• OuterClassName.this

– Inner class can be static• Does not have access to outer class's non-static members

Notes on Inner Class Definitions

• Notes (continued)– To create an object of another class's inner class

• Create an object of outer class and assign it a reference (ref)

• Type statement of form:

OuterClassName.InnerClassName innerRef = ref.new InnerClassName();

Type-Wrapper Classes for Primitive Types

• Type wrapper classes– Each primitive data type has one

• Called Character, Byte, Short, Integer, Long, Float, Double, Boolean

– Manipulate primitive types like objects of class Object• Values can be processed polymorphically

– Declared final, so methods implicitly final• Cannot be overridden

– Numeric classes inherit from Number• Byte, Short, Integer, Long, Float, Double

– Many methods are static– Check documentation if manipulating primitive types

• Method you need may be defined

Documents

Object-Oriented Programming Outline Introduction Superclasses and Subclasses protected Members Relationship between Superclass Objects and Subclass Objects