java聚合,java聚合支付系统

本文目录一览：

• 1、什么是java聚合工程
• 2、Java 聚集 组合
• 3、JAVA中的聚集和组合的区别和联系
• 4、mongondb在java里处理聚合函数？
• 5、java中的组合与聚合，区别。。。详细点
• 6、java怎么理解组合/聚合关系给个例子最好能将细点

什么是java聚合工程

聚合就是由很多节点合到一起的一个工程，但是每个节点不能独立存在。有一个相对的概念叫组合，组合也有很多节点组成，但是它的每个节点可以独立存在。

Java 聚集 组合

聚合和组合的区别在于：聚合关系是“has-a”关系，组合关系是“contains-a”关系；聚合关系表示整体与部分的关系比较弱，而组合比较强；聚合关系中代表部分事物的对象与代表聚合事物的对象的生存期无关，一旦删除了聚合对象不一定就删除了代表部分事物的对象。组合中一旦删除了组合对象，同时也就删除了代表部分事物的对象。

我们用浅显的例子来说明聚合和组合的区别。“国破家亡”，国灭了，家自然也没有了，“国”和“家”显然也是组合关系。而相反的，计算机和它的外设之间就是聚合关系，因为它们之间的关系相对松散，计算机没了，外设还可以独立存在，还可以接在别的计算机上。在聚合关系中，部分可以独立于聚合而存在，部分的所有权也可以由几个聚合来共享，比如打印机就可以在办公室内被广大同事共用。

聚合则一般不是平等的，例如一个公司包含了很多员工，其实现上是差不多的。聚合和组合的区别则在语义和实现上都有差别，组合的两个对象之间其生命期有很大的关联，被组合的对象是在组合对象创建的同时或者创建之后创建，在组合对象销毁之前销毁。一般来说被组合对象不能脱离组合对象独立存在，而且也只能属于一个组合对象，例如一个文档的版本，必须依赖于文档的存在，也只能属于一个文档。聚合则不一样，被聚合的对象可以属于多个聚合对象，例如一个员工可能可以属于多个公司。

JAVA中的聚集和组合的区别和联系

组合实际上是聚集关系的一种特殊形式。聚集模拟了具有（has-a）关系，表示两个对象之间的归属关系。归属关系中的所有者对象称为聚集对象（aggregation object），而它的类称为聚集类（aggregating class）。归属关系中的从属对象称为被聚集类（aggregated object），而它的类被称为被聚集类（aggregated class）。

一个对象可以被几个其他聚集对象所拥有。如果一个对象只归属于一个聚集对象，那么它和聚集对象之间的关系就称为组合（composition）。例如：“一个学生有一个名字”就是组合关系，“一个学生有一个地址”就是聚集关系，因为一个地址可以被几个学生所共享。

mongondb在java里处理聚合函数？

MongoDB sum,avg等聚合函数很弱，可以用MapReduce来实现,我给你个例子

// ※※※※※※※※※※※※※※※※※※※ 数据加载 ※※※※※※※※※※※※※※※※※※※

db.proc.remove();

for(var i = 10; i 1020; i++){db.proc.insert({class:”01″, val:i, name: “name” + i})};

for(var i = 10; i 1030; i++){db.proc.insert({class:”02″, val:i, name: “name” + i})};

for(var i = 10; i 1040; i++){db.proc.insert({class:”03″, val:i, name: “name” + i})};

for(var i = 10; i 1050; i++){db.proc.insert({class:”04″, val:i, name: “name” + i})};

for(var i = 10; i 1060; i++){db.proc.insert({class:”05″, val:i, name: “name” + i})};

for(var i = 10; i 1070; i++){db.proc.insert({class:”06″, val:i, name: “name” + i})};

for(var i = 10; i 1080; i++){db.proc.insert({class:”07″, val:i, name: “name” + i})};

for(var i = 10; i 1090; i++){db.proc.insert({class:”08″, val:i, name: “name” + i})};

for(var i = 10; i 1100; i++){db.proc.insert({class:”09″, val:i, name: “name” + i})};

for(var i = 10; i 1110; i++){db.proc.insert({class:”10″, val:i, name: “name” + i})};

for(var i = 10; i 1120; i++){db.proc.insert({class:”11″, val:i, name: “name” + i})};

