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

Question

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

Answer 1

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

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 2

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