- Concepts of Programming Languages

Inheritance and Dynamic Dispatch

Instructor:

Learning Objectives

How do we support code sharing between classes?

What should happen when methods have the same name?

• Identify classes and inheritance
• Describe the difference between static and dynamic dispatch

Scala: Which toString?

• What is the type of x? Which toString is invoked?

class Animal              { override def toString () = "Animal" }
class Bird extends Animal { override def toString () = "Bird" }
class Cat  extends Animal { override def toString () = "Cat" }
val xs = Array[Animal] (new Bird(), new Cat ())
for (x <- xs) println (x.toString())

Java: Which toString?

• What is the type of x? Which toString is invoked?

class Animal              { public  String toString () { return "Animal"; } }
class Bird extends Animal { public  String toString () { return "Bird"; } }
class Cat  extends Animal { public  String toString () { return "Cat"; } }
Animal[]  xs = { new Bird(), new Cat () };
for (Animal  x : xs) System.out.println (x.toString());

C++: Which toString?

• What is the type of x? Which toString is invoked?

class Animal              { public: string to_string() { return "Animal"; } };
class Bird: public Animal { public: string to_string() { return "Bird"; } };
class Cat:  public Animal { public: string to_string() { return "Cat"; } };
Animal *xs[] = { new Bird(), new Cat() };
for (Animal *x : xs) cout << x->to_string() << endl; 

C++: Which toString?

• What is the type of x? Which toString is invoked?

class Animal              { public: virtual string to_string() { return "Animal";
class Bird: public Animal { public: virtual string to_string() { return "Bird"; }
class Cat:  public Animal { public: virtual string to_string() { return "Cat"; } 
Animal *xs[] = { new Bird(), new Cat() };
for (Animal *x : xs) cout << x->to_string() << endl; 

• C++ dynamically dispatches virtual methods only when object accessed with a pointer/reference

C++: Which toString?

• What is the type of x? Which toString is invoked?

class Animal              { public: virtual string to_string() { return "Animal";
class Bird: public Animal { public: virtual string to_string() { return "Bird"; }
class Cat:  public Animal { public: virtual string to_string() { return "Cat"; } 
Animal  xs[] = {     Bird(),     Cat() };
for (Animal  x : xs) cout <<  x.to_string() << endl; 

• Truncated object, stored in place: C++ truncates the object, coercing to parent class

Which Object?

• Which object are we accessing when invoking g() and f(x-1) in line 4?

val x: A = new A()
x.f(2);

• The object referenced by x; what is its explicit name inside class A?

Which Object: this

• What are the static and dynamic types of this?

val x: A = new A()
x.f(2)

• Reference this has
  • static type of enclosing class (here: A)
  • dynamic type of object (here: A)

Static and Dynamic Type of this

• What are the static and dynamic types of x and this?

val x: B = new B()
x.f(2)

• x has static type B, dynamic type B
• this (line 4) has static type A, dynamic type B

Static and Dynamic Type of this

• What are the static and dynamic types of x and this?

class A:
  def f(x: Int) =
    println(s"A.f($x)")
    if x == 0 then this.g() else this.f(x - 1)
  def g() = println("A.g()")
class B extends A:
  def f(x: Int) = { println(s"B.f($x)"); this.f(x) }
  def g()        = println("B.g()")

val x: A = new B()
x.f(1)

How to Access Method in Super-Class?

• Access A.f with super

class A:
  def f(x: Int) =
    println(s"A.f($x)");
    if x == 0 then this.g() else this.f(x - 1)
  def g() = println("A.g()")
class B extends A:
  def f(x: Int) = { println(s"B.f($x)"); super.f(x) }
  def g()       = println("B.g()")

val x: A = new B ()
x.f(1)

B.f(1) // x.f
A.f(1) // super.f
B.f(0) // this.f
A.f(0) // super.f
B.g()  // this.g

Code Modularity and Reuse

class A:
  def f(x: Int) =
    println(s"A.f($x)")
    if x == 0 then g() else f(x - 1)
  def g() = 
    println("A.g()")

class B extends A:
  def f(x: Int) =
    println(s"B.f($x)") 
    super.f(x)
  def g() = 
    println("B.g()")

def f(a: A, x: Int) = a match
  case _: B =>
    println(s"B.f($x)") 
    fbase(a, x)
  case _ =>
    fbase(a, x)
def fbase(a: A, x: Int) =
  println(s"A.f($x)")
  if x == 0 then g(a) else f(a, x - 1)
def g(a: A) = a match
  case _: B => println("B.g()")
  case _    => println("A.g()")

Document and Check Inheritance

Let programmers specify how classes can be instantiated?
Let programmers decide which methods can/must/cannot be overridden?

abstract class A:
  def f(x: Int) = // ...
  def g() = // ...

val x: A = new A()

abstract class A:
  def f(x: Int) = // ...
  def g() : Unit // abstract method

class B extends A

abstract class A:
  final def f(x: Int) = // ...
  def g() : Unit

class B extends A:
  override def f(x: Int) = // ...
  override def g() = // ...

Use Case: Design Pattern Template Method

Defines the skeleton of an algorithm, deferring varying steps to subclasses

• Factor common behavior into a base class to avoid code duplication
• Implement algorithm structure once, varying behavior in subclasses

abstract class AbstractClass {
  public final void templateMethod() {
    step1();
    operation1();
    step2();    
  }
  protected abstract void operation1();
  private void step1() { /* ... */ }
  private void step2() { /* ... */ }
}
class ConcreteClass extends AbstractClass {
  @override
  protected void operation1() { /* ... */ }
}

Summary

• Inheritance: links classes statically at compile time

• Design patterns often provide object-oriented solutions of functional paradigms
• GoF: Favor object composition over class inheritance
• See Design Patterns, Design Pattern Catalog, and Design Principles

Static and Dynamic Types

interface Fn { int apply (int x); }

Fn[] fs = new Fn[2];
for (int i = 0; 
     i < fs.length; 
     i++) {
  int j = i + 1;
  fs[i] = x -> x + j; 
}

Fn[] fs = new Fn[2];
for (int i = 0; 
     i < fs.length; 
     i++) {
  int j = i + 1;
  fs[i] = new Fn() { 
    int apply (int x) { 
      return j + x; 
    } 
  }
}

Fn[] fs = new Fn[2];
class F implements Fn { 
  public int apply(int x) { 
    return x + 1; 
  } 
}
class G implements Fn { 
  public int apply(int x) { 
    return x + 2; 
  } 
}
fs[0] = new F();
fs[1] = new G();

Examples: C++

class Animal              { public: virtual string to_string() { return "Animal"; } };
class Bird: public Animal { public: virtual string to_string() { return "Bird"; } };
class Cat:  public Animal { public: virtual string to_string() { return "Cat"; } };

Examples: Scala

class A:
  def f () = { println("A.f"); this.g () }
  def g () = { println("A.g"); this.h () }
  def h () = println("A.h")
class B extends A: 
  override def f () = { println("B.f"); super.f () }
  override def h () = println("B.h")
  def i ()          = println("B.i")