Introduction

Inheritance is one of the most important principles of Object-Oriented Programming. It allows one class to acquire the properties and methods of another class. In simple words, inheritance allows a new class to reuse the features of an existing class.

In Object-Oriented Programming, inheritance helps create a relationship between classes. The class that provides properties and methods is called the parent class, base class, or superclass. The class that receives or inherits those features is called the child class, derived class, or subclass.

For example, suppose we have a general class named Vehicle. This class may contain common properties such as brand, model, speed, and fuel level. Now, classes like Car, Bike, and Truck can inherit these common features from Vehicle instead of rewriting the same properties and methods again and again.

Simple Definition of Inheritance

Inheritance is a mechanism in Object-Oriented Programming that allows a class to use the features of another class. It helps create reusable, organized, and hierarchical code.

In simple words:

• Inheritance allows one class to reuse another class.
• It reduces code duplication.
• It creates a parent-child relationship between classes.
• It helps build class hierarchies.
• It supports code reusability and extensibility.
• It allows child classes to add or modify behavior.

Real-World Analogy of Inheritance

To understand inheritance easily, think about family inheritance. A child may inherit certain characteristics from parents, such as surname, eye color, or some family traits. The child may also have unique qualities of their own.

Similarly, in programming, a child class can inherit properties and methods from a parent class, but it can also define its own additional properties and methods.

Why Do We Need Inheritance?

Inheritance is needed because many classes in a program may have common features. Without inheritance, developers may need to write the same properties and methods repeatedly in multiple classes. This increases code duplication and makes maintenance difficult.

For example, Car, Bike, and Truck are different types of vehicles. They may all have brand, model, speed, start(), stop(), and accelerate() features. Instead of writing these features separately in every class, we can create a common Vehicle class and allow Car, Bike, and Truck to inherit from it.

Parent Class and Child Class

In inheritance, two important terms are parent class and child class. The parent class contains common features, and the child class inherits those features.

The child class can use inherited properties and methods. It can also add new properties and methods or modify inherited behavior according to its requirement.

Real-World Example: Vehicle Inheritance

Let us understand inheritance using a vehicle example. A vehicle can be a general class that contains common features. Car, Bike, and Truck can be specialized classes that inherit from Vehicle.

// Conceptual inheritance example

Class Vehicle
{
    brand
    model
    speed

    start()
    {
        print "Vehicle started"
    }

    stop()
    {
        print "Vehicle stopped"
    }
}

Class Car inherits Vehicle
{
    numberOfDoors

    openTrunk()
    {
        print "Trunk opened"
    }
}

Class Bike inherits Vehicle
{
    hasCarrier

    kickStart()
    {
        print "Bike kick started"
    }
}

In this conceptual example, Car and Bike inherit common properties and methods from Vehicle. Car also adds its own feature openTrunk(), while Bike adds kickStart().

Basic Syntax Concept of Inheritance

The syntax of inheritance differs from language to language. However, the basic idea is the same: one class extends or inherits another class.

// General conceptual syntax

Class ParentClass
{
    // common properties and methods
}

Class ChildClass inherits ParentClass
{
    // child-specific properties and methods
}

In many programming languages, keywords such as extends, inherits, or : are used to define inheritance.

Java Example of Inheritance

In Java, inheritance is implemented using the extends keyword. The child class extends the parent class and can use its accessible properties and methods.

class Vehicle {

    String brand;
    int speed;

    void start() {
        System.out.println("Vehicle started");
    }

    void stop() {
        System.out.println("Vehicle stopped");
    }

    void displayVehicleDetails() {
        System.out.println("Brand: " + brand);
        System.out.println("Speed: " + speed);
    }
}

class Car extends Vehicle {

    int numberOfDoors;

    void openTrunk() {
        System.out.println("Car trunk opened");
    }

    void displayCarDetails() {
        displayVehicleDetails();
        System.out.println("Number of Doors: " + numberOfDoors);
    }
}

public class Main {
    public static void main(String[] args) {

        Car car1 = new Car();

        car1.brand = "Toyota";
        car1.speed = 80;
        car1.numberOfDoors = 4;

        car1.start();
        car1.displayCarDetails();
        car1.openTrunk();
        car1.stop();
    }
}

In this example, Vehicle is the parent class and Car is the child class. The Car class inherits brand, speed, start(), stop(), and displayVehicleDetails() from Vehicle. It also adds its own property numberOfDoors and method openTrunk().

JavaScript Example of Inheritance

JavaScript supports class inheritance using the extends keyword. The child class can use the super keyword to call the parent class constructor.

class Vehicle {

    constructor(brand, speed) {
        this.brand = brand;
        this.speed = speed;
    }

    start() {
        console.log("Vehicle started");
    }

    stop() {
        console.log("Vehicle stopped");
    }

    displayVehicleDetails() {
        console.log("Brand: " + this.brand);
        console.log("Speed: " + this.speed);
    }
}