// ※※※※※※※※※※※※※※※※※※※ mapReduce ※※※※※※※※※※※※※※※※※※※

m = function(){emit(this.class, {count:1, max:this.val, sum:this.val})}

r = function(key, values){

var ct = 0, sm = 0, mx = 0;

for(var i = 0; i values.length; i++){

ct += values[i].count;

sm += values[i].max;

mx = Math.max(mx, values[i].max);

}

return {count:ct, max: mx, sum:sm};

}

// ※※※※※※※※※※※※※※※※※※※ 数据处理 ※※※※※※※※※※※※※※※※※※※

res = db.runCommand({mapreduce:”proc”, map:m, reduce:r, out:”proc_res”})

res = db.runCommand({mapreduce:”proc”, map:m, reduce:r, out:”proc_res3″, query:{“class”:{$gt:”03″}}})

res = db.runCommand({mapreduce:”proc”, map:m, reduce:r, out:”proc_res5″, query:{“class”:{$gt:”05″}}})

res = db.runCommand({mapreduce:”proc”, map:m, reduce:r, out:”proc_res6″, query:{“class”:{$gt:”06″}}})

res = db.runCommand({mapreduce:”proc”, map:m, reduce:r, out:”proc_res9″, query:{“class”:{$gt:”09″}}})

res = db.runCommand({mapreduce:”proc”, map:m, reduce:r, out:”proc_res10″,query:{“class”:{$gt:”10″}}})

// ※※※※※※※※※※※※※※※※※※※ 结果查看 ※※※※※※※※※※※※※※※※※※※

db.proc_res.find()

{ “_id” : 1, “value” : { “class” : 1, “count” : 10, “sum” : 145, “max” : 19 } }

{ “_id” : 2, “value” : { “class” : 2, “count” : 20, “sum” : 390, “max” : 29 } }

{ “_id” : 3, “value” : { “class” : 3, “count” : 30, “sum” : 735, “max” : 39 } }

{ “_id” : 4, “value” : { “class” : 4, “count” : 40, “sum” : 1180, “max” : 49 } }

{ “_id” : 5, “value” : { “class” : 5, “count” : 50, “sum” : 1725, “max” : 59 } }

{ “_id” : 6, “value” : { “class” : 6, “count” : 60, “sum” : NaN, “max” : NaN } }

{ “_id” : 7, “value” : { “class” : 7, “count” : 70, “sum” : 3115, “max” : 79 } }

{ “_id” : 8, “value” : { “class” : 8, “count” : 80, “sum” : NaN, “max” : NaN } }

{ “_id” : 9, “value” : { “class” : 9, “count” : 90, “sum” : NaN, “max” : NaN } }

{ “_id” : 10, “value” : { “class” : 10, “count” : 100, “sum” : NaN, “max” : NaN } }

{ “_id” : 11, “value” : { “class” : 11, “count” : 110, “sum” : NaN, “max” : NaN } }

db.proc_res3.find()

{ “_id” : 4, “value” : { “class” : 4, “count” : 40, “sum” : 1180, “max” : 49 } }

{ “_id” : 5, “value” : { “class” : 5, “count” : 50, “sum” : 1725, “max” : 59 } }

{ “_id” : 6, “value” : { “class” : 6, “count” : 60, “sum” : NaN, “max” : NaN } }

{ “_id” : 7, “value” : { “class” : 7, “count” : 70, “sum” : NaN, “max” : NaN } }

{ “_id” : 8, “value” : { “class” : 8, “count” : 80, “sum” : 3960, “max” : 89 } }

{ “_id” : 9, “value” : { “class” : 9, “count” : 90, “sum” : 4905, “max” : 99 } }

{ “_id” : 10, “value” : { “class” : 10, “count” : 100, “sum” : NaN, “max” : NaN } }

{ “_id” : 11, “value” : { “class” : 11, “count” : 110, “sum” : NaN, “max” : NaN } }

db.proc_res5.find()

{ “_id” : 6, “value” : { “class” : 6, “count” : 60, “sum” : 2370, “max” : 69 } }

{ “_id” : 7, “value” : { “class” : 7, “count” : 70, “sum” : NaN, “max” : NaN } }

{ “_id” : 8, “value” : { “class” : 8, “count” : 80, “sum” : NaN, “max” : NaN } }

