Chapter 9 - Mechanisms for Software Reuse

1. Inheritance and Substitutability
   • Should be legal to assign the value derived from a subclass to the variable declared as the superclass. Principle of substitutability.
   • Is-a Rule implies inheritance
   • Has-a Rule implies composition
   • When the relationship (is-a or has-a) is not clear-cut, you need some guidelines to determine whether you should use inheritance or composition.
2. Composition and Inheritance Described - List class exists - want Set class. Is-a, has-a relationship not clear.
   • Using Composition
     • Implement the has-a relationship - Set has a list as one of its fields (components).
     • This method works well in all languages that have ADT's whether or not they are OOP (i.e. have inheritance and polymorphism as well.)
     • Only "tricky" part is the initialization of the external object within the new class.
   • Using Inheritance
     • Implement the is-a relationship - Set is a list.
     • Automatically get all the data and methods of the parent class as parts of the child class. The new class can override any methods in the parent class. The subclass can be a subtype.
     • Subclass is a subtype which may not be true. Can have problems since by definition, the parent's data/methods are available as part of the "full child interface" and that may NOT be a good idea. C++ uses private inheritance to "get around" this problem.
     • Initialization of the parent class done by calling the parents constructor as part of the child's constructor (pg. 174)
     • Less code has to be written with this method than with the composition method.
     • Allows for polymorphism
   • Private Inheritance in C++
     • Allows the use of inheritance when the relationship is has-a instead of is-a.
     • Private inheritance indicates that the subclass in NOT a subtype of the parent class and that any methods that the parent has that are protected or public are NOT available to any user (including subclasses of the derived class) of the class.

       class A
       {
       }
       class B: private A
       {
       }
       class C: public B
       {
       }
       class D: public A
       {
       }
       

     • All the protected and public data and methods of A are directly available to class B.
     • Any application declaring something of type B would NOT be able to access the public data and methods of A through an instance of B.
     • Any subclass of class C would NOT be able to access the public or protected data and methods of A
     • In class D which uses public inheritance, the protected and public parts are directly accessible. Instances of class D can use the public parts of class A directly. Subclass of class D can use the protected and public parts directly.
3. Composition and Inheritance Contrasted
   • +Composition is simpler. Clearly indicates exactly what operations can be performed on the data type. Inheritance requires you to be familiar with the parent class(es) operations before you know exactly what operations are available. Interface with composition tells it all.
   • -Inheritance - operations are a superset of the already defined methods. Yo-yo problem occurs when programmer has to flip back and forth up and down the inheritance hierarchy to understand the methods of the subclass being created.
   • +Inheritance give brevity of code. Less code to write. Often have greater functionality at no extra coding cost.
   • -Inheritance does not prevent the user from misusing the class and going to the parent class for operations that are not appropriate for the new class (Exception: private inheritance in C++ does prevent this.)
   • +Composition uses the idea that the included class is simply an implementation detail. Using a different "container" causes no rewriting of applications that used the original class.
   • +Inheritance allows the possibility of polymorphism. Not possible with composition.
   • +/-Understandability and maintainability - Inheritance has small code but more difficult protocol (hierarchy of classes). Composition has more code but the only thing the programmer needs to understand is the code for the new class.
   • +Inheritance - Data structures using inheritance have a very small execution speed advantage over those using composition. (C++ can eliminate much of the overhead making the 2 almost equal.)
4. Will Widespread Software Reuse Become Reality?
   • Inheritance and compostion provide the means for producing reusable components but do not provide the guidelines for how a task should be performed. Producing good, useful software components is usually harder than creating special purpose software.
   • Benefits of producing reusable software can't be seen (or debited) in a single project. Need a long range view usually not available in projects.
   • Since the benefits don't show up except in the "long run", most don't bother to spend the time developing the reusable components.
   • First attempts at reusable software are usually not "right". This is an evolutionary process. Business usually can't "cost" it out in one or two projects only.
   • Adverse reaction - "not-invented-here" therefore can't use it.
   • Lack of awareness and/or training in OOP