Association, Composition and Aggregation in Java

Satya Prakash Nandy — Wed, 05 Jul 2023 07:20:59 +0000

In Object Oriented Programming, there can be broadly two types of relationships "IS-A" and "HAS-A" relationships.
We can achieve an "IS-A" relationship using Inheritance.
Whereas we can achieve a "HAS-A" relationship using Association.

Composition and Aggregation are two forms of Association.

Association.

Association represents a relationship between two separate classes where objects of one class are related to objects of another class. It is a loosely coupled relationship, meaning that the associated objects can exist independently.

The association can be one-to-one, one-to-many, many-to-one or many-to-many.

Example

Let's take an example of the Car and Engine class. In this example, Both car and engine classes can exist independently. The lifecycle of the Engine class object does not depend on the Car class object.

class Car {
    private Engine engine;

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

class Engine {
    // Engine class implementation
}

Composition.

Composition represents a strong form of association where on class is composed of one or more object of another class. The composed object cannot exist without the existence of parent class.

When the parent object is destroyed all the composed objects are also destroyed.

Example.

In this example, the life cycle of the Engine object is completely dependent on the Car object. Once the Car object is destroyed, the associated Engine object will also be destroyed.
In this example, instead of passing an Engine object through the constructor, we are creating an Engine object inside the Car constructor. Hence, Engine and Car objects are tightly coupled with each other.

class Car {
    private Engine engine;

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

class Engine {
    // Engine class implementation
}

Aggregation.

Aggregation is a specialized form of association where one class has a reference to another class, but the object can exist independently. It represents a “has-a” relationship, where the associated object can be shared among multiple objects.

Example

In this example, Department class contains a list of employee objects.
Each employee object can exist independently and their life cycle does not depend on the Employee object. Also multiple departments can share the same Employee object.

class Department {
    private List<Employee> employees;

    public Department() {
        employees = new ArrayList<>();
    }

    public void addEmployee(Employee employee) {
        employees.add(employee);
    }
}

class Employee {
    // Employee class implementation
}

Conclusion

Aggregation and association are two forms of composition, where aggregation defines a 'HAS-A' relationship with a weak association, while composition represents a 'BELONGS-TO' relationship with a strong association.

Why do we need access modifiers in Java? And How does it work?

Satya Prakash Nandy — Sat, 03 Jun 2023 11:55:49 +0000

Access modifiers are keywords used in programming languages, including Java, to control the visibility and accessibility of class members, such as variables and methods. They allow developers to specify the level of restriction placed on these members and determine how they can be accessed by other developers or code.
In Java, there are four types of access modifiers: public, private, protected, and default (also known as package-private). Each modifier serves a specific purpose in managing access to class members.

To better understand this, let's look at some examples.

As a person, there are some topics or incidents that you don't want to share or discuss with anyone.
You can mark them as private.
For example,

The day you accidentally deleted some user's data from the production database 💻.
Or your childhood crush - Jennifer Connelly ❤️.

Now there are some pieces of information about your life that you willingly share with everyone.
You can mark them as public.
For example,

Your name and Snapchat ID.
Or your selfie with your latest iPhone 📱.

Now, let's say that you are a member of the Flat Earth Society 🌍. You cannot discuss some topics with anyone else except other members of that group.
You can label them as default.
For example,

You found a new mathematical formula ✏️ to prove that the Earth is flat.
Or You visited the North Pole and found a huge wall on the edge ❄️.

You can only share these things with people who belong to that group.

Finally, let's talk about the protected access modifier. Let us say there is something that you can share with your family members, your children, and your grandchildren.
For example,

You can talk about how access modifiers work 📚.
Or you can just brag about how you have played through all the Dark Souls games ⚔️.

In programming, access modifiers work similarly. They allow you to control the visibility and accessibility of class members, just like you control what you share privately, publicly, within specific groups, or with specific individuals. By using access modifiers appropriately, you can ensure the right level of privacy, security, and encapsulation in your code.

Let's look at some code examples

File structure.

We have three different packages FlatEarthSociety, Family, and Office.

In the FlatEarthSociety package, we have two classes, Vickie and Max.
In the Family package, we have one class MaxJunior derived from Max.
And In the Office package, we have one class, Thomas.

Max.class

public class Max {
    public String name = "Max";
    public String latestIphone = "iPhone 14 Pro Max";
    private String childhoodCrush = "Jennifer Connelly";
    boolean iBelieveInFlatEarth = true; // DEFAULT
    protected int numberOfDarkSoulGamesPlayed = 8;
}

Thomas.class

public class Thomas {
    public void display() {
        Max max = new Max();
        System.out.println(max.name);
        System.out.println(max.latestIphone);
    }
}

Thomas can access only "name" and "latestIphone" data members.
As Thomas belongs to a different package, he can only access the public members of Max.

Vickie.class

public class Vickie {
    public void display() {
        Max max = new Max();
        System.out.println(max.name);
        System.out.println(max.latestIphone);
        System.out.println(max.iBelieveInFlatEarth);
        System.out.println(max.numberOfDarkSoulGamesPlayed);
    }
}

Vickie can access "name", "latestIphone", "iBelieveInFlatEarth" and "numberOfDarkSoulGamesPlayed" data members.
As Vickie belongs to the same package, he can access public, protected, and default data members. But cannot access private data members.

MaxJunior.class

public class MaxJunior extends Max {
    public void display() {
       MaxJunior grandpa = new MaxJunior();
       System.out.println(grandpa.latestIphone);
       System.out.println(grandpa.name);
       System.out.println(grandpa.numberOfDarkSoulGamesPlayed);
    }
}

Despite being present in a different package, MaxJunior can access public and protected data members of Max class.
This is because it inherits the Max class.

Last but not least, No one can access Max's childhoodCrush ❤️ except for Max because it's private!

DEV Community: Satya Prakash Nandy

Association, Composition and Aggregation in Java

Association.

Example

Composition.

Example.

Aggregation.

Example

Conclusion

Why do we need access modifiers in Java? And How does it work?

To better understand this, let's look at some examples.

Let's look at some code examples

Summary Table 📎.