Object-Oriented Programming with Java Lecture Notes

17 February 2009 • Inheritance

---

Outline

• Abstraction again.

• Inheritance

  • Overriding

  • Dynamic binding.

  • Casting

Programs

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

  

• Each interaction is a method call.

Class Protocol

• A class C’s protocol is the set of public methods C makes available.

  class Card {
    public boolean sameRank(Card c) { ... }
    public boolean sameSuit(Card c) { ... }
    public void makeFaceUp() { ... }
    }
  

• A protocol is an abstraction emphasizing a class’s behavior.

Protocol Satisfaction

• A class A satisfies (or implements) a class B’s protocol if A provides B’s protocol methods.

  • Every method in B’s protocol is also in A’s protocol.

  • B’s protocol ⊆ A’s protocol.

• Satisfaction is syntactic: the method signatures match.

  • The assumption is that the semantics match too.

Satisfaction Example

class PeggingHand {
  public int pairPoints() { ... }
  public int rankPoints() { ... }
  }

class CribHand {
  public int pairPoints() { ... }
  public int rankPoints() { ... }
  public int rightJackPoints() { ... }
  }

• CribHand satisfies PeggingHand’s protocol.

  • PeggingHand does not satisfy CribHand’s protocol.

Observations

• Suppose class A’s satisfies class B’s protocol.

• A client looking at an A instance also sees a B instance.

  • That is, the client can treat an A instance like a B instance.

• This requires huge, unsupported assumptions about method semantics.

  • The skill in object-oriented programming is establishing and maintaining the semantic assumptions.

The IS-A Relation

• Protocol satisfaction defines relations between classes.

  • Class A satisfies class B’s protocol.

• The relation is behavioral.

  • A behaves as B does with respect to B’s protocol.

• This behavioral relation is called the IS-A relation.

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

• If class A satisfies class B’s protocol, then A IS-A B.

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

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

• This is an example of inter-class abstraction.

Inheritance

• Inheritance is a realization of the IS-A relation in object-oriented programming languages.

  A		inherits from		B
  A		IS-A		B
  A		satisfies		B’s protocol

• Inheritance specifies a behavioral relation between classes.

  • This is a minimalist view of inheritance.

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, descendant (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 descendant of the parent’s method’s return type.

Class Compatibility

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

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

  • This is known as upcasting.

  • The compiler upcasts implicitly.

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

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.

Summary

• Inheritance defines a behavioral relation between classes.

  • None of this code sharing stuff.

• Protected is the fourth and final access permission.

  • Parent-child access only.

• Final prevents inheritance for classes and methods.

References

• Item 15, Design and docmument for inheritance or else prohibit it, in Effective Java by Joshua Bloch, Addison-Wesley, 2001.