Inheritance

Motivation For Inheritance

Use inheritance to create new software structures from existing software units to:

improve productivity
enhance quality

Tension between generality and Specialization

special projects usually require very specialized software
Reusability usually requires very general software
Inheritance allows general software to be specialized for a project

Practical Meaning of Inheritance

Data and behavior defined in parent in parent class are accessible within child
Data and behavior of child class are extensions to data and behavior of parent

With respect to parent class , a child class is , in some sense:

an extension - larger set of properties
a restriction - more specialized objects

Idealized Image of inheritance

Consider the following argument:

Subclass instance must possess all the data areas of the parent
Subclass instances must implement all functionality of parent
Thus, a subclass instance should be indistinguishable from a parent class instance - child can substituted for parent

Principle of Substitutability: If is subclass of A,instances of B can be substituted for instances of A in any situation with no observable effect.

Subclass, Subtype and Substitutability

Subtype: class that satisfies substitutability

Subclass: Something constructed using inheritance, weather or not satisfies the Principle of substitutability.

The two concepts are independent:

Not all subclasses are subtypes
sometimes subtypes are constructed without being subclasses

Forms of inheritance

Specialization: Child class is a special case ( subtype ) of parent

Most common form of inheritance

Example: Professor is a specialize form of Employee
preserves substitutability

Specification: Parent class defines behavior implemented in the child, but not parent

Second most common form of inheritance

Example: abstract class Stack defines methods for class StackInArray
preserves substitutability

Subclasses are realizations of incomplete abstract specification

Defines common interface for group of related classes

Constructor: Parent class used only for its behavior - child class is not subtype - no is-a relationship to parent

Example: extending List class to develop Set, without "hiding" unneeded methods
Example: extending a byte-based I/O stream to a stream for handling other objects Often violates substitutability

More common i dynamically typed languages than in statically typed

Can sometimes use aggregation instead

Generalization: Child class modifies or overrides some methods of parent, extends the behavior to more general kind of object

Example: graphical Window generalized to Color Window (with back ground Color)
Opposite of specialization - violates substitutability

Useful when must build from fixed, difficult-to-modify set of classes Where possible, better to invert class hierarchy or se aggregation

Extension: Child class adds new functionality to parent , but does not change any inherited behavior

Example: String Set extends Set , adding string- related methods (e.g., prefix search) Preserves substitutability

Limitation: child class limits some of the behavior of parent

Example: Stack extends doubleEndedQueue, replacing unneeded methods to give error messages

Violates substitutability

Useful when must build fro fixed, difficult-to modify set of classes

Avoid when possible ,perhaps use aggregation

Variance: Child and parent class are variants of each other- inheritance to allow code sharing- arbitrary relationship

Example: graphics tablet class extending Mouse to share similar control code violates substitutability

Better to define more general parent class like Pointing Device

Combination: Child class inherits features from more than one parent - multiple inheritance

Example: graduate instructor inherits from both Graduate student and Faculty

Often difficult to implement and understand

Often use of "mix-in" specification o another role or protocol

Inheritance and Assertions

Suppose C is a subtype of P

P and C have interface invariants I and IC, respectively
meth( ) is a public method of P with precondition Q and post condition R
meth( ) in C has precondition QC and post condition RC

C should not violate Q,I and R:

IC implements I
Q implements QC
Rc implements R

Trees versus forests

There are two common views of class hierarchies.

Tree: all classes part of single class hierarchy

    Advantage: root's functionality inherited by all objects - all have basic functionality
    Disadvantages: tight coupling of classes, large libraries for an application
    Languages: Smalltalk,Objective -C Delphi object Pascal, Java

Forest: classes only placed in hierarchies if they have a relationship - many small hierarchies.

    Advantages: smaller libraries of classes for application, less coupling possible
    Disadvantage: no shared functionality among all objects
    Languages: C++, Apple Object Pascal

Inheritable in Java

Tree hierarchy with root class Object
Single inheritance - using keyword Extends after class name
Public features accessible from outside class
Private features accessible from inside class only
Protected features accessible inside class or inside any child class
Abstract classes cannot be instantiated
Limited multiple inheritance for specification ( of a protocol or role )

- interface construct to define
- implements after class name to promise implementation of interface

Inheritance in Java

public abstract class stack { //extends Object by default

// data definitions plus signatures and

// possibly implements of methods

}

public class stackInArray extends stack {

// extended features plus overridden implementation

}

Public interface Queue {

// signatures of public methods Queues must provide

}

Public class QueueAsLinkedList implements Queue {

// includes implementations of the queue methods

}

Benefits of Inheritance

Software reuse
Code Sharing
Improved reliability
Consistency of interface
Rapid prototyping
Polymorphism
Information hiding

Costs of inheritance

Execution speed
program size
Message passing overhead
program complexity