大话设计模式的阅读

主要采用JavaScript完成案例,原书采用c

一、代码无错就是优?—> 简单工厂模式

  • 代码规范

  • 面向对象: 可维护;可复用;可扩展。 灵活性好。

  • 通过封装、继承、多态把程序的耦合度降低:低耦合,高聚合;—>容易修改,易于复用;

  • 业务逻辑 与 界面逻辑 分离开;

    一个运算器

    // 一个简单的计算器
    function Operation( num1, num2, operate) {
    let result;
    /*
    if( operate === '+') {
    result = Sum( num1, num2);
    } else if( operate === '-') {
    result = Sub( num1, num2);
    } else if( operate === '*') {
    result = Mul( num1, num2);
    } else if( operate === '/') {
    result = Div( num1, num2);
    }*/
    switch ( operate) {
    case '+': result = Sum( num1, num2); break;
    case '-': result = Sub( num1, num2); break;
    case '*': result = Mul( num1, num2); break;
    case '/': result = Div( num1, num2); break;
    }
    return result;
    }
    let Sum = ( num1, num2) => num1 + num2;
    let Sub = ( num1, num2) => num1 - num2;
    let Mul = ( num1, num2) => num1 * num2;
    let Div = ( num1, num2) => num2 === 0 ? 'num2 === 0' : num1 / num2;
    console.log( Operation( 10, 12, '+') );

UML类图

聚合表示一种弱的‘拥有’关系,体现的是A对象可以包含B对象,但B对象不是A对象的一部分。聚合关系用空心的菱形+实现箭头来表示。

合成(Composition, 组合)是一种强的‘拥有’关系,体现了严格的部分和整体的关系,部分和整体的生命周期一样。合成关系用实心的菱形+箭头来表示。

依赖关系(Dependency),用虚线箭头表示。

编程是一门技术,更加是一门艺术。

二、商场促销—> 策略模式

面向对象的编程,并不是类越多越好,类的划分是为了封装,但分类的基础是抽象,具有相同属性和功能的对象的抽象集合才是类。

策略模式(Strategy)

策略模式:定义了算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化,不会影响到使用算法的用户;

算法本身只是一种策略,最重要的是这些算法都是随时都可以互相替换的,这就是变化点,而封装变化点是我们面向对象的一种和重要的思维方式。

策略模式是一种定义一系列算法的方法,从概率上来看,所有这些算法完成的都是相通的工作,只是实现不同,他可以以相同的方式调用所有的算法,减少了各种算法与使用算法类之间的耦合【DPE】

策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能【DP】。

策略模式的优点是简化了单元测试,因为每个算法都有自己的类,可以通过自己的接口单独测试【DPE】。

当不同的行为堆砌俄在一个类中使,就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中,可以在使用这些行为的类中显出条件语句【DP】

策略模式就是用来封装算法的,但在实践中,我们发现可以用它来封装几乎任何类型的规则,只要在分析过程中听到需要在不同的时间应用不同的业务规则,就可以考虑使用策略模式来处理这种变化的可能性【DPE】

在基本的策略模式中,选择所用的具体实现的职责由客户端对象承担,并转给策略模式Context对象【DPE】。

任何需求的变更都是需要成本的。

三、拍摄UFO —>单一职能原则

​ 就一个类而言,应该仅有一个引起它变化的原因【ASD】;

单一职能原则(SRP),就一个类而言,应该仅有一个引起他变化的原因。

​ 如果一个类承担的职责过多,就等于把这些职责耦和在一起,一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦和慧导致脆弱的设计,当变化发生时,设计会遭受到意想不到的破坏。

​ 软件设计真正要做的许多内容,就是发现职责并把那些职责相互分离。

​ 如果你能够想到多于一个的动机去改变一个类,那么这个类就具有多于一个的职责,就应该考虑类的职责分离。

​ 在类的职责分离上多思考,做到单一职责,这样你的代码才是真正的 易维护、易扩展、易复用、灵活多样

四、考研求职两不误 —> 开放— 封闭原则

开放–封闭原则( The Open-Cloaeed Principle, OCP)或者 开-闭原则:软件实体(类、模块、函数等等)应该是可以扩展,但是不可以修改。A:对于扩展是开放的(Open for extension),B:对于更改是封闭的(Closed for modification)。

