Difference between Is-a and Has-a Relationship in OOPS Concept ?

In object-oriented programming (OOP), the concepts of “Is-a” and “Has-a” relationships are fundamental ways to model real-world relationships between objects in a system. These relationships help in designing classes and determining how objects should interact and relate to each other.

1. Is-a Relationship (Inheritance)

The “Is-a” relationship represents inheritance. This means that one class is a type of another class and inherits its properties and behaviors. It represents a hierarchical relationship and is typically implemented using class inheritance (extends keyword in Java).

Example

Consider a Vehicle class and a Car class:

• Here, Car is a Vehicle, so we can say that Car inherits from Vehicle.
• This means Car will have all the properties and behaviors (methods) of Vehicle, plus any additional ones defined in Car.

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

class Car extends Vehicle {
    public void openTrunk() {
        System.out.println("Trunk is open.");
    }
}

Here:

• Car is a Vehicle.
• Car inherits the start() method from Vehicle, but it also has its own openTrunk() method.

When to Use “Is-a” (Inheritance):

• When you have a clear hierarchical relationship.
• When the subclass can naturally extend or add specific features to the superclass.
• When you want polymorphism, allowing the subclass to be used wherever the superclass is expected.

2. Has-a Relationship (Composition)

The “Has-a” relationship represents composition or aggregation. It means that one class contains a reference to another class as a member, signifying that one class “has” another as a component. This is typically implemented by including the other class as a field inside the containing class.

Example

Consider a Car and an Engine class:

• Here, a Car has an Engine, so we can model this by making Engine a field within Car.

class Engine {
    public void start() {
        System.out.println("Engine started.");
    }
}

class Car {
    private Engine engine; // Has-a relationship

    public Car() {
        this.engine = new Engine();
    }

    public void startCar() {
        engine.start();
        System.out.println("Car started.");
    }
}

Here:

• Car has an Engine, represented by the engine field in the Car class.
• Car uses the Engine class’s functionality by calling engine.start() inside its own startCar() method.

When to Use “Has-a” (Composition):

• When you want to represent a “whole-part” relationship (e.g., a car has an engine, a house has rooms).
• When the relationship between objects is not hierarchical but rather a dependency.
• When you want to create complex objects by combining simpler ones.

Differences Between “Is-a” and “Has-a”

Summary

• Is-a relationship is about inheritance (extends), where one class is a specific type of another class.
• Has-a relationship is about composition, where one class contains another as a part or component.

Using these relationships effectively in OOP design can make your code more organized, modular, and maintainable.