CSC 347 - Concepts of Programming Languages

Inheritance and Dynamic Dispatch

Instructor: Stefan Mitsch

Learning Objectives

How do we support code sharing between classes?

What should happen when methods have the same name?

• Understand inheritance
• Understand how methods are chosen at runtime

Which toString?

• x has static type Animal, dynamic type Bird/Cat

• Dynamic dispatch, late binding: use dynamic/actual type (of object)

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());

• Output at runtime

  $ javac AnimalTest.java && java AnimalTest
  Bird
  Cat
  

Which toString?

• x has static type Animal, dynamic type Bird/Cat

• Static dispatch, early binding: use static/declared type (of variable)

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; 

• Output at runtime

  $ g++ -std=c++11 -o animal1 animal1.cpp && ./animal1
  Animal
  Animal
  

Which toString?

• x has static type Animal, dynamic type Bird/Cat

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

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; 

• Output at runtime

  $ g++ -std=c++11 -o animal2 animal2.cpp && ./animal2
  Bird
  Cat
  

Which toString?

• x has static type Animal, dynamic type Animal

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

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; 

• Output at runtime

  $ g++ -std=c++11 -o animal3 animal3.cpp && ./animal3
  Animal
  Animal
  

Dynamic Dispatch (Java)

interface Fn {                 int apply (int x);                  }
class F implements Fn { public int apply (int x) { return x + 1; } }
class G implements Fn { public int apply (int x) { return x + 2; } }
class H implements Fn { public int apply (int x) { return x + 3; } }

Fn[] fs = { new F (), new G (), new H () };
for (int i = 0; i < fs.length; i++) {
  System.out.format ("fs[%d].apply(20)=%d\n", i, fs[i].apply(20));
}

• Output at runtime

  fs[0].apply(20)=21
  fs[1].apply(20)=22
  fs[2].apply(20)=23
  

With Anonymous Classes

interface Fn { int apply (int x); }

Fn[] fs = new Fn[3];
for (int i = 0; i < fs.length; i++) {
  int j = i + 1;      // effectively final
  fs[i] = new Fn() { int apply (int x) { return j + x; } }
}
for (int i = 0; i < fs.length; i++) {
  System.out.format ("fs[%d].apply(20)=%d\n", i, fs[i].apply(20));
}

• Output at runtime

  fs[0].apply(20)=21
  fs[1].apply(20)=22
  fs[2].apply(20)=23
  

With Lambda Notation

interface Fn { int apply (int x); }

Fn[] fs = new Fn[3];
for (int i = 0; i < fs.length; i++) {
  int j = i + 1;      // effectively final
  fs[i] = x -> x + j; 
}
for (int i = 0; i < fs.length; i++) {
  System.out.format ("fs[%d].apply(20)=%d\n", i, fs[i].apply(20));
}

• Output at runtime

  fs[0].apply(20)=21
  fs[1].apply(20)=22
  fs[2].apply(20)=23
  

Delegation and Inheritance

• Delegation (aka Composition)
  • Object references another object
  • Dynamic relationship between objects
• Inheritance
  • Define class in layers
  • Static relationship between classes

Example

class A {
  int f (int x) {
    System.out.format ("A.f (%d)%n", x);
    return (x == 0) ? this.g () : this.f (x - 1); 
  }
  int g () { System.out.println ("A.g ()"); return 0; }
}

Inheritance

class A {
  int f (int x) {
    System.out.format ("A.f (%d)%n", x);
    return (x == 0) ? this.g () : this.f (x - 1); 
  }
  int g () { System.out.println ("A.g ()"); return 0; }
}
class B extends A {
  int g () { System.out.println ("B.g ()"); return 0; }
}

Abstract Classes

abstract class A {
  int f (int x) {
    System.out.format ("A.f (%d)%n", x);
    return (x == 0) ? this.g () : this.f (x - 1); 
  }
  int g () { System.out.println ("A.g ()"); return 0; }
}
class B extends A {
  int g () { System.out.println ("B.g ()"); return 0; }
}

