精华内容
下载资源
问答
  • 设计模式 - 行为设计模式 - 策略模式(Java)

    万次阅读 多人点赞 2019-02-27 10:38:14
    下面设计的场景是,我们需要画一个图形,可选的策略就是用红色笔来画,还是绿色笔来画,或者蓝色笔来画。 首先,先定义一个策略接口: public interface Strategy { public void draw(int radius, int x, int y); }...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net

    策略模式太常用了,所以把它放到最前面进行介绍。它比较简单,不废话,直接用代码说事吧。

    下面设计的场景是,我们需要画一个图形,可选的策略就是用红色笔来画,还是绿色笔来画,或者蓝色笔来画。

    首先,先定义一个策略接口:

    public interface Strategy {
        public void draw(int radius, int x, int y);
    }

    然后我们定义具体的几个策略:

    public class RedPen implements Strategy {
    
        @Override
        public void draw(int radius, int x, int y) {
            System.out.println("用红色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
        }
    
    }
    
    public class GreenPen implements Strategy {
    
        @Override
        public void draw(int radius, int x, int y) {
            System.out.println("用绿色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
        }
    
    }
    
    public class BluePen implements Strategy {
    
        @Override
        public void draw(int radius, int x, int y) {
            System.out.println("用蓝色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
        }
    
    }

    使用策略的类:

    public class Context {
    
        private Strategy strategy;
    
        public Context(Strategy strategy){
            this.strategy = strategy;
        }
    
        public int executeDraw(int radius, int x, int y){
            return strategy.draw(radius, x, y);
        }
    
    }

    客户端演示:

    public static void main(String[] args) {
        Context context = new Context(new BluePen()); // 使用绿色笔来画
        context.executeDraw(10, 0, 0);
    }

    放到一张图上,让大家看得清晰些:

    Image

    这个时候,大家有没有联想到结构型模式中的桥梁模式,它们其实非常相似,我们把桥梁模式的图拿过来大家对比下: 

    Image

    它们非常相似,桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低,结构更复杂一些。 

    展开全文
  • 设计模式 - 行为设计模式 - 观察者模式(Java)

    万次阅读 多人点赞 2019-02-12 14:59:26
    实际生产过程中,观察者模式往往用消息中间件来实现,如果要实现单机观察者模式,笔者建议读者使用 Guava 中的 EventBus,它有同步实现也有异步实现。 还有,即使是上面的这个代码,也会有很多变种,大家只要记住...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net

    观察者模式对于我们来说,真是再简单不过了。无外乎两个操作,观察者订阅自己关心的主题和主题有数据变化后通知观察者们。

    首先,需要定义主题,每个主题需要持有观察者列表的引用,用于在数据变更的时候通知各个观察者:

    public class Subject {
    
        private List<Observer> observers = new ArrayList<Observer>();
        private int state;
    
        public int getState() {
            return state;
        }
    
        public void setState(int state) {
            this.state = state;
    
            // 数据已变更,通知观察者们
            notifyAllObservers();
        }
    
        // 注册观察者
        public void attach(Observer observer) {
            observers.add(observer);
        }
    
        // 通知观察者们
        public void notifyAllObservers() {
            for (Observer observer : observers) {
                observer.update();
            }
        }
    
    }

    定义观察者接口:

    public abstract class Observer {
        protected Subject subject;
        public abstract void update();
    }

    其实如果只有一个观察者类的话,接口都不用定义了,不过,通常场景下,既然用到了观察者模式,我们就是希望一个事件出来了,会有多个不同的类需要处理相应的信息。比如,订单修改成功事件,我们希望发短信的类得到通知、发邮件的类得到通知、处理物流信息的类得到通知等。

    我们来定义具体的几个观察者类:

    public class BinaryObserver extends Observer {
    
        // 在构造方法中进行订阅主题
        public BinaryObserver(Subject subject) {
            this.subject = subject;
    
            // 通常在构造方法中将 this 发布出去的操作一定要小心
            this.subject.attach(this);
        }
    
        // 该方法由主题类在数据变更的时候进行调用
        @Override
        public void update() {
            String result = Integer.toBinaryString(subject.getState());
            System.out.println("订阅的数据发生变化,新的数据处理为二进制值为:" + result);
        }
    
    }
    
    public class HexaObserver extends Observer {
    
        public HexaObserver(Subject subject) {
            this.subject = subject;
            this.subject.attach(this);
        }
    
        @Override
        public void update() {
            String result = Integer.toHexString(subject.getState()).toUpperCase();
            System.out.println("订阅的数据发生变化,新的数据处理为十六进制值为:" + result);
        }
    
    }

    客户端使用也非常简单:

    public static void main(String[] args) {
    
        // 先定义一个主题
        Subject subject1 = new Subject();
    
        // 定义观察者
        new BinaryObserver(subject1);
        new HexaObserver(subject1);
    
        // 模拟数据变更,这个时候,观察者们的 update 方法将会被调用
        subject.setState(11);
    }
    
    // Output:
    /*
    订阅的数据发生变化,新的数据处理为二进制值为:1011
    订阅的数据发生变化,新的数据处理为十六进制值为:B
    */

    当然,JDK 也提供了相似的支持,具体的可以参考 java.util.Observable 和 java.util.Observer 这两个类。

    实际生产过程中,观察者模式往往用消息中间件来实现,如果要实现单机观察者模式,笔者建议读者使用 Guava 中的 EventBus,它有同步实现也有异步实现。

    还有,即使是上面的这个代码,也会有很多变种,大家只要记住核心的部分,那就是一定有一个地方存放了所有的观察者,然后在事件发生的时候,遍历观察者,调用它们的回调函数。

    展开全文
  • 设计模式 - 行为设计模式 - 状态模式(Java)

    万次阅读 多人点赞 2019-02-12 15:38:33
    商品库存中心有个最基本的需求是减库存和补库存,我们看看怎么用状态模式来写。 核心在于,我们的关注点不再是 Context 是该进行哪种操作,而是关注这个 Context 会有哪些操作。 定义状态接口: public interface ...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net

    我们说一个简单的例子。商品库存中心有个最基本的需求是减库存和补库存,我们看看怎么用状态模式来写。

    核心在于,我们的关注点不再是 Context 是该进行哪种操作,而是关注这个 Context 会有哪些操作。

    定义状态接口:

    public interface State {
        public void doAction(Context context);
    }

    定义减库存的状态:

    public class DeductState implements State {
    
        public void doAction(Context context) {
            System.out.println("商品卖出,准备减库存");
            context.setState(this);
    
            // 执行减库存的具体操作...
        }
    
        public String toString() {
            return "Deduct State";
        }
    
    }

    定义补库存状态:

    public class RevertState implements State {
    
        public void doAction(Context context) {
            System.out.println("给此商品补库存");
            context.setState(this);
    
            // 执行补库存的具体操作...
        }
    
        public String toString() {
            return "Revert State";
        }
    
    }

    前面用到了 context.setState(this),我们来看看怎么定义 Context 类:

    public class Context {
    
        private State state;
        private String name;
        public Context(String name) {
            this.name = name;
        }
    
        public void setState(State state) {
            this.state = state;
        }
    
        public void getState() {
            return this.state;
        }
    
    }

    我们来看下客户端调用,大家就一清二楚了:

    public static void main(String[] args) {
    
        // 我们需要操作的是 iPhone X
        Context context = new Context("iPhone X");
    
        // 看看怎么进行补库存操作
        State revertState = new RevertState();
        revertState.doAction(context);
    
        // 同样的,减库存操作也非常简单
        State deductState = new DeductState();
        deductState.doAction(context);
    
        // 如果需要我们可以获取当前的状态
        context.getState().toString();
    }

    读者可能会发现,在上面这个例子中,如果我们不关心当前 context 处于什么状态,那么 Context 就可以不用维护 state 属性了,那样代码会简单很多。

    不过,商品库存这个例子毕竟只是个例,我们还是有很多实例是需要知道当前 context 处于什么状态的。

    展开全文
  • 设计模式 - 行为设计模式 - 模板方法模式(Java)

    万次阅读 多人点赞 2019-02-26 20:29:04
    请点击http://www.captainbed.net 在含有继承结构的代码中,模板方法模式是非常常用的。 通常会有一个抽象类: public abstract class AbstractTemplate { // 这就是模板方法 public void templateMethod() { init()...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net

    在含有继承结构的代码中,模板方法模式是非常常用的。

    通常会有一个抽象类:

    public abstract class AbstractTemplate {
    
        // 这就是模板方法
        public void templateMethod() {
            init();
            apply(); // 这个是重点
            end(); // 可以作为钩子方法
        }
    
        protected void init() {
            System.out.println("init 抽象层已经实现,子类也可以选择覆写");
        }
    
        // 留给子类实现
        protected abstract void apply();
    
        protected void end() {
        }
    
    }

    模板方法中调用了 3 个方法,其中 apply() 是抽象方法,子类必须实现它,其实模板方法中有几个抽象方法完全是自由的,我们也可以将三个方法都设置为抽象方法,让子类来实现。也就是说,模板方法只负责定义第一步应该要做什么,第二步应该做什么,第三步应该做什么;至于怎么做,由子类来实现。

    我们写一个实现类:

    public class ConcreteTemplate extends AbstractTemplate {
    
        public void apply() {
            System.out.println("子类实现抽象方法 apply");
        }
    
        public void end() {
            System.out.println("我们可以把 end 当做钩子方法来使用,需要的时候覆写就可以了");
    
        }
    }

    客户端调用演示:

    public static void main(String[] args) {
        AbstractTemplate t = new ConcreteTemplate();
    
        // 调用模板方法
        t.templateMethod();
    }

    代码其实很简单,基本上看到了就懂了,关键是要学会用到自己的代码中。

    展开全文
  • 设计模式 - 行为设计模式小结

    万次阅读 2019-03-23 17:23:03
    分享一个大牛的人工... 行为模式部分介绍了策略模式、观察者模式、责任链模式、模板方法模式和状态模式。其实,经典的行为模式还包括备忘录模式、命令模式等,但是它们的使用场景比较有限,这里就不进行介绍了。
  • 设计模式之美(11)-行为型-模版模式

    万次阅读 2021-08-23 21:47:46
    模版模式,全称是模版方法设计模式,模版方法模式在一个方法中定义一个算法骨架,并将某些步骤推迟到子类中实现。模版方法模式可以让子类在不改变算法整体结构的情况下,重新定义算法中的某些步骤。这里的“算法”,...
  • 不过,读者也先别急,看看责任链模式和我们说的这个有什么不一样? 首先,我们要定义流程上节点的基类: public abstract class RuleHandler { // 后继节点 protected RuleHandler successor; public abstract void ...
  • 设计模式之美(12)-行为型-策略模式

    万次阅读 2021-08-23 21:50:26
    策略模式的原理与实现 策略模式(Strategy Design Pattern) 定义一组算法,将每个算法分别封装起来,让他们可以互相替换。策略模式可以使算法的变化独立于使用他们的客户端(这里的客户端代指使用算法的代码)。 ...
  • 模版模式、策略模式、职责链模式。这三种模式都具有相同的作用:复用和扩展,在实际的项目开发中比较常用,特别是框架开发。我们可以利用他们来提供框架的扩展点,能够让框架的使用者在不修改框架源码的情况下,基于...
  • 观察者模式(Observer Design Pattern)也被称为发布订阅模式,在对象之间定义一个一对多的依赖,当一个对象状态改变的时候,所有依赖的对象都会自动收到通知。 被依赖的对象叫做被观察者(Observable),依赖的对象...
  • 设计模式之职责链模式(行为型)

    千次阅读 2018-12-23 00:04:06
    介绍职责链模式之前先介绍一下行为设计模式,因为按照GoF模式分类,职责链就是一种行为设计模式行为设计模式就是主要表示类或者对象之间的关联关系,分为类行为型和对象行为型。类行为型一般都是通过类的...
  • 设计模式——行为型模式

    千次阅读 2019-04-23 21:47:51
    1. 策略模式(Strategy) 2.状态模式(State) 3.责任链模式(Chain Of Responsibility) 4.解释器模式(Interpreter) 5.命令模式(Command) 6.观察者模式(Observer) 7.备忘录模式(Memento) 8.迭代器模式...
  • 设计模式行为型模式

    千次阅读 2020-08-19 17:22:50
    行为模式 一、模板方法模式 (一)定义:定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。 (二)模式说明: 例如,去银行办理业务...
  • 23种设计模式汇总整理

    万次阅读 多人点赞 2015-04-09 10:57:11
    设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式 结构型模式,共七种:适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 ...
  • 设计模式可以分为创建型、结构型、和行为型模式。 创建型模式对类的实现化过程进行了抽象,能够使软件模块做到与对象的创建和组织无关。 结构型模式描述类和对象之间如何进行有效的组织,以形成良好的软件体系结构...
  • 常用设计模式总结

    万次阅读 多人点赞 2019-07-31 19:13:12
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结,是可复用面向对象软件的基础。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 ...
  • Java常见设计模式总结

    万次阅读 多人点赞 2021-09-18 17:18:54
    设计模式是一套经过反复使用的代码设计经验,目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都...总体来说,设计模式分为三大类:5种创建型模式、7种结构型模式、11种行为型模式
  • 设计模式之状态模式(行为型)

    千次阅读 2018-12-23 00:04:55
    一个对象在其内部状态改变时改变其行为,这个对象我们可以称为状态对象,所以状态模式是一种对象行为模式模式结构 Context:环境类 Context类也可以称之为上下文类,实际上就是拥有状态的对象,可以理解为...
  • 行为设计模式:关注对象和行为的分离
  • 设计模式之模板方法模式(行为型)

    千次阅读 2019-01-01 00:02:07
    文章目录一、模式定义二、模式角色三、模式分析四、具体例子五、模式应用场景 ...不属于对象行为模式,因为只是通过类继承实现。 Template Method Pattern: Define the skeleton of an algor...
  • 设计模式之策略模式(行为型)

    千次阅读 2019-01-02 00:16:33
    一、模式定义 ...策略模式是一种对象行为模式。策略模式符合“开闭原则“ Strategy Pattern: Define a family of algorithms, encapsulate each one, and make them interchangeable. Stra...
  • Java设计模式_(行为型)_访问者模式

    万次阅读 2017-10-14 16:45:33
    引用百科访问者模式(Visitor Pattern)是GoF提出的23种设计模式中的一种,属于行为模式。据《大话设计模式》中说算是最复杂也是最难以理解的一种模式了。定义(源于GoF《Design Pattern》):表示一个作用于某对象...
  • Java设计模式行为型:中介者模式

    万次阅读 2021-09-14 17:52:27
    中介者模式通过中介者对象来封装一系列的对象交互,将对象间复杂的关系网状结构变成结构简单的以中介者为核心的星形结构,对象间一对多的关联转变为一对一的关联,简化对象间的关系,便于理解;各个对象之间的关系被...
  • Java设计模式行为型:访问者模式

    万次阅读 2018-11-05 00:27:50
    将数据结构与基于数据的操作进行分离,使得添加作用于这些数据结构的新操作变得简单,并且不需要改变各数据结构,为不同类型的数据结构提供多种访问操作方式,这样是访问者模式设计动机。除了使新增访问操作变得...
  • 史上最全设计模式导学目录(完整版)

    万次阅读 多人点赞 2013-12-24 23:15:16
    2012年-2013年,Sunny在CSDN技术博客中陆续发表了100多篇与设计模式相关的文章,涵盖了七个面向对象设计原则和24个设计模式(23个GoF设计模式 + 简单工厂模式),为了方便大家学习,现将所有与设计模式学习相关文章...
  • Java设计模式行为型:命令模式

    万次阅读 2018-11-04 10:16:56
    命令模式的本质是将请求封装成对象,将发出命令与执行命令的责任分开,命令的发送者和接收者完全解耦,发送者只需知道如何发送命令,不需要关心命令是如何实现的,甚至是否执行成功都不需要理会。命令模式的关键在于...
  • 设计模式-行为型软件设计模式(六)

    千次阅读 2017-07-15 00:05:59
    状态模式介绍状态模式将不同状态下的行为封装在不同的类中,每个类代表一个状态。 (1)Context:定义了与客户程序的接口,它保持了一个ConcreteState的代表现在状态的实例。 (2)State:定义了状态接口,它的...
  • 创建型模式关注对象的创建 结构型模式关注类或对象之间的组织关系 行为型模式关注类或对象间的交互和职责分配(就是用来干什么) ...这一类型的设计模式, 所要表现的是对象的创建过程及和用户所使用的对象之间的关
  • 每个人都会有后悔的时候,可是人生没有后悔药,做过的事情无法再去后悔,软件设计中却是有这么一种后悔机制,叫做备忘录模式,它就是软件中的"后悔药" 什么是备忘录模式 Memento Pattern 在不破坏封装...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 465,101
精华内容 186,040
关键字:

属于行为模式的设计模式