Title: POLYMORPHISM
1POLYMORPHISM
- Quick Look Back at Inheritance
- Polymorphism
- Defined
- The Key to OOP
- The Big Payoff the Generic Button
- Trade-offs
- Partial Overriding
2Quick Look Back at Inheritance
- Remember the inheritance of private instance
variables? - Weve seen that idea before!
- just like public and private properties!
- what can the subclass access in the diagram on
next slide? - what cant it access?
3Quick Look Back at Inheritance
public method of superclass
protected method of superclass
private methods and private instance variables of
superclass
public method of superclass
public abstract method of superclass
public instance variable of superclass
protected instance variable of superclass
4Quick Look Back at Inheritance
- Remember that, when a class provides public
methods, those methods can alter private data! - similarly, inherited methods can alter private
data of the superclass - therefore we do pseudo-inherit private
properties because the normally inherited methods
might need to access them!
5A Contrived Example
- So when we construct an instance of SubMobile, it
makes a new City instance to pass to its
superclasss constructor. - SuperMobile takes that City instance and uses it
to instantiate a ICS111Mobile. - Then our instance of SubMobile calls move(),
which it inherits. - This method uses the superclasss private
instance mobile, so we must have inherited it!
6Polymorphism
- Remember Inheritance lecture
- SportsCar, Van, and ICS111Mobile are all
subclasses of the Car class - Car has an abstract move() method that each of
its subclasses define - however, each of its subclasses defines this
method differently - Thus each subclass responds to move() differently
7Polymorphism
8Polymorphism
- What happens when we
- tell SportsCar to move()?
- (moves fast)
- tell Van to move()?
- (moves at a moderate speed)
- tell ICS111Mobile to move()?
- (sometimes moves, sometimes just sputters along!)
9Polymorphism Defined
- Polymorphism is a fancy word for multiple
forms, - e.g., multiple forms of response to the same
message - Key points about Polymorphism
- subclass inherits methods from superclass, it
responds to the same messages - we can use an instance of subclass as if it were
instance of superclass - Car car // Declaration
- car new Van ()// Instantiation
- object will respond according to implementation
defined in subclass
10Polymorphism Defined
- Key points about Polymorphism
- assignment does NOT create an instance of Car,
since new Car() is illegal, because Car is
abstract. It is a Car, but not an instance of
Car! - car.move() //will move like a Van, though we
refer to it as a Car! - Car is declared type, while Van is actual
type - we can only call Car methods on car since Java
determines which methods can be called by looking
at the declared type, i.e. Car - we cannot assign a superclass instance to a
variable of subclass type because superclass
instance does not know all the declared subtypes
methods
11- / A simple example of Polymorphism. /
- public class RaceTrack
- private Car carOne, carTwo, carThree /they're
all declared as Cars!/ - public RaceTrack ()
- carOne new SportsCar ()
- carTwo new Van ()
- carThree new ICS111Mobile ()
- // but actual types are subtypes of Car
-
- public void startRace() /tell Car instances to
move/ - carOne.move ()
- carTwo.move ()
- carThree.move ()
- / Note move() called as if all were Cars,
but - executed polymorphically on instances of
- subtypes/
-
12Polymorphism The Key to OOP
- When a sending message to an instance, we do not
need to know its exact class... - as long as it is a subclass that extends a
superclass, can send the subclass any message
that we can also send to the subclasss
superclass - but message may be handled differently by
different subclasses, so we may get different
results
13Polymorphism The Key to OOP
- Classic example shapes
- each shape subclass knows how to draw itself, but
all do it differently simply say shape.draw() - See ShapesFrame.java
- public class Shapes
- private Shape shape1 new Triangle()
private Shape shape2 new Square () - public void drawShapes () shape1.draw
() shape2.draw () -
- public static void main(String args)
- new Shapes().drawShapes()
-
-
14Example Adding a new Shape
- Pressing a button will draw a different shape
- RightTriangle, Square, Circle
- See file DrawShapeButtonFrame.java
- What if we added a new Shape subclass?
- Would we need to make a new DrawShapeButton for
each Shape subclass? - By using polymorphism, we can add as many Shape
subclasses as we want, without having to create a
new DrawShapeButton for each subclass!
15The Big Payoff of Polymorphism the Generic Button
- / This button draws any instance of Shape.
Since this class is written generically, we don't
need to recompile it if we add more shapes and
buttons / - class DrawShapeButton extends RoundedRectangle
- private Shape shape
- public DrawShapeButton(Shape shape)
- this.shape shape
-
- public voidmouseReleased(MouseEvent e)
- shape.draw()
-
declared type is a generic parameter! Caller
passes in an instance of a specific actual type
(not to be confused with actual parameter,
which it also is). The declared type may be
abstract, but the actual type must be concrete,
as it must be instantiated.
16More about DrawShapeButton
- DrawShapeButton doesnt know a Square from a
RightTriangle, but it works correctly because it
just expects any instance of Shape - a subclass of Shape may not even be written until
after DrawShapeButton has been compiled! - This is very general way to code
- we can write code that deals only with superclass
(whether concrete or abstract) - we can add new subclass and all code that uses
superclass still works - no need to change existing code!
17More about DrawShapeButton
- Java compiler helps enforce this generality
- we can only use objects that are Shape with
DrawShapeButton, otherwise code would not compile
- DrawShapeButton doesn't care about the actual
type of the instance, as long as it's a Shape - allows many objects, possibly written by
different people or at different times, to
respond to the same message in very different
ways - you "code to" public "interface", not private
implementation
18Example New Shape Application
- To make three buttons, each of which moves a
different Shape, just instantiate three
DrawShapeButton and pass each a different Shape! - public class DrawShapeButtonFrame extends Frame
- private Shape shape1 new RightTriangle(.
. .) - private Shape shape2 new Square(. . . )
- private Shape shape3 new Circle(. . . )
- private DrawShapeButton button1, button2,
button3 - public DrawShapeButtonFrame()
- button1 new DrawShapeButton(100, 400,
shape1) - button2 new DrawShapeButton(300, 400,
shape2) - button3 new DrawShapeButton(500, 400,
shape3) -
- public static void main (String
arguments) - new DrawShapeButtonFrame()
-
-
19Trade-offs of Polymorphism
- Type of variable limits which messages it can be
sent - only messages defined by superclass
- if subclass defines additional methods, they
can't be called directly on a reference to
superclass - In a minor way, this limits our flexibility
- if Circle has a method getRadius() not defined in
Shape, we can't use a generic Shape to call
shape.getRadius() - why? Because all we know what a Shape can do is
in its definition
20Trade-offs of Polymorphism
- But polymorphism also provides us with extra
options - code is the same no matter which subclass of
Shape is actually instantiated - to make a new subclass of Shape work, we dont
need to revise, rewrite or debug methods that are
in the Shape class already huge payoff of OOP!
21Class Exercise
- Create a new shape
- Add the class to file ShapesFrame.java
- For example, an isosceles right triangle
- Add a new button
- Add the button to DrawShapeButtonFrame.java
- Note that we do not have to create a new button
class, as the class DrawShapeButton can reference
(point to) any instance that is a subclass of
Shape
22Partial Overriding
- / Models a version of the ICS111Mobile that
holds clowns in order to demonstrate new idea
partial overriding. / - public class CrazyMobile extends ICS111Mobile
- private BandOfClowns clowns
- public CrazyICS111Mobile(BandOfClowns clowns)
- this.clowns clowns
-
- public void move ()
- clowns.pileIntoCar ()
- super.move ()
- clowns.pileOutOfCar ()
-
23Partial Overriding
- Remember that overriding allows us to replace
superclass definition of method - Partial overriding overrides superclass method
in part - reusing superclass method rather than completely
replacing it - calls superclass method with the same name using
super, plus providing additional code
24Partial Overriding
- public void move ()
- // add some extra functionality
- clowns.pileIntoCar ()
- / We want to move like the superclass moves,
so we call superclass's move() method. No need
to repeat code that is already written in
ICS111Mobile's move() method!/ - super.move ()
- // add some more functionality
- clowns.pileOutOfCar ()
- // end of move()
25Partial Overriding
- super.move() can be called more than once
- super.move() can even be called in another method
- But we can use only overridden methods from
immediate superclass super.super.move() doesn't
work! - Alert what happens here if we call this.move()
instead of super.move()? - Exception in thread "main" java.lang.StackOverflo
wError
26Polymorphism can be tricky
- Lets say that class Garage has following method
- public void storeCar(ICS111Mobile car)...
- . . . and we construct a local variable with
declared type Car and actual type
ICS111MobileCar niceCar new
ICS111Mobile()garage.storeCar(niceCar)//error
27Polymorphism can be tricky
- We cannot pass our niceCar variable into
storeCar() - niceCar, as a Car, doesnt have all of
ICS111Mobiles methods available, hence a
parameter type mismatch - This is the corrected code
- ICS111Mobile niceCar new ICS111Mobile()
- garage.storeCar(niceCar)
28Polymorphism can be tricky
- Declared type of actual parameter must be same
class (or subclass) of declared type of formal
parameter - Car (declared type of actual parameter) is
superclass of ICS111Mobile (declared type of
formal parameter) . . . so wont work!
29Class Exercise
- Whats the output?
- See Tracing.java
- A similar problem will be on the next exam
30Example Code
- Check out the SketchApplication files
- SketchApplication contains classes Cursor
DrawButton - See class websites Example Code link
- Class Cursor contains class Point
- Class DrawButton has 4 subclasses
- UpButton, DownButton, LeftButton, RightButton
- This is an example of polymorphism
- Depending on what type of DrawButton we click
(i.e., UpButton, DownButton), the line will move
up, down, etc.