Asociación, Composición y Agregación en Java

La asociación es una relación entre dos clases separadas que se establece a través de sus Objetos. La asociación puede ser de uno a uno, de uno a muchos, de muchos a uno, de muchos a muchos. En la programación orientada a objetos, un objeto se comunica con otro objeto para usar la funcionalidad y los servicios proporcionados por ese objeto. La composición y la agregación son las dos formas de asociación. 

Ejemplo:

// Java Program to illustrate the
// Concept of Association
 
// Importing required classes
import java.io.*;
 
// Class 1
// Bank class
class Bank {
 
    // Attributes of bank
    private String name;
 
    // Constructor of this class
    Bank(String name)
    {
        // this keyword refers to current instance itself
        this.name = name;
    }
 
    // Method of Bank class
    public String getBankName()
    {
        // Returning name of bank
        return this.name;
    }
}
 
// Class 2
// Employee class
class Employee {
    // Attributes of employee
    private String name;
    // Employee name
    Employee(String name)
    {
        // This keyword refers to current instance itself
        this.name = name;
    }
 
    // Method of Employee class
    public String getEmployeeName()
    {
        // returning the name of employee
        return this.name;
    }
}
 
// Class 3
// Association between both the
// classes in main method
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating objects of bank and Employee class
        Bank bank = new Bank("ICICI");
        Employee emp = new Employee("Ridhi");
 
        // Print and display name and
        // corresponding bank of employee
        System.out.println(emp.getEmployeeName()
                           + " is employee of "
                           + bank.getBankName());
    }
}

Ridhi is employee of ICICI

Salida Explicación: En el ejemplo anterior, dos clases separadas Banco y Empleado están asociadas a través de sus Objetos. El banco puede tener muchos empleados, por lo que es una relación de uno a muchos. 

Agregación

Es una forma especial de Asociación donde:  

• Representa la relación de Has-A.
• Es una asociación unidireccional, es decir, una relación unidireccional. Por ejemplo, un departamento puede tener estudiantes, pero al revés no es posible y, por lo tanto, es de naturaleza unidireccional.
• En Agregación, ambas entradas pueden sobrevivir individualmente , lo que significa que terminar una entidad no afectará a la otra entidad.

Agregación

Ejemplo

// Java program to illustrate Concept of Aggregation
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
// Student class
class Student {
 
    // Attributes of student
    String name;
    int id;
    String dept;
 
    // Constructor of student class
    Student(String name, int id, String dept)
    {
 
        // This keyword refers to current instance itself
        this.name = name;
        this.id = id;
        this.dept = dept;
    }
}
 
// Class 2
// Department class contains list of student objects
// It is associated with student class through its Objects
class Department {
    // Attributes of Department class
    String name;
    private List<Student> students;
    Department(String name, List<Student> students)
    {
        // this keyword refers to current instance itself
        this.name = name;
        this.students = students;
    }
 
    // Method of Department class
    public List<Student> getStudents()
    {
        // Returning list of user defined type
        // Student type
        return students;
    }
}
 
// Class 3
//  Institute class contains list of Department
// Objects. It is associated with Department
// class through its Objects
class Institute {
 
    // Attributes of Institute
    String instituteName;
    private List<Department> departments;
 
    // Constructor of institute class
    Institute(String instituteName,List<Department> departments)
    {
        // This keyword refers to current instance itself
        this.instituteName = instituteName;
        this.departments = departments;
    }
 
    // Method of Institute class
    // Counting total students of all departments
    // in a given institute
    public int getTotalStudentsInInstitute()
    {
        int noOfStudents = 0;
        List<Student> students;
 
        for (Department dept : departments) {
            students = dept.getStudents();
 
            for (Student s : students) {
                noOfStudents++;
            }
        }
 
        return noOfStudents;
    }
}
 
// Class 4
// main class
class GFG {
 
    // main driver method
    public static void main(String[] args)
    {
        // Creating object of Student class inside main()
        Student s1 = new Student("Mia", 1, "CSE");
        Student s2 = new Student("Priya", 2, "CSE");
        Student s3 = new Student("John", 1, "EE");
        Student s4 = new Student("Rahul", 2, "EE");
 
        // Creating a List of CSE Students
        List<Student> cse_students = new ArrayList<Student>();
 
        // Adding CSE students
        cse_students.add(s1);
        cse_students.add(s2);
 
        // Creating a List of EE Students
        List<Student> ee_students
            = new ArrayList<Student>();
 
        // Adding EE students
        ee_students.add(s3);
        ee_students.add(s4);
 
        // Creating objects of EE and CSE class inside
        // main()
        Department CSE = new Department("CSE", cse_students);
        Department EE = new Department("EE", ee_students);
 
        List<Department> departments = new ArrayList<Department>();
        departments.add(CSE);
        departments.add(EE);
 
        // Lastly creating an instance of Institute
        Institute institute = new Institute("BITS", departments);
 
        // Display message for better readability
        System.out.print("Total students in institute: ");
 
        // Calling method to get total number of students
        // in institute and printing on console
        System.out.print(institute.getTotalStudentsInInstitute());
    }
}

Total students in institute: 4

Salida Explicación: En este ejemplo, hay un Instituto que no tiene. de departamentos como CSE, EE. Cada departamento tiene no. de estudiantes. Entonces, creamos una clase de Instituto que tiene una referencia a Objeto o no. de Objetos (es decir, Lista de Objetos) de la clase Departamento. Eso significa que la clase Instituto está asociada con la clase Departamento a través de su(s) Objeto(s). Y la clase Departamento también tiene una referencia a Objeto u Objetos (es decir, Lista de Objetos) de la clase Estudiante, lo que significa que está asociada con la clase Estudiante a través de su(s) Objeto(s). 