怎样的设计才能面对需求的改变却可以保持相对稳定,从而使得系统可以在第一个版本以后不断推出新的版本呢?开放-封闭。

开放-封闭原则的意思就是说,你设计的时候,时刻要考虑,尽量让这个类是足够好的,写好了就不要去修改了,如果新需求来,我们增加一些类就完事儿,原来的代码能不动则不动。

无论模块是多门的‘封闭’,都会存在一些无法对之封闭的变化。既然不可能完全封闭,设计人员必须对他设计的模块应该对哪种变化封闭做出选择。他必须先猜测出最有可能发生的变化种类,然后构造抽象来隔离那些变化。

等到变化发生时立即采取行动。

在我们最初编写代码时,假设变化不会发生。当变化发生时,我们就创建抽象来隔离以后发生的同类变化。

面对需求,对程序的改动是通过增加新代码进行的,而不是更改现有的代码,这就是开放-封闭原则的精神所在。

我们希望的是在开发工作展开不久就知道可能发生的变化。查明可能发生的变化所等待的时间越长,要创建增加的抽象就越困难。

开放-封闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大好处,也就是可维护、可复用、可扩展、灵活性好。开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象,然而,对于应用程序中的每个部分都刻意的进行抽象同样不是一个好主意。拒绝不成熟的抽象和抽象本身一样重要。

五、会修电脑不会修收音机 —> 依赖倒转原则

依赖倒转原则:

A、高层模块不应该依赖底层模块。两个都应该依赖抽象

B、抽象不应该依赖细节,细节应该依赖与抽象—>针对接口编程,不要对实现编程。

高层模块依赖底层模块:函数的可复用性。

里氏代换原则:一个软件实体如果使用的是一个父类的话,那么一定是用于其子类,而且他察觉不出父类对象和子类对象的却别。也就是说,在软件里面,把父类都替换成他的自雷,程序的行为没有改变,简单地说, 子类型必须能够替换掉他们的父类型

只有当子类可以替换掉父类,软件单位的功能不受到影响时,父类才能真正被复用,而子类也能够在父类的基础上增加新的行为。

由于子类型的可替换性才使得使用父类型的模块在无需修改的情况下就可以扩展。

依赖倒转其实就是谁也不要依靠谁,除了约定的解耦,大家都可以灵活自如。

依赖倒转其实可以说是面向对象设计的标志,用哪种语言来编写程序不重要(语言只是一种工具),如果编写时考虑的都是如何针对抽象编程而不是针对细节编程,即程序中所有的依赖关系都是终止于抽象类或者接口,那就是面向对象的设计,反之那就是过程和的设计了。

六、穿什么有这么重要?—> 装饰模式

需要把所需的功能按正确的顺序串联起来进行控制。

装饰模式(Decorator),动态地给一个对相同添加一些额外的职责,就增加功能来说,装饰模式比生产子类更加灵活。

Component定义一个对象接口,可以给这些对象动态地添加职责。ConcreteComponent是定义了一个具体的对象,也可以给这个对象添加一些职责。Decorator,装饰抽象类,继承了Component,从外类累扩展Component类的功能,但对于Component来说,是无需知道Decorator的存在的。至于ConcreteDecorator就是具体的装饰对象,起到给Component添加职责的功能。

装饰模式是利用SetComponent来对对象进行封装的。这样每个装饰对象的实现就和如何使用这个对象分离开了,每个装饰对象只关心自己的功能,不需要关心如何被添加到对象链当中。

如果只有一个ConcreteComponent类而没有抽象的Component类,那么Decorator类可以是ConcreteComponent的一个子类。同样道理,如果只有一个ConcreateDecorator类,那么就没有必要建立一个单独的Decorator类,而可以把Decorator和ConcreteDecorator的责任合并成一个类。

装饰模式是为已有功能动态的添加更多功能的一种方式。

当系统需要新功能的时候,是向旧的的类中添加新的代码。这些新加的代码通常装饰了原有类的核心职责或主要行为。在主类中加入了新的字段,新的方法和新的逻辑,从而增加了主类的复杂度,而这些新加入的东西仅仅是为了满足一些只在某种特定情况下才会执行的特殊行为的需要。而装饰模式却提供了一个非常好的解决方案,他把每个要装饰的功能放在单独的类中,并让这个类包装他所要装饰的对象,因此,当需要执行特殊行为的时候,客户代码就可以在运行时根据需要有选择的,按顺序的使用装饰功能包装对象。

