精华内容
下载资源
问答
  • 设计模式之禅PK之行为类 行为类设计模式 行为类模式: ...观察者模式 ...命令模式和策略模式的类图确实很相似,只是命令模式多了一个接受者(Receiver)角色 两者的区别 不同点 命令模式 策略
    
    

    设计模式之禅PK之行为类

    行为类设计模式

    • 行为类模式:
      • 责任链模式
      • 命令模式
      • 迭代器模式
      • 中介者模式
      • 备忘录模式
      • 观察者模式
      • 状态模式
      • 策略模式
      • 模板方法模式
      • 访问者模式

    【命令模式】VS【策略模式】

    • 命令模式和策略模式的类图确实很相似,只是命令模式多了一个接受者(Receiver)角色
    • 两者的区别
    不同点 命令模式 策略模式
    意图 对动作的解耦,把一个动作的执行分为执行对象(执行者)、执行行为(命令角色)、让两者相互独立而不互相影响 封装算法,他认为“算法”已经是一个完整的、不可分割的原子任务,这些算法独立,并且可以相互替换,这些行为的变化独立于拥有拥有行为的客户
    • 从压缩文件继续PK
      • zip压缩/解压缩【Windows操作系统常用的压缩方法】
      • gzip压缩/解压缩【Linus常用的压缩方法】

    类图对比

    策略模式实现压缩算法 命令模式实现压缩算法

    代码具体实现

    • 策略模式代码

      • Algorithm

        package com.peng.pk_cl;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月13日
         * @description
         */
        public interface Algorithm {
            // 压缩算法
            public boolean compress(String source, String to);
        
            // 解压算法
            public boolean uncompress(String source, String to);
        
        }
        
      • Zip

        package com.peng.pk_cl;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月13日
         * @description
         */
        public class Zip implements Algorithm {
        
            @Override
            public boolean compress(String source, String to) {
                System.out.println(source + "====>>zip压缩成功!======>>" + to);
                return true;
            }
        
            @Override
            public boolean uncompress(String source, String to) {
                System.out.println(source + "====>>zip解压缩成功!======>>" + to);
                return true;
            }
        
        }
        
      • Gzip

        package com.peng.pk_cl;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月13日
         * @description
         */
        public class Gzip implements Algorithm {
        
            @Override
            public boolean compress(String source, String to) {
                System.out.println(source + "====>>Gzip压缩成功!======>>" + to);
                return true;
            }
        
            @Override
            public boolean uncompress(String source, String to) {
                System.out.println(source + "====>>Gzip解压缩成功!======>>" + to);
                return true;
            }
        
        }
        
      • Context

        package com.peng.pk_cl;
        
        
        /**
         * @author kungfu~peng
         * @data 2017年12月13日
         * @description
         */
        public class Context {
            // 指向抽象算法
            private Algorithm al;
        
            // 构造函数传递具体的算法
            public Context(Algorithm al) {
                super();
                this.al = al;
            }
        
            // 执行压缩算法
            public boolean compress(String source, String to) {
                return al.compress(source, to);
            }
        
            // 执行解压缩算法
            public boolean uncompress(String source, String to) {
                return al.uncompress(source, to);
            }
        
        }
        
      • Client

        package com.peng.pk_cl;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月13日
         * @description
         */
        public class Client {
            public static void main(String[] args) {
                // 定义环境角色
                Context context;
                // 执行zip的压缩算法
                System.out.println("====对文件执行zip压缩算法=====");
                context = new Context(new Zip());
                context.compress("a.txt", "a.txt.zip");
                // 执行zip的解压缩算法
                System.out.println("====对文件执行zip解压缩算法=====");
                context = new Context(new Zip());
                context.uncompress("a.txt.zip", "a.txt");
        
                // 执行Gzip的压缩算法
                System.out.println("====对文件执行gZip压缩算法=====");
                context = new Context(new Gzip());
                context.compress("a.txt", "a.txt.gzip");
                // 执行zip的解压缩算法
                System.out.println("====对文件执行Gzip解压缩算法=====");
                context = new Context(new Gzip());
                context.uncompress("a.txt.gzip", "a.txt");
            }
        }
        
      • 执行结果

        ====对文件执行zip压缩算法=====
        a.txt====>>zip压缩成功!======>>a.txt.zip
        ====对文件执行zip解压缩算法=====
        a.txt.zip====>>zip解压缩成功!======>>a.txt
        ====对文件执行gZip压缩算法=====
        a.txt====>>Gzip压缩成功!======>>a.txt.gzip
        ====对文件执行Gzip解压缩算法=====
        a.txt.gzip====>>Gzip解压缩成功!======>>a.txt
        
    • 命令模式代码

      • AbstractCmd

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月13日
         * @description
         */
        public abstract class AbstractCmd {
            // 对接收者的引用
            protected IReceiver zip = new ZipReceiver();
            protected IReceiver gzip = new GzipReceiver();
        
            // 抽象方法,命令的具体单元
            public abstract boolean execute(String source, String to);
        }
        
      • ZipCompressCmd

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class ZipCompressCmd extends AbstractCmd {
            @Override
            public boolean execute(String source, String to) {
                return super.zip.compress(source, to);
            }
        
        }
        
      • ZipUncompressCmd

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class ZipUncompressCmd extends AbstractCmd {
            @Override
            public boolean execute(String source, String to) {
                return super.zip.uncompress(source, to);
            }
        
        }
        
      • GzipCompressCmd

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class GzipCompressCmd extends AbstractCmd {
            @Override
            public boolean execute(String source, String to) {
                return super.gzip.compress(source, to);
            }
        
        }
        
      • GzipUncompressCmd

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class GzipUncompressCmd extends AbstractCmd {
            @Override
            public boolean execute(String source, String to) {
                return super.gzip.uncompress(source, to);
            }
        
        }
        
      • IReceiver

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public interface IReceiver {
            // 压缩
            public boolean compress(String source, String to);
        
            // 解压缩
            public boolean uncompress(String source, String to);
        }
        
      • ZipReceiver

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class ZipReceiver implements IReceiver {
            @Override
            public boolean compress(String source, String to) {
                System.out.println(source + "=====》压缩=====》" + to);
                return true;
            }
        
            @Override
            public boolean uncompress(String source, String to) {
                System.out.println(source + "=====》解压缩=====》" + to);
                return true;
            }
        
        }
        
      • GzipReceiver

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class GzipReceiver implements IReceiver {
            @Override
            public boolean compress(String source, String to) {
                System.out.println(source + "=====》压缩=====》" + to);
                return true;
            }
        
            @Override
            public boolean uncompress(String source, String to) {
                System.out.println(source + "=====》解压缩=====》" + to);
                return true;
            }
        
        }
        
      • Invoker

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class Invoker {
            // 抽象命令的引用
            public AbstractCmd cmd;
        
            public Invoker(AbstractCmd cmd) {
                super();
                this.cmd = cmd;
            }
        
            // 执行命令
            public boolean execute(String source, String to) {
                return cmd.execute(source, to);
            }
        }
        
      • Client

        package com.peng.pk_ml;
        
        /**
         * @author kungfu~peng
         * @data 2017年12月14日
         * @description
         */
        public class Client {
        
            public static void main(String[] args) {
                // 定义一个命令,压缩一个文件
                AbstractCmd cmd = new ZipCompressCmd();
                Invoker invoker = new Invoker(cmd);
                invoker.execute("a.txt", "a.txt.zip");
                // 解压缩
                AbstractCmd cmd2 = new ZipUncompressCmd();
                Invoker invoker2 = new Invoker(cmd2);
                invoker2.execute("a.txt.zip", "a.txt");
                // 定义一个命令,压缩一个文件
                AbstractCmd cmd3 = new GzipCompressCmd();
                Invoker invoker3 = new Invoker(cmd3);
                invoker3.execute("a.txt", "a.txt.gzip");
                // 解压缩
                AbstractCmd cmd4 = new GzipUncompressCmd();
                Invoker invoker4 = new Invoker(cmd4);
                invoker4.execute("a.txt.gzip", "a.txt");
        
            }
        }
        
      • 执行结果

        a.txt=====》压缩=====》a.txt.zip
        a.txt.zip=====》解压缩=====》a.txt
        a.txt=====》压缩=====》a.txt.gzip
        a.txt.gzip=====》解压缩=====》a.txt
        

    最佳实践

    比较项 命令模式 策略模式
    关注点 关注的是解耦问题--把要求的内容封装成一个一个的命令【撤销、记录】 算法替换问题,关注算法的完整性,封装性
    角色功能不同 关注命令的实现,也就是功能的实现 负责一个完整的算法--不可拆分的原子业务单元,一旦变更是对算法整体的变更
    使用的场景 解耦两个有紧耦合关系的对象场合或者多命令撤销的场景 算法要求变换的场景
    过程 关注了命令的封装,是请求者与执行者的彻底分开--相互之间互相独立,各自发展互不影响;命令模式可以排队处理;可以撤回 不可以排队和撤回---一次性操作即结束

    声明

    • 摘自秦小波《设计模式之禅》第2版;
    • 仅供学习,严禁商业用途;
    • 代码手写,没有经编译器编译,有个别错误,自行根据上下文改正;
    展开全文
  • 主要介绍了Ruby设计模式编程中对命令模式的相关使用,文中还讲到了关于观察者模式和命令模式的一些概念区别,需要的朋友可以参考下
  • 设计模式分类和区别

    2013-10-30 23:37:55
    设计模式分为三种类型,共23...行为型模式:模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。 按alphabeta排列简介如下。 A
    设计模式分为三种类型,共23种。
    创建型模式:单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
    结构型模式:适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
    行为型模式:模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。
    按alphabeta排列简介如下。
    Abstract Factory(抽象工厂模式):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
    Adapter(适配器模式):将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
    Bridge(桥接模式):将抽象部分与它的实现部分分离,使它们都可以独立地变化。
    Builder(建造者模式):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
    Chain of Responsibility(职责链模式):为解除请求的发送者和接收者之间耦合,而使多个对象都有机会处理这个请求。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它。
    Command(命令模式):将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可取消的操作。
    Composite(组合模式):将对象组合成树形结构以表示“部分-整体”的层次结构。它使得客户对单个对象和复合对象的使用具有一致性。
    Decorator(装饰模式):动态地给一个对象添加一些额外的职责。就扩展功能而言, 它比生成子类方式更为灵活。
    Facade(外观模式):为子系统中的一组接口提供一个一致的界面, F a c a d e模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
    Factory Method(工厂模式):定义一个用于创建对象的接口,让子类决定将哪一个类实例化。Factory Method使一个类的实例化延迟到其子类。
    Flyweight(享元模式):运用共享技术有效地支持大量细粒度的对象。
    Interpreter(解析器模式):给定一个语言, 定义它的文法的一种表示,并定义一个解释器, 该解释器使用该表示来解释语言中的句子。
    Iterator迭代器模式):提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
    Mediator(中介模式):用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
    Memento(备忘录模式):在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。
    Observer(观察者模式):定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。
    Prototype(原型模式):用原型实例指定创建对象的种类,并且通过拷贝这个原型来创建新的对象。
    Proxy(代理模式):为其他对象提供一个代理以控制对这个对象的访问。
    Singleton(单例模式):保证一个类仅有一个实例,并提供一个访问它的全局访问点。 单例模式是最简单的设计模式之一,但是对于Java的开发者来说,它却有很多缺陷。在本月的专栏中,David Geary探讨了单例模式以及在面对多线程(multithreading)、类装载器(classloaders)和序列化(serialization)时如何处理这些缺陷。
    State(状态模式):允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类。
    Strategy(策略模式):定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法的变化可独立于使用它的客户。
    Template Method(模板方法模式):定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
    Visitor(访问者模式):表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
    展开全文
  • 建造者模式,Builder构造者设计模式,原型模式,创建类模式总结篇,模版方法模式,中介者模式,观察者模式1,观察者模式2,访问者模式,访问者模式讨论篇:java的动态绑定与双分派,命令模式,责任连模式,策略模式...
  • 观察者模式 工厂方法模式和抽象工厂模式有什么区别? 工厂方法模式: 只有一个抽象产品类,具体工厂类只能创建一个具体产品类的实例 抽象工厂模式: 有多个抽象产品类 ,具体工厂类能创建多个具体产品类的实例 ...

    设计模式

    Spring中用到了那些设计模式

    • 简单工厂模式
    • 工厂方法
    • 单例模式
    • 代理模式
    • 观察者模式

    JDK中的设计模式

    • Singleton(单例) Runtime
    • Factory(静态工厂) Class.forName
    • Factory Method(工厂方法) Collection.iterator
    • Abstract Factory(抽象工厂) java.sql
    • Prototype(原型) Object.clone
    • Adapter(适配器) java.io.InputStreamReader(InputStream)
    • Proxy(代理) 动态代理
    • Iterator(迭代器) Iterator
    • Observer(观察者) Swing中的Listener
    • Command(命令) Runnable
    展开全文
  • 行为设计模式,共11种:策略模式、模版方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 这里介绍一下抽象工厂模式。 2.特点

    1.前言

    • 设计模式共有23种(点击这里查看更多分类),根据目的准则分类,分为三类
      • 创建型设计模式,共5种:单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
      • 结构型设计模式,共7中:适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、响元模式。
      • 行为设计模式,共11种:策略模式、模版方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
    • 这里介绍一下抽象工厂模式。

    2.特点

    • 定义:多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类,可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。
    • 解释:抽象工厂模式有如下几种角色
      • Product:抽象产品类
      • ConcreteProduct:具体产品类,实现Product接口
      • Factory:抽象工厂类,该方法返回一个Product类型的对象
      • ConcreteFactory:具体工厂类,返回ConcreateFactory实例

    代码说明

    抽象产品类1,如下:

    public abstract class Computer {
        /**
         * 产品的抽象方法,由具体的产品类实现
         */
        public abstract void run();
    }
    

    具体产品类1,如下:

    public class LenovoComputer extends Computer {
    
        @Override
        public void run() {
            System.out.println("联想运行");
        }
    }
    
    public class MiuiComputer extends Computer {
    
        @Override
        public void run() {
            System.out.println("小米运行");
        }
    }
    
    public class AsusComputer extends Computer {
    
        @Override
        public void run() {
            System.out.println("华硕运行");
        }
    }
    

    抽象产品类2,如下:

    public abstract class Price {
            /**
             * 产品的抽象方法,由具体的产品类实现
             */
            public abstract void cost();
        }
    

    具体产品类2,如下:

    public class LenovoComputerPrice extends Price {
    
            @Override
            public void cost() {
                System.out.println("价值5000");
            }
        }
    
        public class MiuiComputerPrice extends Price {
    
            @Override
            public void cost() {
                System.out.println("价值4500");
            }
        }
    
        public class AsusComputerPrice extends Price {
    
            @Override
            public void cost() {
                System.out.println("价值5500");
            }
        }
    

    抽象工厂类,如下:

    public abstract class ComputerFactory {
        public abstract <T extends Computer> T createComputer(Class<T> clz);
        public abstract <T extends Price> T getComputerPrice(Class<T> clz);
    }
    

    具体工厂类,如下:

    public class ConcreteComputerFactor extends ComputerFactory {
        @Override
        public <T extends Computer> T createComputer(Class<T> clz) {
            Computer computer = null;
            String className = clz.getName();
            try {
                //这里用反射的方式拿到不同厂家的计算机
                computer = (Computer) Class.forName(className).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) computer;
        }
        @Override
        public <T extends Price> T getComputerPrice(Class<T> clz) {
            Price price = null;
            String className = clz.getName();
            try {
                //这里用反射的方式拿到不同厂家的计算机价格
                price = (Price) Class.forName(className).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) price;
        }
    }
    

    最终调用,如下

    ConcreteComputerFactor computerFactor = new ConcreteComputerFactor();
    LenovoComputer lenovoComputer = computerFactor.createComputer(LenovoComputer.class);
    lenovoComputer.run();
    LenovoComputerPrice lenovoComputerPrice = computerFactor.getComputerPrice(LenovoComputerPrice.class);
    lenovoComputerPrice.cost();
    

    和工厂方法模式的区别

    • 工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
    • 工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。

    3.总结

    关于工厂方法模式可以看我的另一篇点击这里
    有疑问可以留言!

    展开全文
  • 设计模式Note

    2017-11-09 19:33:08
    观察者模式 装饰者模式 工厂模式 1工厂方法 2抽象工厂 单例模式 命令模式 适配器外观模式 1适配器 2装饰者模式的区别 3外观模式 模版方法 迭代器模式 组合模式 状态模式 代理模式 复合模式 桥接模式 构建者生成...
  • (一)概述 行为型设计模式涉及到算法...行为型设计模式包括11种:策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式和解释器模式。 (二)区别
  • 观察者模式 中介者模式 迭代器模式 访问者模式 备忘录模式 模板方法模式 解释器模式 写在前面: UML图解 继承实现是比较容易理解的两种类关系。在架构设计中,要注意组合、聚合 依赖这三者的区别。 组合在 语中...
  • 208面试题 设计模式

    2020-11-18 09:36:49
    策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录 模式、状态模式、访问者模式、中介者模式、解释器模式。 详情了解: 请点击 89.简单工厂抽象工厂有什么区别? 简单工厂模式: ...
  • JavaScript设计模式

    2018-08-31 02:47:41
    15.6观察者模式的适用场合 15.7观察者模式之利 15.8观察者模式之弊 15.9小结 第16章命令模式 16.1命令的结构 16.1.1用闭包创建命令对象 16.1.2客户、调用者接收者 16.1.3在命令模式中使用接口 16.2命令对象的类型 ...
  • 基本概念 ...在面向对象编程语言中,响应式编程通常以观察者模式的扩展呈现。还可以将响应式流模式和迭代器模式比较,一个主要的区别是,迭代器基于”拉“,而响应式流基于”推“。 使用迭代器是一种命令
  • 研磨设计模式.part3

    2012-02-10 14:06:23
    12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 研磨设计模式.part1

    2012-02-10 14:05:01
    12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 研磨设计模式.part2

    2012-02-10 14:02:38
    12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 研磨设计模式.part4

    2012-02-10 13:57:47
    12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 第12章 解决、解耦的钥匙——观察者模式224 12.1 观察者模式介绍224 12.2 观察者模式的定义224 12.3 观察者模式的使用场景224 12.4 观察者模式的UML类图224 12.5 观察者模式的简单实现225 12.6 Android源码...
  • 12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 12.2.1 使用观察者模式来解决问题 12.2.2 观察者模式的结构说明 12.2.3 观察者模式示例代码 12.2.4 使用观察者模式实现示例 12.3 模式讲解 12.3.1 认识观察者模式 12.3.2 推模型和拉模型 12.3.3 Java中的观察者...
  • 1.工厂模式 2.单例模式 也叫单元素模式 3.观察者模式 4.命令链模式 5.策略模式 下面有几篇文章,可以看看这几个模式的区别和用法!
  • MVC1MVC2的区别

    2015-07-08 15:20:29
    基本概念: M:Model 程序的业务 V:View 程序的界面 C:Controller 程序的控制部分 ...controller统一进行处理命令,交由model处理具体的业务. ...这种模式主要用于桌面程序,使用观察者模式
  • 二十三种设计模式【PDF版】

    热门讨论 2011-05-30 14:13:49
    设计模式之 Observer(观察者) 介绍如何使用 Java API 提供的现成 Observer 设计模式之 Iterator(迭代器) 这个模式已经被整合入Java的Collection.在大多数场合下无需自己制造一个Iterator,只要将对象装入...
  • 开闭原则、依赖倒置原则、单一职责原则、接口隔离原则、迪米特原则、里氏替换原则、合成复用原则 单例模式、工厂模式、模板模式、代理模式、装饰模式、适配器模式、外观模式、策略模式、观察者模式命令模式、备忘...
  • 行为型模式(11种):策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 工厂模式 抽象工厂模式 单例模式 Public class ...
  • 这使研究人员可以观察比赛中的赢家输家,而在限价订单簿数据中,您看不到输家,因此您无法直接看到比赛。 我们发现延迟套利竞赛非常频繁(对于富时 100 股票,每个符号大约每分钟一次),速度极快(模式竞赛持续...
  • cs413sp15team01p4-源码

    2021-06-14 10:59:05
    使用观察者模式实现事件驱动的行为 使用状态模式实现依赖状态的行为 将任务表示为对象的命令模式 用于从适配器隐藏模型中的复杂性的外观模式 相关的类级设计原则 依赖倒置原则 (DIP) 单一职责原则 (SRP) 接口隔离...
  • JAVA面试题(四)

    2020-09-22 18:46:27
    weisan.yunhua 2020/9/22 完全按简历一点点问的HR ...观察者模式的通知是直接调用方法还是回掉通知? Maven的生命周期?最常用哪个? Git的命令?Git的 branch 的作用? redis常用在哪?redis的setma

空空如也

空空如也

1 2 3 4
收藏数 75
精华内容 30
关键字:

命令模式和观察者模式区别