Abstract Methods

• Abstract methods must be overridden in concrete subclass

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

• Compile error

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

Final Methods

• Final methods cannot be overridden

abstract class A {
  final int f (int x) {
    // ...
  }
  abstract int g ();
}
class B extends A {
  int f (int x) { System.out.format ("B.f (%d)%n", x); return 0; }
  int g () { System.out.println ("B.g ()"); return 0; }  
}

• Compile error

  |  Error:
  |  f(int) in B cannot override f(int) in A
  |    overridden method is final
  |    int f (int x) { System.out.format ("B.f (%d)%n", x); return 0; }
  |    ^--------------------------------------------------------------^
  

Hook Methods

• Nonfinal and abstract methods must be overridden

abstract class A {
  int f (int x) {
    System.out.format ("A.f (%d)%n", x);
    return (x == 0) ? this.g () : this.f (x - 1); 
  }
  abstract int g ();
}
class B extends A {
  int f (int x) { System.out.format ("B.f (%d)%n", x); return 0; }
  int g () { System.out.println ("B.g ()"); return 0; }  
}

Hook Methods

• Nonfinal and nonabstract methods (aka hooks) can provide default implementation

class A {
  int f (int x) {
    System.out.format ("A.f (%d)%n", 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.format ("B.f (%d)%n", x); return 0; }
  int g () { System.out.println ("B.g ()"); return 0; }  
}

Overriding f

• Access A.f with this

class A {
  int f (int x) {
    System.out.format ("A.f (%d)%n", 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.format ("B.f (%d)%n", x); return  this.f(x); }
  int g () { System.out.println ("B.g ()"); return 0; }  
}

How to Access Method in Super-Class?

• Access A.f with super

class A {
  int f (int x) {
    System.out.format ("A.f (%d)%n", 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.format ("B.f (%d)%n", x); return super.f(x); }
  int g () { System.out.println ("B.g ()"); return 0; }  
}

Difference between Inheritance and Delegation

• Inheritance links sub-class to super-class, dynamic dispatch
• Delegation requires explicit linking, static dispatch

class A {
  B that;
  int f (int x) {
    System.out.format ("A.f (%d)%n", x);
    return (x == 0) ? this.g () : this.f (x - 1);
    // return (x == 0) ? that.g () : that.f (x - 1);
  }
  int g () { System.out.println ("A.g ()"); return 0; }
}
class B {  
  A that;
  int f (int x) { System.out.format ("B.f (%d)%n", x); return that.f (x); }
  int g () { System.out.println ("B.g ()"); return 0; }
}

Difference between Inheritance and Delegation

• Inheritance links sub-class to super-class, dynamic dispatch
• Delegation requires explicit linking, static dispatch

class A {
  B that;
  int f (int x) {
    System.out.format ("A.f (%d)%n", x);
    // return (x == 0) ? this.g () : this.f (x - 1);
    return (x == 0) ? that.g () : that.f (x - 1);
  }
  int g () { System.out.println ("A.g ()"); return 0; }
}
class B {  
  A that;
  int f (int x) { System.out.format ("B.f (%d)%n", x); return that.f (x); }
  int g () { System.out.println ("B.g ()"); return 0; }
}

Delegation-based Languages

• Javascript provides syntax to express delegation

var A = {
    f (x) {
        console.log ("A.f (" + x + ")")
        return (x == 0) ? this.g () : this.f (x - 1); 
    },
    g ()  { console.log ("A.g ()"); return 0; }
}
var B = {
    f (x) { console.log ("B.f (" + x + ")"); return super.f (x); },
    g ()  { console.log ("B.g ()"); return 0; }
}

Summary

• Static vs. dynamic dispatch
  • Static dispatch: select method based on type of reference
  • Dynamic dispatch: select method based on type of object
• Inheritance vs. delegation
  • Inheritance: links classes statically at compile time
  • Delegation: links objects dynamically at runtime
    • GoF: Favor object composition over class inheritance
    • See Design Patterns or Design Principles
    • Delegate to methods of components