Generalization
Generalization is a mechanism for combining similar classes of objects
into a single, more general class. Generalization is a bottom-up process.
Generalization and inheritance are powerful abstractions for sharing
similarities among classes while preserving their differences.
Some Forms of Generalization
1. Hierarchy: In the case of hierarchy, the commonalities
are organized into a tree structured form. At the root of any subtree
are found all the attributes and behavior common to all of the descendents
of that root.
2. Genericity: In this case, the commonality is
expressed with the aid of a parameter. Various specializations are
distinguished by what they provide for the parameter. For example,
using genericity it is possible to represent the common properties
of a “stack” through the generalization of a “stack
of anything”, where “anything” represents the parameter.
3. Polymorphism: Polymorphism captures commonality
in algorithms. Polymorphism allows the nested logic (or case statement)
to be collapsed to a single case in which the different object types
are treated in a uniform manner.
4. Patterns: A pattern expresses a general solution
(the key components and relationships) to a commonly occurring design
problem. The attributes and behavior of the individual components
are only partially defined to allow the pattern to be interpreted
and applied to a wide range of situations.
Inheritance
The generalization/specialization relationship is implemented in
object-oriented programming languages with inheritance. Inheritance
is the implementation mechanism for the generalization/specialization
relationship. In single inheritance a subclass has only one superclass.
In multiple inheritance a subclass has two or more superclasses.
One object-oriented concept that helps objects work
together is inheritance. Inheritance defines relationships among classes
in an object-oriented language. In other words,
Inheritance is the mechanism used in object-oriented programming
(OOP) languages to permit a subclass to share attributes and operations
defined in the superclasses.
For example the subclass Car can share
the attributes and operations from the superclass Vehicle. The subclass
Car may add attributes and operations.
