《Head First设计模式》3

HeadFirst设计模式之⽬录只有沉淀、积累，才能远航；沉沉浮浮，脚踏实地。

这本书已经闲置了好久，⼼⾎来潮，决定写个⽬录，让⾃⼰坚持看完这本书创建型模式1. (Abstract factory pattern): 提供⼀个接⼝, ⽤于创建相关或依赖对象的家族, ⽽不需要指定具体类.2. (Builder pattern): 使⽤⽣成器模式封装⼀个产品的构造过程, 并允许按步骤构造. 将⼀个复杂对象的构建与它的表⽰分离, 使得同样的构建过程可以创建不同的表⽰.3. (factory method pattern): 定义了⼀个创建对象的接⼝, 但由⼦类决定要实例化的类是哪⼀个. ⼯⼚⽅法让类把实例化推迟到⼦类.4. (prototype pattern): 当创建给定类的实例过程很昂贵或很复杂时, 就使⽤原形模式.5. (Singleton pattern): 确保⼀个类只有⼀个实例, 并提供全局访问点.6. 多例模式(Multition pattern): 在⼀个解决⽅案中结合两个或多个模式, 以解决⼀般或重复发⽣的问题.结构型模式1. : 将⼀个类的接⼝, 转换成客户期望的另⼀个接⼝. 适配器让原本接⼝不兼容的类可以合作⽆间. 对象适配器使⽤组合, 类适配器使⽤多重继承.2. : 使⽤桥接模式通过将实现和抽象放在两个不同的类层次中⽽使它们可以独⽴改变.3. : 允许你将对象组合成树形结构来表现"整体/部分"层次结构. 组合能让客户以⼀致的⽅式处理个别对象以及对象组合.4. : 动态地将责任附加到对象上, 若要扩展功能, 装饰者提供了⽐继承更有弹性的替代⽅案.5. : 提供了⼀个统⼀的接⼝, ⽤来访问⼦系统中的⼀群接⼝. 外观定义了⼀个⾼层接⼝, 让⼦系统更容易使⽤.6. : 如想让某个类的⼀个实例能⽤来提供许多"虚拟实例", 就使⽤蝇量模式.7. : 为另⼀个对象提供⼀个替⾝或占位符以控制对这个对象的访问.⾏为型模式1. : 通过责任链模式, 你可以为某个请求创建⼀个对象链. 每个对象依序检查此请求并对其进⾏处理或者将它传给链中的下⼀个对象.2. : 将"请求"封闭成对象, 以便使⽤不同的请求,队列或者⽇志来参数化其他对象. 命令模式也⽀持可撤销的操作.3. : 使⽤解释器模式为语⾔创建解释器.4. : 提供⼀种⽅法顺序访问⼀个聚合对象中的各个元素, ⽽⼜不暴露其内部的表⽰.5. : 使⽤中介者模式来集中相关对象之间复杂的沟通和控制⽅式.6. : 当你需要让对象返回之前的状态时(例如, 你的⽤户请求"撤销"), 你使⽤备忘录模式.7. : 在对象之间定义⼀对多的依赖, 这样⼀来, 当⼀个对象改变状态, 依赖它的对象都会收到通知, 并⾃动更新.8. : 允许对象在内部状态改变时改变它的⾏为, 对象看起来好象改了它的类.9. : 定义了算法族, 分别封闭起来, 让它们之间可以互相替换, 此模式让算法的变化独⽴于使⽤算法的客户.10. : 在⼀个⽅法中定义⼀个算法的⾻架, ⽽将⼀些步骤延迟到⼦类中. 模板⽅法使得⼦类可以在不改变算法结构的情况下, 重新定义算法中的某些步骤.11. : 当你想要为⼀个对象的组合增加新的能⼒, 且封装并不重要时, 就使⽤访问者模式.七⼤设计原则1. 单⼀职责原则【SINGLE RESPONSIBILITY PRINCIPLE】：⼀个类负责⼀项职责。

⼀句话的事⼉，Headfirst设计模式head first 设计模式，是⽐较有趣的⼀本设计模式的书。

在学校⾥看书和在⼯作时看书，意义是不⼀样的。

在学校时是为读书⽽读书，我们可以从0到1，我们有的是时间。

但是⼯作后就不⼀样。

我觉得这时的书更像是打通⾃⼰任督⼆脉的武功秘诀。

在平时⼯作中，杂七杂⼋地学了⼀些东西，但是却不能融会贯通。

所以还需要通过书来厘清你的思路。

这是写本⽂的出发点，也是我的碎碎念！看完该书后，转换成⾃⼰的语⾔，再表达出来，可能有错（那是⼀定的），但是，有总⽐没有好。

如果有同学能够从中得到些启发，也算是⾃⼰的⼀种幸运吧！我竟试图以⼀句话来描述⼀个设计模式！1. 策略模式！将统⼀的东西作为基类，可变的东西⾏为独⽴出来，在基类中通过变量进⾏引⽤，通过委托变量的⽅式，使⽤setter⽅法将委托变量改变，使其具有⾏为可变性。

