中介者模式（软考）

Mediator(中介者）

意图：

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

适用性：

• 一组对象以定义良好但是复杂的方式进行通信，产生的相互依赖关系结构混乱且难以理解。
• 一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。
• 想定制一个分布在多个类中的行为，而又不想生成太多的字类。

package 中介者模式;

public class MediatorPattern {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();

        Colleague1 colleague1 = new Colleague1(mediator);    //这里的作用使分别将中介者传入两个同事中
        Colleague2 colleague2 = new Colleague2(mediator);

        mediator.setColleague1(colleague1);    //在具体的中介者中传入两个同事
        mediator.setColleague2(colleague2);

        colleague1.sendMessage("软考加油");
        colleague2.sendMessage("祝大家软考顺利通过！");
    }
}


abstract class Colleague{              //同事类
    protected Mediator mediator;    //引用指针

}

class Colleague1 extends Colleague{
    public Colleague1(Mediator mediator){
        this.mediator = mediator;
    }
    public void sendMessage(String message){                //同事1调用sendMessage（）方法，message=”软考加油“
        mediator.sendMessage(message,this);   //要有发送的消息和发送者，这里用this来调用自身，这里mediator是上面实例化具体中介者的字类名
    }
    public void Notify(String message){
        System.out.println("同事1收到消息："+message);

    }
}


class Colleague2 extends Colleague{
    public Colleague2(Mediator mediator){
        this.mediator= mediator;
    }
    public void sendMessage(String message){
        mediator.sendMessage(message,this);  //要有发送的消息和发送者，这里用this来调用自身
    }

    public void Notify(String message){
        System.out.println("同事2收到消息："+message);
    }
}

abstract class Mediator{    //定义一个中介者类
    public abstract void sendMessage(String message,Colleague colleague);        //中介者模式就是利用中介者来充当传递信息的中间人
}


class ConcreteMediator extends Mediator{
    private Colleague1 colleague1;
    private Colleague2 colleague2;

    public void setColleague1(Colleague1 colleague1){
        this.colleague1 = colleague1;
    }


    public void setColleague2(Colleague2 colleague2){
        this.colleague2 = colleague2;
    }

    public void sendMessage(String message,Colleague colleague){
        if(colleague == colleague1) {
            colleague2.Notify(message);// 让同事2收到消息
        }else{
            colleague1.Notify(message);// 让同事1收到消息
        }
    }
}、

试题2020下半年试题六

试题六（共 15 分）

阅读下列说明和 Java 代码，将应填入 （n） 处的字句写在答题纸的对应栏内。

【说明】

在线支付是电子商务的一个重要环节，不同的电子商务平台提供了不同的支付接口。现

在需要整合不同电子商务平台的支付接口，使得客户在不同平台上购物时，不需要关心具体

的支付接口。拟采用中介者（Mediator）设计模式来实现该需求，所设计的类图如图 6-1 所

示。

从图6-1 类图可以得到的信息有：

1.Amazon类和Ebay类继承WebService类，ConcreteServiceMediator类继承webServiceMediator类（这里的考点有）

有一或者二空是填写（extends）关键字

填写（abstract或者interface）关键字，具体看extends|implements来判断

根据抽象类或者接口的特点，字类继承父类或者实现接口的所有抽象方法

还有可能考super方法的调用，调用父类的方法或者构造函数

2.WebService 有一个依赖 箭头从WebServiceMediator指向

这可以考一个在WebServiceMediator类中创建一个指针（引用对象），来为构造函数赋值，补充（若是组合或者聚合关系，则是在类中补充对应类型 变量名）

3.具体支付接口有多个，可能会考泛化，

List arrayList = new ArrayList();

【Java 代码】 
import java.util.*; 
 
interface WebServiceMediator {   //定义一个接口中介者
public (1)void buy(double money, WebService service);   //这里可以一般根据实现的字类类判断具体是哪个抽象方法
public void SetAmazon(WebService amazon);  //这里创建了两个支付方法
public void SetEbay(WebService ebay); 
} 
 
abstract class WebService { //定义了一个抽象类
protected (2)WebServiceMediator mediator; //这里就是依赖那个关系，相当于引用的作用
public abstract void SetMediator(WebServiceMediator mediator); 
public (3)  abstract void buyService(double money); //这里应该根据extends的子类来判断是什么方法,注意这里需要加abstract
public abstract void search(double money); 
}  
 
class ConcreteServiceMediator implements WebServiceMediator {  //定义了一个具体的中介者
private WebService amazon; //这里是想把这两个支付方式传入中介者当中（这是中介者模式的行为）
private WebService ebay; 
 
 public ConcreteServiceMediator() { //定义了一个无参构造方法
amazon = null; 
ebay = null; 
} 
 
 public void SetAmazon(WebService amazon) { 
this.amazon = amazon; 
} 
 
 public void SetEbay(WebService ebay) { 
this.ebay = ebay; 
} 
 
 public void buy(double money, WebService service) {  //定义了一个参数为钱，一个参数为是哪种支付接口的服务
if (service == amazon) 
amazon.search(money); 
else 
ebay.search(money); 
} 
} 
class Amazon extends WebService { 
public void SetMediator(WebServiceMediator mediator) { 
this.mediator = mediator; 
} 
 
 public void buyService(double money) { 
 (4)mediator.buy(money,this);    //4与5空相似，答案应该差不多，这个是中介者模式，前面定义的buy方法没有用，还出现了两次，则buy方法必须考，则就是调用buy
                                   方法，这里只有mediator对象，用mediator来调用，参数第二个this代表调用自身。
} 
 
 public void search(double money) { 
System.out.println("Amazon receive：" + money); 
} 
} 
 
class Ebay extends WebService { 
public void SetMediator(WebServiceMediator mediator) { 
this.mediator = mediator; 
} 
 
 public void buyService(double money) { 
 (5)mediator.buy(money,this) ; 
} 
 
 public void search(double money) { 
System.out.println("Ebay receive：" + money); 
} 
}