在Java中聚合和组合之间实现差异(Implementation difference betwee

我所知道的聚合和组合之间的概念差别。谁能告诉我在Java中它们之间的结合实例实施差别？

Answer 1:

组成

final class Car {

  private final Engine engine;

  Car(EngineSpecs specs) {
    engine = new Engine(specs);
  }

  void move() {
    engine.work();
  }
}

聚合

final class Car {

  private Engine engine;

  void setEngine(Engine engine) {
    this.engine = engine;
  }

  void move() {
    if (engine != null)
      engine.work();
  }
}

在组合物的情况下，发动机完全被汽车包封。有没有办法对外面的世界去的引擎的引用。该发动机寿命和同车死亡。随着聚集，车上还通过引擎执行其功能，但发动机并不总是汽车内部的一部分。发动机可以交换，甚至完全去除。不仅如此，但外界仍然有引擎的引用，不管它是在汽车与它鼓捣。

Answer 2:

我会用一个漂亮的UML的例子。

采取一个大学有1到20个不同的部门，每个部门都有1至5的教授。有一个大学，其部门之间的组成环节。有一个部门，其教授之间的聚合链路。

组成仅仅是一个强大的聚集，如果学校被破坏，则部门也应该被销毁。但是，我们不应该杀，即使他们的respectives部门消失教授。

在java中：

public class University {

     private List<Department> departments;

     public void destroy(){
         //it's composition, when i destroy a university I also destroy the departments. they cant live outside my university instance
         if(departments!=null)
             for(Department d : departments) d.destroy();
         departments.clean();
         departments = null;
     }
}

public class Department {

     private List<Professor> professors;
     private University university;

     Department(University univ){
         this.university = univ;
         //check here univ not null throw whatever depending on your needs
     }

     public void destroy(){
         //It's aggregation here, we just tell the professor they are fired but they can still keep living
         for(Professor p:professors)
             p.fire(this);
         professors.clean();
         professors = null;
     }
}

public class Professor {

     private String name;
     private List<Department> attachedDepartments;

     public void destroy(){

     }

     public void fire(Department d){
         attachedDepartments.remove(d);
     }
}

事情解决这个问题。

Answer 3:

不同的是，任何组合物是聚合，而不是相反。

让我们的条款。聚集是在UML标准一个metaterm的装置，以及BOTH组合物和共享聚集，简单地命名为共享。常常被错误地命名为“聚合”。它是坏的，对于成分是聚集了。据我所知，你的意思是“共享”。

另外，从UML标准：

复合 - 表示属性复合地聚集，即，复合物具有用于组成对象（份）的存在和存储的责任。

所以，大学cathedras协会是一个组合，因为cathedra的不存在了大学学报（恕我直言）

共享聚集精确语义因应用领域和建模而变化。

也就是说，所有其他社团可以得出共享聚合，如果你只以下到你的或别人的一些原则。另外，也要看看这里。

Answer 4:

简单来说：

这两种成分并聚合是关联。组成 - >强有-A关系汇总 - >疲软已在-A的关系。

Answer 5:

有在下面给定的URL很好的解释。

http://www.codeproject.com/Articles/330447/Understanding-Association-Aggregation-and-Composit

请检查！！！

Answer 6:

简单的构图计划

public class Person {
    private double salary;
    private String name;
    private Birthday bday;

    public Person(int y,int m,int d,String name){
        bday=new Birthday(y, m, d);
        this.name=name;
    }


    public double getSalary() {
        return salary;
    }

    public String getName() {
        return name;
    }

    public Birthday getBday() {
        return bday;
    }

    ///////////////////////////////inner class///////////////////////
    private class Birthday{
        int year,month,day;

        public Birthday(int y,int m,int d){
            year=y;
            month=m;
            day=d;
        }

        public String toString(){
           return String.format("%s-%s-%s", year,month,day);

        }
    }

    //////////////////////////////////////////////////////////////////

}
public class CompositionTst {

    public static void main(String[] args) {
        // TODO code application logic here
        Person person=new Person(2001, 11, 29, "Thilina");
        System.out.println("Name : "+person.getName());
        System.out.println("Birthday : "+person.getBday());

        //The below object cannot be created. A bithday cannot exixts without a Person 
        //Birthday bday=new Birthday(1988,11,10);

    }
}

Answer 7:

首先我们必须谈论什么是真正的区别Aggregation和Composition是要在同一页上。

聚合是在相关联的实体可以存在独立的关联的关联。例如，一个人可能被关联到一个组织，但他/她可以在系统中独立存在。

而

成分是指当关联实体的一个密切相关的其他和没有对方的存在可以不存在的情况。在事实实体的身份总是与其他对象的身份相关联。例如，车轮的车厢内。

现在，聚合可以简单地通过如下另一个拿着一个实体的属性来实现：

class Person {
    Organisation worksFor;
}

class Organisation {
    String name;
}

class Main {
    public static void main(String args[]) {

        //Create Person object independently
        Person p = new Person();

        //Create the Organisation independently
        Organisation o = new Organisation();
        o.name = "XYZ Corporation";

        /*
          At this point both person and organisation 
          exist without any association  
        */
        p.worksFor = o;

    }
}

对于构成是必要的依赖对象总是与它相关联的对象的身份创建。您可以使用一个内部类的相同。

class Car {
    class Wheel {
        Car associatedWith;
    }
}

class Main {
    public static void main() {
        //Create Car object independently
        Car car = new Car();

        //Cannot create Wheel instance independently
        //need a reference of a Car for the same.
        Car.Wheel wheel = car.new Wheel();
    }
}

请注意，相同的使用情况下可以归入根据应用场景聚合/组成。例如，个人与组织的情况下有可能成为组成，如果你正在为人们在一些组织中工作的应用程序和参考组织必须为报名。同样，如果你是保持汽车的零部件库存，汽车轮关系可以聚集。

Answer 8:

这两种类型的当然协会，并没有真正严格地映射到语言元素这样。所不同的是在目的，上下文和系统建模方式。

作为一个实际的例子，比较两种不同类型的具有类似实体系统：

一辆汽车登记系统主要跟踪的车，和它们的主人，等在这里，我们不感兴趣的引擎作为一个独立的实体，但我们仍然可以有与发动机有关的属性，如电力和燃料的类型。在这里，发动机可以在汽车实体的复合材料部件。
汽车服务店管理系统 ，管理汽车零部件，汽车维修，更换零部件，也许完整的发动机。在这里，我们甚至有可能放养发动机，需要跟踪它们，并分别其它部分和独立的汽车。在这里，发动机可以在汽车实体的集合的一部分。

如何实现这在你的语言是次要问题，因为在像可读性该级别的东西重要得多。

文章来源: Implementation difference between Aggregation and Composition in Java