⾯向接⼝编程，⽽⾮⾯向类编程。

其好处是，⽤同样的接⼝，通过不同⾏为类的传⼊产⽣不同的效果，便以改变⾏为变得容易。

2. 观察者模式！类似于发布-订阅模式。

存在注册服务，通知的过程。

其实现⽅式可以理解为，注册服务时，将观察者加⼊到队列当中，当主题发⽣变更时，由主题主动依次从观察者队列中依次调⽤，从⽽达到通知主动推送的作⽤。

其好处是，观察者随时注册观察可以实时收到消息，⽽被观察者对此⼀⽆所知，从⽽在达到通知的同时也解藕了。

3. 装饰者模式！以某对象为主要对象，⽣成后，将其传⼊装饰者构造函数中，经过装饰后，再⾏输出的模式。

该模式，可以许多散乱的⽅法独⽴组装出来，⽽不会影响其他变化，该模式是通过继承来实现的。

典型的装饰者模式运⽤，java io 类的继承，有多个主类，及多个装饰类，从⽽⽅便⽤户操作想要的⽅法。

其好处是，在⼤⽅向不变的情况下，可以反复更改主要的⾏为结果，对于⼀些附加类的变化，可以很⽅便地通过该模式进⾏数据再加⼯。

4. ⼯⼚模式！分为简单⼯⼚模式-⼯⼚模式-抽象⼯⼚模式。

Head First Design Patterns(深入浅出设计模式)-设计模式介绍1.Welcome to Design Patterns -设计模式介绍现在我们要住进对象村(Objectville),我们刚刚开始接触设计模式…每个人都在使用它们。

一会我们将去参加Jim和Betty的星期三晚上的模式聚会!有人已经解决了你的问题。

在这章里，你将学习到为什么(和怎么样)，你将学习到那些幸存下来的开发者的智慧和教训，他们都曾经历过类似的设计问题。

在我们做之前，我们将先看看设计模式的用途和好处，再看一些关键的面向对象设计原则，并且再通过一个实例了解模式的工作方式。

使用模式最好的方法就是把它们装入脑袋里，然后在你设计和现有的应用程序里找到你能够应用它们的地方。

相对于代码重用，使用模式你获得了经验的重用。

-1-从一个简单的模拟鸭子程序开始乔为一个制造非常成功的模拟鸭子池塘游戏(SimUDuck)的公司工作。

这个游戏可以展示很多种鸭子的游泳方式和呷呷叫声。

系统最初的设计者们使用了标准的面向对象技术，他们创建了一个Duck基类供所有其它类型的鸭子继承。

去年，竞争者们给公司带来了越来越多的压力。

经过历时一周在高尔夫球赛场上的集体讨论，公司的经理们都觉得该是进行一次大改革的时候了。

他们需要在下周在毛伊岛举行的股东大会上展示一些真正给人深刻印象的东西。

-2-但是我们现在需要鸭子可以飞经理们确定会飞的鸭子就是模拟器需要的用来击败其他竞争者的东西。

当然，乔的经理告诉他们，对于乔来说在一周内迅速搞定这些根本不是问题。

“毕竟”，乔的上司说，“他是一个面向对象的程序员…那些有什么难的呢？”乔想：我仅仅只需要在Duck类里增加fly()方法，然后所有其他鸭子就都可以继承它了。

现在是展示我真正的面向对象才华的时候了。

-3-但是有些事情严重错误了…乔的上司：乔，我正在股东大会上。

他们刚看完演示，很多橡皮鸭子在屏幕上四处乱飞。

这是你在开玩笑吗？…发生了什么事？乔没有注意到并不是所有Duck的子类都需要fly()方法。

编辑推荐本书荣获2005年第十五届Jolt通用类图书震撼大奖。

本书英文影印版被《程序员》等机构评选为2006年最受读者喜爱的十大IT图书之一 。

本书趋近完美，因为它在提供专业知识的同时，仍然具有相当高的可读性。

叙述权威、文笔优美。

本书共有14章，每章都介绍了几个设计模式，完整地涵盖了四人组版本全部23个设计模式。

前言先介绍这本书的用法；第1章到第11章陆续介绍的设计模式为Strategy、Observer、Decorator、Abstract　Factory、Factory　Method、Singleton、Command、Adapter、Facade、Templat Method、Iterator、Composite、State、Proxy。

最后三章比较特别。

第12章介绍如何将两个以上的设计模式结合起来成为新的设计模式（例如著名的MVC模式），作者称其为复合设计模式（这是作者自创的名称，并非四人组的标准名词），第13章介绍如何进一步学习设计模式，如何发觉新的设计模式等主题，至于第14章则很快地浏览尚未介绍的设计模式，包括Bridge、Builder、Chain of　Responsibility、Flyweight、Interpreter、Mediator、Memento、Prototype、Visitor。

