<pre id="z8nfa"></pre>

<acronym id="z8nfa"><strong id="z8nfa"></strong></acronym><pre id="z8nfa"></pre>
<track id="z8nfa"></track>
  • <acronym id="z8nfa"><strong id="z8nfa"><listing id="z8nfa"></listing></strong></acronym>
  • 
    
    <p id="z8nfa"></p>
      鍍金池/ 教程/ Java/ 中介者模式
      訪問者模式
      訪問者模式討論篇:java的動態綁定與雙分派
      責任連模式
      迭代器模式
      策略模式
      命令模式
      單例模式
      建造者模式
      解釋器模式
      工廠方法模式
      備忘錄模式
      原型模式
      單例模式討論篇:單例模式與垃圾回收
      觀察者模式
      模版方法模式
      創建類模式總結篇
      抽象工廠模式
      中介者模式

      中介者模式

      定義:用一個中介者對象封裝一系列的對象交互,中介者使各對象不需要顯示地相互作用,從而使耦合松散,而且可以獨立地改變它們之間的交互。

      類型:行為類模式

      類圖:

      http://wiki.jikexueyuan.com/project/java-design-pattern/images/mediator-pattern-1.jpg" alt="mediator-pattern" />

      中介者模式的結構

      中介者模式又稱為調停者模式,從類圖中看,共分為3部分:

      • 抽象中介者:定義好同事類對象到中介者對象的接口,用于各個同事類之間的通信。一般包括一個或幾個抽象的事件方法,并由子類去實現。
      • 中介者實現類:從抽象中介者繼承而來,實現抽象中介者中定義的事件方法。從一個同事類接收消息,然后通過消息影響其他同時類。
      • 同事類:如果一個對象會影響其他的對象,同時也會被其他對象影響,那么這兩個對象稱為同事類。在類圖中,同事類只有一個,這其實是現實的省略,在實際應用中,同事類一般由多個組成,他們之間相互影響,相互依賴。同事類越多,關系越復雜。并且,同事類也可以表現為繼承了同一個抽象類的一組實現組成。在中介者模式中,同事類之間必須通過中介者才能進行消息傳遞。

      為什么要使用中介者模式

      一般來說,同事類之間的關系是比較復雜的,多個同事類之間互相關聯時,他們之間的關系會呈現為復雜的網狀結構,這是一種過度耦合的架構,即不利于類的復用,也不穩定。例如在下圖中,有六個同事類對象,假如對象1發生變化,那么將會有4個對象受到影響。如果對象2發生變化,那么將會有5個對象受到影響。也就是說,同事類之間直接關聯的設計是不好的。

      http://wiki.jikexueyuan.com/project/java-design-pattern/images/mediator-pattern-2.jpg" alt="mediator-pattern" />

      如果引入中介者模式,那么同事類之間的關系將變為星型結構,從圖中可以看到,任何一個類的變動,只會影響的類本身,以及中介者,這樣就減小了系統的耦合。一個好的設計,必定不會把所有的對象關系處理邏輯封裝在本類中,而是使用一個專門的類來管理那些不屬于自己的行為。

      http://wiki.jikexueyuan.com/project/java-design-pattern/images/mediator-pattern-3.jpg" alt="mediator-pattern" />

      我們使用一個例子來說明一下什么是同事類:有兩個類A和B,類中各有一個數字,并且要保證類B中的數字永遠是類A中數字的100倍。也就是說,當修改類A的數時,將這個數字乘以100賦給類B,而修改類B時,要將數除以100賦給類A。類A類B互相影響,就稱為同事類。代碼如下:

          abstract class AbstractColleague {
              protected int number;
      
              public int getNumber() {
                  return number;
              }
      
              public void setNumber(int number){
                  this.number = number;
              }
              //抽象方法,修改數字時同時修改關聯對象
              public abstract void setNumber(int number, AbstractColleague coll);
          }
      
          class ColleagueA extends AbstractColleague{
              public void setNumber(int number, AbstractColleague coll) {
                  this.number = number;
                  coll.setNumber(number*100);
              }
          }
      
          class ColleagueB extends AbstractColleague{
      
              public void setNumber(int number, AbstractColleague coll) {
                  this.number = number;
                  coll.setNumber(number/100);
              }
          }
      
          public class Client {
              public static void main(String[] args){
      
                  AbstractColleague collA = new ColleagueA();
                  AbstractColleague collB = new ColleagueB();
      
                  System.out.println("==========設置A影響B==========");
                  collA.setNumber(1288, collB);
                  System.out.println("collA的number值:"+collA.getNumber());
                  System.out.println("collB的number值:"+collB.getNumber());
      
                  System.out.println("==========設置B影響A==========");
                  collB.setNumber(87635, collA);
                  System.out.println("collB的number值:"+collB.getNumber());
                  System.out.println("collA的number值:"+collA.getNumber());
              }
          }

      上面的代碼中,類A類B通過直接的關聯發生關系,假如我們要使用中介者模式,類A類B之間則不可以直接關聯,他們之間必須要通過一個中介者來達到關聯的目的。

          abstract class AbstractColleague {
              protected int number;
      
              public int getNumber() {
                  return number;
              }
      
              public void setNumber(int number){
                  this.number = number;
              }
              //注意這里的參數不再是同事類,而是一個中介者
              public abstract void setNumber(int number, AbstractMediator am);
          }
      
          class ColleagueA extends AbstractColleague{
      
              public void setNumber(int number, AbstractMediator am) {
                  this.number = number;
                  am.AaffectB();
              }
          }
      
          class ColleagueB extends AbstractColleague{
      
              @Override
              public void setNumber(int number, AbstractMediator am) {
                  this.number = number;
                  am.BaffectA();
              }
          }
      
          abstract class AbstractMediator {
              protected AbstractColleague A;
              protected AbstractColleague B;
      
              public AbstractMediator(AbstractColleague a, AbstractColleague b) {
                  A = a;
                  B = b;
              }
      
              public abstract void AaffectB();
      
              public abstract void BaffectA();
      
          }
          class Mediator extends AbstractMediator {
      
              public Mediator(AbstractColleague a, AbstractColleague b) {
                  super(a, b);
              }
      
              //處理A對B的影響
              public void AaffectB() {
                  int number = A.getNumber();
                  B.setNumber(number*100);
              }
      
              //處理B對A的影響
              public void BaffectA() {
                  int number = B.getNumber();
                  A.setNumber(number/100);
              }
          }
      
          public class Client {
              public static void main(String[] args){
                  AbstractColleague collA = new ColleagueA();
                  AbstractColleague collB = new ColleagueB();
      
                  AbstractMediator am = new Mediator(collA, collB);
      
                  System.out.println("==========通過設置A影響B==========");
                  collA.setNumber(1000, am);
                  System.out.println("collA的number值為:"+collA.getNumber());
                  System.out.println("collB的number值為A的10倍:"+collB.getNumber());
      
                  System.out.println("==========通過設置B影響A==========");
                  collB.setNumber(1000, am);
                  System.out.println("collB的number值為:"+collB.getNumber());
                  System.out.println("collA的number值為B的0.1倍:"+collA.getNumber());
      
              }
          }

      雖然代碼比較長,但是還是比較容易理解的,其實就是把原來處理對象關系的代碼重新封裝到一個中介類中,通過這個中介類來處理對象間的關系。

      中介者模式的優點

      • 適當地使用中介者模式可以避免同事類之間的過度耦合,使得各同事類之間可以相對獨立地使用。
      • 使用中介者模式可以將對象間一對多的關聯轉變為一對一的關聯,使對象間的關系易于理解和維護。
      • 使用中介者模式可以將對象的行為和協作進行抽象,能夠比較靈活的處理對象間的相互作用。

      適用場景

      在面向對象編程中,一個類必然會與其他的類發生依賴關系,完全獨立的類是沒有意義的。一個類同時依賴多個類的情況也相當普遍,既然存在這樣的情況,說明,一對多的依賴關系有它的合理性,適當的使用中介者模式可以使原本凌亂的對象關系清晰,但是如果濫用,則可能會帶來反的效果。一般來說,只有對于那種同事類之間是網狀結構的關系,才會考慮使用中介者模式??梢詫⒕W狀結構變為星狀結構,使同事類之間的關系變的清晰一些。

      中介者模式是一種比較常用的模式,也是一種比較容易被濫用的模式。對于大多數的情況,同事類之間的關系不會復雜到混亂不堪的網狀結構,因此,大多數情況下,將對象間的依賴關系封裝的同事類內部就可以的,沒有必要非引入中介者模式。濫用中介者模式,只會讓事情變的更復雜。

      上一篇:備忘錄模式下一篇:抽象工廠模式
      无码丰满熟妇一区二区蜜臀Av
      <pre id="z8nfa"></pre>

      <acronym id="z8nfa"><strong id="z8nfa"></strong></acronym><pre id="z8nfa"></pre>
      <track id="z8nfa"></track>
    1. <acronym id="z8nfa"><strong id="z8nfa"><listing id="z8nfa"></listing></strong></acronym>
    2. 
      
      <p id="z8nfa"></p>