Object-Oriented Programming with Java Lecture Notes

19 February 2008 • Inheritance

Outline

• Inheritance

  • Overriding

  • Dynamic binding.

  • Down casting.

Programs

• An object-oriented program is an interacting collection of class instances.

  

• Each interaction is a method call.

Method Calls

• A method call establishes a caller-called (or client-provider) relation between the class instances involved.

Class Protocol

class BProtcol {
  void m1() { ... }
  void m2() { ... }
  void m3() { ... }
  }

• A class satisfies B's protocol if it provides the same methods as B.

The IS-A Relation

• If A satisfies B's protocol, then A is-a B.

• Justification: any client of B can also be a client of A.

• Claim: An A is just a good as a B to B's clients.

IS-A Example

class Dictionary 

  void add(Key k, Value v) { ... }
  Value find(Key k) { ... }
  void delete(Key k) { ... }

class LinkedListDictionary 

  void add(Key k, Value v) { ... }
  Value find(Key k) { ... }
  void delete(Key k) { ... }

class HashTableListDictionary 

  void add(Key k, Value v) { ... }
  Value find(Key k) { ... }
  void delete(Key k) { ... }

  

IS-A Abstraction

• The IS-A relation abstracts a class's essential behavior into the protocol.

Implementing IS-A Relations

• Java provides the IS-A relation via inheritance.

  • But inheritance is much more powerful than the IS-A relation.

  • Managing that extra power provides much of the difficulty in inheritance.

The Inheritance Relation

• “A IS-A B” corresponds to “A inherits-from B”.

  A is the child, subclass, derived class, descendent (relative to B). B is the parent, superclass, base class, ancestor (relative to A).

• The extends class modifier signals inheritance:

  class Child extends Parent { ...  }
  

  • A child has one parent (single inheritance).

Why Inheritance?

• All the parent's non-private instance variables and methods are available to (are inherited by) the child instance.

  class Dictionary {
  
    void add(Key k, Value v) { ... }
    Value find(Key k) { ... }
    void delete(Key k) { ... }
    }
  
  class LinkedListDictionary
  extends Dictionary {
    }
  

Method Overriding

• Straightforward inheritance isn't too useful.

  • The child should behave the same but operate differently from the parent.

• The child adapts the parent's methods by overriding them.

Overriding Methods

• A child overrides a parent's method by redeclaring it in its class.

  • The redeclaration must be (almost) exact: the same method name, the same argument types in the same order.

    • No type conversions applied when comparing argument types.

  • The overridden return type may be a descendent of the parent's method's return type.

Class Compatability

• Two classes are type compatible if one class is an ancestor of the other.

• An ancestor instance can be assigned to a descendent variable.

  • This is known as upcasting.

  • The compiler upcasts implcitliy.

• A descendant instance requires an explicit downcast to be assigned to an ancestor variable.

Compatability Example

class Blob { ... }
class Spot extends Blob { ... }
class Drop extends Blob { ... }

Spot s = new Drop(); Drop d = new Spot(); Blob b1 = new Spot(); Blob b2 = new Drop(); Spot s = (Spot) b1; Drop d = (Drop) b2;

Static and Dynamic Types

• Every reference variable has two types: a static and dynamic type.

  • Assuming the reference variable is non-null.

• A reference variable's static type is its declared type (that is, class).

• A reference variable's dynamic type is the type (that is, class) of the referenced instance.

  • If the reference variable's null, there's no dynamic type.

Type Example

class Blob { ... }
class Spot extends Blob { ... }



• The dynamic type's a descendant of the static type.

  • The dynamic type may equal the static type.

Testing Dynamic Types

• The instanceof operator tests a reference's dynamic type:

  classInstance instanceof Class

  returns true if classInstance's type (that is, class) is an descendant of Class and false otherwise.

Which Method?

• Given

  class Blob { void moo() { ... } }
  class Spot 
  extends Blob { void moo() { ... } }
  class Drop 
  extends Spot { void moo() { ... } }

  consider

  Blob b = new Drop();
  b.moo();

  Which version of moo() gets called?

Method Look-Up

• Method look-up answers the question “which method gets called?”

• Method look-up starts at the variable's dynamic-type class.

• Look-up proceeds class-by-class up the inheritance hierarchy until the method is found.

• Methods not found result in a compile or run-time error.

Method Look-Up Matching

• When does a called method match a declared method?

  • A signature match on the methods available in the class.

  • The most-specific match within a class wins.

• Overriding and overloading are in competition for selecting the method to call.

  • Be careful to keep them straight.

Look-Up Example

class Blob
  void moo(int) { ... }

class Spot
extends Blob
  void moo(double) { ... }

Blob b = new Spot(); b.moo();

Controlling Look-Up

• Methods can use the super keyword to control lookup.

• super.method(args) call the parent's method.

  • This starts method look-up in the instance's parent class.

• As always, this.method(args) calls method in the instance's class.

Inheritance Problems

• Creating super-classes for inheritance is hard.

  • Designing, documenting, implementing, and using.

  • The child may also violate the parent's encapsulation.

• Inheriting from ill- or undesigned super-classes is bad.

• Either design for inheritance or prohibit it.

  • java.lang.String is a final class.

Example.

• Here's (part of) a set class:

  class Set {
  
    // blah blah blah 
  
    void add(Object element) { ... }
    void add(Set set) { ... }
  
    // blah blah blah
    }
  

• How often are elements added to a set?

Example..

• Create an auditing set to keep track:

  class CountingSet extends Set
  
    private int count = 0
  
    void add(Object element)
      count++
      super.add(element) 
  
    void add(Set set)
      count += set.size()
      super.add(set)
  
    int getCount()
      return count 

Example...

• Everything's jake, or is it?

  CountingSet cs1 = new CountingSet()
  cs1.add("Moe")
  cs1.add("Manny")
  cs1.add("Jack")
  
  CountingSet cs2 = new CountingSet()
  cs2.add(cs1)
  
  System.out.printlin(
    "Add count: " + cs2.getCount())

  • This prints Add count: 6 when run. Why?

Example....

• Set.add(Set) is implemented as

  void add(Set set) 
    for (Object e: set.elements)
      /* this. */add(e)

  

  See the code.

Preventing Inheritance

• The final class and method modifier prohibits inheritance.

  • A final class cannot be subclassed.

  • A final method cannot be overridden.

• Declaring a class final keeps your options open.

  • It's easy to un-final a final class.

  • It's (usually) impossible to un-final a final class.

Final Overload

• Final has three uses:

  • Final variables can only be assigned once.

  • Final classes can't be parents.

  • Final methods can't be overridden.