《设计模式》课后答案

  • 更新时间:
  • 7460人关注
  • 点击下载

给大家带来的是关于设计模式相关的课后习题答案下载,介绍了关于设计模式方面的内容,由晃嘉茂 网友提供,本资源目前已被378人关注,高等院校设计模式类教材综合评分为:8.4分

资源详情相关推荐
《设计模式》封面
  • 出版社:清华大学出版社
  • 作者:刘伟 胡志刚、郭克华
  • 大小:590 KB
  • 类别:设计模式
  • 热度:579
  • Java设计模式及实践
  • Python设计模式 第2版
  • Learning PHP设计模式
  • Android源码设计模式解析与实战
  • 设计模式的艺术:软件开发人员内功修炼之道
  • 《设计模式》系统介绍了设计模式。全书共分27章,内容包括统一建模语言基础知识、面向对象设计原则、设计模式概述、简单工厂模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式、适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式、职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。

    《设计模式》结合大量实例来学习gof设计模式,针对每一个设计模式均提供了一或两个实例,并对每一个模式进行了详尽的讲解,每一章最后均配有量的习题。

    《设计模式》既可作为高等院校计算机相关专业本科生和研究生设计模式、软件体系结构等课程教材,也可作为各软件培训机构培训教材及全国计算机技术与软件专业技术资格(水平)考试辅导教材,还可作为软件架构师、软件工程师等开发人员的参考用书。

    目录

    • 第1章 统一建模语言基础知识
    •  1.1 uml简介
    •  1.2 类图
    •  1.3 顺序图
    •  1.4 状态图
    •  1.5 本章小结
    •  思考与练习
    • 第2章 面向对象设计原则
    •  2.1 面向对象设计原则概述
    •  2.2 单一职责原则
    •  2.3 开闭原则
    •  2.4 里氏代换原则
    •  2.5 依赖倒转原则
    •  2.6 接口隔离原则
    •  2.7 合成复用原则
    •  2.8 迪米特法则
    •  2.9 本章小结
    •  思考与练习
    • 第3章 设计模式概述  
    •  3.1 设计模式的诞生与发展
    •  3.2 设计模式的定义与分类
    •  3.3 gof设计模式简介
    •  3.4 设计模式的优点
    •  3.5 本章小结
    •  思考与练习
    • 第4章 简单工厂模式
    •  4.1 创建型模式
    •  4.2 简单工厂模式动机与定义
    •  4.3 简单工厂模式结构与分析
    •  4.4 简单工厂模式实例与解析
    •  4.5 简单工厂模式效果与应用
    •  4.6 简单工厂模式扩展
    •  4.7 本章小结
    •  思考与练习
    • 第5章 工厂方法模式
    •  5.1 工厂方法模式动机与定义
    •  5.2 工厂方法模式结构与分析
    •  5.3 工厂方法模式实例与解析
    •  5.4 工厂方法模式效果与应用
    •  5.5 工厂方法模式扩展
    •  5.6 本章上结
    •  思考与练习
    • 第6章 抽象工厂模式
    •  6.1 抽象工厂模式动机与定义
    •  6.2 抽象工厂模式结构与分析
    •  6.3 抽象工厂模式实例与解析
    •  6.4 抽象工厂模式效果与应用
    •  6.5 抽象工厂模式扩展
    •  6.6 本章小结
    •  思考与练习
    • 第7章 建造者模式
    •  7.1 建造者模式动机与定义
    •  7.2 建造者模式结构与分析
    •  7.3 建造者模式实例与解析
    •  7.4 建造者模式效果与应用
    •  7.5 建造者模式扩展
    •  7.6 本章小结
    •  思考与练习
    • 第8章 原型模式
    •  8.1 原型模式动机与定义
    •  8.2 原型模式结构与分析
    •  8.3 原型模式实例与解析
    •  8.4 原型模式效果与应用
    •  8.5 原型模式扩展
    •  8.6 本章小结
    •  思考与练习
    • 第9章 单例模式
    •  9.1 单例模式动机与定义
    •  9.2 单例模式结构与分析
    •  9.3 单例模式实例与解析
    •  9.4 单例模式效果与应用
    •  9.5 单例模式扩展
    •  9.6 本章小结
    •  思考与练习
    • 第10章 适配器模式
    •  10.1 结构型模式
    •  10.2 适配器模式动机与定义
    •  10.3 适配器模式结构与分析
    •  10.4 适配器模式实例与解析
    •  10.5 适配器模式效果与应用
    •  10.6 适配器模式扩展
    •  10.7 本章小结
    •  思考与练习
    • 第11章 桥接模式
    •  11.1 桥接模式动机与定义
    •  11.2 桥接模式结构与分析
    •  11.3 桥接模式实例与解析
    •  11.4 桥接模式效果与应用
    •  11.5 桥接模式扩展
    •  11.6 本章小结
    •  思考与练习
    • 第12章 组合模式
    •  12.1 组合模式动机与定义
    •  12.2 组合模式结构与分析
    •  12.3 组合模式实例与解析
    •  12.4 组合模式效果与应用
    •  12.5 组合模式扩展
    •  12.6 本章小结
    •  思考与练习
    • 第13章 装饰模式
    •  13.1 装饰模式动机与定义
    •  13.2 装饰模式结构与分析
    •  13.3 装饰模式实例与解析
    •  13.4 装饰模式效果与应用
    •  13.5 装饰模式扩展
    •  13.6 本章小结
    •  思考与练习
    • 第14章 外观模式
    •  14.1 外观模式动机与定义
    •  14.2 外观模式结构与分析
    •  14.3 外观模式实例与解析
    •  14.4 外观模式效果与应用
    •  14.5 外观模式扩展
    •  14.6 本章小结
    •  思考与练习
    • 第15章 享元模式
    •  15.1 享元模式动机与定义
    •  15.2 享元模式结构与分析
    •  15.3 享元模式实例与解析
    •  15.4 享元模式效果与应用
    •  15.5 享元模式扩展
    •  15.6 本章小结
    •  思考与练习
    • 第16章 代理模式
    •  16.1 代理模式动机与定义
    •  16.2 代理模式结构与分析
    •  16.3 代理模式实例与解析
    •  16.4 代理模式效果与应用
    •  16.5 代理模式扩展
    •  16.6 本章小结
    •  思考与练习
    • 第17章 职责链模式
    •  17.1 行为型模式
    •  17.2 职责链模式动机与定义
    •  17.3 职责链模式结构与分析
    •  17.4 职责链模式实例与解析
    •  17.5 职责链模式效果与应用
    •  17.6 职责链模式扩展
    •  17.7 本章上结
    •  思考与练习
    • 第18章 命令模式
    •  18.1 命令模式动机与定义
    •  18.2 命令模式结构与分析
    •  18.3 命令模式实例与解析
    •  18.4 命令模式效果与应用
    •  18.5 命令模式扩展
    •  18.6 本章小结
    •  思考与练习
    • 第19章 解释器模式
    •  19.1 解释器模式动机与定义
    •  19.2 解释器模式结构与分析
    •  19.3 解释器模式实例与解析
    •  19.4 解释器模式效果与应用
    •  19.5 解释器模式扩展
    •  19.6 本章小结
    •  思考与练习
    • 第20章 迭代器模式
    •  20.1 迭代器模式动机与定义
    •  20.2 迭代器模式结构与分析
    •  20.3 迭代器模式实例与解析
    •  20.4 迭代器模式效果与应用
    •  20.5 迭代器模式扩展
    •  20.6 本章小结
    •  思考与练习
    • 第21章 中介者模式
    •  21.1 中介者模式动机与定义
    •  21.2 中介者模式结构与分析
    •  21.3 中介者模式实例与解析
    •  21.4 中介者模式效果与应用
    •  21.5 中介者模式扩展
    •  21.6 本章小结
    •  思考与练习
    • 第22章 备忘录模式
    •  22.1 备忘录模式动机与定义
    •  22.2 备忘录模式结构与分析
    •  22.3 备忘录模式实例与解析
    •  22.4 备忘录模式效果与应用
    •  22.5 备忘录模式扩展
    •  22.6 本章小结
    •  思考与练习
    • 第23章 观察者模式
    •  23.1 观察者模式动机与定义
    •  23.2 观察者模式结构与分析
    •  23.3 观察者模式实例与解析
    •  23.4 观察者模式效果与应用
    •  23.5 观察者模式扩展
    •  23.6 本章小结
    •  思考与练习
    • 第24章 状态模式
    •  24.1 状态模式动机与定义
    •  24.2 状态模式结构与分析
    •  24.3 状态模式实例与解析
    •  24.4 状态模式效果与应用
    •  24.5 状态模式扩展
    •  24.6 本章小结
    •  思考与练习
    • 第25章 策略模式
    •  25.1 策略模式动机与定义
    •  25.2 策略模式结构与分析
    •  25.3 策略模式实例与解析
    •  25.4 策略模式效果与应用
    •  25.5 策略模式扩展
    •  25.6 本章小结
    •  思考与练习
    • 第26章 模板方法模式
    •  26.1 模板方法模式动机与定义
    •  26.2 模板方法模式结构与分析
    •  26.3 模板方法模式实例与解析
    •  26.4 模板方法模式效果与应用
    •  26.5 模板方法模式扩展
    •  26.6 本章小结
    •  思考与练习
    • 第27章 访问者模式
    •  27.1 访问者模式动机与定义
    •  27.2 访问者模式结构与分析
    •  27.3 访问者模式实例与解析
    •  27.4 访问者模式效果与应用
    •  27.5 访问者模式扩展
    •  27.6 本章小结
    •  思考与练习
    • 参考文献
    展开阅读
    精选笔记1:常见Java设计模式视频和开发模式

    6小时39分钟前回答

        一、设计模式的分类

        设计模式是不分语言的;前辈们总结出来的设计模式分:3种类型及23种模式:

        设计模式主要分三个类型:创建型、结构型和行为型。

        其中创建型有:

        一、Singleton,单例模式:保证一个类只有一个实例,并提供一个访问它的全局访问点

        二、AbstractFactory,抽象工厂:提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们的具体类。

        三、FactoryMethod,工厂方法:定义一个用于创建对象的接口,让子类决定实例化哪一个类,FactoryMethod使一个类的实例化延迟到了子类。

        四、Builder,建造模式:将一个复杂对象的构建与他的表示相分离,使得同样的构建过程可以创建不同的表示。

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

        行为型有:

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

        七、Observer,观察者模式:定义对象间一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知自动更新。

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

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

        十、State,状态模式:允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。

        十一、Strategy,策略模式:定义一系列的算法,把他们一个个封装起来,并使他们可以互相替换,本模式使得算法可以独立于使用它们的客户。

        十二、ChinaofResponsibility,职责链模式:使多个对象都有机会处理请求,从而避免请求的送发者和接收者之间的耦合关系

        十三、Mediator,中介者模式:用一个中介对象封装一些列的对象交互。

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

        十五、Interpreter,解释器模式:给定一个语言,定义他的文法的一个表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

        十六、Memento,备忘录模式:在不破坏对象的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。

        结构型有:

        十七、Composite,组合模式:将对象组合成树形结构以表示部分整体的关系,Composite使得用户对单个对象和组合对象的使用具有一致性。

        十八、Facade,外观模式:为子系统中的一组接口提供一致的界面,fa?ade提供了一高层接口,这个接口使得子系统更容易使用。

        十九、Proxy,代理模式:为其他对象提供一种代理以控制对这个对象的访问

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

        二十一、Decrator,装饰模式:动态地给一个对象增加一些额外的职责,就增加的功能来说,Decorator模式相比生成子类更加灵活。

        二十二、Bridge,桥模式:将抽象部分与它的实现部分相分离,使他们可以独立的变化。

        二十三、Flyweight,享元模式

        开发模式:

        JAVA中的开发模式:

        MVC是一个很常用的程序开发设计模式,M-Model(模型):封装应用程序的状态;V-View(视图):表示用户界面;C-Controlle

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

        二、设计模式的六大原则

        1、开闭原则(OpenClosePrinciple)

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

        2、里氏代换原则(LiskovSubstitutionPrinciple)

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

        3、依赖倒转原则(DependenceInversionPrinciple)

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

        4、接口隔离原则(InterfaceSegregationPrinciple)

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

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

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

        6、合成复用原则(CompositeReusePrinciple)

    以上就是码农之家java培训机构的小编针对“常见Java设计模式视频和开发模式”的内容进行的回答,希望对大家有所帮助,如有疑问,请在线咨询,有专业老师随时为你服务。

    展开阅读
    精选笔记2:深入解析C++编程中对设计模式中的策略模式的运用

    17小时24分钟前回答

    策略模式也是一种非常常用的设计模式,而且也不复杂。下面我们就来看看这种模式。
    定义:策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

    角色:

    •     抽象策略角色(Strategy): 抽象策略类。
    •     具体策略角色(ConcreteStrategy):封装了继续相关的算法和行为。
    •     环境角色(Context):持有一个策略类的引用,最终给客户端调用。

    UML图:

    201639105036032.jpg (548×222)

    例子:

    #include <iostream> 
    using namespace std; 
     
    class WeaponBehavior 
    { 
    public: 
      void virtual useWeapon() = 0; 
    }; 
     
    class AK47:public WeaponBehavior 
    { 
    public: 
      void useWeapon() 
      { 
        cout << "Use AK47 to shoot!" << endl; 
      } 
    }; 
     
    class Knife:public WeaponBehavior 
    { 
    public: 
      void useWeapon() 
      { 
        cout << "Use Knife to kill!" << endl; 
      } 
    }; 
     
    class Character 
    { 
    public: 
      Character() 
      { 
        weapon = 0; 
      } 
      void setWeapon(WeaponBehavior *w) 
      { 
        this->weapon = w; 
      } 
      void virtual fight() = 0; 
    protected: 
      WeaponBehavior *weapon; 
    }; 
     
    class King:public Character 
    { 
    public: 
      void fight() 
      { 
        cout << "The king:" ; 
        if ( this->weapon == NULL) 
        { 
          cout << "You don't have a weapon! Please Set Weapon!" << endl; 
        } 
        else 
        {  
          weapon->useWeapon(); 
        } 
      } 
    }; 
    int main() 
    {   
      WeaponBehavior *ak47 = new AK47(); 
      WeaponBehavior *knife = new Knife();    
     
      Character *kin = new King();    
     
      kin->fight();   
      cout << endl;  
     
      kin->setWeapon(ak47); 
      kin->fight(); 
      cout << endl; 
     
      kin->setWeapon(knife); 
      kin->fight(); 
     
      return 0; 
    } 
    

    适用性:
    1,多个类只区别在表现行为不同,可以使用Strategy模式,在运行时动态选择具体要执行的行为。
    2,需要在不同情况下使用不同的策略(算法),或者策略还可能在未来用其它方式来实现。
    3,对客户隐藏具体策略(算法)的实现细节,彼此完全独立。

    优缺点:
    优点:
    1,策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族。恰当使用继承可以把公共的代码移到父类里面,从而避免代码重复。
    2,使用策略模式可以避免使用多重条件(if-else)语句。多重条件语句不易维护,它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起,统统列在一个多重条件语句里面,比使用继承的办法还要原始和落后。
    缺点:
    1,客户端必须知道所有的策略类,并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别,以便适时选择恰当的算法类。换言之,策略模式只适用于客户端知道算法或行为的情况。
    2,由于策略模式把每个具体的策略实现都单独封装成为类,如果备选的策略很多的话,那么对象的数目就会很可观。

    和其他设计模式的区别:
    1,与状态模式
    在解决的问题上,状态模式是解决内在状态的改变,而策略模式是解决内部算法的改变。在解决的方法上,状态模式是自我控制状态的改变,而策略模式是由外部制定使用使用啥策略。
    2,简单工厂模式
    简单工厂模式是创建型模式,关注对象的创建。策略模式是行为型模式,关注行为的封装。简单工厂模式是根据不同的条件返回一个适合的类给你使用,然后调用者使用工厂类返回的类去完成相应的操作。而策略模式是必须首先创建一个想使用的类实例,然后实例被当作参数传递进去,既而通过该实例去调用不用的算法。在简单工厂模式中实现了通过条件选取一个类去实例化对象,策略模式则将选取相应对象的工作交给模式的使用者,它本身不去做选取工作。

    展开阅读

    设计模式相关资源

    • JavaScript设计模式

      JavaScript设计模式

      《JavaScript设计模式》共分六篇四十章,首先讨论了几种函数的编写方式,体会JavaScript在编程中的灵活性;然后讲解了面向对象编程的知识,其中讨论了类的创建、数据的封装以及类之间的继承

      大小:63.7 MBJavaScript

      立即下载
    • 大话设计模式

      大话设计模式

      大小:69 MB设计

      立即下载
    • 领域驱动设计模式、原理与实践

      领域驱动设计模式、原理与实践

      《领域驱动设计模式、原理与实践》 分为四个部分。第Ⅰ部分主要是介绍DDD的思想体系、原则以及实践。第Ⅱ部分详细介绍集成有界上下文的战术模式。第Ⅲ部分将介绍创建有效领域模型的战

      大小:204.3 MB设计模式

      立即下载
    • React设计模式与最佳实践

      React设计模式与最佳实践

      本书共分为12章,通过介绍React中有价值的设计模式,展示如何将设计模式和zui佳实践应用于现实的新项目和已有项目中。主要内容包括帮助读者理解React的基本概念,学习编写整洁、可维护的代

      大小:8.1 MBReact

      立即下载
    • Java设计模式深入研究

      Java设计模式深入研究

      《Java设计模式深入研究》对高级程序员、软件工程师、系统架构师等专业研究人员也具有一定的参考价值。 Java设计模式深入研究 第1章 接口与抽象类 第2章 反射 第3章 工厂模式 第4章 生成器

      大小:49.2 MBJava

      立即下载
    • Head First 设计模式

      Head First 设计模式

      大小:40.8 MB设计模式

      立即下载
    • 图解Java多线程设计模式

      图解Java多线程设计模式

      本书通过具体的Java 程序,以浅显易懂的语言逐一说明了多线程和并发处理中常用的12 种设计模式。内容涉及线程的基础知识、线程的启动与终止、线程间的互斥处理与协作、线程的有效应用、线程的数量管理以及性能优化的注意事项等。

      大小:86.3 MBJava

      立即下载

    学习笔记

    8小时10分钟前回答

    JavaScript设计模式之观察者模式(发布订阅模式)原理与实现方法示例

    本文实例讲述了JavaScript设计模式之观察者模式(发布订阅模式)原理与实现方法。分享给大家供大家参考,具体如下: 观察者模式,又称为发布订阅模式,它定义了一种一对多的关系,让多个观察者对象同时监听某一个主题对象,这个主题对象的状态发生变化时就会通知所有的观察者对象,使得它们能够自动更新自己的状态。 在观察者模式中,并不是一个对象调用另一个对象的方法,而是一个对象订阅另一个对象的特定活动并在状态改变后获得通知。订阅者也称为观察者,而被观察的对象称为发布者或主题。当发生了一个重要的事件时,发布者将会通知(调用)所有订阅者并且可能经常以事件对象的形……

    5小时38分钟前回答

    用代码和UML图化解设计模式之桥接模式的深入分析

    桥接模式就是 独立和实现相分离。 不同的厂家生产不同的产品。。。。产品和厂家有这组合的关系。 上代码 复制代码 代码如下: // Bridge.cpp : 定义控制台应用程序的入口点。 /************************************************************************/ #include "stdafx.h" #include iostream using namespace std; class Product { public: Product(){} virtual ~Product(){} virtual void make()=0; virtual void sell()=0; }; class ProductA:public Product { public: ProductA(){} virtual ~ProductA(){} virtual void make() { cout"ProductA:make()"endl; } virtual void sell() { cout"ProductA:sell()"endl; } }; class ProductB:public Product { public: ProductB(){} virtual ~ProductB(){} virtual void make() { cout"ProductB:make()"endl; } virtual void sell() { c……

    4小时20分钟前回答

    Java多例设计模式实例详解

    本文实例讲述了Java多例设计模式。分享给大家供大家参考,具体如下: 一、多例设计模式定义 多例设计模式就是存在多个对象实例,供外部应用裯用,比喻数据库连接池。 二、多例模式静态类图 三、多例模式代码实现 1. 多例模式核心类 package com.demo.multipleton;import java.util.ArrayList;/** * 多例模式 * * @author * */public class Multipleton { // 多例数量 private static final int N = 10; // 存放N个实例对象的容器 private static ArrayListMultipleton list = new ArrayListMultipleton(N); // 每个对象的序号 标识 private int no; // 私有构造方法 防止外界应用程序实例化 private Multipleton(int no) { this.no = no; System.out.println("-- Create Multipleton Object[" + no + "]!"……