- 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?

A x = 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?

A x = 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?

B x = 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 {
  int f (int x) {
    System.out.println("A.f(" + x + ")");
    return (x == 0) ? this.g() : this.f(x - 1); 
  }
  int g () { System.out.println("A.g()"); return 0; }
}
class B extends A {
  int f (int x) { System.out.println("B.f(" + x + ")"); return this.f(x); }
  int g ()      { System.out.println("B.g()"); return 0; }
}

A x = new B(); 
x.f(1);

How to Access Method in Super-Class?

• Access A.f with super

class A {
  int f (int x) {
    System.out.println("A.f(" + x + ")");
    return (x == 0) ? this.g() : this.f(x - 1); 
  }
  int g () { System.out.println("A.g()"); return 0; }
}
class B extends A {
  int f (int x) { System.out.println("B.f(" + x + ")"); return super.f(x); }
  int g ()      { System.out.println ("B.g()"); return 0; }
}

A x = new B (); 
x.f(1);

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

Document and Check Inheritance

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

Abstract Classes

• Abstract class A

abstract class A {
  int f (int x) { /* ... */ }
  int g () { /* ... */ }
}

A x = new A(); 

What happens?

• Compile error: abstract classes cannot be instantiated

  |  Error:
  |  A is abstract; cannot be instantiated
  |  A x = new A ();
  |        ^------^
  

Abstract Methods

• Abstract method g

abstract class A {
  int f (int x) { /* ... */ }
  abstract int g ();
}

class B extends A { 
}

What happens?

• Compile error: Abstract methods must be overridden in concrete subclass

  |  Error:
  |  B is not abstract and does not override abstract method g() in A
  |  class B extends A {
  |  ^------------------...
  

Final Methods

• Final method f

abstract class A {
  final int f(int x) { /* ... */ }
  abstract int g();
}

class B extends A {
  int f(int x) { /* ... */ }
  int g() { /* ... */ }
}

What happens?

• Compile error: final methods cannot be overridden

  |  Error:
  |  f(int) in B cannot override f(int) in A
  |    overridden method is final
  |    int f (int x) { ... }
  |    ^-------------------^
  

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")