Composition in Java

Last Updated : 7 Jan 2026

Composition and inheritance both are design techniques. The Composition is a way to design or implement the "has-a" relationship while inheritance is used to implement the "is-a" relationship. It is used to ensure the code reusability in our program. In Composition, we use an instance variable that refers to another object.

The composition relationship of two objects is possible when one object contains another object, and that object is fully dependent on it. The contained object should not exist without the existence of its parent object. In a simple way, we can say it is a technique through which we can describe the reference between two or more classes. And for that, we use the instance variable, which should be created before it is used.

It represents a strong association, if the parent object is destroyed, the contained object also ceases to exist.

Important points to Remember

The Composition represents a part-of relationship.
Both entities are related to each other in the Composition.
The Composition between two entities is done when an object contains a composed object, and the composed object cannot exist without another entity. For example, if a university HAS-A college-lists, then a college is a whole, and college-lists are parts of that university.
Favor Composition over Inheritance.
If a university is deleted, then all corresponding colleges for that university should be deleted.

Let's take an example of a university and its colleges to understand the concept of Composition.

We create a class College that contains variables, i.e., name and address. We also create a class University that has a reference to refer to the list of colleges. A University can have more than one collages. So, if a university is permanently closed, then all colleges within that particular university will be closed because colleges cannot exist without a university. The relationship between the university and colleges is Composition.

Example

import java.util.*;   
// class College  
class College {   
    public String name;   
    public String address;   
    College(String name, String address)   
    {   
        this.name = name;   
        this.address = address;   
    }   
}   
// University has more than one college.   
class University {   
    // reference to refer to list of college.   
    private final List<College> colleges;   
    University(List<College> colleges)  
    {  
        this.colleges = colleges;  
    }   
    // Getting total number of colleges  
    public List<College> getTotalCollegesInUniversity()   
    {   
        return colleges;   
    }   
}   
public class Main {   
    public static void main(String[] args)   
    {   
        // Creating the Objects of College class.   
        College c1   
            = new College("ABES Engineering College", "Ghaziabad");   
        College c2   
            = new College("AKG Engineering College", "Ghaziabad");   
        College c3 = new College("ACN College of Engineering & Management Studies",   
                           "Aligarh");   
        // Creating list which contains the no. of colleges.   
        List<College> college = new ArrayList<College>();   
        college.add(c1);   
        college.add(c2);   
        college.add(c3);   
        University university = new University(college);   
        List<College> colleges = university.getTotalCollegesInUniversity();   
        for (College cg : colleges) {   
            System.out.println("Name: " + cg.name   
                               + " and "  
                               + " Address: " + cg.address);   
        }   
    }   
}  

Compile and Run

Output:

Name: ABES Engineering College and Address: Ghaziabad
Name: AKG Engineering College and Address: Ghaziabad
Name: ACN College of Engineering & Management Studies and Address: Aligarh

Advantages of Composition

Composition allows us to reuse the code.
In Java, we can use multiple Inheritance by using the composition concept.
The Composition provides better test-ability of a class.
Composition allows us to easily replace the composed class implementation with a better and improved version.
Composition allows us to dynamically change our program's behavior by changing the member objects at run time.
It avoids diamond problem.

When to Use Composition?

We should use composition in the following cases:

If we want flexibility and avoid tight coupling
If multiple behaviors are needed without inheritance limitations.
If we are designing modular systems (for example, frameworks like Spring rely heavily on composition).
When lifecycle dependency is natural (for example, Room belongs to Building).

Composition Vs. Inheritance

Aspect	Composition (Has-A)	Inheritance (Is-A)
Definition	It involves creating complex objects by combining simpler ones, composition in OOPs.	It is a mechanism where a new class is derived from an existing class.
Relationship	It establishes Has-a relationship (strong association) between objects.	It establishes is-a relationship (hierarchical, parent-child) between objects.
Flexibility	Highly flexible because it can change behavior at runtime.	It has low flexibility because tightly coupled to superclass.
Dependency	Objects can exist independently of each other.	Dependents on the base class, changes to which can affect derived classes.
Complexity	It typically leads to simpler, more modular code.	It may lead to complex class hierarchies that might be harder to understand.
Encapsulation	It pramotes encapsulation as objects hide their internal details.	It may violate encapsulation as derived classes have access to all members of the base class.
Code Reuse	Achieved via contained objects.	Achieved via superclass methods.
Multiple Behaviors	Possible (because combines different classes).	Not possible (because no multiple inheritance allowed).
Example	Car has an Engine.	Dog is an Animal.

Next TopicCharbuffer-hasarray-method-in-java

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.