Difference between Inheritance and Polymorphism (original) (raw)

Last Updated : 12 Jul, 2025

**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 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: