Has-A-Relationship In Java

The Has-A-relationship in Java shows how one class is connected to another. It’s also called composition. In simple terms, one class owns or contains another class. For example, a car has an engine. Here, the car is the main class, and the engine is a part of it.

Now, let’s expand on this with an example. Imagine we have three classes: Car, Verna, and Engine. The Car class is the parent or base class. The Verna class inherits from the Car class, forming an Is-A relationship. Then, the Verna class has an Engine class as part of it, creating a Has-A-relationship.

Let’s look at the implementation with code: 

// Base class: Car
class Car {
    void display() {
        System.out.println("This is a car.");
    }
}

// Class: Engine
class Engine {
    void start() {
        System.out.println("Engine is starting...");
    }

    void stop() {
        System.out.println("Engine is stopping...");
    }
}

// Derived class: Verna
class Verna extends Car {
    Engine engine; // Has-A-relationship with Engine

    // Constructor to initialize Engine
    Verna() {
        engine = new Engine();
    }

    void startCar() {
        System.out.println("Starting Verna...");
        engine.start(); // Using Engine's start method
    }

    void stopCar() {
        System.out.println("Stopping Verna...");
        engine.stop(); // Using Engine's stop method
    }
}

// Main class to test the code
public class Main {
    public static void main(String[] args) {
        Verna myVerna = new Verna(); // Create an instance of Verna
        myVerna.display();          // Calling Car's display method
        myVerna.startCar();         // Starting Verna using Engine
        myVerna.stopCar();          // Stopping Verna using Engine
    }
}

Output

This is a car.
Starting Verna...
Engine is starting...
Stopping Verna...
Engine is stopping...

=== Code Execution Successful ===

How The Code Works

Car Class: The base class with a general method display() to show it’s a car.

Verna Class: Inherits from Car (forming an Is-A relationship) and contains an instance of Engine (forming a Has-A-relationship).

Engine Class: Contains methods start() and stop() that are used by the Verna class.

Main Class: Demonstrates how the Verna class uses both inheritance (Car) and composition (Engine) to function.

In object-oriented programming, defining relationships between objects is essential for organising your code properly. Let’s break down how to choose the right relationship between objects using the same car example we saw before.

In the example of a Hyundai Verna. We can say, "Hyundai Verna is a car" because the Verna is a type of car. This is an Is-A relationship, where one object is a specialised version of another class.

Now, consider the statement "Hyundai Verna has a sunroof" or "Hyundai Verna has a navigation system." These make sense because the Verna contains or owns those features. This is a Has-A-relationship, where one object contains another object as a part of it.

To decide which relationship to use:

• If the phrase includes ".... is a ...", use an Is-A relationship.
• If the phrase includes ".... has a ...", use a Has-A-relationship.

How to Decide which Type of Relation We Need

Consider Flexibility and Maintenance:

If the code needs to be flexible and easy to update, Has-A is better. It keeps things modular so changes in one class won’t disrupt others. This is useful for big projects where frequent updates happen. Is-A makes code tightly connected, which is a little hard to modify. 

Assess Reusability Needs:

If a class needs to reuse existing functionalities in a structured way then Is-A works well. It helps in extending features without rewriting code. But if we need parts of a class in different places without forcing a relationship, Has-A is better. It allows using one class inside another without strict connections hence the code is reusable in different ways.

Evaluate Coupling:

Has-A keeps classes independent as one class can change without breaking another. This is called loose coupling, and it makes future updates easier. Is-A creates tight coupling, where child classes depend too much on the parent. If the parent changes, all child classes get affected. So, for less dependency, Has-A is the better choice.

Think About Extensibility:

When future updates and adding new features are expected then Has-A gives more flexibility. We can change parts of a class without disturbing the whole structure. Is-A is less flexible, especially if the class hierarchy is deep. If we need to modify only one feature, it’s harder in inheritance. So Has-A helps in easy expansion.

Specificity of Use Cases:

If a class is a specialized version of another, Is-A makes sense to use. For example, a Verna is a Car, so it should inherit from Car. But if a class just needs another’s features without being its type, Has-A is better. A Car has an Engine, but it is not an engine. Understanding the use case helps decide the right approach.

There are two main types of Has-A-relationships in object-oriented programming: Aggregation and Composition. Both of these are types of association. This association is a connection between two distinct classes using their objects. 

Aggregation 

Aggregation is a basic form of the Has-A-relationship. It shows that one object owns or contains another, but the objects involved have independent lifecycles. This means the contained object can exist independently of the container object.

For instance, in the relationship between a library and students, the library "has" students, but if the library is removed, the students can still study. However, the library loses its purpose if a student doesn’t exist. Aggregation represents a weak bond between objects. 

Composition 

Composition is a stronger and more dependent version of aggregation. In this case, one object depends on another for its existence. If the container object is destroyed, the contained object also ceases to exist.

For example, a car has an engine, but the engine cannot exist without the car. If the car is destroyed, the engine is useless and cannot function. The composition represents a strong bond between objects.

That brings the question of how composition and inheritance differ. Here’s how:

When we use the “Has-A” relationship in Java, it brings many benefits to our code:

• It breaks big systems into small parts, which makes our code easier to understand.
• We can use the same classes in different situations. This reduces repetition and makes our code reusable.
• Encapsulation improves because each class handles its own job. Therefore, it is easier to maintain the code.
• We can change parts of a class without affecting how other classes work. Hence, we have more flexibility, and it makes our code adaptable.

Understanding the “Has-A” relationship is very important for anyone learning Java. It helps write a better-organised code that is reusable and easy to maintain. If you get this concept right, you can design better, more flexible systems. It’s key to writing clean and efficient Java code. Mastering this will help you build a strong foundation in object-oriented programming and make you a better Java developer. To build a strong foundation in coding, join the CCBP 4.0 Academy and become job-ready by the time you finish your education. 

1. What is the “Has-A” relationship in Java?

It means one class has an object of another class. It’s like saying, "A car has an engine". The car and engine are both classes. The car contains the engine, but they are separate.

2. How is “Has-A” different from inheritance?

In inheritance, a child class inherits properties from a parent class. In Has-A, one class just contains another class and they are independent.

3. Can I use “Has-A” with any class?

Yes, it’s possible to do so. You can use it in many situations, like if a class needs to contain another class to function properly.

4. What is the main advantage of using "Has-A" in Java?

It makes your code more modular, flexible, and easier to maintain. You can change one part without affecting the whole system.

5. Is a "Has-A" relationship good for big projects?

It is good for big projects. Because using "Has-A" keeps things organised and makes the code easier to manage. You can break it into smaller parts so everything works properly.