Type generalization is a technique commonly used in refactoring. The idea is to draw on the benefits of object-orientation and make more-generalized types, thus enabling more code sharing, leading to better maintainability as there is less code to write. Too-general code can, however, become completely useless, leading to spaghetti code doing effectively nothing.
Type generalization refers to making more general or more abstract some subset of the traits of a specific type. A superclass has wider use than a specific subclass, and so is more 'general'.
An example of generalizing a type would be moving a method from a child to a parent class for common use by all the parent class' children, not just the original child.
In object-oriented programming, inheritance is the mechanism of basing an object or class upon another object or class, retaining similar implementation. Defined as deriving new classes from existing ones and forming them into a hierarchy of classes. In most class-based object-oriented languages, an object created through inheritance acquires all the properties and behaviors of the parent object. Inheritance allows programmers to create classes that are built upon existing classes, to specify a new implementation while maintaining the same behaviors, to reuse code and to independently extend original software via public classes and interfaces; the relationships of objects or classes through inheritance give rise to a directed graph. Inheritance was invented in 1969 for Simula. An inherited class is called a subclass of its parent class or super class; the term "inheritance" is loosely used for both class-based and prototype-based programming, but in narrow use the term is reserved for class-based programming, with the corresponding technique in prototype-based programming being instead called delegation.
Inheritance should not be confused with subtyping. In some languages inheritance and subtyping agree. To distinguish these concepts, subtyping is known as interface inheritance, whereas inheritance as defined here is known as implementation inheritance or code inheritance. Still, inheritance is a used mechanism for establishing subtype relationships. Inheritance is contrasted with object composition. Composition implements a has-a relationship, in contrast to the is-a relationship of subtyping. There are various types of inheritance, based on specific language. Single inheritance where subclasses inherit the features of one superclass. A class acquires the properties of another class. Multiple inheritance where one class can have more than one superclass and inherit features from all parent classes. "Multiple Inheritance was supposed to be difficult to implement efficiently. For example, in a summary of C++ in his book on objective C Brd. Cox claimed that adding Multiple inheritance to C++ was impossible.
Thus, multiple inheritance seemed more of a challenge. Since I had considered multiple inheritance as early as 1982 and found a simple and efficient implementation technique in 1984. I couldn't resist the challenge. I suspect this to be the only case in which fashion affected the sequence of events." In JDK 1.8, Java now has support for multiple inheritance. Multilevel inheritance, it is not uncommon that a class is derived from another derived class as shown in the figure "Multilevel inheritance". The class A serves as a base class for the derived class B, which in turn serves as a base class for the derived class C; the class B is known as intermediate base class because it provides a link for the inheritance between A and C. The chain ABC is known as inheritance path. A derived class with multilevel inheritance is declared as follows: This process can be extended to any number of levels. Hierarchical inheritance where one class serves as a superclass for more than one sub class. Hybrid inheritance a mix of two or more of the above types of inheritance.
Subclasses, derived classes, heir classes, or child classes are modular derivative classes that inherits one or more language entities from one or more other classes. The semantics of class inheritance vary from language to language, but the subclass automatically inherits the instance variables and member functions of its superclasses; the general form of defining a derived class is: The colon indicates that the subclass inherits from the superclass. The visibility, if present, may be either private or public; the default visibility is private. Visibility specifies whether the features of the base class are derived or publicly derived; some languages support the inheritance of other constructs. For example, in Eiffel, contracts that define the specification of a class are inherited by heirs; the superclass establishes a common interface and foundational functionality, which specialized subclasses can inherit and supplement. The software inherited by a subclass is considered reused in the subclass.
A reference to an instance of a class may be referring to one of its subclasses. The actual class of the object being referenced is impossible to predict at compile-time. A uniform interface is used to invoke the member functions of objects of a number of different classes. Subclasses may replace superclass functions with new functions that must share the same method signature. In some languages a class may be declared as non-subclassable by adding certain class modifiers to the class declaration. Examples include the final keyword in Java and C++11 onwards or the sealed keyword in C#; such modifiers are added to the class declaration before the class keyword and the class identifier declaration. Such non-subclassable classes restrict reusability when developers only