精华内容
下载资源
问答
  • 一.内容说明 制作如图所示GUI界面,需求如下: 1.鼠标左键点击界面时,在鼠标所在位置填充一个直径...2.两个标签内容的变更使用观察者模式;。 二.设计类图 三.全部类代码 首先设计一个Circle类,该类对象用来记录鼠

    一.内容说明

    制作如图所示GUI界面,需求如下:
    1.鼠标左键点击界面时,在鼠标所在位置填充一个直径为20像素的圆,并在界面上方的标签上显示“新增圆点位于:(x,y)”;
    2.鼠标右键点击时,则实现undo操作,将最后填充的圆点从界面中删除,并在界面上方的标签上显示“删除圆点位于:(x,y)”;
    3.界面下方的标签随时显示“鼠标位于:(x,y)”。
    要求:1.绘制和撤销圆点使用命令模式;
    2.两个标签内容的变更使用观察者模式;。

    二.设计类图

    在这里插入图片描述

    三.全部类代码

    首先设计一个Circle类,该类对象用来记录鼠标位置以及圆的位置信息,每填充一个圆点,就实例化一个Circle类对象,并将其放置到具体命令对象关联的List对象中,用来作为undo操作的依据;
    然后设计一个Command抽象命令类,里面包含execute和undo抽象方法,具体命令LeftCommand类实例化Command类,在LeftCommand类中实现对填充以及删除圆点的具体操作,然后设计一个接受者类Receive,它是真正执行命令的对象,Invoker类用于命令对象执行请求,这是客户端真正出发命令并要求命令执行相应操作的地方。
    再设计一个抽象观察者Observer类,里面定义抽象方法update类,然后设计两个具体观察者类ConcreteObserver和ConcreteObserver2,ConcreteObserver类用于记录新增及删除的圆点位置,ConcreteObserver2类用于记录鼠标的位置;再设计一个被观察者的抽象类Subject,里面包含两个抽象方法addObserver和deleteObserver,最后设计一个具体被观察者类去实现者两个抽象方法。

    //Circle类:
    package demo4;
    
    public class Circle {
        private int x;
        private int y;
    
        public int getX() {
            return x;
        }
    
        public void setX(int x) {
            this.x = x;
        }
    
        public int getY() {
            return y;
        }
    
        public void setY(int y) {
            this.y = y;
        }
    
        public Circle(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    //抽象命令类:
    import javax.swing.*;
    
    public interface Command {
        void execute(JPanel jPanel, Circle circle);
        void undo(JPanel jPanel);
    }
    //具体命令类:
    import javax.swing.*;
    import java.util.ArrayList;
    
    public class LeftCommand implements Command {
        private Receiver receiver;
        private ArrayList<Circle> arrayList;
        private ConcreteOfInvoke concreteOfInvoke;
    
        public LeftCommand(Receiver receiver, ArrayList<Circle> arrayList, ConcreteOfInvoke concreteOfInvoke) {
            this.receiver = receiver;
            this.arrayList = arrayList;
            this.concreteOfInvoke = concreteOfInvoke;
        }
    
        @Override
        public void execute(JPanel jPanel, Circle circle) {
            receiver.addSpot(jPanel, circle);
            arrayList.add(circle);
        }
    
        @Override
        public void undo(JPanel jPanel) {
            Circle circle;
            if (arrayList.size() >= 1) {
                circle = arrayList.get(arrayList.size() - 1);
                receiver.deleteSpot(jPanel, circle);
                arrayList.remove(arrayList.size() - 1);
                int n = 2;
                concreteOfInvoke.notifyObservers(n, circle.getX(), circle.getY());
            }
        }
    }
    //接收者类:
    import javax.swing.*;
    import java.awt.*;
    import java.awt.geom.Ellipse2D;
    
    public class Receiver {
        private Graphics2D graphics2D;
        public void addSpot(JPanel jPanel,Circle circle) {
            Shape shape = new Ellipse2D.Double(circle.getX()-10,circle.getY()-10,20,20);
            graphics2D = (Graphics2D) jPanel.getGraphics();
            graphics2D.setPaint(Color.BLACK);
            graphics2D.fill(shape);
        }
        public void deleteSpot(JPanel jPanel, Circle circle) {
            Shape shape = new Ellipse2D.Double(circle.getX()-10,circle.getY()-10,20,20);
            graphics2D = (Graphics2D) jPanel.getGraphics();
            graphics2D.setPaint(jPanel.getBackground());
            graphics2D.fill(shape);
        }
    }
    //命令对象类:
    import javax.swing.*;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    import java.awt.event.MouseMotionListener;
    
    public class Invoke extends JPanel {
        private Command command;
        private ConcreteOfInvoke concreteOfInvoke;
    
        public Invoke(Command command, ConcreteOfInvoke concreteOfInvoke) {
            this.command = command;
            this.concreteOfInvoke = concreteOfInvoke;
            this.addMouseListener(new Mouse());
            this.addMouseMotionListener(new MouseMotion());
        }
        class Mouse implements MouseListener {
    
            @Override
            public void mouseClicked(MouseEvent arg0) {
                executeCommand(arg0);
            }
    
            @Override
            public void mousePressed(MouseEvent e) {
    
            }
    
            @Override
            public void mouseReleased(MouseEvent e) {
    
            }
    
            @Override
            public void mouseEntered(MouseEvent e) {
    
            }
    
            @Override
            public void mouseExited(MouseEvent e) {
    
            }
        }
        class MouseMotion implements MouseMotionListener {
            @Override
            public void mouseDragged(MouseEvent e) {
    
            }
    
            @Override
            public void mouseMoved(MouseEvent arg0) {
                int n = 0;
                concreteOfInvoke.notifyObservers(n,arg0.getX(), arg0.getY());
            }
        }
        public void executeCommand(MouseEvent mouseEvent) {
            int x = mouseEvent.getX();
            int y = mouseEvent.getY();
            Circle circle = new Circle(x, y);
    
            if (mouseEvent.getButton() == mouseEvent.BUTTON1) {
                this.command.execute(this,circle);
                int n = 1;
                concreteOfInvoke.notifyObservers(n,mouseEvent.getX(),mouseEvent.getY());
            } else if (mouseEvent.getButton() == mouseEvent.BUTTON3) {
                this.command.undo(this);
            }
        }
    }
    
    public interface ConcreteOfInvoke {
        void notifyObservers(int n, int x, int y);
    }
    
    //抽象观察者类:
    public interface Observer {
        void update(int n, int x, int y);
    }
    
    //具体观察者类:
    import javax.swing.*;
    
    public class ConcreteObserver extends JLabel implements Observer {
        public ConcreteObserver() {
            super("新增圆点位于:(0,0)");
        }
        @Override
        public void update(int n, int x, int y) {
            if (n == 1) {
                this.setText("新增圆点位于:(" + x + "," + y + ")");
            } else if (n == 2) {
                this.setText("删除圆点位于:(" + x + "," + y + ")");
            }
        }
    }
    
    import javax.swing.*;
    
    public class ConcreteObserver2 extends JLabel implements Observer {
        @Override
        public void update(int n, int x, int y) {
            this.setText("鼠标位于:(" + x + "," + y + ")");
        }
    }
    //被观察者类:
    
    public interface Subject {
        void addObserver(Observer observer);
        void deleteObserver(Observer observer);
    }
    //被观察者子类:
    import java.util.ArrayList;
    
    public class ConcreteSubject implements ConcreteOfInvoke,Subject{
        ArrayList<Observer> arrayList;
    
        public ConcreteSubject(ArrayList<Observer> arrayList) {
            this.arrayList = arrayList;
        }
    
        @Override
        public void addObserver(Observer observer) {
            arrayList.add(observer);
        }
        @Override
        public void deleteObserver(Observer observer) {
            arrayList.remove(observer);
        }
        @Override
        public void notifyObservers(int n, int x, int y) {
            for (Observer observer : arrayList) {
                observer.update(n, x, y);
            }
        }
    }
    //客户类:
    import javax.swing.*;
    import java.util.ArrayList;
    
    public class Client extends JFrame {
        public Client() {
            Receiver receiver = new Receiver();
            ArrayList arrayList = new ArrayList();
            ConcreteSubject concreteSubject = new ConcreteSubject(arrayList);
            Command command = new LeftCommand(receiver, arrayList, concreteSubject);
            Invoke invoke = new Invoke(command,concreteSubject);
            ConcreteObserver concreteObserver = new ConcreteObserver();
            ConcreteObserver2 concreteObserver2 = new ConcreteObserver2();
            concreteSubject.addObserver(concreteObserver);
            concreteSubject.addObserver(concreteObserver2);
            this.add("North",concreteObserver);
            this.add("South",concreteObserver2);
            this.add("Center", invoke);
            this.setSize(800,600);
            this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
            this.setVisible(true);
    
        }
    
        public static void main(String[] args) {
            new Client();
        }
    }
    

    四.运行结果

    1.增加圆点时:
    在这里插入图片描述
    2.删除圆点时:
    在这里插入图片描述

    五.分析和总结

    1.整体构造:
    观察者模式(Observer),又叫发布-订阅模式(Publish/Subscribe),定义对象间一种一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于它的对象都会得到通知并自动更新。
    命令模式(Command Pattern)是一种数据驱动的设计模式,它属于行为型模式。请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该命令的合适的对象,并把该命令传给相应的对象,该对象执行命令。

    2.优点:
    观察者模式:
    (1) 观察者和被观察者是抽象耦合的
    (2) 建立了一套触发机制
    命令模式:
    (1)调用者角色与接收者角色之间没有任何依赖关系,调用者实现功能时只需调用Command 抽象类的execute方法就可以,不需要了解到底是哪个接收者执行。
    (2)Command的子类可以非常容易地扩展,而调用者Invoker和高层次的模块Client不产生严 重的代码耦合。
    (3)命令模式可以结合责任链模式,实现命令族解析任务;结合模板方法模式,则可以减少 Command子类的膨胀问题。

    3.缺点:
    观察者模式:
    (1)如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间
    (2)如果观察者和观察目标间有循环依赖,可能导致系统崩溃
    (3)没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的
    命令模式:
    如果有N个命令,问题就出来 了,Command的子类就可不是几个,而是N个,这个类膨胀得非常大,这个就需要读者在项 目中慎重考虑使用。

    展开全文
  • 它们用的是==命令模式+观察者模式==,你答对了吗?简单科普一下啥是==Command模式==? Command模式:- 模式类型:行为类模式- 定义:将一个操作、一个方法调用、一个命令封装成一个对象,在合适的时候让这个对象进行...


    现有场景描述:
    现在无论是系统自带的键盘还是第三方的键盘一般都自带撤销和恢复功能,你知道它们是用的什么模式实现的吗?
    它们用的是==命令模式+观察者模式==,你答对了吗?
    简单科普一下
    啥是==Command模式==
    Command模式:
    - 模式类型:行为类模式
    - 定义:将一个操作、一个方法调用、一个命令封装成一个对象,在合适的时候让这个对象进行执行。
    - 适用场景(执行意愿):像个皇帝身边的守护侍卫一样,随叫随到。随时准备着等待被调用。例如:软件提供的菜单按钮,点击了,就会执行相应的操作。
    - 类图:

     

    调用者中有个聚合关系的命令类
    命令类索引着命令接受者
    是不是==So Easy!!==

    啥是==Obsevser模式==?
    - 模式类型:行为类模式
    - 定义:表示的是一种一对多的关系。当被观察者类A的属性aa发生了改变,就会主动去通知观察类B、C、D,这样观察类们的状态就会及时的被更新了。
    - 适用场景(执行意愿):控制器观察model中的属性,当属性变化了就去更新View的信息。系统时刻观察者键盘的字符输入,有了输入时,就把输入信息通知给View展示。等等。
    - 类图:

     

    被观察者索引着观察者对象
    是不是==So Easy!!==

    Cocoa Touch框架内的实际应用
    NSUndoManager是苹果提供的撤销恢复管理类,它里面主要有三个要素构成
    - 恢复栈
    - 撤销栈
    - 命令对象:NSInvocation
    图表显示如下:进入撤销栈时,NSInvocation执行撤销命令

     

     


    进入恢复栈时,NSInvocation执行恢复命令

    开发中如何将它们合起来用呢?
    1.在Command中添加命令执行对象NSInvocation
    2.在Command中添加观察者列表,当命令执行是通知列表中的观察者
    3.创建一个类似NSUndoManager的类,来管理整体commond列表

     

    文章同步发布在简书:https://www.jianshu.com/p/ec11c30b100d

     

    转载于:https://www.cnblogs.com/zhou--fei/p/9905536.html

    展开全文
  • 观察者模式主要是是定义对象间的一种一对多(变化)的依赖关系,以便当一个对象(Subject)的状态发生改变时,所有依赖于它的对象都得到通知并自动更新。  而我们设计程序有两个基本原则,开闭原则依赖倒置原则,...

    1、命令模式

     命令模式(Command Pattern)是一种数据驱动的设计模式,它属于行为型模式。请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该命令的合适的对象,并把该命令传给相应的对象,该对象执行命令。

    1.1 实例

     假设客户向服务器进行多次的请求,实现和服务器之间解耦,用容器保存请求。

    在这里插入图片描述
    代码步骤:
    1、先封装一个类(HandleClientProtocol),类中是client的命令
    2、封装一个抽象类(AbstractCommand)
    3、把client中的每个命令封装成一个类,同时继承抽象类
    4、server方面,Server中维护一个队列,用于接收命令和执行命令

    class  HandleClientProtocol {
    public:
    	//增加金币
    	void AddMoney()
    	{
    		cout << "给玩家增加金币"<<endl;
    	}
    	//增加钻石
    	void AddDiamond()
    	{
    		cout << "给玩家增加钻石" << endl;
    	}
    	//升级
    	void Update()
    	{
    		cout << "给玩家升级" << endl;
    	}
    };
    //协议命令接口
    class AbstractCommand{
    public:
    	virtual void handle() = 0;
    };
    
    //增加金币请求
    class AddMoneyCommand :public AbstractCommand{
    public:
    	AddMoneyCommand(HandleClientProtocol* Protocol)
    	{
    		pProtocol = Protocol;
    	}
    	virtual void handle()
    	{
    		this->pProtocol->AddMoney();
    	}
    public:
    	HandleClientProtocol* pProtocol;
    };
    
    //增加钻石请求
    class AddDiamondCommand :public AbstractCommand {
    public:
    	AddDiamondCommand(HandleClientProtocol* Protocol)
    	{
    		pProtocol = Protocol;
    	}
    	virtual void handle()
    	{
    		this->pProtocol->AddDiamond();
    	}
    public:
    	HandleClientProtocol* pProtocol;
    };
    
    //增加升级
    class AddUpdateCommand :public AbstractCommand {
    public:
    	AddUpdateCommand(HandleClientProtocol* Protocol)
    	{
    		pProtocol = Protocol;
    	}
    	virtual void handle()
    	{
    		this->pProtocol->Update();
    	}
    public:
    	HandleClientProtocol* pProtocol;
    };
    
    //服务器程序  命令不一定及时处理,将请求加到队列
    //函数不能增加到队列中,可以是对象
    class Server {
    public:
    	void addRequest(AbstractCommand* command)
    	{
    		mCommands.push(command);
    	}
    	void startHandle()
    	{
    		while (!mCommands.empty()) {
    			Sleep(1000);
    			AbstractCommand* command = mCommands.front();
    			command->handle();
    			mCommands.pop();
    		}
    	}
    public:
    	queue<AbstractCommand*> mCommands;
    };
    void test()
    {
    	HandleClientProtocol* protocol = new HandleClientProtocol;
    	//增加金币请求
    	AbstractCommand* addmoney = new AddMoneyCommand(protocol);
    	//增加钻石请求
    	AbstractCommand* adddiamond = new AddDiamondCommand(protocol);
    	//增加升级请求
    	AbstractCommand* addupdate= new AddUpdateCommand(protocol);
    
    	Server* svr = new Server;
    	svr->addRequest(addmoney);
    	svr->addRequest(adddiamond);
    	svr->addRequest(addupdate);
    
    	svr->startHandle();
    
    }
    int main()
    {
    	test();
    	return 0;
    }
    

    2、观察者模式

     观察者模式主要是是定义对象间的一种一对多(变化)的依赖关系,以便当一个对象(Subject)的状态发生改变时,所有依赖于它的对象都得到通知并自动更新。
     而我们设计程序有两个基本原则,开闭原则和依赖倒置原则,开闭原则在于对源代码的更改是不建议的,而对原始程序进行模块添加是建议的(策略模式)。而依赖倒置原则是要求具体的类要依赖于抽象类,借助于抽象类的接口,实现具体的类或功能。
     现在有大量的关于设计模式的书,讲的都挺不错,但基本上都是使用java语言的,是使用c++语言的很少,这里我们使用c++语言来实现。我们的设计模型:首先我们假设有多个hero攻击boss,当boos被消灭的时候会通知hero,让停止攻击进入等待状态。
    在这里插入图片描述
    这里,boosA就是被观察者,而heroA,heroB,heroC 是观察者。

    2.2 实例

     对于观察者,被观察者都要将他们抽象出具体的接口,然后再底层进行实现。而且再被观察者的类中,需要添加一个链表或者队列,里面是需要通知的观察者,并且各个观察者的地位是平等的。

    #include<iostream>
    #include<list>
    using namespace std;
    ///观察者抽象方法
    class AbstractHero {
    public:
    	virtual void Update() = 0;
    };
    
    ///具体的观察者
    class HeroA :public AbstractHero {
    public:
    	HeroA() {
    		cout << "英雄A正在打boss..." << endl;
    	}
    	virtual void Update() {
    		cout << "英雄A停止打boss,待机..." << endl;
    	}
    };
    class HeroB :public AbstractHero {
    public:
    	HeroB() {
    		cout << "英雄B正在打boss..." << endl;
    	}
    	virtual void Update() {
    		cout << "英雄B停止打boss,待机..." << endl;
    	}
    };
    class HeroC :public AbstractHero {
    public:
    	HeroC() {
    		cout << "英雄C正在打boss..." << endl;
    	}
    	virtual void Update() {
    		cout << "英雄A停止打boss,待机..." << endl;
    	}
    };
    ///被观察者抽象方法
    class AbstractBoss {
    public:
    	//添加观察者
    	virtual void addHero(AbstractHero* hero) = 0;
    	//删除观察者
    	virtual void deleteHero(AbstractHero* hero) = 0;
    	//通知观察者
    	virtual void notify() = 0;
    };
    //具体地被观察者 BOSS
    class BossA :public AbstractBoss {
    public:
    	//添加观察者
    	virtual void addHero(AbstractHero* hero) {
    		pHeroList.push_back(hero);
    	}
    	//删除观察者
    	virtual void deleteHero(AbstractHero* hero) {
    		pHeroList.remove(hero);
    	}
    	//通知观察者
    	virtual void notify() {
    		for (auto e : pHeroList)
    		{
    			e->Update();
    		}
    	}
    private:
    	list<AbstractHero*> pHeroList;
    };
    
    void test() {
    	//创建观察者
    	AbstractHero* heroA = new HeroA;
    	AbstractHero* heroB = new HeroB;
    	AbstractHero* heroC = new HeroC;
    	//创建观察目标
    	AbstractBoss* boosA = new BossA;
    	boosA->addHero(heroA);
    	boosA->addHero(heroB);
    	boosA->addHero(heroC);
    	cout << "heroC阵亡..." << endl;
    	boosA->deleteHero(heroC);
    	cout << "boosA消灭,通知..." << endl;
    	boosA->notify();
    }
    int main()
    {
    	test();
    }
    

    在这里插入图片描述

    展开全文
  • 文章目录前言一、模板方法模式二、命令模式三、策略模式四、观察者模式 前言 模板方法模式、命令模式、策略模式、观察者模式 一、模板方法模式 模板方法模式:是将一些事件按照给定的模板进行下去,共用相似的...

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    前言

    模板方法模式、命令模式、策略模式、观察者模式


    一、模板方法模式

    模板方法模式:是将一些事件按照给定的模板进行下去,共用相似的部分,重写不同的部分。
    例如:泡茶和冲咖啡,有一些相同的步骤,比如加水,倒入杯子是相同的步骤。

    #include <iosteram>
    using namespace std;
    
    class MakeDrink{
    public:
    	virtual void AddWater(){
    		cout << "加水" << endl;
    	}
    	virtual void AddOther() = 0;
    	virtual void PutInCup(){
    		cout << "倒入杯子" << endl;
    	}
    	void make(){
    		AddWater();
    		AddOther();
    		PutInCup();
    	}
    };
    class MakeTea: public MakeDrink{
    public:
    	virtual void AddOther(){
    		cout << "加入茶叶" << endl;
    	}
    };
    class MakeCoffee: public MakeDrink{
    public:
    	virtual void AddOther(){
    		cout << "加入咖啡" << endl;
    	}
    };
    
    int main()
    {
    	MakeDrink* makeTea = new MakeTea;
    	makeTea->make();
    	MakeDrink* makeCoffee = new MakeCoffee;
    	makeCoffee->make();	
    	return 0;
    }
    

    二、命令模式

    命令模式:像执行命令一样,发出命令才执行。
    例如:医院等号看病,护士登记病人,挨个叫号去看病

    #include <iostream>
    #include <queue>
    using namespace std;
    //医生类
    class Doctor{
    public:
    	void treatEye(){
    		cout << "医生治疗了眼睛" << endl;
    	}
    	void treatNose(){
    		cout << "医生治疗了鼻子" << endl;
    	}
    };
    //患者类,被治疗
    class Patient{
    public:
    	Patient(Doctor* d) :doctor(d){}
    	virtual void treat() = 0;
    protected:
    	Doctor* doctor;
    };
    //眼疾患者类
    class EyePatient : public Patient{
    public:
    	EyePatient(Doctor* d) :Patient(d){}
    	virtual void treat(){
    		doctor->treatEye();
    	}
    };
    //鼻子患者类
    class NosePatient : public Patient{
    public:
    	NosePatient(Doctor* d) :Patient(d){}
    	virtual void treat(){
    		doctor->treatNose();
    	}
    };
    //护士类,命令医生治疗患者
    class Nurse{
    public:
    	//登记患者
    	void addPatient(Patient* p){
    		m_queue.push(p);
    	}
    	//通知治疗后删除记录
    	void notify(){
    		while (!m_queue.empty()){
    			m_queue.front()->treat();
    			m_queue.pop();
    		}
    	}
    private:
    	queue<Patient*> m_queue;
    };
    int main()
    {
    	Doctor* d = new Doctor;
    	Patient* p1 = new EyePatient(d);
    	Patient* p2 = new NosePatient(d);
    
    	Nurse* nurse = new Nurse;
    	nurse->addPatient(p1);
    	nurse->addPatient(p2);
    	nurse->notify();
    	return 0;
    }
    

    三、策略模式

    策略模式:使用不同的策略,达到相同的目的。
    例如:商城搞促销活动,上午全场八折,下午全场满200减100,两种不同的促销策略,都是为了达到促销的目的;枪击游戏可以用刀或枪击打目标,使用不同的武器打击目标。

    #include <iostream>
    using namespace std;
    
    class Weapon{
    public:
    	virtual void attack() = 0;
    };
    class Gun: public Weapon{
    public:
    	virtual void attack(){
    		cout << "使用枪打击目标" << endl;
    	}
    };
    class Knife: public Weapon{
    public:
    	virtual void attack(){
    		cout << "使用小刀攻击目标" << endl;
    	}
    };
    //任务配置武器攻击
    class Hero{
    public:
    	void selectWeapon(Weapon* w){
    		this->w = w;
    	}
    	void fight(){
    		w->attack();
    	}
    private:
    	Weapon* w;
    };
    int main()
    {
    	Hero* h = new Hero;
    	Weapon* w1 = new Knife;
    	Weapon* w2 = new Gun;
    	h->selectWeapon(w1);
    	h->fight();
    	h->selectWeapon(w2);
    	h->fight();
    	return 0;
    }
    

    四、观察者模式

    观察者模式:类似与QT下的信号与槽机制,通知后改变行为。
    例如:班长放哨,其他学生没有学习,老师来了通知其他学生赶紧学习。

    #include <iostream>
    #include <list>
    #include <string>
    using namespace std;
    //抽象的监听类,等待通知
    class Listener{
    public:
    	virtual void doing() = 0;
    	virtual void teacherComing() = 0;
    };
    //学生
    class Student : public Listener{
    public:
    	Student(string name, string thing){
    		this->name = name;
    		this->thing = thing;
    	}
    	virtual void doing(){
    		cout << name << "正在" << thing << endl;
    	}
    	virtual void teacherComing(){
    		cout << name << "从" << thing << "变为学习" << endl;
    	}
    private:
    	string name;
    	string thing;
    };
    //抽象的通知者
    class Notifiler{
    public:
    	virtual void addListener(Listener* l) = 0;
    	virtual void delListener(Listener* l) = 0;
    	virtual void notify() = 0;
    };
    //班长
    class Monitor : public Notifiler{
    public:
    	virtual void addListener(Listener* l){
    		m_list.push_back(l);
    	}
    	virtual void delListener(Listener* l) {
    		m_list.remove(l);
    	}
    	virtual void notify(){
    		for (auto it = m_list.begin(); it != m_list.end(); ++it){
    			(*it)->teacherComing();
    		}
    	}
    private:
    	list<Listener*> m_list;
    };
    
    int main()
    {
    	Listener* s1 = new Student("张三", "打架");
    	Listener* s2 = new Student("李四", "吃零食");
    	Listener* s3 = new Student("王五", "打游戏");
    	s1->doing();
    	s2->doing();
    	s3->doing();
    	Notifiler* m = new Monitor;
    	m->addListener(s1);
    	m->addListener(s2);
    	m->addListener(s3);
    	m->notify();
    	return 0;
    }
    

    展开全文
  • 设计模式 代理模式(静态代理/动态代理)Proxy Subject是顶层接口,RealSubject是真实对象,Proxy是代理对象,代理对象持有被代理对象的引用,客户端调用代理对象的方法,同时也调用被代理对象的方法,但是在代理...
  • 主要用于使多个对象都有机会处理请求,避免请求的的发送者和接受之间的耦合关系。在现实生活中我们多数遇到的是不纯的责任链模式即每个对象都处理请求的一部分后再交给下家。而纯的职责链模式则要求对于一个请求,...
  • 行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象行为模式比类行为...
  • 观察者模式 定义了对象之间一对多的依赖,让多个观察者对象同时监听一个主题对象,当主体对象发生改变时,他的所有依赖者(观察者)都会收到通知并更新。 类型:行为型 使用场景:关联行为场景,建立一套触发机制...
  • 整个app采用的是最新的Android api现在最流行的第三方框架,以及谷歌提倡的MVP设计模式。 整个app分层是按照功能职责来划分的,ui层是安装功能模块来划分的,页面简单的直接用Activity来承载页面,复杂的页面用...
  • 行为模式是模块模块之间发生行为 结构模式 代理模式 优先浏览缩略图片 class ImageProxy{//代理类 private ImageDisplay id; public ImageProxy(ImageDisplay id){ this.id = id; } public void ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,114
精华内容 445
关键字:

命令模式和观察者模式