Chapter 7 - Inheritance

Relationships Between Objects

• is-a - where object1 is a refinement of object2 - the base object (parent, superclass, etc.) is ideally more general than the derived (child, subclass, etc.)
  • dog "is a" mammal
  • couch "is a" chair
  • square "is a" geometric shape
• has-a - where object1 has an object2 as a data member
  • car "has an" engine
  • couch "has a" leg
  • complex number "has a" real_number

Inheritance

• ideally, implements the "is a" relationship
• is the property by which instances of a child class can access both the data and behavior of its copy of the parent. This access may not be direct, it is possible to restrict the access of a child class so that the child cannot directly access its copy of the parent fields.

1. An Intuitive Description of Inheritance
   • Flo (an instance of the class Florist) inherits attributes and behaviors of the class Shopkeeper. A Florist is-a Shopkeeper
   • Ideally, the behavior and data of a child are an extension of the parent class. A subclass should have all the properties of the parent class as well as extras.
   • Child is a more specialized version of the parent class.
   • Child classes can override (change) the behavior of a parent class. Phyllis the platypus needs to override the birthing method of mammals.
2. Subclass, Subtype, and Substitutability
   • Principle of substitutability
     • Instances of the subclass possess all data areas associated with the parent class.
     • Instances of the subclass must implement all functionality defined for the parent class.
     • An instance of a child class can mimic the behavior of the parent class and should be indistinguishable from an instance of the parent class if substituted in similar situations.
   • Subtype - principle of substitutability is maintained
   • Subclass - principle of substitutability is NOT maintained
   • Subtypes and Strong Typing - more important to statically typed languages than to dynamic typed languages. Statically typed languages characterize objects by their class. Dynamically typed languages characterize objects by their behavior.
3. Forms of Inheritance
   • Specialization (Subtyping - Ideal) - Ideal form of inheritance

     Florist is a specialization of Shopkeeper

   • Specification - (Ideal) - Special case of specialization Used to guarantee that the subclasses all maintain the same interface. Often the parent class only specifies methods that must be defined in the child class. Parent is often an abstract class. Substitutability is maintained.

     Shape is the abstract parent class specifying that all child classes have certain properties and functionalities.

   • Construction (Not great) - Used when one class provides most of the functionality needed by another but the 2 classes may not have any relationship. Substitutability may not be maintained. C++ has a mechanism (private inheritance) that makes this type of subclassing less dangerous to use.

     Dictionary and symbol table from the book

   • Generalization - (Bad) - Opposite of specialization - Child extends the behavior of the parent class to be more general. Avoid whenever possible. At least one method is overriden.

     Shopkeeper as child of Florist

   • Extension - (OK) - maintains substitutability - adds totally new abilities.

     StringSet is a Set - new methods for handling stuff for strings

   • Limitation - (Bad) - the behavior of the subclass is smaller or more restrictive than that of the parent. Does NOT maintain substitutability. Avoid as much as possible

     Making Stack from the double-ended-queue data structure

   • Variance - (Weak) - Two or more classes have similar implementations but don't have an hierarchical relationship. Avoid - it would be better to abstract out the commonalities into a parent class for both.

     Mouse and Tablet - same but different - better to use PointingDevice as a parent for both mouse and tablet

   • Combination - (OK) - Combination of features from 2 or more classes - multiple inheritance - very complex to use - most languages don't support it.

     iostream inherits from both istream and ostream

4. Inheritance in Various Languages
   • Object Pascal
   • Smalltalk
   • Objective-C
   • C++
     • Types of inheritance
       • public inheritance - implements subtype concept
       • private inheritance - implements subclassing for construction (see Chap. 11)
     • Access controls
       • public: section of a class - implements the interface to be used
       • private: section of a class - details of the implementation to be shared with no other classes
       • protected: section of a class - details of the implementation to be shared with only child classes.
     • Polymorphism - use of reserved word virtual along with the use of pointers provides the mechanism(s) for polymorphic behavior (see Chap. 11).
   • Java
5. Benefits of Inheritance
   • Software Reusability - Code providing the behavior inherited from another class does not have to be rewritten. Code that has been used in a variety of applications is usually more reliable. Errors have been caught and corrected. Maintenance costs are reduced because the code is shared and one correction corrects all occurrences.
   • Code Sharing -
     • Many users or projects use the same classes
     • Two or more classes are derived from a single parent
   • Consistency of Interface - classes that inherit from the same parent present the same interface for use. They all behave similarly.
   • Software Components - Create components that can be combined in new ways for creating applications with little actual programming.
   • Rapid Prototyping - exploratory programming - easy to get something up and running to show the user so that modifications can be made - this is an iterative process to get the final version.
   • Polymorphism and Frameworks - Provide portability at high level of abstraction - modifications are made at the lowest level to fit the new application.
   • Information Hiding - programmer using a class only needs to understand that class and its interface. He/she does not need to understand all the details of how the class does its thing. Reduces interconnectedness of software components.
6. Costs of Inheritance
   • Execution Speed - general-purpose software is rarely as fast as carefully hand-crafted systems (off-the-rack vs. tailor-made). Often the lose of speed is small and is more than offset by the reduced coding time and increased reliability of the code.
   • Program Size - Use of libraries increases the size of the program. While this may be large, it is offset by the ever-increasing availability of cheap memory. Again, this cost is offset to some extent by reducing the development time and maintenence costs for the software.
   • Message-Passing Overhead - Message passing takes more execution time than a simple procedure call (the receiver of the message must be determined as well as all the other stuff that happens with a procedure call.) Most of the time this cost is 2-3 extra assembly instructions with a maximum cost of about 10%. C++ even has ways of eliminating or reducing this overhead cost. Again, the benefits outweigh this cost.
   • Program Complexity - misuse and/or overuse of inheritance can increase rather than decrease complexity. If you must take many turns up and down the inheritance hierarchy to understand what is going on, this is called the yo-yo problem.