第1章还介绍了四个OO基本概念（抽象、封装、继承、多态），而第１章到第9章也陆续介绍了九个OO原则（Principle）。

千万不要轻视这些OO原则，因为每个设计模式背后都包含了几个OO原则的概念。

很多时候，在设计时有两难的情况，这时候我们必须回归到OO原则，以方便判断取舍。

可以这么说：OO原则是我们的目标，而设计模式是我们的做法。

本书作者Eric Freeman和Elisabeth Freeman是作家、讲师和技术顾问。

Eric拥有耶鲁大学的计算机科学博士学位，Elisabath拥有耶鲁大学的计算机科学硕士学位。

headfirst设计模式java_吐血整理HeadFirst设计模式大全首先，要理解Head First设计模式，需要明白设计模式的概念。

设计模式是在软件开发中经过实践验证的解决方案，它们是解决特定问题的经验总结。

Head First系列是一本非常经典的计算机科学图书系列，其中《Head First设计模式》专门介绍了23种常见的设计模式，并以Java语言进行讲解。

本书从实际问题出发，用生动形象的方式讲解设计模式，以帮助读者更好地理解和应用这些设计模式。

下面将介绍一些书中提到的设计模式和其在Java编程中的应用。

1. 策略模式（Strategy Pattern）：策略模式将一组行为封装成策略类，使其在运行时可以相互替换。

在Java中，可以使用接口来定义策略，不同的策略类实现相同的接口，根据不同情况选择不同的策略。

2. 观察者模式（Observer Pattern）：观察者模式定义了对象间的一种一对多的关系，当一个对象状态改变时，所有依赖它的对象都会被通知并自动更新。

在Java中，可以使用java.util.Observable类和java.util.Observer接口来实现观察者模式。

3. 装饰者模式（Decorator Pattern）：装饰者模式动态地将责任附加到对象上，通过创建一个装饰者类来包装原始对象，以提供额外的功能。

在Java中，可以通过继承原始对象并添加额外功能的方式来实现装饰者模式。

4. 工厂模式（Factory Pattern）：工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。

在Java中，可以使用工厂方法模式来实现，通过定义一个工厂接口和具体的工厂类来创建实例。

5. 单例模式（Singleton Pattern）：单例模式确保一个类只有一个实例，并提供一个全局访问点。

在Java中，可以使用私有构造函数和静态方法来实现单例模式。

以上只是其中一部分介绍的设计模式，还有其他如适配器模式、迭代器模式、模板方法模式等。

计算机四大天书学习顺序
1、《计算机运作的简单原理》。

2、《算法图解》。

3、《HeadFirst设计模式》。

4、《交互式设计四策略》。

这四本书对应了四个阶段：
1、第一个阶段，初来乍到，需要学习计算机本质是什么，进而理解如何与计算机交流（编程语言），懂得代码是如何被执行的。

2、第二个阶段，已经初步学会使用一门编程语言求解计算问题，这个时候需要思考如何让你的程序更快更省（空间）的解决问题。

此时，经典算法和数据结构登场。

程序=代码+算法，算法是解决特定问题的特定方法（套路），一个算法是一个不会失败的，确保达到既定目标的过程。

3、第三个阶段，同学们开始学习高级编程语言或者编程平台（Web 应用、Android应用等）了，课程设计需要实现综合性的系统。

大家已明白现代软件是诸多组件的结合体，组件之间的交互需要精密的设计；开发的过程需要同小组的成员进行协作，也需要同未来的自己进行写作。

这时候，就需要设计模式出场了。

它既是解决领域的对象如何组织的特定方法（套路），也是同行之间交流的工具。

4、第四个阶段，我们的目标不只在于课程设计了，而是正经（假装会有人用）的产品了。

但是为何有些人做的软件用起来如“丝滑般
感受”，而有的却那么不懂用户的心思。

这时候，你需要学习一定的产品设计思维、用户体验设计技巧。

HeadFirst设计模式中文版课程设计一、课程简介HeadFirst设计模式中文版是一门面向对象设计模式的课程，主要介绍23个常用的设计模式以及如何在实际项目中应用它们。

课程难度适中，适合有一定编程基础的学员学习。

本课程旨在帮助学员深入理解面向对象设计原则以及如何将其应用于实践中。

二、课程目标本课程将通过以下几个方面来使学员达到掌握面向对象设计模式的目标：1.让学员了解23个常用的设计模式。

2.帮助学员了解如何将设计模式应用到实际项目中。

3.培养学员的面向对象设计思维。

4.掌握常见的面向对象设计原则。

三、课程结构本课程共分为6个单元，每个单元包含了多个设计模式的讲解，学员将会通过理论课、案例分析和练习来深入掌握每种设计模式的概念和实现方式。

