What do you mean by Inheritance?

Inheritance is a process through which one object can inherit the characteristics of another object. This is similar to the parent-child relationship in real time scenario where a child can inherit the characteristics of parent.

Inheritence  helps in setting up relationships among objects and can help in reusing of code. Implementations of the parent can be simply inherited by the child. The child need not re-implement the functionality unless any change in behaviour is expected.This also impleves maintainability by avoiding duplication of code and hence reduces defects as well as development time. This in turn can improve code quality.

In inheritance, objects are defined by classes. The existing class is also called as– super class, parent class, base class and ancestral class. The inherited class is called as – sub class, child class, heir class or derived class.

 

Inheritence can be depicted by a simpe example -
To represent different kinds of geometric shapes, such as circles or rectangles programmatically we can use inheritance. We can create separate classes for each shape, but these different kinds of shapes share a number of things in common. We can define a type called "Shapes" to represent any of these different kinds of figures (circles or rectangles). We could then say that circles and rectangles are a kind of figure. A given type includes all of the record components specific to it, plus all the record components of its ancestors, so a square has all the information a rectangle would.

We'll also need to define some operations on these types, such as "Draw", "Area", and "Perimeter". Each calculated in a different way for each of the shape. Pictorial representation of this example is shown below.




Inheritance Example

 

 

We have seen how and when to use inheritence. We have also discussed its advantages. This does not mean that we implement inheritence in all scenarios. Do not use inheritence just for the sake of reuse. Avoid using it if there is no sub type relationship. Overuse of implementation inheritance can break all the subclasses, if the superclass is modified. Use composition for code reuse in such cases.

Quality of code can be achieved when the developer is smart enough to decide on the feature to put into use from OOP.

Why do we need object oriented programming?

The Object Oriented Programming Languages directly represent the real life objects like Automobile, Flower, Pen etc. The most used  and powerful features of OO programming are polymorphism, inheritance and encapsulation.

[Tip to remember : PIE - Polymorphism, Inheritence and Encapsulation.].

Benefits of OOP

Reusable: Using the concept of inheritance the implementation of other class can be used. For example, if we have a to create classes for birds, we can have a prent class Bird which can implement functionality fly(). This functionality remains same for all child bird classes which inherit the parent class Bird.

Simple: OOP represents the real life objects. This real mapping easy understanding, reduction of complexity and makes the program structure simpler.

Modular: Usage of objects, classes etc helps in clubbing the relevent functinality together. This helps in easy understanding if the system and also makes the implementation independent of each other. This makesThis in turn will make it very easy to modify the system when required.  

Maintainable: It becomes very easy to make minor changes to the system as this approach is modular and is loosely coupled. The entire system need not be modified to incorporate the changes and hence reduces the development time.

Extensible: It is specified that the system becomes loosely coupled. This makes it easy to plug in more features to the system. This way we can extend the application to provide more features to the user. 

Summary

Considering the above points we can conclude that using OOP can definetly help us in providing quality code. This can be achieved as we will be able to reuse the code which helps us avoid code and test the reuse sections. This not only helps us in reducing the defects but can also reduces the development time.

Maintainence of the application becomes very easy as OOP is more extensible, reusable and modular.