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;   

}

所以，關聯、聚合、組合只能配合語義，結合上下文才能夠判斷出來，而只給出一段代碼讓我們判斷是關聯，聚合，還是組合關係，則是無法判斷的。