具体的课程结构如下：内容单元单内容元1 面向对象设计概述、策略模式、观察者模式、装饰者模式、工厂模式2 单例模式、命令模式、适配器模式、外观模式、模板方法模式3 迭代器模式、组合模式、状态模式、代理模式、桥接模式4 生成器模式、原型模式、享元模式、责任链模式、解释器模式5 中介者模式、备忘录模式、访问者模式6 雷打设计模式四、教学方法本课程采用“理论+实践”的教学方式，其中理论课主要通过PPT、视频等多种形式给学员讲解各个设计模式的概念和实现方式；实践环节包括编程练习和项目案例分析，让学员深入理解并掌握每种设计模式的应用场景以及具体实现方法。

同时，我们还将为每位学员提供在线答疑服务，帮助他们解决学习中遇到的问题。

五、考核方式本课程的考核方式主要包括两个环节：作业和项目。

其中，作业主要考察学员对每种设计模式的理解和具体应用方法，要求学员在规定时间内完成编程练习和课堂练习；项目考核环节要求学员在实际项目上应用所学的设计模式，完成实际项目需求并提交相关文档和源代码。

六、课程资料本课程的主要资料包括：1.HeadFirst设计模式中文版课程PPT。

2.HeadFirst设计模式中文版课程视频。

《Head.First设计模式》读书笔记目录1、创建型设计模式 (1)1.1工厂方法Factory Method【类】与抽象工厂Abstract Factory【对象、chapter 4】 (1)1.2单件Singleton【chapter5、对象】 (2)2、结构型设计模式 (2)2.1适配器Adapter【chapter7、类/对象】 (2)2.2组合Composite【chapter9、对象】 (2)2.3装饰者Decorator【chapter3、对象】 (2)2.4外观Facade【chapter7、对象】 (3)2.5代理Proxy【chapter11、对象】 (3)3、行为型设计模式 (3)3.1模板方法Template Method【chapter8、类】 (3)3.2命令Command【chapter6、对象】 (3)3.3迭代器Iterator【chapter9、对象】 (4)3.4观察者Observer【chapter2、对象】 (4)3.5状态State【chapter10、对象】 (4)3.6策略Strategy【chapter1、对象】 (4)4、与设计模式相处 (5)1、创建型设计模式1.1工厂方法Factory Method【类】与抽象工厂Abstract Factory【对象、chapter 4】(1) 工厂方法Factory Method：定义：由子类决定要实例化的类是哪一个。

让类把实例化推迟到子类。

实例：拓展披萨工厂，有各地风味的加盟店。

实现：分为Product(产品类披萨)和Creator(创建者类PizzaStore)两个类层级，都有许多具体的子类，每个子类都有自己特定的实现。

相关：“依赖倒置原则Dependency Inversion Principle”【6】。

要依赖抽象，不要依赖具体类。

PizzaStore是高层组件、比萨实现是低层组件，前者依赖后者。

head first中所有的设计原则在《Head First 设计模式》一书中，提到了以下几种设计原则：
1. 单一职责原则：一个类应该只有一个引起变化的原因。

也就是说，每个类应该只有一个职责，只负责一项功能。

2. 开放封闭原则：软件实体（类、模块、函数等等）应该是可以扩展的，但是不可修改。

也就是说，新的功能应该通过添加新的模块或者子类来实现，而不是修改现有的代码。

3. 里氏替换原则：如果S是T的子类，则程序中使用T类型的对象的地方都可以用S类型的对象来替换，而不会引起任何不期望的后果。

4. 接口隔离原则：客户端不应该依赖它不使用的接口。

接口隔离原则可以降低客户代码与实现细节之间的耦合度，使得客户端更加灵活和易于维护。

5. 依赖倒置原则：高层模块不应该依赖于低层模块，它们都应该依赖于抽象。

抽象不应该依赖于细节，细节应该依赖于抽象。

6. 迪米特法则：一个对象应该对其他对象保持最少的了解。

也就是说，一个对象应当尽可能少的与其他对象直接相互作用，不应该强制具体的对象直接通信，而应该使用一种规约方式（例如抽象类或接口）来进行间接通信。

7. 合成复用原则：尽量使用合成/聚合，而不是继承关系达到软件复用的目的。

以上是《Head First 设计模式》中提到的设计原则，这些原则可以帮助我们设计出更加健壮、可维护和可扩展的软件系统。

Head First 设计模式介绍Head First 设计模式是一本由埃里克·弗里曼（Eric Freeman）、伊丽沙白·弗里曼（Elisabeth Freeman）、考思温·西迪（Kathy Sierra）和贾尼特·贝茨（Bert Bates）合著的图书，该书使用了一种独特的学习方式，通过大量的图表、示例和练习来帮助读者理解和实践面向对象设计模式。

本文档将对 Head First 设计模式进行简要概述，并介绍其中涵盖的几种常见的设计模式。

设计模式概述设计模式是在软件开发过程中经常出现的问题的解决方案。

它们旨在提供一种通用的方法，帮助开发人员解决特定类型的问题。

