Lecture 11: Polymorphism and Dynamic Binding

1
Lecture 11 Polymorphism and Dynamic Binding

• Polymorphism
• Static (compile-time) binding
• Dynamic (run-time) binding

2
Polymorphism

• A fundamental feature of OOP
• Greek for many shapes
• Idea one abstract operation is implemented
  differently for different classes
• Example toString method
• x.toString() calls different implementations of
  the toString method depending on whether x is an
  object reference of class Object, String, Date,
  Time, etc
• aside toString is called by System.out.println(x)
  when x is an object reference
• in other words, System.out.println(x) has the
  same effect as System.out.println(x.toString())

3
The Words Static and Dynamic

• These words are opposites
• Static means fixed, unchanging
• Dynamic means changing with time
• Static variable of a class value does not depend
  on individual objects (instances) of a class
• Static method of a class effect does not depend
  on individual objects (instances) of a class
• Static binding (this term not used by text)
  binding a method call to the right method
  implementation at compile time
• Dynamic binding (this term is used by text)
  binding a method call to the right method
  implementation at run time

4
Static (Compile-Time) Binding

• Binding a method call to the right method
  implementation at compile-time
• This is possible for static methods because it
  depends only on matching the argument types to
  the method signature
• NOT POSSIBLE for instance methods, because at
  compile-time we only know the type of the object
  reference, NOT the actual class of the object
  instance

5
Example

• Object o new Time()
• Date d new Time()
• Time t new Time()
• System.out.println(o.toString())
• System.out.println(d.toString())
• System.out.println(t.toString())
• Which toString is called?
• Does it know which one to call at compile time,
  or only at run time?

6
Dynamic Binding

• Used for instance methods
• Actual class of object is not known at compile
  time, only at run time
• Then, binding of method call to the right
  implementation of the method takes place, based
  on the class of the implicit parameter object
• Which method is called when o.toString() is
  executed does not depend on type of the object
  reference o, but on the actual class of the
  object that it points to
• When execution takes place, the JVM looks for a
  matching method in that class. If there isnt
  one, it looks in the superclass, and so on.if
  there are none in the inheritance tree below
  Object, it will use the toString method in the
  Object class

7
What about the Explicit Parameters?

• The method binding does not depend on the class
  of any object that is passed as an explicit
  parameter!
• Thus, which implementation of x.equals(y) is
  called
• depends on the class of the object instance that
  the implicit parameter x points to
• does not depend on the class of the object
  instance that the explicit parameter y points to
• However, the method signatures must match!

8
Matching the Method Signatures

• Consider x.equals(y)
• Which method is called depends on the actual type
  of the object instance that x points to
• However, the only candidates are methods whose
  signature matches the object reference type of y
• These are the ones with a formal parameter whose
  type is the same class or a subclass, but not a
  superclass
• If none match, there is a compile-time error

9
Example

• class Date
• public boolean equals(Date other)
• return (this.year other.year
• this.month other.month
• this.day other.day)
• Object o new Date(2006,10,18)
• Date d new Date(2006,10,18)
• System.out.println(d.equals(o))// no matching
  signature
• System.out.println(o.equals(d))// more subtle

10
Overriding a Method in a Superclass

• Method in superclass is overridden ONLY if
  signature matches
• To override the equals method in the Object
  class, we must specify that the explicit
  parameter has type Object
• Then inside the method code, we must CAST this to
  the actual type of the object before we use it

11
The instanceof operator

• note not instanceOf
• x instanceof y returns true if the object that x
  points to is an instance of class y, and false
  otherwise
• good idea to use it inside any method such as
  Date that overrides the equals method of the
  Object class, checking whether the explicit
  parameter really is an instance of the right
  class before casting it (otherwise an error will
  be generated)
• equals should return false if the actual
  parameter object is an instance of the wrong class

12
Now what happens?

• Object o new Date(2006,10,18)
• Date d new Date(2006,10,18)
• Time t new Date(2006,10,18,11,0,0)
• o.equals(d)
• d.equals(o)
• o.equals(t)
• t.equals(o)
• etc.