java设计模式_中介者模式

/**
 * @Title: Country.java
 * @Package com.wangbiao.design.mediator
 * @Description: TODO 
 * @author wangbiao   
 * @date 2014-9-24 下午12:02:02 
 * @version V1.0
 */
package com.wangbiao.design.mediator;

/**
 * @Title: Country.java
 * @Package com.wangbiao.design.mediator
 * @Description: TODO 
 * @author wangbiao   
 * @date 2014-9-24 下午12:02:02 
 * @version V1.0
 */
public abstract class Country {

    public UnitedNationsMediator mediator;
    
    public Country() {
        // TODO Auto-generated constructor stub
    }
    
    public Country(UnitedNationsMediator mediator) {
        this.mediator = mediator;
    }
    
    public abstract void declare(String message);
    public abstract void getMessage(String message);
    
}

class China extends Country{
    
    public China(UnitedNationsMediator mediator) {
        super(mediator);
    }
    
    @Override
    public void getMessage(String message) {
        System.out.println("中国收到消息 : "+message);
    }

    @Override
    public void declare(String message) {
        mediator.declare(message, this);
    }
    
}

class USA extends Country{
    
    public USA(UnitedNationsMediator mediator) {
        super(mediator);
    }

    @Override
    public void getMessage(String message) {
        System.out.println("美国收到消息 : "+message);
    }

    @Override
    public void declare(String message) {
        mediator.declare(message, this);
    }
    
}

package com.wangbiao.design.mediator;

/**
 * 
 * @Title: UnitedNationsMediator.java
 * @Package com.wangbiao.design.mediator
 * @Description: TODO 
 * @author wangbiao   
 * @date 2014-9-24 下午01:57:02 
 * @version V1.0
 */

public abstract class UnitedNationsMediator {

    public abstract void declare(String message,Country country);
    
}

class UnitedNationSecurityCouncil extends UnitedNationsMediator{
    
    private China china;
    private USA usa;
    
    public China getChina() {
        return china;
    }

    public void setChina(China china) {
        this.china = china;
    }

    public USA getUsa() {
        return usa;
    }

    public void setUsa(USA usa) {
        this.usa = usa;
    }

    @Override
    public void declare(String message, Country country) {
        
        if (country instanceof China) {
            usa.getMessage(message);
        }else {
            china.getMessage(message);
        }
        
    }

}

/**
 * @Title: Client.java
 * @Package com.wangbiao.design.mediator
 * @Description: TODO 
 * @author wangbiao   
 * @date 2014-9-24 下午01:56:55 
 * @version V1.0
 */
package com.wangbiao.design.mediator;

/**
 * @Title: Client.java
 * @Package com.wangbiao.design.mediator
 * @Description: TODO 
 * @author wangbiao   
 * @date 2014-9-24 下午01:56:55 
 * @version V1.0
 */
public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        UnitedNationSecurityCouncil mediator = new UnitedNationSecurityCouncil();
        
        China country1 = new China(mediator);
        USA country2 = new USA(mediator);
        
        mediator.setChina(country1);
        mediator.setUsa(country2);
        
        country2.declare("为什么你每年的军费这么多?");
        country1.declare("管你屁事");
    }

}
时间: 2024-11-17 18:02:58

java设计模式_中介者模式的相关文章

折腾Java设计模式之中介者模式

博文原址:折腾Java设计模式之中介者模式 中介者模式 中介者模式(Mediator Pattern)是用来降低多个对象和类之间的通信复杂性.这种模式提供了一个中介类,该类通常处理不同类之间的通信,并支持松耦合,使代码易于维护.中介者模式属于行为型模式. 通俗点来讲就是提供一个中介平台,说到平台,那其实很容易联系到我们很熟悉的房地产中介.我们可以直接通过这个平台得到我们想要的信息,不用对象自身与其他对象交互. 买房子租房子就不需要去找房东,只需要在中介那里获取相应的×××信息.如下图那样,两方只

大话设计模式_中介者模式(Java代码)

中介者模式:用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显示的相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 简单描述:1个抽象Colleague,其派生多个具体ConcreteColleague,每个具体ConcreteColleague都认识一个具体中介者.他们发送消息的时候是通过中介者发送.1个中介者,具体中介者认识所有的ConcreteColleague(即持有所有具体ConcreteColleague的引用),它提供向其他具体ConcreteColleag

JAVA设计模式之 中介者模式【Mediator Pattern】

一.概述 用一个中介对象(中介者)来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互.中介者模式又称为调停者模式,它是一种对象行为型模式. 二.适用场景 协调多个对象之间的交互. 三.UML类图 四.参与者 1.Mediator(抽象中介者):它定义一个接口,该接口用于与各同事对象之间进行通信. 2.ConcreteMediator(具体中介者):它是抽象中介者的子类,通过协调各个同事对象来实现协作行为,它维持了对各个同事对象的引用.

Java 设计模式之中介者模式

本文继续23种设计模式系列之中介者模式. 定义 用一个中介者对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使耦合松散,而且可以独立地改变它们之间的交互. 角色 抽象中介者:定义好同事类对象到中介者对象的接口,用于各个同事类之间的通信.一般包括一个或几个抽象的事件方法,并由子类去实现. 中介者实现类:从抽象中介者继承而来,实现抽象中介者中定义的事件方法.从一个同事类接收消息,然后通过消息影响其他同时类. 同事类:如果一个对象会影响其他的对象,同时也会被其他对象影响,那么这两个对

java设计模式之中介者模式

中介者模式 用一个中介对象来封装一系列的对象交互.中介者使各个对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 中介者模式UML图 中介者模式代码 package com.roc.mediator; /** * 抽象中介者类 * @author liaowp * */ public abstract class Mediator { public abstract void send(String message,Colleague colleague); } pa

设计模式_中介者模式

定义 Define an object that encapsulates how a set of objects interact.  Mediator promptes loose coupling by keeping objects from referring to each other explicitly,and it lets you vary their interaction independently.(用一个中介对象封装一系列的对象交互.中介者使各对象不须要显示地相互作

大话设计模式_简单工厂模式(Java代码)

简单的描述:一个父类.多个子类,实例化那个子类由一个单独的工厂类来进行 图片摘自大话设计模式: 运算类: 1 package com.longsheng.simpleFactory; 2 3 public class Calculate { 4 5 private double firstNum; 6 private double secondNum; 7 8 public double getFirstNum() { 9 return firstNum; 10 } 11 12 public v

大话设计模式_抽象工厂模式(Java代码)

抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们的具体类. 简单描述:有多种抽象产品,并且每种抽象产品都有多个具体产品.一个抽象工厂,提供多个具体工厂,每个工厂则提供不同种类的具体产品. 大话设计模式中的截图: 例子代码: AbstractProductA类: 1 package com.longsheng.abstractfactory; 2 3 public abstract class AbstractProductA { 4 5 public abstract v

【GOF23设计模式】中介者模式

来源:http://www.bjsxt.com/ 一.[GOF23设计模式]_中介者模式.同事协作类.内部类实现 1 package com.test.mediator; 2 /** 3 * 同事类的接口 4 */ 5 public interface Department { 6 void selfAction();//做本部门的事情 7 void outAction();//向总经理发出申请 8 } 1 package com.test.mediator; 2 3 public class