Representa una relación Tiene-A . En el ejemplo anterior: Student Has-A name. El estudiante tiene una identificación. Student Has-A Dept. Department Has-A Students como se muestra en los siguientes medios. 
 

¿Cuándo usamos Agregación?  
La reutilización de código se logra mejor mediante la agregación.  

Concepto 3: Composición 

Composición

La composición es una forma restringida de agregación en la que dos entidades son altamente dependientes entre sí.  

• Representa parte de la relación.
• En composición, ambas entidades son dependientes entre sí.
• Cuando hay una composición entre dos entidades, el objeto compuesto no puede existir sin la otra entidad.

Biblioteca de ejemplo

// Java program to illustrate
// the concept of Composition
 
// Importing required classes
import java.io.*;
import java.util.*;
 
// Class 1
//  Book
class Book {
 
    // Attributes of book
    public String title;
    public String author;
 
    // Constructor of Book class
    Book(String title, String author)
    {
 
        // This keyword refers to current instance itself
        this.title = title;
        this.author = author;
    }
}
 
// Class 2
class Library {
 
    // Reference to refer to list of books
    private final List<Book> books;
 
    // Library class contains list of books
    Library(List<Book> books)
    {
 
        // Referring to same book as
        // this keyword refers to same instance itself
        this.books = books;
    }
 
    // Method
    // To get total number of books in library
    public List<Book> getTotalBooksInLibrary()
    {
 
        return books;
    }
}
 
// Class 3
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating objects of Book class inside main()
        // method Custom inputs
        Book b1
            = new Book("EffectiveJ Java", "Joshua Bloch");
        Book b2
            = new Book("Thinking in Java", "Bruce Eckel");
        Book b3 = new Book("Java: The Complete Reference",
                           "Herbert Schildt");
 
        // Creating the list which contains number of books
        List<Book> books = new ArrayList<Book>();
 
        // Adding books
        // using add() method
        books.add(b1);
        books.add(b2);
        books.add(b3);
 
        Library library = new Library(books);
 
        // Calling method to get total books in library
        // and storing it in list of user0defined type -
        // Books
        List<Book> bks = library.getTotalBooksInLibrary();
 
        // Iterating over books using for each loop
        for (Book bk : bks) {
 
            // Printing the title and author name of book on
            // console
            System.out.println("Title : " + bk.title
                               + " and "
                               + " Author : " + bk.author);
        }
    }
}

Title : EffectiveJ Java and  Author : Joshua Bloch
Title : Thinking in Java and  Author : Bruce Eckel
Title : Java: The Complete Reference and  Author : Herbert Schildt

Explicación de salida: En el ejemplo anterior, una biblioteca puede tener no. de libros sobre los mismos o diferentes temas. Entonces, si la biblioteca se destruye, todos los libros dentro de esa biblioteca en particular serán destruidos. es decir, los libros no pueden existir sin las bibliotecas. Por eso es composición. El libro es parte de la biblioteca.

Agregación vs Composición 

1. Dependencia: La agregación implica una relación en la que el hijo puede existir independientemente del padre. Por ejemplo, Banco y Empleado, elimine el Banco y el Empleado aún existe. mientras que Composición implica una relación en la que el hijo no puede existir independientemente del padre. Ejemplo: humano y corazón, el corazón no existe separado de un humano

2. Tipo de relación: la relación de agregación es «tiene un» y la composición es una relación «parte de» .

3. Tipo de asociación: Composición es una Asociación fuerte mientras que Agregación es una Asociación débil .

Ejemplo:

// Java Program to Illustrate Difference between
// Aggregation and Composition
 
// Importing I/O classes
import java.io.*;
 
// Class 1
// Engine class which will
// be used by car. so 'Car'
// class will have a field
// of Engine type.
class Engine {
 
    // Method to starting an engine
    public void work()
    {
 
        // Print statement whenever this method is called
        System.out.println(
            "Engine of car has been started ");
    }
}
 
// Class 2
// Engine class
final class Car {
 
    // For a car to move,
    // it needs to have an engine.
 
    // Composition
    private final Engine engine;
 
    // Note: Uncommented part refers to Aggregation
    // private Engine engine;
 
    // Constructor of this class
    Car(Engine engine)
    {
 
        // This keywords refers to same instance
        this.engine = engine;
    }
 
    // Method
    // Car start moving by starting engine
    public void move()
    {
 
        // if(engine != null)
        {
            // Calling method for working of engine
            engine.work();
 
            // Print statement
            System.out.println("Car is moving ");
        }
    }
}
 
// Class 3
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Making an engine by creating
        // an instance of Engine class.
        Engine engine = new Engine();
 
        // Making a car with engine so we are
        // passing a engine instance as an argument
        // while creating instance of Car
        Car car = new Car(engine);
 
        // Making car to move by calling
        // move() method inside main()
        car.move();
    }
}

Engine of car has been started 
Car is moving 

En caso de agregación, el Coche también realiza sus funciones a través de un Motor. pero el Motor no siempre es una parte interna del Automóvil. Un motor se puede cambiar o incluso se puede quitar del automóvil. Es por eso que hacemos que el campo Tipo de motor no sea definitivo.

Este artículo es una contribución de Nitsdheerendra . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.