装饰模式的优点,把类中的装饰功能从类中搬移去除,这样可以简化原有的类,有效地把类的核心职责和装饰功能区分开了,而且可以去除相关类中重复的装饰逻辑。

最理想的情况,是保证装饰类之间彼此独立,这样他们就可以任意的顺序进行组合了。

七、为别人做嫁衣 —> 代理模式

代理模式(Proxy):是为其他对象提供一种代理以控制对这个对象的访问。

Subject类,定义了RealSubject和Proxy的共用接口,这样就在任何使用RealSubject的地方都可以使用Proxy。

RealSubject类,订了Proxy所代表的真实实体。

Proxy类,保存了一个引用使得代理可以访问实体,并提供一个与Subject的接口相同的借口,这样代理就可以用来代替实体。

代理模式的应用:

第一种:远程代理,也就是一个对象在不同的地址空间提供局部代理。这样可以隐藏一个对象存在于不同的地址空间的事实。

第二种:虚拟代理,是根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真是对象。这样可以达到性能的最优化。

第三种:安全代理,用来控制真实对象访问时的权限。一般用于对象应该有不同的访问权限的时候。

第四种:智能指引,是指当调用真实的对象时,代理处理另外一些事。

八、雷锋依然在人间 —> 工厂方法模式

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖。

工厂方法模式(Factory Method),定义了一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

工厂方法模式实现,客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的,也就是说,工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要添加功能,本来是改工厂类的,而现在是修改客户端。

工厂方法克服了简单工厂违背开放-封闭原则的缺点,又保持了封装对象创建过程的优点。它们都是集中封装了对象的创建,使得要更换对象时,不需要做大的的改动就可实现,降低了客户程序与产品对象的耦合。工厂方式模式是简单工厂模式的进一步抽象和推广。由于使用了多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。但缺点就是由于每加一个产品就需要加一个产品工厂的类,增加了额外的开发量。

九、简历复印 —> 原型模式

原型模式(Prototype),用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

原型模式其实就是从一个对象再创建另外一个可定制的对象,而且不需要知道任何创建的细节。

一般在初始化的信息不发生的情况下,克隆是最好的办法,这既隐藏了创建的细节,有对性能是大大的提高。

不用重新初始化对象,而是动态的获得对象运行时的状态。

浅复制,被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用都仍指向原来的对象。

深复制,把要复制的对象所引用的对象都复制一遍,深复制把引用对象的变量指向复制过的新对象,而不是原有的被引用的对象。

十、考题抄错会做也白搭 —> 模版方式模式

既然用了继承,并且肯定这个继承有意义,就应该要成为子类的模版,所有的重复的代码都应该要上升到父类去,而不是让每个子类都去重复。

当我们要完成在某一细节层次一致的一个过程或一个系列步骤,但其个别步骤在更细节的层次上的实现可能不同时,我们通常考虑用模版方法模式来处理。

模版方法模式,定义一个操作中的 算法的骨架,而将一些步骤延迟到子类中,模版方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

AbstractClass是抽象类,其实也就是一抽象模版,定义并实现了一个模版方法。这个模版方法一般是一个具体方法,他给出了一个顶级逻辑的骨架,而逻辑的组成步骤在相应的抽象操作中,推迟到子类实现。

ConcreteClass,实现父类所定义的一个或多个抽象方法。每一个AbstractClass都可以有任意多个ConcreteClass与之对应,而每个ConcreteClass都可以给出这些抽象放大的不同实现从而使得顶级逻辑的实现各不相同。

模版方式模式就是通过把不变行为搬移到超类,去除子类中的重复代码,

模版方法模式就是提供了一个很好的代码复用平台。

当不变的和可变的行为在方法的子类实现中混合在一起的时候,不变的行为就会在子类中重复出现,通过模版方法模式把这些行为搬移到单一的地方,这样就帮助子类摆脱重复的不变的行为的纠缠。

十一、无熟人难办事? —> 迪米特法则

迪米特法则,又叫做最少知识原则,如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用。

迪米特法则首先强调的前提是在类的结构设计上,每一个类都应当尽量降低成员的访问权限,也就是说,一个类包装好自己的private状态,不需要让别的类知道的字段或行为就不要公开。

