Agregación

La agregación es otro concepto fundamental en la programación orientada a objetos (POO) que, al igual que la composición, se basa en la relación "tiene-un". Sin embargo, hay una diferencia clave entre ambas: la dependencia entre los objetos.

¿Qué es la agregación?

La agregación es una forma de asociación entre objetos donde un objeto "contiene" o "utiliza" otros objetos, pero estos objetos componentes pueden existir independientemente del objeto contenedor. En otras palabras, la agregación representa una relación más débil que la composición.

Características clave de la agregación:

• Relación "tiene-un" más débil: Un objeto agregado "tiene-un" objeto componente, pero este último puede existir sin el primero. Por ejemplo, un departamento "tiene-un" profesor, pero un profesor puede existir sin pertenecer a un departamento.
• Acoplamiento débil: El objeto agregado no depende fuertemente de los objetos componentes. Si se elimina el objeto agregado, los objetos componentes pueden seguir existiendo.
• Reutilización de código: Al igual que la composición, la agregación permite reutilizar objetos existentes.
• Flexibilidad: La agregación ofrece mayor flexibilidad que la composición, ya que permite compartir objetos entre diferentes objetos agregados.

Diferencia clave entre composición y agregación:

La principal diferencia radica en la propiedad y el ciclo de vida de los objetos componentes. En la composición, el objeto contenedor es responsable de crear y destruir los objetos componentes. En la agregación, los objetos componentes pueden ser creados y destruidos independientemente del objeto contenedor.

Ejemplos en diferentes lenguajes de programación:

A continuación, te presento ejemplos de agregación en C++, C#, Python y Java:

C++:

C++

#include <iostream>
#include <vector>

class Profesor {
public:
    std::string nombre;

    Profesor(std::string nombre) : nombre(nombre) {}
};

class Departamento {
public:
    std::vector<Profesor*> profesores; // Agregación: Departamento tiene-un Profesor

    void agregarProfesor(Profesor* profesor) {
        profesores.push_back(profesor);
    }
};

int main() {
    Profesor* profesor1 = new Profesor("Juan");
    Profesor* profesor2 = new Profesor("Maria");

    Departamento departamento;
    departamento.agregarProfesor(profesor1);
    departamento.agregarProfesor(profesor2);

    // Los profesores pueden existir independientemente del departamento
    delete profesor1;
    delete profesor2;

    return 0;
}

C#:

C#

using System;
using System.Collections.Generic;

public class Profesor {
    public string Nombre { get; set; }

    public Profesor(string nombre) {
        Nombre = nombre;
    }
}

public class Departamento {
    public List<Profesor> Profesores { get; set; } // Agregación: Departamento tiene-un Profesor

    public Departamento() {
        Profesores = new List<Profesor>();
    }

    public void AgregarProfesor(Profesor profesor) {
        Profesores.Add(profesor);
    }
}

public class EjemploAgregacion {
    public static void Main(string[] args) {
        Profesor profesor1 = new Profesor("Juan");
        Profesor profesor2 = new Profesor("Maria");

        Departamento departamento = new Departamento();
        departamento.AgregarProfesor(profesor1);
        departamento.AgregarProfesor(profesor2);

        // Los profesores pueden existir independientemente del departamento
    }
}

Python:

Python

class Profesor:
    def __init__(self, nombre):
        self.nombre = nombre

class Departamento:
    def __init__(self):
        self.profesores = [] # Agregación: Departamento tiene-un Profesor

    def agregar_profesor(self, profesor):
        self.profesores.append(profesor)

profesor1 = Profesor("Juan")
profesor2 = Profesor("Maria")

departamento = Departamento()
departamento.agregar_profesor(profesor1)
departamento.agregar_profesor(profesor2)

# Los profesores pueden existir independientemente del departamento

Java:

Java

import java.util.ArrayList;
import java.util.List;

public class Profesor {
    public String nombre;

    public Profesor(String nombre) {
        this.nombre = nombre;
    }
}

public class Departamento {
    public List<Profesor> profesores; // Agregación: Departamento tiene-un Profesor

    public Departamento() {
        profesores = new ArrayList<>();
    }

    public void agregarProfesor(Profesor profesor) {
        profesores.add(profesor);
    }

    public static void main(String[] args) {
        Profesor profesor1 = new Profesor("Juan");
        Profesor profesor2 = new Profesor("Maria");

        Departamento departamento = new Departamento();
        departamento.agregarProfesor(profesor1);
        departamento.agregarProfesor(profesor2);

        // Los profesores pueden existir independientemente del departamento
    }
}

En todos estos ejemplos, la clase Departamento tiene una lista de objetos Profesor, pero los objetos Profesor pueden existir independientemente del objeto Departamento.