java - 面向对象编程中，组合和聚合，一般是在类里面怎么实现的呢？

Question

在面向对象开发的时候，组合和聚合，一般是在类里面怎么实现的呢？
是否是将B类的实例作为A类的一个属性进行实现的？

Answer 1

组合关系（Composition）表示一个类（A类）由另一个类（B类）的对象组成，并且类A负责创建、管理和销毁类B的对象。通常，我们会将类B的实例作为类A的一个属性来实现组合关系。这意味着类A拥有类B的对象，并且该对象的生命周期由类A控制。
聚合关系（Aggregation）表示一个类（A类）包含另一个类（B类）的对象，但两者之间的关系不如组合关系紧密。类A包含的类B对象可以独立存在，并且可以从类A中移除而不影响类B的生命周期。在实现上，同样可以将类B的实例作为类A的一个属性。

Answer 2

实现上来说是这样的。区别在于聚合的话部分的实例可以独立于整体的实例存在，组合的话部分的实例不可以独立于整体的实例存在，整体实例消失部分实例也会消失。
聚合的例子——部门和员工，部门就算没了员工也还是可以存在：

public class Employee {
    private String name;

    public Employee(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class Department {
    private List<Employee> employees;

    public Department() {
        this.employees = new ArrayList<>(); // 初始化的时候员工列表可以为空
    }

    public void addEmployee(Employee employee) {
        employees.add(employee);
    }

    public void removeEmployee(Employee employee) {
        employees.remove(employee);
    }

    public List<Employee> getEmployees() {
        return employees;
    }
}

组合的例子——引擎和汽车，引擎是汽车的一部分，同时引擎不能创建自己的实例，必须由汽车创建:

public class Engine {
    private boolean isRunning;

    public void start() {
        isRunning = true;
    }

    public void stop() {
        isRunning = false;
    }

    public boolean isRunning() {
        return isRunning;
    }
}

public class Car {
    private Engine engine;

    public Car() {
        this.engine = new Engine(); // 引擎只能在汽车创建实例的时候也创建实例
    }

    public void startEngine() {
        engine.start();
    }

    public void stopEngine() {
        engine.stop();
    }

    public boolean isEngineRunning() {
        return engine.isRunning();
    }
}

Answer 3

在面向对象编程中，组合（Composition）和聚合（Aggregation）确实通常是通过将一个类的实例作为另一个类的属性来实现的。不过，虽然这两种概念在实现方式上可能相似（即将一个对象作为另一个对象的属性），它们在表示对象间关系的本质和生命周期管理上有所不同。

组合（Composition）

组合是一种“强拥有”关系，其中一个对象（称为整体）包含另一个对象（称为部分）。整体负责部分的生命周期，即整体创建部分，并在整体被销毁时销毁部分。

实现方式：

在组合中，通常会将“部分”类的实例作为“整体”类的一个属性。但是，关键在于整体类负责管理这个部分实例的创建和销毁。这可以通过在整体类的构造函数中创建部分实例，并在整体类的析构函数或清理方法中销毁这个实例来实现。

class Engine {
    // Engine 的实现
}

class Car {
    private Engine engine;

    public Car() {
        engine = new Engine(); // 整体（Car）创建并包含部分（Engine）
    }

    // 当 Car 被销毁时，Engine 实例通常也会通过垃圾回收机制被清理
    // 但在某些情况下，可能需要显式地管理资源释放
}

聚合（Aggregation）

聚合是一种“弱拥有”关系，它表示一个对象（称为整体）与另一个对象（称为部分）之间存在关联，但整体并不负责部分的生命周期。部分可以独立于整体存在，整体仅仅是对部分的一个引用。

实现方式：

聚合也是通过将“部分”类的实例作为“整体”类的一个属性来实现的，但与组合不同的是，整体类不负责管理部分实例的创建和销毁。

class Employee {
    // Employee 的实现
}

class Department {
    private List<Employee> employees;

    public Department() {
        employees = new ArrayList<>();
        // 可以在这里添加员工，但不需要创建员工实例
    }

    // 添加员工
    public void addEmployee(Employee employee) {
        employees.add(employee);
    }

    // 移除员工（不销毁员工实例）
    public void removeEmployee(Employee employee) {
        employees.remove(employee);
    }
}

在这个例子中，Department 类包含了 Employee 类的实例列表，但它并不负责 Employee 实例的创建和销毁。Employee 实例可以在没有 Department 的情况下独立存在，而 Department 仅仅是对这些实例的引用。

总结

组合和聚合都是通过将一个类的实例作为另一个类的属性来实现的，但它们在对象间关系的强度和生命周期管理方面有所不同。组合表示一种更强的“拥有”关系，而聚合则表示一种较弱的“关联”关系。