面向对象的设计原则和面向对象的三大特性本就不是矛盾的。迪米特法则其根本思想,是强调了类之间的松耦合。

类之间的耦合越弱,越有利于复用,一个处在弱耦合的类被修改,不会对有关系的类造成波及。

十二、牛市股票还会亏钱?? —> 外观模式

外观模式(Facade),为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

外观模式完美地体现了依赖倒转原则和迪米特法则的思想。

外观模式的使用:

分为三个阶段:

首先,在设计初期阶段,应该要用意识的将不同的两个层分离,比如经典的三层架构,就需要考虑在数据访问层和业务逻辑层、业务逻辑层和表示层的 层与层之间建立外观Facade,这样可以为复杂的子系统提供一个简单的借口,使得耦合大大降低。

其次,在开发阶段,子系统往往因为不断的重构演化而变得越来越复杂,大多数的模式使用时都会产生很多很小的类 ,这本是好事,但也给外部调用他们的用户程序带来了使用上的困难, 增加外观Facade可以提供一个简单的接口,减少它们之间的依赖。

第三,在维护一个遗留的大型系统时,可能这系统已经非常难以维护和扩建了,但因为它包含非常重要的功能,新的需求开发必须要依赖于它。此时使用外观模式Facade也是非常合适的。你可以 为新系统开发一个外观Facade类,来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口,让新系统与Facade对象交互,Facade与遗留代码交互所有复杂的工作。

十三、好菜每回味不同 —> 建造者模式

依赖倒转原则?抽象不应该依赖细节,细节应该依赖于抽象。

需要 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示的意图时,我们需要应用于一个设计模式, 建造者(Builder)模式,又叫 生成器模式。建造者模式可以将一个产品的内部表象与产品的生成过程分割开来,从而可以使一个建造过程具有不同的内部表象的产品对象。 如果我们用了建造者模式,那么用户就只需要建造的类型就可以得到它们,而具有建造的过程和细节就不需知道了。

建造者模式(Builder),将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

Builder:是为创建一个Product对象的各个部件指定的抽象接口;

ConcreteBuilder,他是具体建造者,实现Builder接口,构造和装配各个部件。

Product,具体指各个部件,角色产品。

Director,指挥者:他是构建一个使用Builder 接口的对象。

When:主要是用于创建一些复杂的对象,这些对象内部构建间的建造顺序通常是稳定的,但对象内部的构建通常面临着复杂的变化。建造者模式的好处就是使得建造代码与表示代码分离,由于建造者隐藏了该产品是如何组装的,所以若需要改变一个产品的内部表示,只需要再定义一个具体的建造者就可以了。

建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式。

十四、 老板回来,我不知道 —> 观察者模式

观察者模式,又叫做发布-订阅(Publish/Subscribe)模式,定义了一种一个对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自动更新自己。

Subject类,可翻译为主题或抽象通知者,一般用一个抽象类或者一个接口实现,他把所有对观察者对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察者。抽象主题提供一个接口,可以增加和删除观察者对象;

Observer类,抽象观察者,为所有的具体观察者定义一个接口,在得到主题的通知时更新自己,这个接口叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个Update() 方法,这个方法叫做更新方法。

ConcreteSubject类,叫做腿主题或者通知通知者,将有关状态存入具体观察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现。

ConcreteObserver类,具体观察者,实现抽象观察者角色所要求的更细接口,以便使本身状态与主题的状态相协调。具体观察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

使用观察者模式的动机是: 将一个系统分割成一系列相互协作的类有一个很不好的副作用,那就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合,这样会给维护、扩展和重用都带来不便。而观察者模式的关键对象是主题Subject和观察者Observe,一个Subject可以有任意数目的依赖它的Observer,一旦Subject的状态发生了改变,所有的Observer都可以得到通知。Subject发出通知时并不需要知道谁是它的观察者,也就是说,具体观察者是谁,他根本不需要再换掉。而任何一个具体观察者不知道也不需要知道其他观察者的存在。

使用:当一个对象的改变需要同时改变其他对象,而且不知道具体有多少个对象有待改变时,应该考虑使用观察者模式,一个抽象模型有两个方面,其中一方面依赖于另一方面,这时使用观察者模式可以将这两者封装在独立的对象中国呢使他们各自独立的改变和复用,观察者模式所做的工作其实就是在接触耦合。让耦合的双方都依赖于抽象,而不是具体。从而使得各自的变化都不会影响到另一边的变化。