{ “_id” : 9, “value” : { “class” : 9, “count” : 90, “sum” : 4905, “max” : 99 } }

{ “_id” : 10, “value” : { “class” : 10, “count” : 100, “sum” : 5950, “max” : 109 } }

{ “_id” : 11, “value” : { “class” : 11, “count” : 110, “sum” : NaN, “max” : NaN } }

db.proc_res6.find()

{ “_id” : 7, “value” : { “class” : 7, “count” : 70, “sum” : 3115, “max” : 79 } }

{ “_id” : 8, “value” : { “class” : 8, “count” : 80, “sum” : NaN, “max” : NaN } }

{ “_id” : 9, “value” : { “class” : 9, “count” : 90, “sum” : NaN, “max” : NaN } }

{ “_id” : 10, “value” : { “class” : 10, “count” : 100, “sum” : NaN, “max” : NaN } }

{ “_id” : 11, “value” : { “class” : 11, “count” : 110, “sum” : NaN, “max” : NaN } }

db.proc_res9.find()

{ “_id” : 10, “value” : { “class” : 10, “count” : 100, “sum” : 5950, “max” : 109 } }

{ “_id” : 11, “value” : { “class” : 11, “count” : 110, “sum” : NaN, “max” : NaN } }

db.proc_res10.find()

{ “_id” : 11, “value” : { “class” : 11, “count” : 110, “sum” : NaN, “max” : NaN } }

java中的组合与聚合，区别。。。详细点

聚合就是：表示两个对象之间是整体和部分的弱关系，部分的生命周期可以超越整体。如下：实例化Person，不一定要实例化Telephone。has a

public class Person{

private Telephone tel;

private Hand hand = new Hand();

…….

}

class Telephone{

……

}

组合：组合：表示两个对象之间是整体和部分的强关系，部分的生命周期不能超越整体，或者说不能脱离整体而存在。组合关系的“部分”，是不能在整体之间进行共享的。如人和手的关系：人是整体，手是部分。is a 的关系 。手不能脱离人。

public class hand{

……

}

java怎么理解组合/聚合关系给个例子最好能将细点

聚合(Aggregation) 关系是关联关系的一种，是强的关联关系。聚合是整体和个体之间的关系。例如，汽车类与引擎类、轮胎类，以及其它的零件类之间的关系便整体和个体的关系。与关联关系一样，聚合关系也是通过实例变量实现的。但是关联关系所涉及的两个类是处在同一层次上的，而在聚合关系中，两个类是处在不平等层次上的，一个代表整体，另一个代表部分。 

组合(Composition) 关系是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分对象的生命周期，组合关系是不能共享的。代表整体的对象需要负责保持部分对象和存活，在一些情况下将负责代表部分的对象湮灭掉。代表整体的对象可以将代表部分的对象传递给另一个对象，由后者负责此对象的生命周期。换言之，代表部分的对象在每一个时刻只能与一个对象发生组合关系，由后者排他地负责生命周期。部分和整体的生命周期一样。

class Driver {   

    //使用成员变量形式实现关联   

    Car mycar;   

    public void drive(){   

        mycar.run();   

    }   

    …   

    //使用方法参数形式实现关联   

    public void drive(Car car){   

        car.run();   

    }   

}

聚合关系是是一种比较强的关联关系，java中一般使用成员变量形式实现。对象之间存在着整体与部分的关系。例如上例中

class Driver {   

    //使用成员变量形式实现聚合关系   

    Car mycar;   

    public void drive(){   

        mycar.run();   

    }   

}

假如给上面代码赋予如下语义：车是一辆私家车，是司机财产的一部分。则相同的代码即表示聚合关系了。聚合关系一般使用setter方法给成员变量赋值。 

假如赋予如下语义：车是司机的必须有的财产，要想成为一个司机必须要先有辆车，车要是没了，司机也不想活了。而且司机要是不干司机了，这个车就砸了，别人谁也别想用。那就表示组合关系了。一般来说，为了表示组合关系，常常会使用构造方法来达到初始化的目的，例如上例中，加上一个以Car为参数的构造方法 

public Driver(Car car){   

    mycar = car;   

}

所以，关联、聚合、组合只能配合语义，结合上下文才能够判断出来，而只给出一段代码让我们判断是关联，聚合，还是组合关系，则是无法判断的。