访问者模式（Visitor）--中介者模式（Mediator）--解释器模式（Interpreter）

最新推荐文章于 2024-02-28 10:46:17 发布

土戈

最新推荐文章于 2024-02-28 10:46:17 发布

阅读量366

点赞数

分类专栏：设计模式

设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

21、访问者模式（Visitor）

访问者模式：把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。访问者模式使得增加算法操作变得容易。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。其缺点就是增加新的数据结构很困难。

public interface Visitor {

public void visit(Subject sub);

}

public class MyVisitor implements Visitor {

@Override

public void visit(Subject sub) {

System.out.println("visit the subject："+sub.getSubject());

}

Subject类，accept方法，接受将要访问它的对象，getSubject()获取将要被访问的属性，

public interface Subject {

public void accept(Visitor visitor);

public String getSubject();

}

public class MySubject implements Subject {

@Override

public void accept(Visitor visitor) {

visitor.visit(this);

}

@Override

public String getSubject() {

return "love";

}

public class Test {

public static void main(String[] args) {

Visitor visitor = new MyVisitor();

Subject sub = new MySubject();

sub.accept(visitor);

}

该模式适用场景：如果我们想为一个现有的类增加新功能，不得不考虑几个事情：1、新功能会不会与现有功能出现兼容性问题？2、以后会不会再需要添加？3、如果类不允许修改代码怎么办？面对这些问题，最好的解决方法就是使用访问者模式，访问者模式适用于数据结构相对稳定的系统，把数据结构和算法解耦

22、中介者模式（Mediator）

中介者模式也是用来降低类类之间的耦合的，因为如果类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。如果使用中介者模式，只需关心和Mediator类的关系，具体类类之间的关系及调度交给Mediator就行，这有点像spring容器的作用。

中介者模式的作用就是解除对象与对象之间的紧耦合关系，它也称‘调停者’。所有的对象都通过中介者对象来通信，而不是相互引用，所以当一个对象发生改变时，只需要通知中介者即可。

如：机场的指挥塔，每架飞机都只需要和指挥塔通信即可，指挥塔知道每架飞机的飞行状况，可以安排所有起降时间，调整航线等

中介者模式：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之前的交互。
   主要解决：对象与对象之间存在大量的关联关系，这样势必会造成系统变得复杂，若一个对象改变，我们常常需要跟踪与之关联的对象，并做出相应的处理。
   如何解决：将网状结构分离为星型结构。
   关键代码：将相关对象的通信封装到一个类中单独处理。

public interface Mediator {

public void createMediator();

public void workAll();

}

public class MyMediator implements Mediator {

private User user1;

private User user2;

public User getUser1() {

return user1;

}

public User getUser2() {

return user2;

}

@Override

public void createMediator() {

user1 = new User1(this);

user2 = new User2(this);

}

@Override

public void workAll() {

user1.work();

user2.work();

}

public abstract class User {

private Mediator mediator;

public Mediator getMediator(){

return mediator;

}

public User(Mediator mediator) {

this.mediator = mediator;

}

public abstract void work();

}

public class User1 extends User {

public User1(Mediator mediator){

super(mediator);

}

@Override

public void work() {

System.out.println("user1 exe!");

}

public class User2 extends User {

public User2(Mediator mediator){

super(mediator);

}

@Override

public void work() {

System.out.println("user2 exe!");

}

public class Test {

public static void main(String[] args) {

Mediator mediator = new MyMediator();

mediator.createMediator();

mediator.workAll();

}

class Mediator;

class Person   //抽象同事类
{
public:
    virtual ~Person(){}
    virtual void setMediator(Mediator* mediator)
    {
        m_mediator = mediator;
    }
    virtual void sendMessage(const string& message) = 0;
    virtual void getMessage(const string& message) = 0;
protected:
    Mediator* m_mediator;
};

class Mediator    //抽象中介类
{
public:
    virtual ~Mediator(){}
    virtual void setBuyer(Person* buyer) = 0;
    virtual void setSeller(Person* seller) = 0;
    virtual void send(const string& message, Person* person) = 0;
};

class Buyer:public Person   //买家类
{
public:
    void sendMessage(const string& message)
    {
        m_mediator->send(message, this);
    }
    void getMessage(const string& message)
    {
        cout << "Buyer Get: " << message.data() << endl;
    }
};

class Seller:public Person  //卖家类
{
public:
    void sendMessage(const string& message)
    {
        m_mediator->send(message, this);
    }
    void getMessage(const string& message)
    {
        cout << "Seller Get: " << message.data() << endl;
    }
};

class HouseMediator:public Mediator  //具体的中介类
{
public:
    HouseMediator():m_buyer(nullptr),m_seller(nullptr){}
    void setBuyer(Person* buyer)
    {
        m_buyer = buyer;
    }
    void setSeller(Person *seller)
    {
        m_seller = seller;
    }
    void send(const string& message, Person* person)
    {
        if(person == m_buyer)
        {
            m_seller->getMessage(message);
        }
        if(person == m_seller)
        {
            m_buyer->getMessage(message);
        }
    }
private:
    Person* m_buyer;
    Person* m_seller;
};

int main()
{
    Person* buyer = new Buyer;
    Person* seller = new Seller;
    Mediator* houseMediator = new HouseMediator;
    buyer->setMediator(houseMediator);
    seller->setMediator(houseMediator);
    houseMediator->setBuyer(buyer);
    houseMediator->setSeller(seller);
    buyer->sendMessage("1.5?");
    seller->sendMessage("2!!!");
    return 0;
}