事件委托说明:

委托就是一种引用方法的类型。一旦委托分配了方法,委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样,具有参数和返回值。委托可以看作是对函数的抽象,是函数的‘类’,委托的实例将代编一个具体的函数。

一个委托可以搭载多个方法,所有方法被依次唤起,可以使得委托对象所搭载的方法并不需要属于同一个类。

委托对象所搭载的所有方法必须具有相同的原形和形式,也就是拥有相同的参数列表和返回值类型。

十五、 就不能不换DB吗?—> 抽象工厂模式

工厂方法模式是定义一个用于创建对象的接口,让子类决定实例化哪一个类。

抽象工厂模式(Abstract Factory),提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

好处:易于交换产品系列,由于具体工厂类,在一个应用中只需要在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它只需要改变具体工程即可使用不同的产品配置。他让具体的创建实例过程与客户端分离,客户端是通过它们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离,不会出现在客户代码中。

编程是门艺术,这样大批量的改动,显然是非常丑陋的做法。

依赖注入(Dependency Injection)

所有在用简单工厂的地方,都可以考虑用反射技术来去除switch或if,解除分支判断带来的耦合。

一个程序员如果从来没有熬夜写程序的经历,不能算是一个好程序员,因为他没有痴迷过,所以他不会有大成就。

十六、无尽加班何时休 —> 状态模式

面向对象设计其实就是希望做到代码的责任分解。

状态模式(State),当一个对象的内在状态改变时允许改变其行为,找个对象看起来像是改变了其类。

状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况,把状态的判断逻辑转移到表示不同状态的一系列类当中,可以把复杂的判断逻辑简化。

状态模式的好处是将与特定状态相关的行为局部化,并且将不同状态的行为分割开来。

将特定的状态相关的行为都放入一个对象中,由于所有与状态相关的代码都存在于某个ConcreteState中,所以通过定义新的子类可以很容易的增加新的状态和转换。

目的就是为了消除庞大的条件分支语句。

状态模式通过把各种状态转移逻辑分布到State的子类之间,来减少相互间的依赖。

When: 当一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为时,就可以考虑使用状态模式 了。

十七、在NBA我需要翻译 —> 适配器模式

适配器模式(Adapter),将一个类的接口转换成客户希望的另一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

在软件开发中,也就是系统的数据和行为都正确,但接口不符时,我们应该考虑用适配器,目的是使控制范围之外的一个原有对象与某个接口匹配。适配器模式主要应用于希望复用一些现存的类,但是接口又与复用环境要求不一致的情况。

类适配器模式和对象适配器模式。

When:使用一个已经存在的类,但如果他的接口,也就是他的方法和你的要求不相同时,就应该用适配器模式。两个类所做的事情相同或相似,但是具有不同的接口时要使用它。客户代码可以统一调用同一接口,这样可以更简单、更直接、更紧凑。

在双方都不太容易修改的时候再使用适配器模式适配。

十八、如果再回到从前 —> 备忘录模式

代码无错未必优

备忘录模式(Memento):在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

把要保存的细节给封装在了Memento中了,哪一天要更改保存的细节也不用影响客户端了。

Memento模式比较适用于功能比较复杂的,但需要维护或记录属性历史的类,或者需要保存的属性只是众多属性中的一小部分时,Originator可以根据保存的Memento信息还原到前一状态。

如果在某个系统中使用命令模式时,需要实现命令的撤销功能,那么命令模式可以使用备忘录模式来存储可撤销操作的状态。有时一些对象的内部信息必须保存在对象以外的地方,但是必须要由对象自己读取,这时,使用备忘录可以把复杂的对象内部信息对其他的对象屏蔽起来,从而可以恰当地保持封装的边界。

作用:当角色的状态改变的时候,有可能这个状态无效,这时候就可以使用暂时存储起来的备忘录将状态复原。

缺点:角色状态需要完整存储到备忘录对象中,如果状态数据很大很多,那么在资源消耗上,备忘录对象会非常耗内存。

十九、 分公司=一部门 —> 组合模式

整体于部分可以被一致对待的问题

组合模式(Composite),将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

