chap09

Inheritance and substitutability

Idealization of inheritance: instance of subclass can substitute for instance of parent

Abstract concept captured with two rules of thumb

is-a relation

"A dog is-a mammal" sounds right

Natural from dog to inherit from mammal

has-a relation

"A car is-a(n) engine" sounds wrong

Not natural to use inheritance

but " a car has-a(n)engine" sounds right

Can use composition

Two approaches to software reuse in OOP

Inheritance - the is-a relationship

Useful when new software is a component has all the behavior of the existing component , plus more.

If "new component is-a old thing" sounds reasonable, then inheritance can be used

Composition(aggregation)- the has-a relationship

Useful when the new software component builds from the existing system but differs fundamentally from the existing system

If "new thing has-a old-thing" sounds resonable,composition can be used

Example -Building sets from Lists

Suppose already have List data type with the following behavior:

class List
{
      public List( ) {. . . . }
      public void add(int ) {. . . . }
      public void remove(int ) {. . . . }
      public boolean includes(int ) {. . . . }
      public int firstElement( ) {. . . . }
     . . . . . .
}

Wish to build a set data type - elements are unique and unordered in set

Using Inheritance

class Set extends List
    {
         public void add(int) {. . .}
     }

Only need specify what is new - add method overrides the one in list
Everything else stays the same as in List
Inherits unneeded firstElement operation

Using Composition(Aggreration)

class Set
   {
          public Set( ) {. . .data = new list( ). . . }
          public void add(int ) {. . . . }
          public void remove(int ) {. . . . }
          public boolean includes(int ) {return data.includes(int) }
          private list data;
}

Note data field of type List

Redefine all operation- except unneeded operation firstElement()

may use List operation on data field

Comparison of Inheritance and Composition

Advantages of inheritance over composition:

Shorter code
increased functionality
sometimes less execution overhead

Advantages of composition over inheritance:

easier to see and understand functionality (no "yo-yo" effect)
inappropriate operations on constituent ("parent") type hidden
easier to change to different constituent type

Will Widespread Software Reuse Become Reality?

even wit the right mechanisms, software reuse not guaranteed to occur

Also need the right culture

Solid reusable component libraries
Guidelines for producing reusable components
Appropriate training of programmers for reuse
Willingness of programmers for reuse
Willingness of managers to pay for development of reusable components
patience and long-term dedication to reuse