Open In App

Difference between Inheritance and Polymorphism

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Inheritance is one in which a new class is created that inherits the properties of the already exist class. It supports the concept of code reusability and reduces the length of the code in object-oriented programming.

Types of Inheritance are:

  1. Single inheritance
  2. Multi-level inheritance
  3. Multiple inheritances
  4. Hybrid inheritance
  5. Hierarchical inheritance

Example of Inheritance: 

C++
#include <iostream>
using namespace std;

class A {
    int a, b;

public:
    void add(int x, int y)
    {
        a = x;
        b = y;
        cout << "addition of a+b is:" << (a + b) << endl;
    }
};

class B : public A {
public:
    void print(int x, int y)
    {
        add(x, y);
    }
};

int main()
{
    B b1;
    b1.print(5, 6);
    return 0;
}
Java
class A {
    int a, b;
    public void add(int x, int y)
    {
        a = x;
        b = y;
        System.out.println("addition of a + b is:" + (a + b));
    }
}
class B extends A {
    public void sum(int x, int y)
    {
        add(x, y);
    }

    // Driver Code
    public static void main(String[] args)
    {
        B b1 = new B();
        b1.sum(5, 6);
    }
}
C#
using System;

class A {
    private int a, b;

    // Method to perform addition and print the result
    public void Add(int x, int y)
    {
        a = x;
        b = y;
        Console.WriteLine("Addition of a + b is: "
                          + (a + b));
    }
}

class B : A {
    // Method to call the Add method from base class
    public void Print(int x, int y) { Add(x, y); }
}

class Program {
    static void Main(string[] args)
    {
        B b1 = new B();
        b1.Print(5, 6);
    }
}
Javascript
// Define a class A
class A {
    constructor() {
        this.a = 0;
        this.b = 0;
    }

    // Method to calculate and print the sum of two numbers
    add(x, y) {
        this.a = x;
        this.b = y;
        console.log(`Addition of a + b is: ${this.a + this.b}`);
    }
}

// Define a class B that extends class A
class B extends A {
    // Method to call the 'add' method from the base class
    sum(x, y) {
        this.add(x, y);
    }
}

// Driver Code
const b1 = new B();

// Call the 'sum' method to calculate and print the sum of 5 and 6
b1.sum(5, 6);
Python3
class A:
    def __init__(self):
        self.a = 0
        self.b = 0

    def add(self, x, y):
        self.a = x
        self.b = y
        print("addition of a + b is:", self.a + self.b)


class B(A):
    def sum(self, x, y):
        self.add(x, y)


# Driver Code
b1 = B()

# custom sum 
b1.sum(5, 6)

Output
addition of a+b is:11



Here, class B is the derived class which inherit the property(add method) of the base class A.
Polymorphism: 
Polymorphism is that in which we can perform a task in multiple forms or ways. It is applied to the functions or methods. Polymorphism allows the object to decide which form of the function to implement at compile-time as well as run-time.

Types of Polymorphism are: 

  1. Compile-time polymorphism (Method overloading)
  2. Run-time polymorphism (Method Overriding)


Example of Polymorphism: 

C++
#include "iostream"
using namespace std;

class A {
    int a, b, c;

public:
    void add(int x, int y)
    {
        a = x;
        b = y;
        cout << "addition of a+b is:" << (a + b) << endl;
    }

    void add(int x, int y, int z)
    {
        a = x;
        b = y;
        c = z;
        cout << "addition of a+b+c is:" << (a + b + c) << endl;
    }

    virtual void print()
    {
        cout << "Class A's method is running" << endl;
    }
};

class B : public A {
public:
    void print()
    {
        cout << "Class B's method is running" << endl;
    }
};

int main()
{
    A a1;

    // method overloading (Compile-time polymorphism)
    a1.add(6, 5);

    // method overloading (Compile-time polymorphism)
    a1.add(1, 2, 3);

    B b1;

    // Method overriding (Run-time polymorphism)
    b1.print();
}
Java
class A {
    int a, b, c;

    public void add(int x, int y)
    {
        a = x;
        b = y;
        System.out.println("addition of a+b is:" + (a + b));
    }

    public void add(int x, int y, int z)
    {
        a = x;
        b = y;
        c = z;
        System.out.println("addition of a+b+c is:" + (a + b + c));
    }

    public void print()
    {
        System.out.println("Class A's method is running");
    }
};

class B extends A {
    public void print()
    {
        System.out.println("Class B's method is running");
    }

    // Driver Code
    public static void main(String[] args)
    {
        A a1 = new A();

        // method overloading (Compile-time polymorphism)
        a1.add(6, 5);

        // method overloading (Compile-time polymorphism)
        a1.add(1, 2, 3);

        B b1 = new B();

        // Method overriding (Run-time polymorphism)
        b1.print();
    }
}

Output
addition of a+b is:11
addition of a+b+c is:6
Class B's method is running


Difference between Inheritance and Polymorphism:

S.NOInheritancePolymorphism
1.Inheritance is one in which a new class is created (derived class) that inherits the features from the already existing class(Base class).Whereas polymorphism is that which can be defined in multiple forms.
2.It is basically applied to classes.Whereas it is basically applied to functions or methods.
3.Inheritance supports the concept of reusability and reduces code length in object-oriented programming.Polymorphism allows the object to decide which form of the function to implement at compile-time (overloading) as well as run-time (overriding).
4.Inheritance can be single, hybrid, multiple, hierarchical and multilevel inheritance.Whereas it can be compiled-time polymorphism (overload) as well as run-time polymorphism (overriding).
5.It is used in pattern designing.While it is also used in pattern designing.
6.

Example :

The class bike can be inherit from the class of two-wheel vehicles, which is turn could be a subclass of vehicles.  

Example : 

The class bike can have method name set_color(), which changes the bike’s color based on the name of color you have entered. 



Last Updated : 18 Mar, 2024
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads