Why the concept of inheritance was introduced in OOP?

Answer 1

In object-oriented programming, inheritance allows the creation of is-a relationships. For example, a car is a vehicle, and a bike is a vehicle, so those could be modeled through a vehicle class, and a pair of car and bike classes, both derived from (inheriting from) the vehicle class. Derived classes like car and bike share common vehicle properties, such as speed, location, direction, number of wheels, etc.

Answer 2

Inheritance is useful whenever we need to work with a collection of objects of different types but where all those objects have something in common. Planes, trains and automobiles are different types of vehicle; cows, sheep and chickens are different types of farm animal; ellipses, rectangles and triangles are different types of shape.

Whenever objects of different type share something in common, we can combine those common properties within a (base) class from which we can inherit a more specific (derived) class of object. The derived class inherits all the public and protected properties of its base class and can therefore be treated just as if it really were that base class.

Classes intended to be used as base classes usually provide one or more virtual methods which can be overridden by derived classes to provide more specialised behaviour. This allows us to generalise our code; we do not need to know the exact runtime type of a derived object so long as we know one of its base classes. If we invoke a virtual method of the base class, the most-derived override of that method will be invoked. This is known as polymorphism; objects automatically behave according to their runtime type even when the runtime type is completely unknown to us.

Consider the following:

void draw (Vector<Shape*>& shapes) {

for (auto shape : shapes) shape->draw();

}

Here, we assume that Shape::draw() is a virtual method. Classes that inherit from Shape (such as Circle, Rectangle, Triangle, Hexagon, and so on), can override the Shape::draw() method in order to provide the exact method we expect of these specific shapes. Note how the code does not need to know the specific type of shape to draw; the shapes know how to draw themselves according to their runtime type, all we need do is invoke the method. Even if we knew all the types that inherit from shape, we may add new shapes at a future date and the code will still work without any modification.

Of course we could achieve the same thing without inheritance. Typically this would involve using a type field to differentiate between shapes:

enum Type {circle, triangle, rectangle, pentagon, hexagon };

class Shape {

private:

Type type;

public

void draw();

// ...

};

However, rather than allowing derived classes to provide the specific behaviours, we have to place all the behaviours in the shape class using thinly-veiled switches:

void Shape::draw() {

if (type==circle) // draw a circle

else if (type==triangle) // draw a triangle

else if (type==rectangle) // draw a rectangle

// and so on...

}

This means that whenever we add a new type of shape, we have to update the enum, and then update every class method within shape that uses the type field. That in itself increases the maintenance burden. It can also lead to errors if we forget to update every method -- of which there may be many. More importantly, selecting the appropriate method based on a type field has a far greater performance impact than invoking a virtual function.

Another problem is how we choose to represent every type of shape using just the one class. If we represent all the properties of every type of shape, we find that some properties apply to many shapes while others only apply to a few. A radius only applies to circles, for instance, but every shape would still need to have a radius property. With inheritance, we simply place all the properties (if any) that are common to all derived classes, and place specialised properties only in those classes that require them. In this way, only circles need have a radius property.

Answer 3

Inheritance allows you to save time and code by allowing you to pull the details from one class and allow it to overlap with the details of another class, all the while allowing both classes to stay separate and distinct. Let me give a really simple example: I have a class named Mammal. Mammals have distinct traits such as being born alive, producing milk, having hair, large brains, etc. Now I have a different class named Human. The class Human contains all of the traits of the class Mammal, but it also has details of its own, separate than that of Mammal, such as the ability to think intelligently, walk on two legs, etc.

Inheritance works in a IS_A relationship. For example, a Human IS_A Mammal, but the reverse is not true, not all Mammals are Humans.

Answer 4

Inheritance is a key feature of object oriented programming because:

• It promotes code reuse
• It avoids code redundancy

Java allows us to use Inheritance extensively in our programs.

Answer 5

Because true inheritance was impossible to implement in a structural programing environment.