Java Object-Oriented Programming potx

1
 2000 Prentice Hall, Inc. All rights reserved.
Java Object-Oriented Programming
Outline
1 Introduction
2 Superclasses and Subclasses
3 protected Members
4 Relationship between Superclass Objects and Subclass Objects
5 Implicit Subclass-Object-to-Superclass-Object Conversion
6 Software Engineering with Inheritance
7 Composition vs. Inheritance
8 Introduction to Polymorphism
9 Type Fields and switch Statements
10 Dynamic Method Binding
11 final Methods and Classes
12 Abstract Superclasses and Concrete Classes
13 Polymorphism Example
14 New Classes and Dynamic Binding
15 Case Study: Inheriting Interface and Implementation
16 Case Study: Creating and Using Interfaces
17 Inner Class Definitions
18 Notes on Inner Class Definitions
2
 2000 Prentice Hall, Inc. All rights reserved.
1. Introduction
•
Object-Oriented Programming (OOP)
–
Inheritance - form of software reusability
•
New classes created from existing ones

•
Absorb attributes and behaviors, 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 hierarchy
–
Polymorphism
•
Write programs in a general fashion to handle a wide variety
of classes
–
Abstraction - seeing the big picture
3
 2000 Prentice Hall, Inc. All rights reserved.
1 Introduction (II)
•
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
4
 2000 Prentice Hall, Inc. All rights reserved.
2 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)
5
 2000 Prentice Hall, Inc. All rights reserved.
2 Superclasses and Subclasses (II)
•
Using inheritance
–
Use keyword extends
class 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

6
 2000 Prentice Hall, Inc. All rights reserved.
3 protected Members

•
In a superclass
–
public members
•
Accessible anywhere program has a reference to a superclass
or subclass type
–
private members
•
Accessible 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
7
 2000 Prentice Hall, Inc. All rights reserved.
4 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
8
 2000 Prentice Hall, Inc. All rights reserved.
4 Relationship between Superclass
Objects and Subclass Objects (II)
•
Overriding methods

–
Subclass can redefine superclass method
•
When method mentioned in subclass, subclass version used
•
Access original superclass method with super.methodName
–
To invoke superclass constructor explicitly (called implicitly by
default)
•
super(); //can pass arguments if needed
•
If called explicitly, must be first statement
•
Every Applet has used these techniques
–
Inheritance concept formalized
–
Java implicitly uses class Object as superclass for all classes
–
We have overridden init and paint when we extended
JApplet
 2000 Prentice Hall, Inc. All rights reserved.
Outline
1. Point definition
1.1 Data members
1.2 Constructors
1.3 Methods
1 // Fig. 27.3: Point.java
2 // Definition of class Point

3
4 public class Point {
5 protected int x, y; // coordinates of the Point
6
7 // No-argument constructor
8 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; }
30
 2000 Prentice Hall, Inc. All rights reserved.
Outline

1.2 Methods

1. Circle Definition
1.1 extends Point
1.2 Multiple
constructors
38 // Fig. 27.3: Circle.java
39 // Definition of class Circle
40
41 public class Circle extends Point { // inherits from Point
42 protected double radius;
43
44 // No-argument constructor
45 public Circle()
46 {
47 // implicit call to superclass constructor occurs here
48 setRadius( 0 );
49 }
50
51 // Constructor
52 public Circle( double r, int a, int b )
53 {
54 super( a, b ); // call to superclass constructor
55 setRadius( r );
56 }
57
58 // Set radius of Circle
59 public void setRadius( double r )
60 { radius = ( r >= 0.0 ? r : 0.0 ); }
31 // get y coordinate

32 public int getY() { return y; }
33
34 // convert the point into a String representation
35 public String toString()
36 { return "[" + x + ", " + y + "]"; }
37 }
37 }
 2000 Prentice Hall, Inc. All rights reserved.
Outline
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
69 public String toString()
70 {
71 return "Center = " + "[" + x + ", " + y + "]" +
72 "; Radius = " + radius;
73 }
74 }
 2000 Prentice Hall, Inc. All rights reserved.
Outline
1. Initialize objects
2. Refer to a subclass
object with a

superclass reference
2.1 toString
2.2 Downcast
2.3 toString
75 // Fig. 27.3: InheritanceTest.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 );
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
95 pointRef = c; // assign Circle to pointRef
96
97 output += "\n\nCircle c (via pointRef): " +
98 pointRef.toString();
99
100 // Use downcasting (casting a superclass reference to a

101 // subclass data type) to assign pointRef to circleRef
102 circleRef = (Circle) pointRef;
103
104 output += "\n\nCircle c (via circleRef): " +
105 circleRef.toString();
 2000 Prentice Hall, Inc. All rights reserved.
Outline
2.4 Print area
3. if statement
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
113 if ( p instanceof Circle ) {
114 circleRef = (Circle) p; // line 40 in Test.java
115 output += "\n\ncast successful";
116 }
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 }

 2000 Prentice Hall, Inc. All rights reserved.
Outline
Program Output
15
 2000 Prentice Hall, Inc. All rights reserved.
5 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
16
 2000 Prentice Hall, Inc. All rights reserved.
6 Software Engineering with Inheritance
•
Inheritance
–
Customize existing software
•
Create a new class, add attributes and behaviors as needed
•
Software reuse key to large-scale projects
–
Java and OOP does this
–
Availability of class libraries and inheritance
•
Superclass
–
Specifies commonality
–
Look for commonality among a set of classes
•
"Factor it out" to form the superclass
–
Subclasses are then customized
17
 2000 Prentice Hall, Inc. All rights reserved.
7 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
18
 2000 Prentice Hall, Inc. All rights reserved.
8 Introduction to Polymorphism
•
With polymorphism
–
Write extensible programs
–
Generically process superclass objects
–
Easy to add classes to hierarchy
•
Little or no modification required
•
Only parts of program that need direct knowledge of new class
must be changed
19
 2000 Prentice Hall, Inc. All rights reserved.
9 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
20
 2000 Prentice Hall, Inc. All rights reserved.
10 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
21
 2000 Prentice Hall, Inc. All rights reserved.
11 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
22
 2000 Prentice Hall, Inc. All rights reserved.
12 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 define constructor
–
Too generic to define real objects
–

Declare class with keyword abstract
•
Concrete class
–
Can instantiate objects
–
Provide specifics
•
Class hierarchies
–
Most general classes are usually abstract
•
TwoDimensionalShape - too generic to be concrete
23
 2000 Prentice Hall, Inc. All rights reserved.
13 Polymorphism Example
•
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
•
Can use same superclass array as before - "fits right in"
24
 2000 Prentice Hall, Inc. All rights reserved.
13 Polymorphism Example (II)
•
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
25
 2000 Prentice Hall, Inc. All rights reserved.
13 Polymorphism Example (III)
•
Iterator classes
–
Walks through all the objects in a container (such as an
array)
–
Used in polymorphic programming
•
Walk through an array of superclass references
•
Call draw method for each reference