class Car extends Vehicle {

    constructor(brand, speed, numberOfDoors) {
        super(brand, speed);
        this.numberOfDoors = numberOfDoors;
    }

    openTrunk() {
        console.log("Car trunk opened");
    }

    displayCarDetails() {
        this.displayVehicleDetails();
        console.log("Number of Doors: " + this.numberOfDoors);
    }
}

const car1 = new Car("Honda", 90, 4);

car1.start();
car1.displayCarDetails();
car1.openTrunk();
car1.stop();

In this JavaScript example, Car extends Vehicle. The super() call sends brand and speed values to the parent class constructor.

The super Keyword

In many object-oriented languages, a keyword like super is used to refer to the parent class. It can be used to call the parent class constructor or parent class methods.

The exact syntax depends on the programming language, but the idea is that the child class can use parent class functionality through a special reference.

class Vehicle {

    Vehicle() {
        System.out.println("Vehicle constructor called");
    }
}

class Car extends Vehicle {

    Car() {
        super();
        System.out.println("Car constructor called");
    }
}

In this example, super() calls the parent class constructor from the child class constructor.

Is-A Relationship in Inheritance

Inheritance represents an Is-A relationship. This means the child class should be a specialized version of the parent class.

For example, a Car is a Vehicle, a Dog is an Animal, and a Student is a Person. These are good examples of inheritance because the relationship is natural and logical.

Types of Inheritance

Inheritance can be categorized into several types based on how classes are connected. Not every programming language supports every type of inheritance directly, but understanding these types is important for OOP theory and design.

Types of Inheritance Comparison

Single Inheritance Example

Single inheritance occurs when one child class inherits from one parent class.

class Animal {

    void eat() {
        System.out.println("Animal eats food");
    }
}

class Dog extends Animal {

    void bark() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {

        Dog dog1 = new Dog();

        dog1.eat();
        dog1.bark();
    }
}

In this example, Dog inherits the eat() method from Animal and also has its own bark() method.

Multilevel Inheritance Example

Multilevel inheritance occurs when a class inherits from another child class, forming a chain.

class Vehicle {

    void start() {
        System.out.println("Vehicle started");
    }
}

class Car extends Vehicle {

    void drive() {
        System.out.println("Car is driving");
    }
}

class ElectricCar extends Car {

    void chargeBattery() {
        System.out.println("Battery is charging");
    }
}

public class Main {
    public static void main(String[] args) {

        ElectricCar tesla = new ElectricCar();

        tesla.start();
        tesla.drive();
        tesla.chargeBattery();
    }
}

In this example, ElectricCar inherits from Car, and Car inherits from Vehicle. Therefore, ElectricCar can use methods from both Car and Vehicle.

Hierarchical Inheritance Example

Hierarchical inheritance occurs when multiple child classes inherit from the same parent class.

class Shape {

    void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {

    void calculateCircleArea() {
        System.out.println("Calculating circle area");
    }
}

class Rectangle extends Shape {

    void calculateRectangleArea() {
        System.out.println("Calculating rectangle area");
    }
}

public class Main {
    public static void main(String[] args) {

        Circle circle1 = new Circle();
        Rectangle rectangle1 = new Rectangle();

        circle1.draw();
        circle1.calculateCircleArea();

        rectangle1.draw();
        rectangle1.calculateRectangleArea();
    }
}

In this example, both Circle and Rectangle inherit the draw() method from Shape.

Method Overriding in Inheritance

Method overriding occurs when a child class provides its own version of a method that is already defined in the parent class. This allows the child class to customize inherited behavior.

For example, an Animal class may have a makeSound() method. Dog and Cat classes can override this method to produce different sounds.

class Animal {

    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {

    void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {

    void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {

        Dog dog1 = new Dog();
        Cat cat1 = new Cat();

        dog1.makeSound();
        cat1.makeSound();
    }
}

In this example, Dog and Cat override the makeSound() method from Animal and provide their own behavior.

Method Overloading vs Method Overriding

Method overloading and method overriding are different concepts. Overloading means multiple methods with the same name but different parameters. Overriding means redefining a parent class method in a child class.

Access Modifiers and Inheritance

Access modifiers affect what members of a parent class can be accessed by a child class. The exact rules depend on the programming language, but common modifiers include public, private, and protected.

Real-World Example: Employee and Manager

In many business applications, Employee can be a parent class and Manager can be a child class. A manager is an employee, but a manager may also have additional responsibilities.

class Employee {

    String employeeId;
    String name;
    double salary;

    void displayEmployeeDetails() {
        System.out.println("Employee ID: " + employeeId);
        System.out.println("Name: " + name);
        System.out.println("Salary: " + salary);
    }

    void work() {
        System.out.println(name + " is working");
    }
}

class Manager extends Employee {

    String department;

    void conductMeeting() {
        System.out.println(name + " is conducting a meeting for " + department);
    }

    void displayManagerDetails() {
        displayEmployeeDetails();
        System.out.println("Department: " + department);
    }
}

public class Main {
    public static void main(String[] args) {

        Manager manager1 = new Manager();

        manager1.employeeId = "E101";
        manager1.name = "Ayesha";
        manager1.salary = 75000;
        manager1.department = "IT";

        manager1.work();
        manager1.displayManagerDetails();
        manager1.conductMeeting();
    }
}

In this example, Manager inherits employeeId, name, salary, work(), and displayEmployeeDetails() from Employee. Manager also adds department and conductMeeting().

Real-World Example: School Management System

In a school management system, Person can be a parent class. Student and Teacher can inherit from Person because both students and teachers are people with common details such as name, age, and contact number.

class Person {

    String name;
    int age;
    String contactNumber;

    void displayBasicDetails() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Contact Number: " + contactNumber);
    }
}

class Student extends Person {

