Java Object Oriented Programming Encapsulation, Inheritance, Polymorphism (Java: An Eventful...
-
Upload
hope-gardner -
Category
Documents
-
view
246 -
download
0
Transcript of Java Object Oriented Programming Encapsulation, Inheritance, Polymorphism (Java: An Eventful...
JavaObject Oriented Programming
Encapsulation, Inheritance, Polymorphism(Java: An Eventful Approach - Ch. 17, 21.7),
Slides Credit: Bruce, Danyluk and Murtagh
CS 120 Lecture 20
27 November 2012
2
Shared Features
• Common to define classes that share features– FilledRect and FramedRect
• Desirable to let classes with common features and behaviors share code– saves programmer time– improves code reliability
3
Inheritance
• mechanism that provides means to share code in related classes
• already familiar...sort of– classes that extend WindowController
• inherit variables and other features from WindowController
• canvas, getContentPane(), and others defined in WindowController class
4
Extension as Specialization• a class that extends another is a subclass• a class that is extended is a superclass• inheritance describes relationship between a
subclass and superclass– subclass inherits features from superclass it extends
– subclass will include every method and instance variable in superclass
– subclass may also include new features
• subclass like the superclass- but more special or specialized
5
An Interactive Card Game
Note the small framed display areas in this game interface
6
Framed Displays
current score “lives remaining”
time remaining start message
7
Design Choices
• Could define independent class for each category of frame
or
• Better:– define class describing empty frame– extend it to define classes of specialized
frames
8
Using extends
• Say we want to display text in a frame
• A FramedText class– if written from scratch, would repeat much
of FramedDisplay– define as an extension of FramedDisplay
9
public class FramedText extends FramedDisplay
• extends FramedDisplay– tells Java to include all instance variables and
methods from FramedDisplay in FramedText– no need to redefine in new class
• add what we need to manipulate Text object displayed in frame
10
Subclass Constructors
• often want to– inherit behavior of superclass constructor– but also do more
• write new constructor– begin with special instruction to invoke constructor
of superclass
ex. super( x, y, width, height, canvas );– add statements to perform additional work desired
11
super• an invocation of super can only appear as
first command in a constructor’s body• if invocation of super not included, Java
inserts
super(); automatically
Note: Will result in error if class being extended has no parameterless constructor
12
Methods of subclasses can be used in the usual way.
If we haveprivate FramedText welcome;
and executewelcome = new FramedText( “Hello”, 20, 20, 100, 30, canvas );
can legally execute
welcome.setTextSize( 24 );
and
welcome.highlight();
13
Access Control
• public- can be accessed in other classes• private
– only accessible within class in which defined– restriction applies even for subclasses; private
name defined in superclass cannot be accessed in subclass
• protected– accessible in classes that extend the one in which
name defined
14
Designing for Extension• easy to imagine designing subclasses of
FramedDisplay that will require info about– dimensions of parts of frame– locations of parts of frame
• in designing interface for a class, must consider– what methods would be helpful to objects outside of the
class– what would be useful to those extending the class
• prefer protected accessor methods to protected variables– access to protected variables (if not final) allows changes
that can lead to errors
15
Inheritance Hierarchies
• Implement a FramedCounter class– display value of a counter (as in FramedText)– include an increment method
• FramedCounter inherits features from FramedText– includes features that FramedText inherits from
FramedDisplay
16
// A FramedCounter object displays a numeric counter on// a background framed by a distinct borderpublic class FramedCounter extends FramedText {
private int counter = 0; // Current value of counter
// Create a FramedCounter object displaying 0// at the position and with the dimensions specifiedpublic FramedCounter( double x, double y, double width,
double height, DrawingCanvas canvas ) {super( “0”, x, y, width, height, canvas );
}
// Increase the counter’s value and update displaypublic void increment( int amount ) {
counter = counter + amount;message.setText( counter );positionContents();
}}
17
Subclasses and Superclasses
• A is a superclass of B if– B extends A or– B extends C and A is a superclass of C
• B is a subclass of A if– B extends A or– B extends C and C is a subclass of A
18
Subclass Type Compatibility
• Can assign an object to a variable as long as type of object is either– same as type of variable or– a subclass of the variable type
19
Assume these variable definitions
FramedDisplay someFrame;FramedText someText;FramedCounter someCounter;
The following assignments are legal:
someFrame = new FramedDisplay( ... );someFrame = new FramedText( ... );someFrame = new FramedCounter( ... );someText = new FramedText( ... );someText = new FramedCounter( ... );someCounter = new FramedCounter( ... );
20
Assuming the variable definitions:
FramedDisplay someFrame;FramedText someText;FramedCounter someCounter;
The following are also legal:
someFrame = someText;someFrame = someCounter;someText = someCounter;
21
Parameter Compatibility
• Same rules apply
• Actual parameter compatible with formal parameter as long as– its type is same as type of formal
parameter or– its type is a subclass of the formal
parameter type
22
Assuming the variable definitions:
FramedDisplay someFrame;FramedText someText;FramedCounter someCounter;
And a collection class with method:
public void addFrame( FramedText someText ) { ...
the following are legal for an object of the collection type
scoreDisplays.addFrame( someText );scoreDisplays.addFrame( someCounter );
23
what about
someCounter = someFrame;someText = someFrame;
and
scoreDisplays.addFrame( someFrame );
24
what about
someCounter = someFrame;someText = someFrame;
andscoreDisplays.addFrame( someFrame );
All Illegal
25
Checking Types• Consider
someFrame = new FramedCounter( ... );someCounter = someFrame;someText = someFrame;scoreDisplays.addFrame( someFrame );
• last 3 lines still considered illegal by Java.• If programmer confident variable of correct type can introduce
type castsomeCounter = (FramedCounter) someFrame;
• To ensure type cast can be doneif ( someFrame instanceof FramedCounter ) {
someCounter = (FramedCounter) someFrame}
26
Overriding Method Definitions
• Sometimes need to change behavior of methods in superclass for proper functionality in subclass.– define method in body of subclass with
same name– new method is said to override the original
method.
27
The Object Class
• Java class Object is a superclass of all Java classes
• All classes inherit certain methods from Object– equals: version defined in Object compares
using == ; can override to tailor behavior of equals for a class
– toString: returns a String describing the object on which it is invoked; often useful to override.
28
Accessing Overridden Methods
• sometimes want to extend- not totally change- steps performed by a method in a superclass.
• super as a means to access an overridden method from within a subclass
29
Using super
Say we have added a move method to FramedDisplay
// Move the parts of the framed display by offsetspublic void move( double xoff, double yoff ) {
border.move( xoff, yoff );body.move( xoff, yoff );
}
Can override this method in FramedText as follows:
// Move the display by specified offsetspublic void move( double xoff, double yoff ) {
super.move( xoff, yoff ); // Move the body and borderpositionContents();
}
30
Can refer to any nonprivate method of a superclass with
“super.methodname”in the definition of a subclass
31
Dynamic Method Invocation
Say we declare
private FramedDisplay someFrame;and later execute
someFrame = new FramedText( “Follow me”, 50, 50, 80, 25, canvas );someFrame.move( 100, 50 );
Which version of move is executed?– the version in FramedDisplay?– the version in FramedText?
32
Dynamic Method Invocation
Say we declare
private FramedDisplay someFrame;and later execute
someFrame = new FramedText( “Follow me”, 50, 50, 80, 25, canvas );someFrame.move( 100, 50 );
Which version of move is executed?– the version in FramedDisplay?– the version in FramedText
33
• Java invokes the version of a method associated with an object’s class regardless of the type of name through which it is accessed
• process of identifying correct method is called dynamic method invocation
34
A More Complex ExampleSay we define moveTo in FramedDisplaypublic void moveTo( double x, double y ) {
this move( x - border.getX(), y - border.getY() );}
• Java interprets this dynamically• invocation refers to move method of this, the object
whose moveTo was invoked
If we executeFramedText welcomeMessage = new FramedText( “Click to begin”,... );welcomeMessage.moveTo( centerX, centerY );
move in FramedText is used
35
Design Suggestions• Sometimes useful to define a method of a
superclass with the expectation it will be overridden
• Consider adding the following to FramedDisplay– move, as before– setWidth, setHeight
Subclasses will need to override all of these for correct functionality
36
Better Design• Define positionContents method in FramedDisplay:
protected void positionContents( ) {}
• Define move as:// Move the parts of the framed display by offsetspublic void move( double xoff, double yoff ) {
border.move( xoff, yoff );body.move( xoff, yoff );positionContents();
}• If setWidth and setHeight defined similarly, only
positionContents needs to be overridden in subclasses
37
Abstract Classes and Methods
• Abstract class– provides base for defining useful subclasses
– not useful by itself
• We defined positionContents in FramedDisplay to ensure that subclasses of FramedDisplay would define it
• Unsatisfying to define an empty method• Could replace definition of positionContents with
abstract protected void positionContents() ;and make class abstract
public abstract class FramedDisplay { ...
38
• Given the description of a problem,– how do you determine what classes to
define?– how do you design each class?
• Need a design methodology
Object-Oriented Design
39
Object-Oriented Design
• Often software mimics the real world
• Decompose problem into objects– identify properties and behaviors– model in software
40
Abstraction
• An object provides an abstraction– can use without knowing details of its
implementation– abstract away details; understand at higher level
• Follows from our use of objects in real world– can use a stopwatch without knowing exactly how
it works
• Well-designed classes provide good abstractions.
41
Encapsulation
• notion of taking variables and data structures and wrapping them inside a class definition
Information Hiding
• notion of hiding details of implementation as much as possible
• Eg. Users of our Triangle class don’t need to know HOW it stores the triangle.
42
Why Important?• protects variables from being modified
inappropriately by other classes
• can present classes to others for use by simply specifying interface
ex. You used objectdraw library without knowing any implementation details!
• can change details of class definition without affecting those using it.
43
Writing Comments• Each class should have a class comment
– Description of class– Author’s name and date
• Each constant and variable should be commented– describe purpose (what, not how!)– parameters– return value, if any
• For long/complex methods– include comments in method– explain what is happening– balance clarity and brevity
Student To Do’s• HW10
– Green Screen program.
– Review Lab 10 to get started.
– There is a grading criteria, check it!• Includes both style and commenting
– Try to get your web page online.
• Java Project – – Due 12/12
• Practice examples on your own!
44