Polymorphism

1

• Polymorphism

2
Upcasting revisited

• Taking an object reference and treating it as a
  reference to its base type is called upcasting
  because of the way inheritance trees are drawn
  with the base class at the top.

3
Forgetting the object type

• Why should anyone intentionally forget the type
  of an object?
• This is what happens when you upcast.
• It is nice if you could forget that there are
  derived classes, and write your code to talk only
  to the base class.

4
Method-call binding

• Connecting a method call to a method body is
  called binding. When binding is performed before
  the program is run (by the compiler and linker,
  if there is one), its called early binding.
• And the late binding means that the binding
  occurs at run time, based on the type of object.
• Late binding is also called dynamic binding or
  runtime binding.

5

• All method binding in Java uses late binding
  unless the method is static or final (private
  methods are implicitly final). This means that
  ordinarily you dont need to make any decisions
  about whether late binding will occurit happens
  automatically.

6

• Why would you declare a method final? As noted in
  the last chapter, it prevents anyone from
  overriding that method. Perhaps more important,
  it effectively turns off dynamic binding, or
  rather it tells the compiler that dynamic binding
  isnt necessary. This allows the compiler to
  generate slightly more efficient code for final
  method calls.
• However, in most cases it wont make any overall
  performance difference in your program, so its
  best to only use final as a design decision, and
  not as an attempt to improve performance.

7
Producing the right behavior

• send a message to an object and let the object
  figure out the right thing to do.
• you can write your code to talk to the base class
  and know that all the derived-class cases will
  work correctly using the same code.

8
Classic Shape Example

• The shape example has a base class called Shape
  and various derived types Circle, Square,
  Triangle, etc.

9
Extensibility

• Because of polymorphism, you can add as many new
  types as you want to the system without changing
  the method. In a well-designed OOP program, most
  or all of your methods will follow the model of
  this method and communicate only with the
  base-class interface.

10

• Such a program is extensible because you can add
  new functionality by inheriting new data types
  from the common base class.
• The methods that manipulate the base-class
  interface will not need to be changed at all to
  accommodate the new classes.

11
Example
12
Pitfall overriding private methods

• Only non-private methods may be overridden, but
  you should watch out for the appearance of
  overriding private methods, which generates no
  compiler warnings, but doesnt do what you might
  expect.
• To be clear, you should use a different name from
  a private base-class method in your derived
  class.

13
Pitfall fields and static methods

• For one thing, youll generally make all fields
  private and so you wont access them directly,
  but only as side effects of calling methods. In
  addition, you probably wont give the same name
  to a base-class field and a derived-class field,
  because its confusing.
• If a method is static, it doesnt behave
  polymorphically.

14
Constructors and polymorphism

• Constructors are different from other kinds of
  methods. This is also true when polymorphism is
  involved.
• Even though constructors are not polymorphic
  (theyre actually static methods, but the static
  declaration is implicit), its important to
  understand the way constructors work in complex
  hierarchies and with polymorphism

15
Order of constructor calls

• A constructor for the base class is always called
  during the construction process for a derived
  class, chaining up the inheritance hierarchy so
  that a constructor for every base class is
  called.
• This makes sense because the constructor has a
  special job to see that the object is built
  properly.

16

• A derived class has access to its own members
  only, and not to those of the base class (whose
  members are typically private). Only the
  base-class constructor has the proper knowledge
  and access to initialize its own elements.
• Therefore, its essential that all constructors
  get called otherwise the entire object wouldnt
  be constructed.

17

• It will silently call the default constructor if
  you dont explicitly call a base-class
  constructor in the derived-class constructor
  body.
• If there is no default constructor, the compiler
  will complain.

18

• When you inherit, you know all about the base
  class and can access any public and protected
  members of the base class.
• You must be able to assume that all the members
  of the base class are valid when youre in the
  derived class.
• The only way to guarantee this is for the
  base-class constructor to be called first. Then
  when youre in the derived-class constructor, all
  the members you can access in the base class have
  been initialized

19
Inheritance and cleanup

• If you do have cleanup issues, you must be
  diligent and create a dispose( ) method (the name
  I have chosen to use here you may come up with
  something better) for your new class.
• And with inheritance, you must override dispose(
  ) in the derived class if you have any special
  cleanup that must happen as part of garbage
  collection.

20

• When you override dispose( ) in an inherited
  class, its important to remember to call the
  base-class version of dispose( ), since otherwise
  the base-class cleanup will not happen.

21
Behavior of polymorphic methods inside
constructors

• If you call a dynamically-bound method inside a
  constructor, the overridden definition for that
  method is used.
• However, the effect of this call can be rather
  unexpected because the overridden method will be
  called before the object is fully constructed.
  This can conceal some difficult-to-find bugs

22
Actual process of initialization

• 1. The storage allocated for the object is
  initialized to binary zero before anything else
  happens.
• 2. The base-class constructors are called as
  described previously. At this point, the
  overridden draw( ) method is called (yes, before
  the RoundGlyph constructor is called), which
  discovers a radius value of zero, due to Step 1.
  
• 3. Member initializers are called in the order
  of declaration.
• 4. The body of the derived-class constructor is
  called.

23
Covariant return types

• Java SE5 adds covariant return types, which means
  that an overridden method in a derived class can
  return a type derived from the type returned by
  the base-class method.

24
Designing with inheritance

• Once you learn about polymorphism, it can seem
  that everything ought to be inherited, because
  polymorphism is such a clever tool. This can
  burden your designs.
• A better approach is to choose composition first,
  especially when its not obvious which one you
  should use.

25
Substitution vs. extension

• t would seem that the cleanest way to create an
  inheritance hierarchy is to take the pure
  approach. That is, only methods that have been
  established in the base class are overridden in
  the derived class.

26
Pure substitution
27

• This can be called a pure is-a relationship
  because the interface of a class establishes what
  it is. Inheritance guarantees that any derived
  class will have the interface of the base class
  and nothing less. If you follow this diagram,
  derived classes will also have no more than the
  base-class interface.
• This can be thought of as pure substitution

28

• That is, the base class can receive any message
  you can send to the derived class because the two
  have exactly the same interface.

29
Extension
30

• This can be termed an is-like-a relationship,
  because the derived class is like the base
  classit has the same fundamental interfacebut
  it has other features that require additional
  methods to implement

31
Downcasting and runtime type information

• to move back down the inheritance hierarchyyou
  use a downcast.
• There must be some way to guarantee that a
  downcast is correct, so that you wont
  accidentally cast to the wrong type and then send
  a message that the object cant accept. This
  would be quite unsafe

32

• in Java, every cast is checked. You get a
  ClassCastException if error occurred.
• This act of checking types at run time is called
  runtime type identification (RTTI).

33
Summary

• Polymorphism means different forms. In
  object-oriented programming, you have the same
  interface from the base class, and different
  forms using that interface the different
  versions of the dynamically bound methods.
• To use polymorphismand thus object-oriented
  techniqueseffectively in your programs, you must
  expand your view of programming to include not
  just members and messages of an individual class,
  but also the commonality among classes and their
  relationships with each other.