设计模式有助于提高软件的可重用性、可维护性和可扩展性。

Head First 设计模式一书介绍了23种常见的设计模式，分为三种类型：创建型模式、结构型模式和行为型模式。

•创建型模式：这些模式关注对象的创建过程，包括如何实例化对象和配置对象的创建流程。

•结构型模式：这些模式关注对象之间的组合，以建立更大的结构，并提供对象之间的简化操作。

•行为型模式：这些模式关注对象之间的交互和通信，以实现特定的行为和协作。

以下是 Head First 设计模式中介绍的一些常见设计模式：创建型模式单例模式单例模式确保一个类只有一个实例，并提供一个全局访问点来访问该实例。

通过单例模式，我们可以限制对某个类的实例化，避免多个对象同时存在。

工厂模式工厂模式是一种创建型模式，它定义了一个创建对象的接口，但将具体的实现交给了子类来决定。

工厂模式可以通过将对象的创建和使用解耦，从而提供一种灵活的方法来创建多个对象的实例。

结构型模式适配器模式适配器模式将一个类的接口转换为客户端所期望的另一个接口，从而使两个类能够协同工作。

适配器模式适用于需要将一个类集成到另一个类中，并且不能修改原有类的情况。

装饰器模式装饰器模式允许在不改变现有对象结构的情况下，动态地添加行为。

Head First设计模式介绍Head First设计模式是一本由Eric Freeman、Elisabeth Robson、Kathy Sierra和Bert Bates合著的经典书籍，它以一种有趣且易于理解的方式介绍了软件设计模式的概念和实例。

该书通过生动的插图、真实的场景和互动式的内容，帮助读者更好地理解和应用设计模式。

本文将简要介绍Head First设计模式的主要内容，并通过几个设计模式示例来展示如何应用这些模式来解决常见的软件设计问题。

设计模式概述设计模式是一套经过反复验证的、可复用的解决方案，用于解决软件设计中的常见问题。

设计模式提供了一种共享的词汇，并描述了如何将这些词汇组合成解决方案。

设计模式通常可以分为三类：创建型模式、结构型模式和行为型模式。

•创建型模式关注如何创建对象，包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式。

•结构型模式关注如何组织对象，包括适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式和享元模式。

•行为型模式关注对象之间的通信和职责分配，包括模板方法模式、策略模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、状态模式、访问者模式和解释器模式。

接下来，我们将通过几个具体的设计模式示例来说明Head First设计模式的应用。

示例1：工厂方法模式工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。

工厂方法模式将对象的实例化推迟到子类中，从而实现了解耦和灵活性。

public abstract class PizzaStore {public Pizza orderPizza(String type) {Pizza pizza = createPizza(type);pizza.prepare();pizza.bake();pizza.cut();pizza.box();return pizza;}protected abstract Pizza createPizza(String t ype);}在上面的代码中，我们定义了一个抽象的PizzaStore类，其中的createPizza()方法由子类来实现，用于创建具体的Pizza对象。

读HeadFirst设计模式以往虽也看过相关设计模式的书籍，但能和与HeadFirt设计模式这本书相⽐不是缺乏严谨性就是缺乏具体应⽤实例，还有幽默⽣动以及引⼈启发的观点。

设计原则设计原则并不能光靠死记硬背，我们需要通过具体的设计模式来反思：该模式符合与违背了哪些设计原则。

不过在进⼊下⽂讨论之前，让我们先⼤概看看设计原则都有哪些。

封装变化针对接⼝编程，⽽不是实现多⽤组合少⽤继承松耦合对修改关闭，对扩展开放依赖抽象不依赖具体最少知识原则：只和亲密对象交谈好莱坞原则：别打电话给我，我会打给你单⼀职责谈谈模板⽅法我们都知道在GoF⾥⾯的设计模式含有23种，在HeadFirst设计模式⼀书中主要介绍了11种常见的设计模式。

本⽂挑选模板⽅法这个设计模式着重介绍下，主要是该模式在前后端的开发中经常遇到，也便于理解。

为了探析模板⽅法，让我们先看看⽇常⽣活中我们泡茶与泡咖啡的步骤。

泡茶把⽔烧开放茶包往杯⼦中加⽔加⼊柠檬⽤Java实现如下：public class Tea {public void prepareRecipe() {this.boilWater();this.steepTeaBag();this.pourInCup();this.addLemon();}private void addLemon() {System.out.println("add lemon...");}private void pourInCup() {System.out.println("pour in cup...");}private void steepTeaBag() {System.out.println("steep tea bag...");}private void boilWater() {System.out.println("boil water...");}}泡咖啡把⽔烧开研磨咖啡往杯⼦中加⽔加⼊糖和⽜奶⽤Java实现如下：public class Coffee {public void prepareRecipe() {this.boilWater();this.brewCoffeeGrinds();this.pourInCup();this.addSugarAndMilk();}private void addSugarAndMilk() {System.out.println("add sugar and milk...");}private void pourInCup() {System.out.println("pour in cup...");}private void brewCoffeeGrinds() {System.out.println("brew coffee grinds...");}private void boilWater() {System.out.println("boil Water....");}}探析当写完代码，不管你记不记得封装变化这条设计原则，你肯定觉得泡茶喝泡咖啡有些地⽅代码⾮常的相似，例如：烧⽔, 把⽔倒⼊被⼦, 对于研磨咖啡⾖和放茶包其本质都是：研磨喝的固体物质，我们可以把这些不变的部分提取出来。