    int rollNumber;
    String course;

    void displayStudentDetails() {
        displayBasicDetails();
        System.out.println("Roll Number: " + rollNumber);
        System.out.println("Course: " + course);
    }
}

class Teacher extends Person {

    String teacherId;
    String subject;

    void displayTeacherDetails() {
        displayBasicDetails();
        System.out.println("Teacher ID: " + teacherId);
        System.out.println("Subject: " + subject);
    }
}

This example shows how inheritance helps avoid duplication. Common person details are written once in Person and reused by Student and Teacher.

Real-World Example: E-Commerce Product Hierarchy

In an e-commerce application, Product can be a parent class. ElectronicsProduct and ClothingProduct can inherit common product features and add their own specific details.

Advantages of Inheritance

Inheritance provides many advantages in software development when used properly. It helps build reusable and organized class structures.

Limitations of Inheritance

Inheritance is powerful, but it should be used carefully. Poor inheritance design can make programs complicated and difficult to maintain.

Inheritance vs Composition

Inheritance represents an is-a relationship, while composition represents a has-a relationship. Both are used for code reuse, but they solve different design problems.

For example, a Car is a Vehicle, so inheritance may be suitable. But a Car has an Engine, so composition is more suitable for connecting Car and Engine.

How to Decide Whether to Use Inheritance

Before using inheritance, developers should check whether the relationship between classes is natural. Inheritance should not be used only because two classes share some code. The child class should truly be a specialized version of the parent class.

Inheritance Best Practices

Good inheritance design makes software easier to understand and maintain. Poor inheritance design can make code complicated. Beginners should follow simple best practices.

Common Mistakes Beginners Make

Beginners often use inheritance incorrectly. Understanding these mistakes helps improve OOP design and prevents confusing class structures.

Mini Practice Activity

Try to identify parent classes, child classes, and inherited features from the following scenarios. This activity will help you understand inheritance practically.

Frequently Asked Questions

1. What is inheritance in OOP?

Inheritance is an OOP concept where one class can acquire or reuse the properties and methods of another class. It creates a parent-child relationship between classes.

2. Why is inheritance used?

Inheritance is used to reuse code, reduce duplication, organize related classes, and allow child classes to extend or customize parent class behavior.

3. What is a parent class?

A parent class is the class whose features are inherited by another class. It is also called a base class or superclass.

4. What is a child class?

A child class is the class that inherits features from another class. It is also called a derived class or subclass.

5. What is an Is-A relationship?

An Is-A relationship means the child class is a specialized type of the parent class. For example, a Car is a Vehicle, and a Dog is an Animal.

6. What is method overriding?

Method overriding occurs when a child class provides its own version of a method that already exists in the parent class.

7. What is the difference between inheritance and composition?

Inheritance represents an Is-A relationship, while composition represents a Has-A relationship. For example, a Car is a Vehicle, but a Car has an Engine.

8. Can a child class add new methods?

Yes. A child class can inherit parent methods and also define its own new methods and properties.

9. Should inheritance always be used for code reuse?

No. Inheritance should be used when there is a real Is-A relationship. If the goal is only code reuse, composition may sometimes be a better choice.

10. What is the main benefit of inheritance?

The main benefit of inheritance is code reusability. Common features can be written once in a parent class and reused by multiple child classes.

Summary

Inheritance is one of the core concepts of Object-Oriented Programming. It allows one class to inherit properties and methods from another class. The class that provides features is called the parent class, and the class that receives those features is called the child class.

Inheritance helps reduce code duplication, improve reusability, organize related classes, and support method overriding. It is commonly used when classes have a natural Is-A relationship, such as Car is a Vehicle, Dog is an Animal, and Student is a Person.

Although inheritance is powerful, it should be used carefully. Deep inheritance hierarchies and wrong parent-child relationships can make programs difficult to maintain. Developers should use inheritance only when the relationship is clear and meaningful.