Differentiating Composition and Aggregation programmatically

Question

I was going through below link to figure out differentiation between Composition and Aggregation.

https://www.geeksforgeeks.org/association-composition-aggregation-java/

I am able to understand that Composition implies a relationship where the child cannot exist independent of the parent while Aggregation implies a relationship where the child can exist independently of the parent. But not able to understand how can i differentiate that programmatically . Below is an example of Aggregation and Composition as given in link.In both cases the classes are same in structure except that Student and Department class has an extra variable "name" .As in Composition "child cannot exist independent of the parent ",but here I can create a separate object of Book and use it without adding it to Library.

Aggregation

// student class
class Student 
{
    String name;
    int id ;
    String dept;

    Student(String name, int id, String dept) 
    { 
        this.name = name;
        this.id = id;
        this.dept = dept;
    }
}



/* Department class contains list of student
Objects. It is associated with student
class through its Object(s). */
class Department 
{
    String name;
    private List<Student> students;

    Department(String name, List<Student> students) 
    {
        this.name = name;
        this.students = students;    
    }

    public List<Student> getStudents() 
    {
        return students;
    }
}

Composition

class Book 
{
    public String title;
    public String author;

    Book(String title, String author)
    {
        this.title = title;
        this.author = author;
    }
}

// Libary class contains 
// list of books.
class Library 
{
    // reference to refer to list of books.
    private final List<Book> books;

    Library (List<Book> books)
    {
        this.books = books; 
    }

    public List<Book> getTotalBooksInLibrary()
    {
       return books;  
    }

}

Answer 1

As far as I can tell (and maybe somebody else can give a better answer), you can't evaluate if the relationship is aggregation or composition just by looking at Java code. It's the other way around.

First you create a conceptual model of the world. Libraries have books, and cars have wheels. Then you think - does it make sense for a book to exist without a library, or for a wheel to exist without a car, in the context I'm working in. So for example if you are writing a car racing game, you will have no use of wheels outside of cars. But if you are writing some auto-repair application, you will deal with wheels independently of some particular car.

So first you decide if you need aggregation or composition, and then implement it in your code. The implementation could be that object Car has List<Wheel> but you can't tell if it's composition or aggregation just from that. The key is that you interpret the code (implementation) based on your conceptual model and then use it according to that.

If it's composition, the usage it might have some restrictions:

• No object other than Car will hold a reference to Wheel.
• Wheel might even be a private or package-private class.
• If Car is saved in database, when you delete it, you also automatically delete all of its Wheels.

But it's up to you to enforce these restrictions if you decide it's composition.