3

我有几个需要相互交互的演示文稿中涉及的“小部件”，但交互已经变得足够复杂，以至于需要一个新对象来处理交互。

在尝试将调解器作为该对象进行工作时，我对如何有效地构建参与者感到困惑。中介者必须知道小部件，小部件必须知道中介者。

使用下面的玩具类，有人可以向我展示构造函数的外观以及它们通常以什么顺序创建？

干杯，
贝里尔

class WidgetOne {       
    Mediator _mediator;
} 

class WidgetTwo {       
    Mediator _mediator;
} 

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;               
}
4

2 回答 2

2

你没有指定一种语言，所以我会尽可能保持通用。

abstract class Participant {
    public string Notify(string message);
}

class WidgetOne  extends Participant {       
    Mediator _mediator;
    public WidgetOne(Mediator theMediator){
        _mediator = theMediator;
    }
    public string Notify(string message){
       #do whatever
    }
    public string Talk(string message){
       return _mediator.Talk(message, this);
    }
} 

class WidgetTwo extends Participant  {       
    Mediator _mediator;
    public WidgetOne(Mediator theMediator){
        _mediator = theMediator;
    }
    public string Notify(string message){
       #do whatever
    }
    public string Talk(string message){
       return _mediator.Talk(message, this);
    }
}

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;
    public void setWidgetOne(WidgetOne theWidget){
        _wiidgetOne = theWidget;
    }
    public void setWidgetTwo(WidgetTwo theWidget){
        _wiidgetTwo = theWidget;
    }
    public string Talk(string message, Participant p){
           #make sure you do the correct ==/equals/etc.
          if(p == _widgetOne){
              response = _widgetTwo.Notify(message);    
          }else if (p == _widgetTwo){
               response  = _widgetOne.Notify(message);
          }
          return response;
    }

}

class Main {
    public void run(){
       Mediator theMediator = new Mediator();
       WidgetOne  one = new WidgetOne(theMediator);
       WidgetTwo  two = new WidgetTwo(theMediator);
       theMediator.setWidgetOne(one);
       theMediator.setWidgetTwo(two);
       one.Talk("hi there");
    }
}

因此，在高级别上，您有 2 个参与者想要交谈，因此您需要设置一个通用界面来这样做。

  1. 我们创建一个方法调用 Notify(message); 这基本上是你的沟通渠道。

  2. 为了进行设置，我们实例化了一个调解器，然后实例化两个参与者，将它们传递给调解器。

  3. 最后一步 insetup 是注入/设置中介参与者。在我们的例子中，我们只使用简单的设置器。

  4. 当需要进行通信时，每个参与者只需调用中介，将消息和自身作为参数传递。

  5. 调解员看看谁联系了他们，然后打电话给相反的人。

如果您有任何问题，请告诉我，这种模式显然有很多变体，所以如果您还想看到其他内容，请告诉我。

小心。

于 2011-06-21T01:58:48.417 回答
2

这实际上取决于许多其他情况，但我可能会这样做：

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

    void setWidgetOne(WidgetOne one){_widgetOne = one;}
    void setWidgetTwo(WidgetTwo one){_widgetTwo = one;}            
}

class WidgetOne {
    Mediator me
    void WidgetOne(Mediator me){
        this.me = me
        me.setWidgetOne(this);
    }
}

class WidgetTwo {
    Mediator me
    void WidgetTwo(Mediator me){
        this.me = me
        me.setWidgetTwo(this);
    }
}

Mediator me = new Mediator();
WidgetOne one = new WidgetOne(me);
WidgetTwo two = new WidgetTwo(me);

当然，如果没有其他关于小部件的信息，那么我将摆脱 setter 并拥有以下内容：

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

     void Mediator(){
        _widgetOne = new WidgetOne(this);
        _widgetTwo = new WidgetTwo(this);
     }            
}

class WidgetOne {
    Mediator me
    void WidgetOne(Mediator me){
        this.me = me
    }
}

class WidgetTwo {
    Mediator me
    void WidgetTwo(Mediator me){
        this.me = me
    }
}

其他几个简短的...简短的形式：

// Factory:

class Mediator {    
    WidgetOne _widgetOne;
    WidgetTwo _widgetTwo;   

     void Mediator(){
        _widgetOne = WidgetFactory.getW1(this);
        _widgetTwo = WidgetFactory.getW2(this);
     }            
}

class W1 {
    Mediator me
    void W1(){
    }
    void setMediator(Mediator med){me = med}
}

class WidgetFactory {
    W1 getW1(Mediator me){ W1 w = new W1(); w.setMediator(me); return me}
}


// Centralized "model" (variant of factory)
class Mediator {
   W1 w1;

   static Mediator getInstance(){ return inst; }// See Singleton

   void registerW1(W1 w){w1 = w; w.setMediator(this);}
}
于 2011-06-21T02:03:55.657 回答