Head First 设计模式简介Head First 设计模式是一本经典的设计模式入门书籍，它以清晰的语言和丰富的图片，结合了实际案例和有趣的插图，帮助读者轻松理解和应用设计模式。

本文将介绍Head First 设计模式的概述和书中提到的一些设计模式示例。

设计模式的重要性在软件开发中，设计模式是一种经过验证的解决方案，可以帮助开发人员解决常见的设计问题。

设计模式提供了一种通用的语言，使得开发人员能够共享和交流设计思想，并且可以重用已经验证的解决方案。

设计模式分类Head First 设计模式按照不同的目标进行分类，包括创建型模式、结构型模式和行为型模式。

创建型模式创建型模式主要处理对象创建的机制，包括了单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式。

单例模式单例模式用来确保一个类只有一个实例，并且提供一个全局访问点来访问这个实例。

这在需要共享资源的情况下非常有用。

工厂模式工厂模式用来创建对象，而无需暴露对象创建的逻辑。

它通过将对象的创建委托给工厂类来实现。

抽象工厂模式抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

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

原型模式通过复制现有对象来创建新对象，而无需耗费额外的资源。

结构型模式结构型模式主要处理对象之间的组合，包括了适配器模式、装饰者模式、代理模式、外观模式、桥接模式和组合模式。

适配器模式适配器模式用于将一个类的接口转换成客户端所期望的接口。

装饰者模式装饰者模式通过将对象包装在其他对象中来动态地为对象添加额外的行为。

代理模式代理模式提供了一个代理对象，可以控制对真实对象的访问，并可以在访问真实对象之前或之后添加额外的逻辑。

外观模式提供了一个统一的接口，用于访问子系统的一组接口。

通过使用外观模式，可以简化复杂系统的接口，使得系统更易于使用。

桥接模式桥接模式将抽象与实现进行分离，以便它们可以独立地变化。

《Head First设计模式》阅读笔记1、模式（Pattern）定义策略（Strategy）模式：定义一组算法族，分别封装起来，让各个算法之间可以相互替换。

此模式让算法的变化独立于使用算法的客户。

观察者模式：定义了对象之间的一对多依赖关系，当一个对象（主题对象）的状态改变时，它的所有依赖者（观察者对象）都会收到通知并自动更新。

装饰者模式：动态地将责任加到对象身上。

如果要扩展功能，装饰者模式提供了比继承更有弹性的替代方案。

*用静态方法定义的工厂被成为静态工厂，这样就不用使用创建对象的方法来实例化对象，使用方便。

但是这样做的缺点是无法通过继承来改变创建方法的行为。

*简单工厂不是一种设计模式，但是它比较常用。

*工厂方法用来处理对象的创建，并将这样的行为封装在子类中。

这样，客户程序中关于超类的代码就和子类对象的创建代码解耦（Decouple）了。

工厂方法的定义：abstract Product factoryMethod(String type);工厂（Factory Method Pattern）方法模式：定义了一个创建对象的接口，但是由子类来决定要实例化的类是哪一个。

它让类把实例化推迟到了子类。

抽象工厂模式：提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。

单件（Singleton）模式：确保一个类只有一个实例，并提供一个全局访问点。

命令（Command）模式：将“请求”封装成对象，以便使用请求、队列或日志来参数化其它对象。

命令模式也支持可撤销的操作。

适配器模式：将一个类的接口，转换成客户希望的另一个接口。

适配器让原本接口不兼容的类合作无间。

外观模式：提供了一个统一的接口，用来访问子系统中的一群接口。

外观模式定义了一个高层接口，让子系统更容易使用。

迭代器模式：提供一种顺序访问集合对象中各个元素的方法，而又不暴露其内部的表示（也就是数据结构）。

组合模式：将对象组合成树状结构来表现“整体/部分”的层级结构，让客户以一致的方式来处理个别对象以及对象组合。

Head First 设计模式概述Head First 设计模式是一本由埃里克·弗里曼（Eric Freeman）和伊丽莎白·弗里曼（Elisabeth Freeman）共同著作的畅销书籍。

本书旨在通过幽默而易懂的方式，向读者介绍常见的设计模式，并教导读者如何应用这些设计模式来解决实际的软件设计问题。

本文将对《Head First 设计模式》进行分析和总结，并探讨其对软件开发的影响。