透明方式:也就是说在Component中声明所有用来管理子对象的方法,其中包括Add、Remove等。这样实现Component接口的所有子类都具备了Add和Remove。这样做的好处就是叶节点和枝节点对于外界没有区别,它们具备完全一致的行为接口脸蛋问题也很明显,因为Leaf类本身不具备Add()、Remove()方法的功能,所以实现它是没有意义的。

安全方式:也就是Component接口中不去声明Add和Remove方法,那么子类的Leaf也就不需要去实现它,而是在Composite声明所有用来管理子类对象的方法,不过由于不够透明,所以树叶和树枝类将不具有相同的接口,客户端的调用需要做相应的判断,带来了不便。

When:

需求中时体现部分和整体层次的结构时,以及希望用户可以忽略组合对象和单个对象的不同,统一的使用组合结构中的所有对象时,就应该考虑用组合模式了。

组合模式定义了包含基本对象和组合对象的类层次结构。基本对象可以被组合成更复杂的组合对象,而这个组合对象又可以被组合,这样不断的递归下去,客户代码中,任何用到基本对象的地方都可以使用组合对象了。

用户是不用关心到底是处理一个叶节点还是处理一个组合组件,也就用不着为定义组合而写一些选择判断语句了。

组合模式让客户可以一致的使用组合结构和单个对象。

二十、想走?可以!先买票 —> 迭代器模式

迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示。

When: 当你需要访问一个聚集对象,而且不管这些对象是什么都需要遍历的时候,你就应该考虑用迭代器模式。

你需要对聚集有多种方式遍历时,可以考虑用迭代器模式。

为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

研究历史是为了更好地迎接未来。

当你需要对聚集有多种方式遍历时,可以考虑用迭代器模式。

迭代器(Iterator)模式就是分离了集合对象的遍历行为,抽象出一个迭代器类来负责,这样既可以做到不暴力集合的内部结构,又可让外部代码透明地访问集合内部的数据。

二十一、有些类也需计划生育 —> 单例模式

所有类都有构造方法,不编码则系统默认生成空的构造方法,若有显示定义的构造方法,默认的构造方法就会失效。

单例模式(Singleton),保证一个类仅有一个实例,并提供一个访问它的全局访问点。

通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象。一个最好的办法就是,让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建,并且它可以提供一个访问该实例的办法。

单例模式因为Singleton类封装它的唯一实例,这样它可以严格地控制客户怎样访问它以及何时访问它。简单的说就是对唯一实例的受控访问。

单例类是有状态的,实用类不能用于继承多态,而单例虽然实例唯一,却是可以有子类来继承,实用类只不过是一些方法属性的集合,而单例却是有着唯一的对象实例。

.Net中 lock是确保当一个线程位于代码的临界区时,另一个线程不进入临界区。如果其他线程试图进入锁定的代码,则它将一直等待(被阻止),直到该对象被释放。

这种静态初始化的方式是在自己被加载时就将自己实例化,所以被形象地称之为饿汉式单例类,原先的单例模式处理方式是要在第一次被引用时,才会将自己实例化,所以就被称为懒汉式单例类。

二十二、手机软件何时统一 —> 桥接模式

对象的继承关系是在编译时就定义好了,所以无法在运行时改变从父类继承的实现。子类的实现与他的父类有非常紧密的依赖关系,以至于父类视线中的任何变化必然会导致子类发生变化。当你需要复用子类时,如果继承下来的实现不适合解决新的问题,则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终线了复用性。

合成/聚合复用原则(CARP),尽量使用合成/聚合,尽量不要使用类继承。

合成(Composition)和聚合(Aggregation)都是关联的特殊种类。聚合表示一种弱的‘拥有’关系,体现的是A对象可以包含B对象,但B对象不是A对象的一部分;合成则是一种强的‘拥有’关系,体现了严格的部分和整体的关系,部分和整体的生命周期一样。

合成/聚合复用原则的好处是,优先使用对象的合成/聚合将有助于你保持每个类被封装,并被集中在单个任务上。这样类和类继承层次会保持较小规模,并且不太可能增长为不可控制的庞然大物。

桥接模式(Bridge),将抽象部分与它的实现部分分离,使他们都可以独立地变化。

什么叫抽象与它的实现分离,这并不是说,让抽象类与其派生类分离,因为这没有任何意义。实现指的是抽象类和它的派生类用来实现自己的对象。

