Java软件工程: Composition vs Aggregation

Question

我真的很难理解码合和聚合。在下面的代码中，我想知道以下哪个汽车实例使用组合逻辑或聚合逻辑。

public class Engine {

    public Engine() {

    }
}

public class Car1 {

    public final Engine engine;

    public Car1() {
        engine = new Engine();

    }

}

class Car2{

    public Engine engine;

    public Car2(Engine engine) {
        this.engine = engine;
    }
}

class Car3{

    public final Engine engine;

    public Car3(Engine engine) {
        this.engine = engine;
    }
}

class Car4{

       Engine engine;

       public Car4(){

        this.engine = new Engine();

       }

}


class Main{

    public static void main(String[] args) {

        Engine engine = new Engine(); 
        Car1 car1 = new Car1(); 

        Car2 car2_1 = new Car2(new Engine());
        Car2 car2_2 = new Car2(engine);

        Car3 car3_1 = new Car3(new Engine());
        Car3 car3_2 = new Car3(engine);

        Car4 car4_1 = new Car4();

    }
}

据我所知，car1、car2_1、car3_1 遵循组合逻辑。但我读过很多地方说car3_2也是组合。为什么？如果我们销毁 car3_2，引擎实例仍然存在，所以应该是聚合。

Answer 1

• Aggregation implies a relationship where the child can exist independently of the parent. Example: Class (parent) and Student (child). Delete the Class and the Students still exist.
• Composition implies a relationship where the child cannot exist independent of the parent. Example: House (parent) and Room (child). Rooms don't exist separate to a House.

因此，就其本质而言，它不能成为任何以下对象的组合:

• 可以被多个其他对象拥有
• 可以无主(初始化完成后)
• 可以更改所有者

car3_2 不能是组合，因为它与 car2_2 共享引擎。

其他都是组合吗？从逻辑上讲，在现实生活中，您可以从一辆车上拆下发动机并将其安装在另一辆车上，因此汽车与发动机的关系是聚合。

以编程方式，final 关键字会阻止从 Car 中删除 Engine，但不会阻止将相同的引擎添加到另一辆车，并且它不会阻止该车被“删除”以及引擎更改所有者，因此 final 本身并不能确保组合关系。

当构造函数将引擎作为参数时，Car类无法确保引擎不被共享，因此无法确保组合关系。

仅当 Engine 由 Car 构造函数创建且该字段为 final(或有效最终的，本质上是 private 没有 setter 方法)，是否保证遵守 Composition 的定义。

并不意味着其他以Engine作为参数的不能有效地组合。这取决于它的使用方式。例如。如果 Car 是由 Factory 类创建的，则工厂可以强制执行组合规则。