内容概述《Head First 设计模式》一书共包含23种常见的设计模式，这些设计模式被分为三个不同的类别：创建型模式、结构型模式和行为型模式。

在每个模式的介绍中，作者通过生动的例子和图示，以及清晰的解释，帮助读者理解模式的概念和实际应用。

创建型模式创建型模式在对象的创建过程中提供了一种更加灵活且易于扩展的方式。

《Head First 设计模式》详细讲解了以下四种创建型模式：1.工厂模式（Factory Pattern）：工厂模式通过定义一个创建对象的接口，但是由子类决定要实例化的类是哪一个。

2.抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

3.单例模式（Singleton Pattern）：单例模式确保一个类只有一个实例，并提供对该实例的全局访问点。

4.建造者模式（Builder Pattern）：建造者模式使用多个简单的对象一步一步构建一个复杂的对象。

结构型模式结构型模式主要关注对象之间的组合，以创建更大的结构。

本书重点介绍了以下七种结构型模式：1.适配器模式（Adapter Pattern）：适配器模式将一个对象包装起来，以改变其接口。

2.装饰者模式（Decorator Pattern）：装饰者模式动态地将责任附加到对象上，以扩展其功能。

3.代理模式（Proxy Pattern）：代理模式为其他对象提供一种代理以控制对这个对象的访问。

headfirst设计模式读书总结——命令模式在本章，我们将把封装带到一个全新的境界：把方法调用(method invocation)封装起来。

通过封装发发调用，我们可以把运算块包装成形。

所以调用此运算的对象不需要关心事情是如何进行的。

只要知道如何使用包装成形的方法来完成它就可以。

通过封装方法调用，也可以做一些很聪明的事情，例如记录日志，或者重复使用这些封装来实现撤销(undo)。

题例：家电自动化设计一个家电自动化遥控器的API。

这个遥控器具有七个可编程的插槽，每个插槽都有对应的开关按钮，这个遥控器还具备一个整体的撤销按钮。

希望你能够创建一组控制遥控器的API，让每个插槽都能够控制一个或一组装置，能够控制目前的装置和任何未来可能出现的装置，这一点很重要。

(这里有一组Java类，这些类时由多个厂商开发出来的，用来控制家电自动化装置，例如点灯，风扇，热水器，音响设备和其他类似的可控制装置。

)上面是很多的厂商类，看不清不要紧。

你只要知道它很多，控制各种电器。

有许多类都具备on()和off()方法，除外还有其他的一些方法。

遥控器应该知道如何解读按钮被按下的动作，然后发出正确的请求，但是遥控器不需要知道这些家电自动化的细节，或者如何打开热水器。

提示：命令模式可将“动作的请求者”从“动作的执行者”对象中解耦，在我们的题例中，请求者是遥控器，而执行者对象就是厂商类。

利用命令对象，把请求(打开点灯)封装成一个特定对象(客厅点灯对象)，如果对每个按钮都存一个命令对象，那么当按钮被按下的时候，就可以请命令对象做相关的工作，遥控器并不需要知道工作内容是什么，只要有个命令对象能和正确的对象沟通，把事情做好久可以了。

命令模式的简单介绍(如果你已经理解命令模式可以不看下面的例子)餐厅解析：研究顾客，女招待，订单，以及快餐厨师之间的交互。

1：你，也就是顾客，把订单交个女招待。

2：女招待拿了订单放在订单柜台，然后喊了一声“订单来了”。

读《⼤话设计模式》和《headfirst设计模式》⼼得1.⾯向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。

2.如果你能够想到多于⼀个的动机去改变⼀个类，那么这个类就具有多于⼀个的职责。

就⼀个类⽽⾔，应该仅有⼀个引起它变化的原因。

3.开放－封闭原则是⾯向对象设计的核⼼所在。

遵循这个原则可以带来⾯向对象技术所声称的巨⼤好处，也就是可维护、可扩展、可复⽤、灵活性好。

开发⼈员应该仅对程序员呈现出频繁变化的那些部分做出抽象，然⽽，对于应⽤程序中每个部分都刻意地进⾏抽象同样不是⼀个好主意。

拒绝不成熟的抽象和抽象本⾝⼀样重要。

⾯对需求，对程序的改动是通过增加新代码进⾏的，⽽不是更改现有的代码。

4.⾥⽒代换原则：⼦类型必须能够替换掉它们的⽗类型。

只有当⼦类可以替换掉⽗类，软件单位的功能不受到影响时，⽗类才能真正被复⽤，⽽⼦类也能够在⽗类的基础上增加新的⾏为。

（企鹅不能继承鸟类！）5.迪⽶特法则（最少知识原则）：在类的结构设计上，每⼀个类都应当尽量降低成员的访问权限，也就是说，⼀个类包装好⾃⼰的private状态，不需要让别的类知道的字段或⾏为不要公开。

如果两个类不必彼此直接通信，那么这两个类就不应当发⽣直接的相互作⽤，可以通过第三⽅转发这个调⽤。

