精华内容
下载资源
问答
  • 小弟的平常心谈软件设计模式(一)中讲解了原型模式,有位大侠给我建议很好,说叫我要一个一个将设计模式具体的运用场景,小弟打算从(三)中开始摆出实际例子来说说设计模式到底怎么去用。我之所以在这一篇中还是不去...

    小弟平常心谈软件设计模式(一)中讲解了原型模式,有位大侠给我建议很好,说叫我要一个一个将设计模式具体的运用场景,小弟打算从()中开始摆出实际例子来说说设计模式到底怎么去用。我之所以在这一篇中还是不去讲解,主要是还是想跟各位分享下设计模式的美妙成果,强调一下设计模式无处不在。

    小弟这一讲主要是Observer模式,也就是传说中的观察者或者订阅-发布模式。简单讲模式本身,重点分析该模式的两个典型运用:javawebMVC架构和MFCdoc/view架构。

     

    一.Observer模式:

    先引用下K_Eckel老师的模式图:

    Subject作为发布者为它的关联对象Observer提供注册和注销功能,这些关联对象放在一个链表中,当有Notify动作的时候就能遍历链表,找到注册的对象去调用它们的函数,这里给的是例子是Update()。由于SubjectObserver出现了两种关系,这里简单区分下:关系立场去区分,它们只是关联关系(a-a)subject是分别强依赖于Observer的各个子类,创建各个子类的操作对象;动作立场上去区分,它们是组合关系(contains-a):发起某一个动作的时候需要强依赖于一组对象,也就是对象链表。

     

    二.运用之一:MVC

    上个简图:

    MVC就是是模型(model)-视图(view)-控制器(controller)Controller的主要用途就是决定调用那个model去处理数据,组织那个view去显示内容。View主要负责用户界面的显示和操作。Model负责数据的处理。

    当然在这里 ViewControllerModelcontroller是双向关联关系,彼此包含和调用(小弟认为我们平常的运用系统可以按这个结构划分,但是仅仅使用一个observer模型,缺点太多,威力大减,需要配合mediator等其它模式方发挥最强威力,此是后话,下片详解)。

    这个MVCObserver模式的对应关系为:controller就是 Subject的位置。Viewmodel就是Observer的位置。

    小弟只是在这里简略的介绍了下MVC的最最基本的思想,比如具体MVMC是怎么交互的,如果是做B/S系统的大侠在SSH框架中应该比较清楚,不做的话,知道这个思想也就够了。

    三.运用之二:Doc/View

    先来看看MFC的对象关系图:

    D/V模型中主要讲解的就是 CDocumentCView之间的关系。

    首先简单的阐述下MFC的单文档工程的创建和工作过程:

    一个单文档工程的CWinApp最先创建出来,CWinApp对象去创建一个单文档模版CDocTemplate对象。CDocTemplate对象去创建CFrameWnd对象,CFrameWnd初始化中去创建CView对象,CView对象被创建出来后会将自身的this指针注册到CDocument类中去。

    CDocument主要管理数据,CView负责界面展示,CFrameWnd负责工程框架。当CDocument管理的数据有更新时就会通过UpdateAllViews(…)函数给注册过的CView对象发消息去通知CView类数据有变化,CView接收到CDocumentUpdate消息后就会响应OnUpdate(…)CView接着就会通过GetDocument()去获取具体变化的数据,然后在OnDraw()函数内通过DC对象绘制到界面。

    好了,很笼统的说了下D/V流程。这个不是我要讲述的重点,我要表述的关键是这个模型体现Observer设计模式的思想。

     不难看出,CDocument扮演的就是设计模式中的Subject,而CView就是Observer角色。

     

    四.知识点扩展:

    1.             MVC框架思想的最好的实例得数当下流行的WEB工程框架:Struts-Spring-Hibernate。由于小弟不是重点研究SSH工程的,也无法给出明确划分界定,可以肯定strutActionServlet绝对是C的角色。

    2.             MFC的消息机制。MFC的命令消息的运转过程可以分三部分讲解,一是消息的发送函数体,二是消息的接收队列及分发消息函数,三是消息映射机制。MFC工程的CWinApp创建一条主线程或者叫UI线程然后会继承父类的消息循环体Run()函数以及消息泵PumpMessage(),还会继承祖父类的OnCmdMsg()函数去传递发送消息或者重新去实现之。当然各个从CCmdTarget派生出来的子类都可以覆盖这个超类的OnCmdMsg函数体。在默认的OnCmdMsg函数体内会去调用GetMessageMap得到目标类的消息映射数组,经过匹配然后去触发命令消息的函数体。OnCmdMsg()传输消息,Run()维护消息队列,PumpMessage()分发消息,GetMessageMap去触发消息响应函数。

    五.总结:

    该模式实现了展示层跟数据层的真正解耦,是我们平常开发运用项目的经典模型。

    当然如果Observer角色有多个,并且有上下层次的区别时,我们仅仅就用Observer模式去实现就只能达到单向的解耦无法实现层次之间的真正解耦,如果配合上使用Mediator中介角色那就不一样了,敬请关注小弟的小一讲 observer+mediator+Command模式搭建QQ通信框架。

    展开全文
  • 创建型模式这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式,而不是使用新的运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。工厂模式与抽象工厂模式 (Factory ...
    创建型模式

    这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式,而不是使用新的运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

    • 工厂模式与抽象工厂模式 (Factory Pattern)(Abstract Factory Pattern):不同条件下创建不同实例
    • 单例模式 (Singleton Pattern):保证一个类仅有一个实例,适用于只需要一个对象的情况
    • 建造者模式 (Builder Pattern)将一个复杂的构建过程与其具表示细节相分离,使得同样的构建过程可以创建不同的表示,创建复杂对象
    • 原型模式 (Prototype Pattern)通过拷贝原型创建新的对象,复制对象,包括深度复制和浅度复制,深度复制重建引用对象,浅度复制不创建

    结构型模式

    这些设计模式关注类和对象的组合。

    • 适配器模式 (Adapter Pattern)使得原本由于接口不兼容而不能一起工作的那些类可以一起工作,开发阶段不考虑,适用于后期维护时添加功能
    • 装饰器模式 (Decorator Pattern)保持接口,增强性能,说白了就是实现接口,扩展方法功能,可在方法执行前后加代码
    • 桥接模式 (Bridge Pattern)两个维度独立变化,依赖方式实现抽象与实现分离:需要一个作为桥接的接口/抽象类,多个角度的实现类依赖注入到抽象类,使它们在抽象层建立一个关联关系,通过setXxx方法任意修改引用实例,调用同样方法实现不同功能
    • 外观模式 (Facade Pattern)在客户端和复杂系统之间再加一层,这一次将调用顺序、依赖关系等处理好。即封装底层实现,隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统的高层接口
    • 代理模式 (Proxy Pattern)为其他对象提供一种代理以控制对这个对象的访问,调用引用对象方法实现自身功能
    • 过滤器模式 (Filter、Criteria Pattern)使用不同的标准来过滤一组对象,通过逻辑运算以解耦的方式把它们连接起来
    • 组合模式 (Composite Pattern)用户对单个对象和组合对象的使用具有一致性的统一接口,部分与整体,常用于表示树形结构
    • 享元模式 (Flyweight Pattern)维护资源集合,经典案例:数据库连接池,避免重新开启数据库链接的开销

    行为型模式

    这些设计模式特别关注对象之间的通信。

    • 责任链模式(Chain of Responsibility Pattern)拦截的类都实现统一接口,每个接收者都包含对下一个接收者的引用。将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止。依次引用,依次执行.
    • 观察者模式(Observer Pattern)目标方法被调用,通知所有观察者
    • 模板模式(Template Pattern)父类定义公共方法,不同子类重写父类抽象方法,得到不同结果
    • 命令模式(Command Pattern)将"行为请求者"与"行为实现者"解耦:调用者依赖命令,命令依赖接收者,调用者Invoker→命令Command→接收者Receiver,各司其职,逐层调用,有点像三层架构
    • 解释器模式(Interpreter Pattern):定义解释类,解释包装对象
    • 迭代器模式(Iterator Pattern):迭代器实现原理
    • 中介者模式(Mediator Pattern)对象与对象之间存在大量的关联关系,将对象之间的通信关联关系封装到一个中介类中单独处理,从而使其耦合松散,可以独立地改变它们之间的交互,中介类维护对象行为。主程序直接调用中介对象即可
    • 策略模式(Strategy Pattern)定义多个不同的实现类,这些类实现公共接口,通过调用接口调用不同实例得到不同结果
    • 状态模式(State Pattern)通过改变状态,改变行为
    • 备忘录模式(Memento Pattern):建立原始对象副本,用于存储恢复原始对象数据。
    展开全文
  • 小弟在以前的文章(平台整合系列)中提到了设计模式,设计模式到底是个什么东西,有什么用途呢?小弟打算在该系列中理论联系实际介绍下设计模式的前世今生,用途意义。小弟在这里主要讲解在C++开发中遇见的或者运用...

    小弟在以前的文章(平台整合系列)中提到了设计模式,设计模式到底是个什么东西,有什么用途呢?小弟打算在该系列中理论联系实际介绍下设计模式的前世今生,用途意义。小弟在这里主要讲解在C++开发中遇见的或者运用到的。

    一、两段简单的代码:

    代码段一:

    struct SUser
    {
     CString strUserID ; 
     int nAge ;

     SUser()
     {
      strSystemID  = _T("");
     nAge = 0 ;
     }

     ~SUser()
     {

     }

     SUser(const SUser& other)
     {
      *this = other;
     }

     SUser& operator = (const SUser& other)
     {
      strUserID   = other.strUserID;
      nAge= other.nAge;

      return *this;
     };

    };

    代码段二:

    class CUser
    {
      public:
       CUser() ;
       CUser(const CUser& user) ;
       ~CUser() ;

       CUser* Clone() const { return new CUser(*this);};

    private:

     CString strUserID ;
      int nAge ;
    }

    二、两段代码的简单解说:

    代码段一 是我们熟悉的C中的结构体定义,不仅定义了结构体内部成员,还定义了结构的operator=重载。

    代码段二是我们熟悉的C++的类定义,不仅定义了构造函数和属性还定义copy constructor方法。

    三、涉及到的设计模式:

    这个的设计模式就是传说中的 原型模式 (Prototype pattern)。结构图如下:

    简单解析:ConcretePrototype子类通过拷贝构造函数(位拷贝)或者包括指针、复合对象的拷贝(值拷贝)为Client类提供Prototype操作对象。

    Prototype模式通过复制原型(Prototype)而获得新对象创建,即Prototype本身就是对象工程,跟AbstractFactory(抽象工厂模式)的区别就在于它是再不断的复制自己制造出新对象。

    四、知识点扩充透析:

    浅层拷贝跟深层拷贝。

    浅层拷贝(位拷贝):浅层拷贝是指地址的复制,是指将一个对象的内存映像按位原封不动的复制给另一个对象,所有创建出来的对象所指的内存都是同一块地址。典型的例子就是代码片段二,copy constructor拷贝构造函数。

    深层拷贝(值拷贝):深层拷贝是指值的复制,是将一个对象的内存内容原封不动的复制到另一块内存中,所有创建出来的对象都有自己独立的内存块。典型的例子就是代码片段一中的copy constructor加上operator=

    五、总结:

    小弟用直白的话做一个总结:原型模式 就完成了自己的裂变,一个自己变出无数个自己。无数个自己如果是影子那就是浅层拷贝得到的,要是价真货实那就是深层拷贝过。

     

    小弟还打算在后续的博客中继续用平常心去聊聊发布订阅者模式,适配器模式等等。

     

    展开全文
  • 一、设计模式的分类 总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象...行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模...
        

    图片描述

    一、设计模式的分类

    总体来说设计模式分为三大类:

    创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

    其实还有两类:并发型模式和线程池模式。用一个图片来整体描述一下:

    clipboard.png

    二、设计模式常用到的六大原则

    1、开闭原则(Open Close Principle)

    开闭原则就是说对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。

    2、里氏代换原则(Liskov Substitution Principle)

    里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。 LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

    3、依赖倒转原则(Dependence Inversion Principle)

    这个是开闭原则的基础,具体内容:真对接口编程,依赖于抽象而不依赖于具体。

    4、接口隔离原则(Interface Segregation Principle)

    这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。还是一个降低类之间的耦合度的意思,从这儿我们看出,其实设计模式就是一个软件的设计思想,从大型软件架构出发,为了升级和维护方便。所以上文中多次出现:降低依赖,降低耦合。

    5、迪米特法则(最少知道原则)(Demeter Principle)

    为什么叫最少知道原则,就是说:一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。

    6、合成复用原则(Composite Reuse Principle)

    原则是尽量使用合成/聚合的方式,而不是使用继承。

    各大工厂里常用到的设计模式

    从这一块开始,我们详细介绍Java中23种设计模式的概念,应用场景等情况,并结合他们的特点及设计模式的原则进行分析。

    1、工厂方法模式(Factory Method)

    工厂方法模式分为三种:

    1.1:普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。首先看下关系图:

    clipboard.png

    举例如下:(我们举一个发送邮件和短信的例子)
    首先,创建二者的共同接口:

    clipboard.png
    其次,创建实现类:

    clipboard.png

    最后,建工厂类:

    clipboard.png

    我们来测试下:

    clipboard.png

    输出:this is sms sender!
    1.2:多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。关系图:

    clipboard.png
    将上面的代码做下修改,改动下SendFactory类就行,如下:

    clipboard.png

    测试类如下:

    clipboard.png

    输出:this is mailsender!
    1.3:静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可。

    clipboard.png

    输出:this is mailsender!
    总体来说,工厂模式适合:凡是出现了大量的产品需要创建,并且具有共同的接口时,可以通过工厂方法模式进行创建。在以上的三种模式中,第一种如果传入的字符串有误,不能正确创建对象,第三种相对于第二种,不需要实例化工厂类,所以,大多数情况下,我们会选用第三种——静态工厂方法模式。

    2、抽象工厂模式(Abstract Factory)

    工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题,如何解决?就用到抽象工厂模式,创建多个工厂类,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。因为抽象工厂不太好理解,我们先看看图,然后就和代码,就比较容易理解。

    clipboard.png

    请看例子:

    clipboard.png

    两个实现类:

    clipboard.png

    两个工厂类:

    clipboard.png

    在提供一个接口:

    clipboard.png

    测试类:

    clipboard.png

    其实这个模式的好处就是,如果你现在想增加一个功能:发及时信息,则只需做一个实现类,实现Sender接口,同时做一个工厂类,实现Provider接口,就OK了,无需去改动现成的代码。这样做,拓展性较好!

    3、单例模式(Singleton)

    单例对象(Singleton)是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。这样的模式有几个好处:
    1、某些类创建比较频繁,对于一些大型的对象,这是一笔很大的系统开销。
    2、省去了new操作符,降低了系统内存的使用频率,减轻GC压力。
    3、有些类如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个的话,系统完全乱了。(比如一个军队出现了多个司令员同时指挥,肯定会乱成一团),所以只有使用单例模式,才能保证核心交易服务器独立控制整个流程。
    首先我们写一个简单的单例类:

    clipboard.png

    这个类可以满足基本要求,但是,像这样毫无线程安全保护的类,如果我们把它放入多线程的环境下,肯定就会出现问题了,如何解决?我们首先会想到对getInstance方法加synchronized关键字,如下:

    clipboard.png

    但是,synchronized关键字锁住的是这个对象,这样的用法,在性能上会有所下降,因为每次调用getInstance(),都要对对象上锁,事实上,只有在第一次创建对象的时候需要加锁,之后就不需要了,所以,这个地方需要改进。我们改成下面这个:

    clipboard.png

    似乎解决了之前提到的问题,将synchronized关键字加在了内部,也就是说当调用的时候是不需要加锁的,只有在instance为null,并创建对象的时候才需要加锁,性能有一定的提升。但是,这样的情况,还是有可能有问题的,看下面的情况:在Java指令中创建对象和赋值操作是分开进行的,也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序,也就是说有可能JVM会为新的Singleton实例分配空间,然后直接赋值给instance成员,然后再去初始化这个Singleton实例。这样就可能出错了,我们以A、B两个线程为例:
    a>A、B线程同时进入了第一个if判断
    b>A首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();
    c>由于JVM内部的优化机制,JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance成员(注意此时JVM没有开始初始化这个实例),然后A离开了synchronized块。
    d>B进入synchronized块,由于instance此时不是null,因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
    e>此时B线程打算使用Singleton实例,却发现它没有被初始化,于是错误发生了。
    所以程序还是有可能发生错误,其实程序在运行过程是很复杂的,从这点我们就可以看出,尤其是在写多线程环境下的程序更有难度,有挑战性。我们对该程序做进一步优化:

    clipboard.png

    实际情况是,单例模式使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候,JVM能够帮我们保证instance只被创建一次,并且会保证把赋值给instance的内存初始化完毕,这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制,这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式:

    clipboard.png

    其实说它完美,也不一定,如果在构造函数中抛出异常,实例将永远得不到创建,也会出错。所以说,十分完美的东西是没有的,我们只能根据实际情况,选择最适合自己应用场景的实现方法。也有人这样实现:因为我们只需要在创建类的时候进行同步,所以只要将创建和getInstance()分开,单独为创建加synchronized关键字,也是可以的:

    clipboard.png

    考虑性能的话,整个程序只需创建一次实例,所以性能也不会有什么影响。
    补充:采用"影子实例"的办法为单例对象的属性同步更新

    clipboard.png

    通过单例模式的学习告诉我们:
    1、单例模式理解起来简单,但是具体实现起来还是有一定的难度。
    2、synchronized关键字锁定的是对象,在用的时候,一定要在恰当的地方使用(注意需要使用锁的对象和过程,可能有的时候并不是整个对象及整个过程都需要锁)。
    到这儿,单例模式基本已经讲完了,结尾处,笔者突然想到另一个问题,就是采用类的静态方法,实现单例模式的效果,也是可行的,此处二者有什么不同?
    首先,静态类不能实现接口。(从类的角度说是可以的,但是那样就破坏了静态了。因为接口中不允许有static修饰的方法,所以即使实现了也是非静态的)
    其次,单例可以被延迟初始化,静态类一般在第一次加载是初始化。之所以延迟加载,是因为有些类比较庞大,所以延迟加载有助于提升性能。
    再次,单例类可以被继承,他的方法可以被覆写。但是静态类内部方法都是static,无法被覆写。
    最后一点,单例类比较灵活,毕竟从实现上只是一个普通的Java类,只要满足单例的基本需求,你可以在里面随心所欲的实现一些其它功能,但是静态类不行。从上面这些概括中,基本可以看出二者的区别,但是,从另一方面讲,我们上面最后实现的那个单例模式,内部就是用一个静态类来实现的,所以,二者有很大的关联,只是我们考虑问题的层面不同罢了。两种思想的结合,才能造就出完美的解决方案,就像HashMap采用数组+链表来实现一样,其实生活中很多事情都是这样,单用不同的方法来处理问题,总是有优点也有缺点,最完美的方法是,结合各个方法的优点,才能最好的解决问题!

    4、建造者模式(Builder)

    工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码:
    还和前面一样,一个Sender接口,两个实现类MailSender和SmsSender。最后,建造者类如下:

    clipboard.png

    测试类:

    clipboard.png

    从这点看出,建造者模式将很多功能集成到一个类里,这个类可以创造出比较复杂的东西。所以与工程模式的区别就是:工厂模式关注的是创建单个产品,而建造者模式则关注创建符合对象,多个部分。因此,是选择工厂模式还是建造者模式,依实际情况而定。

    5、原型模式(Prototype)

    原型模式虽然是创建型的模式,但是与工程模式没有关系,从名字即可看出,该模式的思想就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。本小结会通过对象的复制,进行讲解。在Java中,复制对象是通过clone()实现的,先创建一个原型类:

    clipboard.png

    很简单,一个原型类,只需要实现Cloneable接口,覆写clone方法,此处clone方法可以改成任意的名称,因为Cloneable接口是个空接口,你可以任意定义实现类的方法名,如cloneA或者cloneB,因为此处的重点是super.clone()这句话,super.clone()调用的是Object的clone()方法,而在Object类中,clone()是native的,具体怎么实现,我会在另一篇文章中,关于解读Java中本地方法的调用,此处不再深究。在这儿,我将结合对象的浅复制和深复制来说一下,首先需要了解对象深、浅复制的概念:
    浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。
    深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底。
    此处,写一个深浅复制的例子:

    clipboard.png

    要实现深复制,需要采用流的形式读入当前对象的二进制输入,再写出二进制数据对应的对象。
    我们接着讨论设计模式,上篇文章我讲完了5种创建型模式,这章开始,我将讲下7种结构型模式:适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源,我们看下面的图:

    clipboard.png

    6、适配器模式(adapter)

    适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。首先,我们来看看类的适配器模式,先看类图:

    clipboard.png

    核心思想就是:有一个Source类,拥有一个方法,待适配,目标接口时Targetable,通过Adapter类,将Source的功能扩展到Targetable里,看代码:

    clipboard.png

    Adapter类继承Source类,实现Targetable接口,下面是测试类:

    clipboard.png

    输出:
    this is original method!
    this is the targetable method!
    这样Targetable接口的实现类就具有了Source类的功能。

    对象的适配器模式

    基本思路和类的适配器模式相同,只是将Adapter类作修改,这次不继承Source类,而是持有Source类的实例,以达到解决兼容性的问题。看图:

    clipboard.png

    只需要修改Adapter类的源码即可:

    clipboard.png

    测试类:

    clipboard.png

    输出与第一种一样,只是适配的方法不同而已。
    第三种适配器模式是接口的适配器模式,接口的适配器是这样的:有时我们写的一个接口中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些,此处为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽象类取得联系,所以我们写一个类,继承该抽象类,重写我们需要的方法就行。看一下类图:

    clipboard.png

    这个很好理解,在实际开发中,我们也常会遇到这种接口中定义了太多的方法,以致于有时我们在一些实现类中并不是都需要。看代码:

    clipboard.png

    抽象类Wrapper2:

    clipboard.png

    测试输出:
    the sourceable interface's first Sub1!
    the sourceable interface's second Sub2!
    达到了我们的效果!
    讲了这么多,总结一下三种适配器模式的应用场景:
    类的适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。
    对象的适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Wrapper类,持有原类的一个实例,在Wrapper类的方法中,调用实例的方法就行。
    接口的适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。

    7、装饰模式(Decorator)

    顾名思义,装饰模式就是给一个对象增加一些新的功能,而且是动态的,要求装饰对象和被装饰对象实现同一个接口,装饰对象持有被装饰对象的实例,关系图如下:

    clipboard.png

    Source类是被装饰类,Decorator类是一个装饰类,可以为Source类动态的添加一些功能,代码如下:

    clipboard.png

    测试类:

    clipboard.png

    输出:
    before decorator!
    the original method!
    after decorator!
    装饰器模式的应用场景:
    1、需要扩展一个类的功能。
    2、动态的为一个对象增加功能,而且还能动态撤销。(继承不能做到这一点,继承的功能是静态的,不能动态增删。)
    缺点:产生过多相似的对象,不易排错!

    8、代理模式(Proxy)

    其实每个模式名称就表明了该模式的作用,代理模式就是多一个代理类出来,替原对象进行一些操作,比如我们在租房子的时候回去找中介,为什么呢?因为你对该地区房屋的信息掌握的不够全面,希望找一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,我们需要请律师,因为律师在法律方面有专长,可以替我们进行操作,表达我们的想法。先来看看关系图:

    clipboard.png

    根据上文的阐述,代理模式就比较容易的理解了,我们看下代码:

    clipboard.png

    测试类:

    clipboard.png

    输出:
    before proxy!
    the original method!
    after proxy!
    代理模式的应用场景:
    如果已有的方法在使用的时候需要对原有的方法进行改进,此时有两种办法:
    1、修改原有的方法来适应。这样违反了“对扩展开放,对修改关闭”的原则。
    2、就是采用一个代理类调用原有的方法,且对产生的结果进行控制。这种方法就是代理模式。
    使用代理模式,可以将功能划分的更加清晰,有助于后期维护!

    9、外观模式(Facade)

    外观模式是为了解决类与类之家的依赖关系的,像spring一样,可以将类和类之间的关系配置到配置文件中,而外观模式就是将他们的关系放在一个Facade类中,降低了类类之间的耦合度,该模式中没有涉及到接口,看下类图:(我们以一个计算机的启动过程为例)

    clipboard.png

    我们先看下实现类:

    clipboard.png

    clipboard.png

    User类如下:

    clipboard.png

    输出:
    start the computer!
    cpu startup!
    memory startup!
    disk startup!
    start computer finished!
    begin to close the computer!
    cpu shutdown!
    memory shutdown!
    disk shutdown!
    computer closed!
    如果我们没有Computer类,那么,CPU、Memory、Disk他们之间将会相互持有实例,产生关系,这样会造成严重的依赖,修改一个类,可能会带来其他类的修改,这不是我们想要看到的,有了Computer类,他们之间的关系被放在了Computer类里,这样就起到了解耦的作用,这,就是外观模式!

    在此我向大家推荐一个交流学习群:575745314 里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

    10、桥接模式(Bridge)

    桥接模式就是把事物和其具体实现分开,使他们可以各自独立的变化。桥接的用意是:将抽象化与实现化解耦,使得二者可以独立变化,像我们常用的JDBC桥DriverManager一样,JDBC进行连接数据库的时候,在各个数据库之间进行切换,基本不需要动太多的代码,甚至丝毫不用动,原因就是JDBC提供统一接口,每个数据库提供各自的实现,用一个叫做数据库驱动的程序来桥接就行了。我们来看看关系图:

    clipboard.png

    实现代码:
    先定义接口:

    clipboard.png

    分别定义两个实现类:

    clipboard.png

    定义一个桥,持有Sourceable的一个实例:

    clipboard.png

    测试类:

    clipboard.png

    output:
    this is the first sub!
    this is the second sub!
    这样,就通过对Bridge类的调用,实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用。接下来我再画个图,大家就应该明白了,因为这个图是我们JDBC连接的原理,有数据库学习基础的,一结合就都懂了。

    clipboard.png

    11、组合模式(Composite)

    组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便,看看关系图:

    clipboard.png

    直接来看代码:

    clipboard.png

    clipboard.png

    使用场景:将多个对象组合在一起进行操作,常用于表示树形结构中,例如二叉树,数等。

    12、享元模式(Flyweight)

    享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用。

    clipboard.png

    FlyWeightFactory负责创建和管理享元单元,当一个客户端请求时,工厂需要检查当前对象池中是否有符合条件的对象,如果有,就返回已经存在的对象,如果没有,则创建一个新对象,FlyWeight是超类。一提到共享池,我们很容易联想到Java里面的JDBC连接池,想想每个连接的特点,我们不难总结出:适用于作共享的一些个对象,他们有一些共有的属性,就拿数据库连接池来说,url、driverClassName、username、password及dbname,这些属性对于每个连接来说都是一样的,所以就适合用享元模式来处理,建一个工厂类,将上述类似属性作为内部数据,其它的作为外部数据,在方法调用时,当做参数传进来,这样就节省了空间,减少了实例的数量。
    看个例子:

    clipboard.png

    看下数据库连接池的代码:

    clipboard.png

    通过连接池的管理,实现了数据库连接的共享,不需要每一次都重新创建连接,节省了数据库重新创建的开销,提升了系统的性能!本章讲解了7种结构型模式,因为篇幅的问题,剩下的11种行为型模式,

    本章是关于设计模式的最后一讲,会讲到第三种设计模式——行为型模式,共11种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。这段时间一直在写关于设计模式的东西,终于写到一半了,写博文是个很费时间的东西,因为我得为读者负责,不论是图还是代码还是表述,都希望能尽量写清楚,以便读者理解,我想不论是我还是读者,都希望看到高质量的博文出来,从我本人出发,我会一直坚持下去,不断更新,源源动力来自于读者朋友们的不断支持,我会尽自己的努力,写好每一篇文章!希望大家能不断给出意见和建议,共同打造完美的博文!

    先来张图,看看这11中模式的关系:
    第一类:通过父类与子类的关系进行实现。第二类:两个类之间。第三类:类的状态。第四类:通过中间类

    clipboard.png

    13、策略模式(strategy)

    策略模式定义了一系列算法,并将每个算法封装起来,使他们可以相互替换,且算法的变化不会影响到使用算法的客户。需要设计一个接口,为一系列实现类提供统一的方法,多个实现类实现该接口,设计一个抽象类(可有可无,属于辅助类),提供辅助函数,关系图如下:

    clipboard.png

    图中ICalculator提供同意的方法,
    AbstractCalculator是辅助类,提供辅助方法,接下来,依次实现下每个类:
    首先统一接口:

    clipboard.png

    辅助类:

    clipboard.png

    三个实现类:

    clipboard.png

    简单的测试类:

    clipboard.png

    输出:10
    策略模式的决定权在用户,系统本身提供不同算法的实现,新增或者删除算法,对各种算法做封装。因此,策略模式多用在算法决策系统中,外部用户只需要决定用哪个算法即可。

    14、模板方法模式(Template Method)

    解释一下模板方法模式,就是指:一个抽象类中,有一个主方法,再定义1...n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用,先看个关系图:

    clipboard.png

    就是在AbstractCalculator类中定义一个主方法calculate,calculate()调用spilt()等,Plus和Minus分别继承AbstractCalculator类,通过对AbstractCalculator的调用实现对子类的调用,看下面的例子:

    clipboard.png

    测试类:

    clipboard.png

    我跟踪下这个小程序的执行过程:首先将exp和"\+"做参数,调用AbstractCalculator类里的calculate(String,String)方法,在calculate(String,String)里调用同类的split(),之后再调用calculate(int ,int)方法,从这个方法进入到子类中,执行完return num1 + num2后,将值返回到AbstractCalculator类,赋给result,打印出来。正好验证了我们开头的思路。

    15、观察者模式(Observer)

    包括这个模式在内的接下来的四个模式,都是类和类之间的关系,不涉及到继承,学的时候应该 记得归纳,记得本文最开始的那个图。观察者模式很好理解,类似于邮件订阅和RSS订阅,当我们浏览一些博客或wiki时,经常会看到RSS图标,就这的意思是,当你订阅了该文章,如果后续有更新,会及时通知你。其实,简单来讲就一句话:当一个对象变化时,其它依赖该对象的对象都会收到通知,并且随着变化!对象之间是一种一对多的关系。先来看看关系图:

    clipboard.png

    我解释下这些类的作用:MySubject类就是我们的主对象,Observer1和Observer2是依赖于MySubject的对象,当MySubject变化时,Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表,可以对其进行修改:增加或删除被监控对象,且当MySubject变化时,负责通知在列表内存在的对象。我们看实现代码:

    一个Observer接口:

    [java] view plaincopy
     public interface Observer {  
    public void update();  
    }  
    

    两个实现类:

     [java] view plaincopy
      public class Observer1 implements Observer {  
      @Override  
    public void update() {  
        System.out.println("observer1 has received!");  
    }  
    }  
    
    
          [java] view plaincopy
          public class Observer2 implements Observer {  
         @Override  
       public void update() {  
        System.out.println("observer2 has received!");  
       }  
        }  
        

    Subject接口及实现类:

         [java] view plaincopy
          public interface Subject {  
         /*增加观察者*/  
       public void add(Observer observer);  
         /*删除观察者*/  
    public void del(Observer observer);  
        /*通知所有的观察者*/  
    public void notifyObservers();  
         /*自身的操作*/  
    public void operation();  
    }  
    
          [java] view plaincopy
         public abstract class AbstractSubject implements Subject {  
      private Vector<Observer> vector = new Vector<Observer>();  
         @Override  
      public void add(Observer observer) {  
        vector.add(observer);  
      }  
      @Override  
      public void del(Observer observer) {  
        vector.remove(observer);  
      }  
      @Override  
       public void notifyObservers() {  
        Enumeration<Observer> enumo = vector.elements();  
        while(enumo.hasMoreElements()){  
            enumo.nextElement().update();  
           }  
       }  
    }    
      
    
       [java] view plaincopy
      public class MySubject extends AbstractSubject {  
    
       @Override  
    public void operation() {  
        System.out.println("update self!");  
        notifyObservers();  
    }  
    
     }     
    
    

    测试类:

          [java] view plaincopy
            public class ObserverTest {  
             public static void main(String[] args) {  
        Subject sub = new MySubject();  
        sub.add(new Observer1());  
        sub.add(new Observer2());  
               sub.operation();  
     }  
      }  
      
      

    输出:
    update self!
    observer1 has received!
    observer2 has received!
    这些东西,其实不难,只是有些抽象,不太容易整体理解,建议读者:根据关系图,新建项目,自己写代码(或者参考我的代码),按照总体思路走一遍,这样才能体会它的思想,理解起来容易!

    16、迭代子模式(Iterator)

    顾名思义,迭代器模式就是顺序访问聚集中的对象,一般来说,集合中非常常见,如果对集合类比较熟悉的话,理解本模式会十分轻松。这句话包含两层意思:一是需要遍历的对象,即聚集对象,二是迭代器对象,用于对聚集对象进行遍历访问。我们看下关系图:

    clipboard.png

    这个思路和我们常用的一模一样,MyCollection中定义了集合的一些操作,MyIterator中定义了一系列迭代操作,且持有Collection实例,我们来看看实现代码:
    两个接口:

    clipboard.png

    两个实现:

    clipboard.png

    测试类:

    clipboard.png

    输出:A B C D E
    此处我们貌似模拟了一个集合类的过程,感觉是不是很爽?其实JDK中各个类也都是这些基本的东西,加一些设计模式,再加一些优化放到一起的,只要我们把这些东西学会了,掌握好了,我们也可以写出自己的集合类,甚至框架!

    17、责任链模式(Chain of Responsibility)

    接下来我们将要谈谈责任链模式,有多个对象,每个对象持有对下一个对象的引用,这样就会形成一条链,请求在这条链上传递,直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求,所以,责任链模式可以实现,在隐瞒客户端的情况下,对系统进行动态的调整。先看看关系图:

    clipboard.png

    Abstracthandler类提供了get和set方法,方便MyHandle类设置和修改引用对象,MyHandle类是核心,实例化后生成一系列相互持有的对象,构成一条链。

    clipboard.png

    clipboard.png

    输出:
    h1deal!
    h2deal!
    h3deal!
    此处强调一点就是,链接上的请求可以是一条链,可以是一个树,还可以是一个环,模式本身不约束这个,需要我们自己去实现,同时,在一个时刻,命令只允许由一个对象传给另一个对象,而不允许传给多个对象。

    18、命令模式(Command)

    命令模式很好理解,举个例子,司令员下令让士兵去干件事情,从整个事情的角度来考虑,司令员的作用是,发出口令,口令经过传递,传到了士兵耳朵里,士兵去执行。这个过程好在,三者相互解耦,任何一方都不用去依赖其他人,只需要做好自己的事儿就行,司令员要的是结果,不会去关注到底士兵是怎么实现的。我们看看关系图:

    clipboard.png

    Invoker是调用者(司令员),Receiver是被调用者(士兵),MyCommand是命令,实现了Command接口,持有接收对象,看实现代码:

    clipboard.png
    clipboard.png

    输出:command received!
    这个很哈理解,命令模式的目的就是达到命令的发出者和执行者之间解耦,实现请求和执行分开,熟悉Struts的同学应该知道,Struts其实就是一种将请求和呈现分离的技术,其中必然涉及命令模式的思想!

    其实每个设计模式都是很重要的一种思想,看上去很熟,其实是因为我们在学到的东西中都有涉及,尽管有时我们并不知道,其实在Java本身的设计之中处处都有体现,像AWT、JDBC、集合类、IO管道或者是Web框架,里面设计模式无处不在。因为我们篇幅有限,很难讲每一个设计模式都讲的很详细,不过我会尽我所能,尽量在有限的空间和篇幅内,把意思写清楚了,更好让大家明白。本章不出意外的话,应该是设计模式最后一讲了,首先还是上一下上篇开头的那个图:

    clipboard.png

    本章讲讲第三类和第四类。

    19、备忘录模式(Memento)

    主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,个人觉得叫备份模式更形象些,通俗的讲下:假设有原始类A,A中有各种属性,A可以决定需要备份的属性,备忘录类B是用来存储A的一些内部状态,类C呢,就是一个用来存储备忘录的,且只能存储,不能修改等操作。做个图来分析一下:

    clipboard.png

    Original类是原始类,里面有需要保存的属性value及创建一个备忘录类,用来保存value值。Memento类是备忘录类,Storage类是存储备忘录的类,持有Memento类的实例,该模式很好理解。直接看源码:

    clipboard.png

    clipboard.png

    测试类:

    clipboard.png

    输出:
    初始化状态为:egg
    修改后的状态为:niu
    恢复后的状态为:egg
    简单描述下:新建原始类时,value被初始化为egg,后经过修改,将value的值置为niu,最后倒数第二行进行恢复状态,结果成功恢复了。其实我觉得这个模式叫“备份-恢复”模式最形象。

    在此我向大家推荐一个交流学习群:575745314 里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多
    图片描述

    20、状态模式(State)

    核心思想就是:当对象的状态改变时,同时改变其行为,很好理解!就拿QQ来说,有几种状态,在线、隐身、忙碌等,每个状态对应不同的操作,而且你的好友也能看到你的状态,所以,状态模式就两点:1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。看图:

    clipboard.png

    State类是个状态类,Context类可以实现切换,我们来看看代码:

    clipboard.png

    clipboard.png

    测试类:

    clipboard.png

    输出:

    execute the first opt!
    execute the second opt!
    根据这个特性,状态模式在日常开发中用的挺多的,尤其是做网站的时候,我们有时希望根据对象的某一属性,区别开他们的一些功能,比如说简单的权限控制等。

    21、访问者模式(Visitor)

    访问者模式把数据结构和作用于结构上的操作解耦合,使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化,经常有新的数据对象增加进来,则不适合使用访问者模式。访问者模式的优点是增加操作很容易,因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中,其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。—— From 百科
    简单来说,访问者模式就是一种分离对象数据结构与行为的方法,通过这种分离,可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。简单关系图:

    clipboard.png

    来看看原码:一个Visitor类,存放要访问的对象,

    clipboard.png

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

    clipboard.png

    测试:

    clipboard.png

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

    22、中介者模式(Mediator)

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

    clipboard.png

    User类统一接口,User1和User2分别是不同的对象,二者之间有关联,如果不采用中介者模式,则需要二者相互持有引用,这样二者的耦合度很高,为了解耦,引入了Mediator类,提供统一接口,MyMediator为其实现类,里面持有User1和User2的实例,用来实现对User1和User2的控制。这样User1和User2两个对象相互独立,他们只需要保持好和Mediator之间的关系就行,剩下的全由MyMediator类来维护!基本实现:

    clipboard.png

    clipboard.png

    测试类:

    clipboard.png

    输出:
    user1 exe!
    user2 exe!

    23、解释器模式(Interpreter)

    解释器模式是我们暂时的最后一讲,一般主要应用在OOP开发中的编译器的开发中,所以适用面比较窄。

    clipboard.png

    Context类是一个上下文环境类,Plus和Minus分别是用来计算的实现,代码如下:

    clipboard.png

    clipboard.png
    最后输出正确的结果:3。

    基本就这样,解释器模式用来做各种各样的解释器,如正则表达式等的解释器等等!

    设计模式基本就这么大概讲完了,总体感觉有点简略,的确,这么点儿篇幅,不足以对整个23种设计模式做全面的阐述,此处读者可将它作为一个理论基础去学习。通过这篇博文,先基本有个概念,虽然我讲的有些简单,但基本都能说明问题及他们的特点,如果对哪一个感兴趣,可以继续深入研究!同时我也会不断更新,尽量补全遗漏、修正不足,欢迎广大读者及时提出好的建议。

    展开全文
  • 设计模式之工厂模式

    2018-12-14 15:50:54
    工厂模式在我们平常开发中应用比较广泛,或许你不知道,但你已经使用了很多次了。我们明确地计划不同条件下创建不同实例时,就会使用到工厂模式。工厂模式分为简单工厂模式和抽象工厂模式。这边我们先说简单的工厂...
  • Github 三种克隆模式

    2017-01-21 16:58:00
    1、我称为平常模式,用于项目的本地克隆使用。(无权限、无加密、ssh protocol) git clone http://github.com/username/exampleproject 2、我称为公共模式,用于安全性较低的项目管理。(有权限、协议加密、web_...
  • 设计模式6-代理模式

    2017-08-03 12:17:23
    代理模式我们平常用的比较多,比如spring的aop就是使用的代理模式。代理又分为静态代理和动态代理,动态代理又分了两种,具体的代理模式,我之前有博客已经提及了,这里就不多少了,具体的参考...
  • 前言23种设计模式速记单例(singleton)模式工厂方法(factory method)模式抽象工厂(abstract factory)模式建造者/构建器(builder)模式原型(prototype)模式享元(flyweight)...,外观模式一定是我们平常使用最多的一种...
  • 委派模式和模板模式 目录 委派模式和模板模式 1、委派模式 1.1 什么是委派模式 ...委派模式不属于23种设计模式,在平常其他设计模式中可能也有体现。同样在现实生活中也有相关的体现,比如一个具体...
  • 状态对于我们开发者而言是相当熟悉的,平常开发中总是离不开对象的状态,比如我们审核流程,就是一个状态不断流转的过程,订单流程也是一个状态不断流转的过程,而状态模式就是为了更好地解决我们状态流转过程中的...
  • 【设计模式系列23】设计模式的终极BOSS:访问者模式

    千次阅读 热门讨论 2020-11-01 11:08:23
    设计模式系列到这里已经是23种设计模式的最后一个设计模式了,访问者模式也可以说是所有设计模式中最难的一种设计模式了,当然我们平常也很少会用到它。设计模式的作者是这么评价访问者模式的:大多情况下,你并不...
  • 外观模式是我们平时使用频率很高的一种模式,我们在平常的开发中也会不经意的使用外观模式;外观模式是为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层的接口,这个接口使得这一子系统更加容易调用。...
  • 设计模式-工厂模式

    2017-03-07 17:12:45
    工程模式是一个大家族,里面根据时间的推移和不断的...静态工厂模式: 我们平常常用的静态工具类其实就是使用了静态工厂模式,类+静态方法,这种实现,例子: public class StaticFactoryDemo { public static boo
  • 设计模式之单例模式

    2017-04-25 09:24:26
    单例模式详解在平常开发中,经常用到的一个设计模式就是单例模式,我这里说两个我经常用的三种类型的设计模式: 懒汉式 package gsww; /** * 单例模式之懒汉式 * @author luweicheng * */ public class ...
  • 模板方法模式(Template Method Pattern)隶属于设计模式中的行为型模式,与策略模式一样,是在平常编码过程最常用的模式之一,理念也很简单明确:老大制定流程,具体执行由小弟接手。 模式定义 模版方法模式:在一...
  • MVC模式

    2019-09-06 19:26:39
    由于平常所写的代码缺乏条理性,二次开发困难,不适合多人协作,在大型web开发中效率低下,所以需要学习设计模式。 目前主流在Java Web应用中最广泛的设计模式便是MVP模式,目前主流的Web框架大多也是基于MVC设计...
  • 什么是模板模式 模板模式可以说是最简单的设计模式,用一个抽象类将所有的操作...抽象父类定义了所有子类需要完成的动作,但是各个子类具有不同的完成动作,模板模式在我们平常的编程中经常使用,这里就不举例子了...
  • 适配器就是一种适配中间件,它存在于不匹配的二者之间,用于连接二者,将不匹配变得匹配,简单点理解就是平常所见的转接头,转换器之类的存在. 适配器模式有对象适配器和类适配器两种实现. 模式结构 Target:目标抽象接口...
  • 平常主要用到了就两种,工厂模式(Factory Method)和抽象工厂模式(Abstract FactoryMethod)。这两个模式很相似,但是又有所不同,抽象工厂可以看作是工厂模式的扩展。 首先来看工厂模式,我们为什么要用到工厂模式?...
  • 设计模式之外观模式

    2020-11-06 13:59:18
    你家里有各种电器的开关,照明灯开关,家电开关什么的,你平常用用哪个电器就去打开哪个电器的开关。但是你家里也有一个电源总开关,可以控制这些家电的开关使用,这个总共开关便可以理解为这些家电系统的外观模式...
  • 设计模式学习笔记——迭代器模式

    千次阅读 2014-02-12 22:32:00
    迭代器模式据说有人要将它从设计模式中剔除,原因是各种语言基本都内置了这种模式,比如c#的foreach语句,实在是太平常了,不值得特别一提。但我对这个迭代器,尤其是.NET的IEnumerable、IEnumerator甚感迷惑,有...
  • 观察者模式是经典设计模式中很常用的一种,平常我们看到的监听器,基本上都是采用这种设计模式实现的,这里探讨一下观察者模式的演化
  • 无论是在python代码中,还是面试中单例设计模式都是经常被问到和使用的,例如面试中会让你用代码实现单例模式分几种不同的方式,或者问你在平常工作中哪些地方有用到单例设计模式,然后深入探讨。在本文中我将针对这...
  • 访问者模式也可以说是所有设计模式中最难的一种设计模式了,当然我们平常也很少会用到它。设计模式的作者是这么评价访问者模式的:大多情况下,你并不需要使用访问者模式,但是一旦需要使用它时,那就真的需要使用了...
  • 今天是设计模式学习系列的第8篇--外观模式。 开篇问题 什么是外观模式?外观模式和适配器模式的区别? 外观模式解析 首先我们先看一个场景,我们平常肯定都是用银行的app,在注册时,都要经过实名认证这个步骤。...
  • 委派模式 我们可以理解成上级分配任务到具体的员工,比如说您是一个大老板 手下有上千个员工,平常端茶递水的活肯定不是自己干。一般口渴了 就会跟下面经理说:小张啊 我口渴了给我倒点茶!然后张经理面带微笑:好的...
  • 日常开发中我们见过的建造者模式应该还不算少,平常用的Dialog和一些第三方框架,挺多一部分正是用了建造者模式。 建造者模式是创建一个复杂对象的创建型模式,有人也称它为生成器模式,它将其构建复杂对象的过程和...
  • 其实有很多备忘录模式的例子,像我们平常使用的开发工具如Ctrl + Z就提供了一种撤销的功能、我们通常的事务回滚等都是备忘录模式的范例。 通用类图: 角色分析: Original: 原始对象,即需要被备...
  • 这个模式我们在平常开发中总会不自觉的使用到。就像我们平时一样的各种网站模板、建立模板、PPT模板等等。啥意思呢?简单,也就是把共同的东西拿出来,你需要具体去实现你自己的那么就另外加上自己的特有行为就是了...
  • 适配器模式:将一个类的接口转换成客户希望的另一个接口。适配器模式让那些接口不...适配器就是一种适配中间件,它存在于不匹配的二者之间,用于连接二者,将不匹配变得匹配,简单点理解就是平常所见的转接头,转...

空空如也

空空如也

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

平常模式