实现系统可能有多角度分类,每一种分类都有可能变化,那么就把这种多角度分离出来让它们独立变化,减少它们之间的耦合。

只要真正深入地理解了设计原则,很多设计模式其实就是原则的应用而已,或者在不知不觉中就在使用设计模式了。

二十三、烤羊肉引来的思考 —> 命令模式

命令模式(Command),将一个请求封装为一个对象,从而使你可用不同请求对客户进行参数化,对请求排队或请求日志,以及支持可撤销的操作。

作用:

第一:他能较容易的设计一个命令队列;

第二:在需要的情况下,可以较容易的将命令记入日志;

第三:允许接收请求的的一方决定是否要否决请求;

第四:可以容易地实现对请求的撤销和重做;

第五:由于加进新的具体命令类不影响其他的类,因此增加新的具体命令类很容易。

Important:命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开。

敏捷开发原则告诉我们,不要为代码添加基于猜测的,实际不需要的功能。如果不清楚一个系统是否需要命令模式,一般就是不要着急去实现它,事实上,在需要的时候通过重构实现这模式并不困难,只有在真正需要如撤销/恢复操作等功能时,把原来的代码重构为命令模式才有意义。

二十四、加薪非要老总批? —> 职责链模式

责任链模式(Chain of Responsibility):使多个对象都有机会处理请求,从而避免请求的发达者和接收者之间的耦合关系。将这个对象连成一条链,并沿着这条链传递该请求,知道有一个对象处理它为止。

责任链的好处:

最关键的是:当客户提交一个请求时,请求是沿链传递直至有 一个ConcreteHandler对象负责处理它。

接收者和发送者都没有对方的明确信息,且链中的对象自己并不知道链的结构。结果是指责链可简化对象的相互连接,它们仅需保持一个指向其后继者的引用,而不需保持它所有的候选接受者的引用。

随时地增加或修改处理一个请求的结构。增强了给对象指派指责的灵活性。

一个请求极有可能到了链的末端都得不到处理,活着因为没有正确配置而得不到处理。

二十五、世界需要和平 —> 中介者模式

尽管将一个系统分割成许多对象通常可以增加其可复用性,但是对象间相互连接的激增又会降低其可复用性了。

大量的连接使得一个对象不可能在没有其他对象的支持下工作,系统表现为一个不可分割的整体,所以,对系统的行为进行任何较大的改动就十分困难了。

中介者模式(Mediator),用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

中介者模式很容易在系统中应用,也很容易在系统中误用。当系统出现了‘多对多’交互复杂的对象群时,不要急于使用中介者模式,而要先反思你的系统在设计上是不是合理。

优点:

首先是Mediator的出现减少了各个Colleague的耦合,使得可以独立地改变和复用各个Colleague类和Mediator;其次,由于把对象如何协作进行了抽象,将中介作为一个独立的概念并将其封装在一个对象中,这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来,也就是站在一个更宏观的角度去看待系统。

由于C哦你吃热特 Mediator控制了集中化,于是就把交互复杂性变为了中介者的复杂性,这就使得中介者会变得比任何一个ConcreteColleague都复杂。

中介者模式的优点来自集中控制,其缺点也就是它。

中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合,以及想定制一个分布在多个类中的行为,而又不想生成太多的子类的场合。

二十六、项目多也别傻做 —> 享元模式

享元模式(Flyweight),运用共享技术有效地支持大量细粒度的对象。

享元模式可以避免大量非常相似类的开销。在程序设计中,有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的,有时就能够受大幅度地减少需要实例化的类的数量。如果能把那些参数移到类实例的外面,在方法调用时将它们传递进来,就可以通过共享大幅度地减少单个实例的数目。

如果一个应用程序使用了大量的对象,而大量的这些对象造成了很大的储存开销时就应该考虑使用;还有就是对象的大多数状态可以外部状态,如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象,此时可以考虑使用享元模式。

二十七、其实你不懂老板的心 —> 解释器模式

解释器模式(interpreter):给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

解释器模式需要解决的事:如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实施表述为一个简单语言中的句子。这样就可以构成一个解释器,该解释器通过解释这些句子来解决该问题。

当有一个语言需要解释执行,并且你可将该语言中句子表示为一个抽象语法树时,可使用解释器模式。

