Что такое агрегация в контексте ООП?

# Агрегация в ООП

Агрегация — это тип отношения между объектами, в котором один объект содержит ссылку на другой объект как на часть своего состояния. Это один из видов отношения «часть-целое» в объектно-ориентированном программировании.

Основная суть

Агрегация моделирует отношение, когда объект одного класса (целое) имеет один или несколько объектов другого класса (части). При этом части могут существовать независимо от целого.

Агрегация vs Композиция

Это два разных отношения, и важно их различать:

Агрегация (слабая связь - "has-a"):

• Части могут существовать независимо
• При удалении целого, части остаются в живых
• Отношение более слабое
• Например: Университет и Студент

class University {
    private List<Student> students;
    
    public void addStudent(Student student) {
        students.add(student);
    }
}

class Student {
    private String name;
}

// Студент может существовать без университета

Композиция (сильная связь - "is-part-of"):

• Части не могут существовать независимо
• При удалении целого, части также удаляются
• Отношение более сильное
• Например: Автомобиль и Двигатель

class Car {
    private Engine engine; // При удалении Car удаляется и Engine
    
    public Car() {
        this.engine = new Engine(); // Создается в конструкторе
    }
}

class Engine {
    private int horsePower;
}

// Двигатель не может существовать без автомобиля

Практические примеры агрегации

Пример 1: Компания и Сотрудники

class Company {
    private String name;
    private List<Employee> employees;
    
    public Company(String name) {
        this.name = name;
        this.employees = new ArrayList<>();
    }
    
    public void hireEmployee(Employee employee) {
        employees.add(employee);
    }
    
    public void fireEmployee(Employee employee) {
        employees.remove(employee);
    }
}

class Employee {
    private String name;
    private String position;
    
    public Employee(String name, String position) {
        this.name = name;
        this.position = position;
    }
}

// Сотрудник может продолжать существовать после увольнения из компании
Employee emp = new Employee("John", "Developer");
Company company = new Company("TechCorp");
company.hireEmployee(emp);
company.fireEmployee(emp); // emp все еще существует

Пример 2: Проект и Разработчики

class Project {
    private String title;
    private List<Developer> developers;
    
    public Project(String title) {
        this.title = title;
        this.developers = new ArrayList<>();
    }
    
    public void addDeveloper(Developer dev) {
        developers.add(dev);
    }
}

class Developer {
    private String name;
    private String expertise;
}

// Разработчик может работать над несколькими проектами одновременно
Developer alice = new Developer("Alice", "Java");
Project project1 = new Project("Backend API");
Project project2 = new Project("Mobile App");
project1.addDeveloper(alice);
project2.addDeveloper(alice); // alice участвует в обоих проектах

Отличие от других отношений

Наследование (is-a):

class Employee extends Person { } // Employee является Person

Ассоциация (связь между объектами):

class Author {
    private List<Book> books; // Автор пишет книги
}

Агрегация — это частный случай ассоциации, но с более слабым отношением зависимости.

Когда использовать агрегацию?

1. Когда части могут существовать независимо — используй агрегацию
2. Когда части имеют смысл только в контексте целого — используй композицию
3. Когда нужна слабая связь — агрегация обеспечивает гибкость
4. Когда части используются в нескольких местах — агрегация позволяет переиспользование

Пример классической агрегации: Деньги в кошельке

class Wallet {
    private double amount;
}

class Person {
    private String name;
    private Wallet wallet; // Агрегация
    
    public Person(String name, Wallet wallet) {
        this.name = name;
        this.wallet = wallet; // wallet может быть передан извне
    }
    
    public void takeWallet(Wallet newWallet) {
        this.wallet = newWallet; // Можно заменить кошелек
    }
}

// Кошелек существует независимо от человека
Wallet myWallet = new Wallet();
Person john = new Person("John", myWallet);
Person jane = new Person("Jane", myWallet); // Разные люди могут иметь один кошелек

Выводы: Агрегация — это мощный инструмент для моделирования отношений между объектами, когда части имеют независимое существование. Правильное использование агрегации вместо композиции делает код более гибким и переиспользуемым.