也就是说，不要对具体的实现编程，应该对接⼝编程。

6.合成/聚合利⽤原则：尽量使⽤合成/聚合，尽量不要使⽤类继承。

继承是⼀种强耦合，组合是⼀种弱耦合。

7.每个地⽅都采⽤开放－关闭原则，是⼀种浪费，也没必要，还会导致代码变得复杂且难以理解。

我们需要把注意⼒集中在设计中最有可能改变的地⽅，然后应⽤开发-关闭原则。

这牵涉到设计OO系统的经验，和对你⼯作领域的了解。

8.要依赖抽象，不要依赖具体类。

下⾯的指导⽅针，能帮你避免在OO设计中违反信赖倒置原则：1>变量不可以持有具体类的引⽤;2>不要让类派⽣⾃具体类;3>不要覆盖蕨类中已实现的⽅法。

读headFirst设计模式-策略模式有些⼈已经解决你的问题了什么是设计模式？我们为什么要使⽤设计模式？怎样使⽤？按照书上的说法和我⾃⼰的理解，我认为是这样的：我们遇到的问题其他开发⼈员也遇到过，他们利⽤他们的智慧和经验将问题解决了，把他们解决问题的⽅法提炼总结出来使其能解决其他同类问题。

使⽤设计模式是为了更⽅便快捷的解决问题。

把模式装进脑⼦⾥，然后在你的设计和已有的应⽤中，寻找何处可以使⽤这些模式，以往是代码复⽤，现在是经验复⽤。

先把书上的例⼦过⼀遍，简单的鸭⼦模拟应⽤Joe所在的公司决定开发⼀款模拟鸭⼦的应⽤。

系统中有各种鸭⼦，鸭⼦可以游泳，可以呱呱叫，各种鸭⼦有不同的外观。

此系统建⽴了⼀个鸭⼦的基类，其中有游泳的⽅法swim，有呱呱叫的⽅法quack，有显⽰鸭⼦外貌的⽅法display。

每种鸭⼦的外貌不同，必须在其⼦类中重写display⽅法。

就像这样：由于竞争加剧，公司决定搞定不⼀样的东西：“嘿，Joe，我想鸭⼦应该能飞！”，“嗯, 这个听起来很容易”，在Duck中加⼀个fly⽅法就⾏了。

过了⼏天，公司开会，“Joe，怎么会有⼀只橡⽪鸭（RubberDuck，不会飞，吱吱叫）在屏幕⾥⾯飞来飞去？”，好吧，这是Joe疏忽了，只有真正的鸭⼦能飞，橡⽪鸭会叫，会游泳但是不会飞，马上修复(覆盖RubberDuck中的fly⽅法, 让它什么也不做)。

但是如果我需要⼀只诱饵鸭（DecoyDuck，不会飞也不会叫）呢，也在⼦类中重写quack和fly⽅法？Joe还收到通知，此系统还会不定时更新，⾄于怎么更新还没有想到，于是Joe意识到继承不是⼀个好⽅法，因为每添加⼀个鸭⼦的⼦类，他就要被迫检查该⼦类的quack和fly⽅法并可能需要重写他们，如果直接修改⽗类中的⽅法，但有些⼦类并不想修改，那么这些⼦类就都要重写这些⽅法。

继承所采⽤的代码Duckpublic abstract class Duck {public void quack(){System.out.println("呱呱叫");}public void swim(){System.out.println("游泳");}//每个鸭⼦的外观不同, 在⼦类中实现public abstract void display();//鸭⼦飞⾏的⽅法public void fly(){System.out.println("飞⾏");}}View CodeMallardDuck/*** 外观是绿⾊的鸭⼦*/public class MallardDuck extends Duck {@Overridepublic void display() {System.out.println("绿头鸭");}}View CodeRubberDuck/*** 橡⽪鸭* 橡⽪鸭不会呱呱叫(quack), ⽽是吱吱叫(squeak)*/public class RubberDuck extends Duck {@Overridepublic void display() {System.out.println("可爱的黄⾊橡⽪鸭");}//橡⽪鸭不会呱呱叫(quack), ⽽是吱吱叫(squeak)@Overridepublic void quack() {System.out.println("橡⽪鸭吱吱叫");}//橡⽪鸭不会飞@Overridepublic void fly() {}}View CodeDecoyDuck/*** 诱饵鸭, 不会飞也不会叫*/public class DecoyDuck extends Duck {@Overridepublic void display() {System.out.println("诱饵鸭");}@Overridepublic void quack() {System.out.println("什么都不会做, 不会叫");}@Overridepublic void fly() {System.out.println("什么都不做, 不会飞");}}View Code采⽤接⼝呢将⾏为抽离出来，⽐如将fly⽅法抽离出来放到Flyable接⼝中，只有会飞的Duck的⼦类才实现该接⼝，同样的也可以将quack⽅法抽离到Quackable接⼝中。