用了解释器模式,就意味着可以很容易地解决地改变和扩展文法,因为该模式使用类来表示文法规则,你可使用继承来改变或者扩展该文法。也比较容易实现文法,因为定义抽象语法树中各个节点的类的实现大体类似,这些类都易于直接编写。

解释器的不足:解释器模式为文法中的每一条规则至少定义了一个类,因此包含很多规则的文法可能难以管理和维护。建议当文法非常复杂时,使用其他的技术如语法分析程序或编译器生成器来处理。

二十八、男人和女人 —> 访问者模式

访问者模式(Visitor),表示一个作用于某对象结构中的各元素对的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

访问者模式适用于数据结构相对稳定的系统,它把数据结构和作用于结构上的操作之间的耦合解脱开,使得操作操作集合可以相对自由的演化。

访问者模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开,如果这样的系统有比较稳定的数据结构,又有易于变化的话,使用访问者模式就是比较合适的,因为访问者模式使得算法操作的增加变得容易。反之,如果这样的系统的数据结构对象易于变化,经常要有新的数据对象增加进来,就不合适使用访问者模式。

访问者模式的优点就是增加新的操作很容易,因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。

访问者的缺点:使增加新的数据结构变得困难了。

二十九、OOTV杯超级模式大赛 —> 模式总结

  • 创建型:
  • 抽象工厂:提供一个创建一系列或相关依赖对象的接口,而无需指定它们具体的类。
  • 建造者: 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
  • 工厂方法:定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂模式使一个类的实例化延迟到其子类。
  • 原型:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
  • 单例:保证一个类仅有一个实例,并提供一个访问它的全局访问点。
  • 内聚性描述的是一个例程内部组成部分之间相互联系的紧密程度,而耦合性描述的是一个例程与其他历程之间联系的机密成都。内部完整,高聚合,低耦合
  • 结构型:
  • 适配器:将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
  • 桥接: 将抽象部分与它的实现部分分离,使他们都可以独立地变化。
  • 组合: 将对象组合成树形结构以表示‘部分-整体’的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。
  • 装饰:动态的给一个对象添加一些额外的职责,就增加能来说,装饰模式相比生成子类更加灵活。
  • 外观:为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
  • 享元:为运用共享技术有效的支持大量细粒度的对象。
  • 代理:为其他对象提供一种代理以控制对这个对象的访问。
  • 行为型:
  • 观察者:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所以依赖于它的对象都得到通知并被自动更新。
  • 模版:定义一个操作的算法骨架,而将一些步骤延迟到子类中,模版方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
  • 命令:将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,可以对请求排队或者记录日志请求,以及支持可撤销的操作。
  • 状态:允许一个对象在其内部状态改变时改变它的行为,让对象看起来似乎修改了他的类。
  • 职责链:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,知道有一个对象处理它为止。
  • 解释器:给定一个语言,定一个他的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
  • 中介者:用一个中介者对象来封装一系列的对象交互,中介者使各对象不需要显示地相互引用,从而使其耦合松散,而且可以地改变它们之间的交互。
  • 访问者:表示一个作用于某对象结构中的个元素的操作,它使你可以在不改变各元素的类的前提下定义作用于这些元素的饿心操作。
  • 策略:定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换,本模式使得算法可独立于使用它的客户而变化。
  • 备忘录:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后就可将该对象恢复到原先保存的状态。
  • MVC是包括三类对象,Model是应用对象,View是它在屏幕上的表示,Controller定义用户界面对用户输入的相应方式。
  • 对象是一个自包含的实体,用一组可识别的特性和行为来标识。
  • 类就是具有相同的属性和功能的对象的抽象的集合:类名称首字母记着要大写,对外公开的方法需要用public 修饰符。
  • 构造方法:又叫做构造函数,其实就是对类进行初始化。构造方法与类同名,无返回值,也不需要void,在new时候调用
  • 方法重载提供了创建同名的多个方法的能力,但这些方法需使用不同的参数类型,方法重载可在不改变原方法的基础上,新增功能。
  • 属性是一个方法或一对方法,但在调用它的代码看来,他是一个字段,即属性适合于以字段的方式使用方法调用的场合。字段是存储类药满足其设计所需啊哟的数据,字段是与类相关的变量。
  • 继承
  • 多态