深入浅出设计模式

出版时间：2005-11-1  出版社：东南大学出版社  作者：弗里曼  页数：638  
Tag标签：无  

内容概要

　　你不想重新发明车轮（或者更差的是，没有充气车胎的轮子），所以你从设计模式中寻求帮助——设计模式是过去人们面对同样的软件设计问题所得到的经验。 有了设计模式，就可以利用其他人的实践经验的精华，因此省下的时间可以用在其他的事情上，如：更有挑战性的事情、更复杂的事情以及更有趣的事情。你想要学习：　　·重要的模式 ；　　·何时使用某个模式，为何使用该模式；　　·如何在你自己的设计中马上采用这些模式；　　·何时不该使用该模式（如何避免滥用模式）；　　·某个模式是依据哪些面向对象设计原理而设计出来的。　　更重要的是，你想在学习设计模式的过程中，不感觉到昏昏欲睡。如果你曾经读过任何一本深入浅出（Head First）系列书籍，你就会知道能够从本书中得到的是：透过丰富的视觉效果让你的大脑充分地运作。本书的编写运用许多最新的研究，包括神经生物学、认知科学以及学习理论，这使得这本书能够将这些设计模式深深地烙印在你的脑海中，不容易被遗忘。你将会更擅长于解决软件设计中的问题，并能够和你的团队成员用模式的语言来更好地沟通。

作者简介

作者：(美)弗里曼Eric Freeman以及Elisabeth Freeman是作家、教育家以及技术发明者。他们在迪斯尼公司领导了四年的数字媒体以及因特网的开发,后来他们将这些经验应用在他们自己的媒体中,包括这本书中。Eric具有耶鲁大学的计算机科学博士学位,Elisbeth具有耶鲁大学的计算机科学硕士学位。    Kathy Sierra(javaranch.com的创始者)以及Bert Bates是畅销的“深入浅出”(Head First)系列书籍的策划者,也是Sun公司Java开发员认证考试的开发者。

书籍目录

Intro1  Welcome to Design Patterns：an introduction2  Keepingyour Objects in the know：／he Observer Pattern3  Decorating Objects：the Decorator Pattern4  BakingwithOO goodness：the FactoryPattern5  One of aKindObjects：the SingletonPattern6  Encapsulating Invocation：the Command Pattern7  BeingAdaptive：theAdapterandFacadePatterns8  Encapsulating Algorithms：the Template Method Patterm9  Well—managed Collections：the Iterator and Composite Patterns10  The State ofThings：the State Pattern11  Controlling Objcct Access：the Proxy Pattern12  Patterns of Patterns：Compound Patlerns13  Patterns in the Real World：Better Living with Patterns14  Appendix：Leftover Patterns

媒体关注与评论

书评本书荣获2005年第十五届Jolt通用类图书震撼大奖。　　“我昨天收到了这本书，然后就开始阅读……我简直欲罢不能。酷毙了！内容相当有趣，涵盖层面很广，而且切中要点。这本书让我感到印象深刻。”　　　　　　　　　　　　　　　　——Erich Gamma，IBM顶级工程师、《Design Patterns》作者之一    “我感到读这本书的效果等同于读一千磅重的同类书的效果。”                              ——Ward Cunningham，Wiki发明者、Hillside Group创始人    “本书趋近完美，因为它在提供专业知识的同时，仍然具有相当高的可读性。叙述权威、文笔优美。”                                  ——David Gelernter，耶鲁大学计算机科学系教授    “这是我阅读过的最有趣且最聪明的软件设计书籍之一。”                                   ——Aaron LaBerge，ESPN.com技术副主席

编辑推荐

☆本书荣获2005年第十五届Jolt通用类图书震撼大奖 ☆"我昨天收到了这本书,然后就开始阅读……我简直欲罢不能。酷毙了!内容相当有趣,涵盖层面很广,而且切中要点。这本书让我感到印象深刻。" 　　　——Erich Gamma,IBM顶级工程师、《Design Patterns》作者之一☆"我感到读这本书的效果等同于读一千磅重的同类书的效果。"——Ward Cunningham,Wiki发明者、Hillside Group创始人☆"本书趋近完美,因为它在提供专业知识的同时,仍然具有相当高的可读性。叙述权威、文笔优美。"——David Gelernter,耶鲁大学计算机科学系教授☆"这是我阅读过的最有趣且最聪明的软件设计书籍之一。" ——Aaron LaBerge,ESPN.com技术副主席☆If you want to UNDERSTAND Java, go buy this book.　　"Head First Java"... gives new meaning to their marketing phrase "There's an O Reilly for that." I picked this up because several others I respect had described it in terms like "revolutionary' and a described a radically different approach to the textbook. They were (are) right... In typical O'Reilly fashion, they've taken a scientific and well considered approach. The result is funny, irreverent, topical, interactive, and brillliant...Reading this book is like sitting in the speakers lounge at a view conference, learning from and laughing with-peers... If you want to UNDERSTAND Java, go buy this book."   你不想重新发明车轮(或者更差的是，没有充气车胎的轮子)，所以从设计模式中寻求帮助，设计模式是过去人们面对同样的软件设计问题所得到的经验。有了设计模式，就可以利用其他人的实践经验的精华，因此省下的时间可以用在其他的事情上，如：更有挑战性的事情、更复杂的事情以及更有趣的事情。你想要学习：　　·重要的模式　　·何时使用某个模式，为何使用该模式　　·如何在你自己的设计中马上采用这些模式　　·何时不该使用该模式(如何避免滥用模式)　　·某个模式是依据哪些面向对象设计原理而设计出来的　　更重要的是，你想在学习设计模式的过程中不感觉到昏昏欲睡。如果你曾经读过任何一本"深入浅出"(Head First)系列书籍，你就会知道能够从《深入浅出设计模式》(影印版)中得到的是：透过丰富的视觉效果让你的大脑充分地运作。

用户评论 (总计53条)

•   书是我读书的时候买的，看了一大半，但没看完。 在面试的时候跟面试官掰了一些，后来就放那儿了， 工作了一段时间后，发现真应该详细看看。 这本书以图为主的讲解方式，我很喜欢，比那本薄薄的设计模式容易理解，别看它厚，可看的时候很快，讲得很细致
•   非常好的一本书，通俗易懂，深入浅出推荐~~~
•   质量好！绝对正版，很有帮助的，实用
•   这本书只有亚马逊有卖，head first系列的书看起来都很有趣，书的内容很好，插图很丰富，本来还想买head first java影印版，但现在已经没卖了，有点可惜，希望能重印head first java影印版
•   花了1个多月的时间看完，讲了13个常用的模式，其它11个并不是很常用，所以书里只是提了一个，如果你有经验，会发现原来设计模式并不深奥，学好模式，对于看一些开源框架的源代码的理解很有帮助，这本书需要你最好有6级的英文水平，否则看起来还是比较吃力的，生词会海量地涌来。我是边看边查词典，既学英语，又学技术，对于计算机英语的提高亦有好处，编程里有一些词在字典里是查不到的，比如多态，polymorphism，在书里却可以学到。既然是headfirst系列的，少不了生动活泼的风格，书中经常模拟师生对话来阐明某个模式的方方面面，讲得很详细，尽管有时候看起来都有点啰嗦了，例子举得不是太好，有的例子篇幅过长，实践起来没有必要，比如建造者模式，我打印出来，代码有15页，花了1个小时才全部type完。不管怎么说，写得要比阎宏的《java 与模式》好得多。那本例子举得不好，不是猪八戒就是孙悟空的，总以为读者理解不了似的，弄出那么多比喻来，弄巧成拙，例子写得也不好，不全。
•   英文的，不过语言容易看懂和理解，想学习模式的话值得一看的
•   写得通俗易懂，正好也练练英文，我是配合着《大话设计模式》来看的，觉得效果不错。
•   真真正正的“深入浅出”。强烈推荐。
•   写得通俗易懂，深入浅出，主要是很有趣，能抓住读者的心，步步引导深入，无形中得到提升，与一般让人一看就乏困的书相比，本书的确相当好
•   书真的好旧啊。。同学都说是旧书。还那么贵。。。书特别脏。。不过里面还不错。
•   很好很好呀，经典就是经典！
•   还是看原版比较好，讲的非常透彻而且易懂
•   很不错的一本书，可以学习到很多东西，看英文版不用忍受蹩脚的翻译
•   感觉作者实际工作经验不够丰富，只举些小猫小狗的例子来说事。读起来没有脚踏实地的感觉。
•   好书~推荐购买。配合大话设计模式看
•   这本书讲得浅显易懂，随时英文，但是读起来也还行，推荐购买
•   通俗易懂幽默风趣，当然这种方式不是每个人都喜欢
•   设计模式的入门好书，读着不犯困。难能可贵
•   非常喜欢里面的例子和解释。
•   设计模式入门书
•   封面很诱惑哦
•   收藏起来再说！以后慢慢看！
•   书店尾货
•   Head First系列里最经典的一本
•   设计模式的经典
•   这本书可是！！
•   书不错，值得买，绝对划算
•   真的是“深入浅出”
•   　　。。。。。。书评开始捏。。。。。。
  　　为了让自己真正的读一本书（源自《如何读一本书》），所以开始练习写书评，对自己学到的东西进行总结，也为以后复习提供便利。以后也会对这篇书评进行不断的修改，希望自己能够进步~~~~~~啦啦啦~~~~~~
•   　　确实是一本很不错的书，值得去看看，特别是刚开始入门的，图文并茂，谅解的很透彻！！！不看你会后悔的哦！！！
•   　　这本书写得挺好的，通俗易懂。以前买了那本GoF的书，试图看了几遍也没看完几个模式。每页的信息量不大，书特别厚，所以看完以后会有一种错觉：看完了好厚一本书！
  　　这本书把设计模式讲清楚的同时把一些OO思想也解释得很清楚，至少在合上书的时候”多用组合，少用继承“这个原则已经牢记于心。
  　　
  　　1. 代码虽然是Java写的，但是很好懂
  　　书中的设计模式是以Java代码展现的，不过学过C++的也能看懂，用C++实现也不是很难，注意以下几点就可以了：
  　　* Java里的对象：类似C++里对象的引用
  　　* Java里的接口：在C++里，把类里的函数声明为类似 virtual void f() = 0 就可以了
  　　* 当谈到“Java不支持多重继承，所以只能...”时，会心一笑就可以了
  　　
  　　2. 知道设计模式以后才知道代码之后的原理
  　　初学Java的IO时，经常会碰到下面的代码（代码来源于stackoverflow）：
  　　 First open an inputstream of it:
  　　 > FileInputStream fis = new FileInputStream("/objects.gz");
  　　 We want speeeed, so let's buffer it in memory:
  　　 > BufferedInputStream bis = new BufferedInputStream(fis);
  　　 The file is gzipped, so we need to ungzip it:
  　　 > GzipInputStream gis = new GzipInputStream(bis);
  　　以上的代码写成一行就是 GzipInputStream gis = new GzipInputStream(new BufferedInputStream(new FileInputStream("/objects.gz")));
  　　其实上面用的就是装饰者模式。知道这个模式之前，可能不知道为什么要那样写，为什么能那样写；知道之后，对代码后面的世界又有了进一步的理解。
•   　　之前只在语言本身的层面徘徊，却从没想过，在对象之上还有如此beautiful 的经验化方法，所谓设计模式不像语言本身一些确定的语法条目，或是像算法，有一个固定的执行流。这才是设计的伟大之处，也是更能够体现程序员设计水平和个人造诣的东西。
  　　竟然抱着坛子上下的非清晰扫描版看了好久。确实生动简单易懂的例子对于设计模式本身的理解很有好处。之前一直不喜欢这种写作风格，所谓道可道非常道。觉得每一个具体的例子往往就能让读者的理解陷入偏颇，或是思维受到限制。但如今才发现，往往对于一些抽样的模式之类却是肯定需要生动有趣的例子来理解，随着理解的加深，变回逐渐从局部转向更为全面。
  　　读罢有一个概念一直在脑中徘徊，设计模式追求的是清晰，易于维护，易于扩展的代码。不管是接口的封装，变和不变的分离，开放扩展，关闭修改，都是为了追求高效稳定，易于维护和扩展的代码。这也是现代面向软件设计的核心。从语言数据结构到设计模式，确是一个很大的跳跃。
  　　深入浅出，当之无愧。
•   　　2010年开始接触设计模式，当时看的是《大话设计模式》，翻完，没啥实质领悟。也许是当年修行不够悟道不深。之后几年里设计模式对于我还是一个自认为不能理解好的领域，买了四人帮的书也丢在一边。因为工作中主要用C，而模式多用面向对象语言描述。我一直在思考如何在C中采用面向对象的观点来解耦，让模块更清晰可读。3年里敏捷、重构，折腾了不少次，慢慢也能写出让自己满意的代码。今年觉得有点底子了，终于下决心再次学习设计模式，买了这本最最深入浅出的，居然看得很清晰很明白。很多地方都留下了自己的笔记。突然间觉得这几年的功夫没白费，可能自己并没有去可以学习、套用模式，但已经在工作实践中不自觉地运用了很多模式。
  　　下一步，再认真读一遍四人帮的书，再次感悟下经典教材。
•   　　利用公交时间读完了这本书，很是不错，可看作入门书。
  　　
  　　入门后想读一些设计模式汇总的书，望豆油们推荐一本
  　　
  　　可恶的书评，不能简短评论么
•   　　第一次接触Head First系列的时候是，head first web，刚开始并不是很感冒，那本书是中文版。这次偶然地从图书馆借了本 Head First Design Patterns （英文版），一下子被里面的英语表达方式吸引住了。对，我是从喜欢读书中的英文句子转而喜欢上该系列的书的。而且，在阅读的过程中，我发现它讲解的具体、易懂。值得推荐
•   　　这是我看过最幽默最搞笑最亲切同时又让我收获巨大的技术书籍！
  　　
  　　森森的膜拜Freeman(s)！Amen！
  　　
  　　深入浅出，娓娓道来，有的地方能笑死你！
  　　
  　　不知是翻译还是原著的问题，有几个小地方有点小错误，个人观点，值得商榷。但是瑕不掩瑜啦！
  　　
  　　其实我最先买的那本是四人帮写的，四人帮那本是这本书的五分之一厚。但是这本书我只花了三天时间就读完了！
  　　
  　　想学Design Patter吗？赶紧买来看！强烈推荐！
  　　
  　　
•   　　此书适合初学设计模式的，并且有一两年工作经验的更好，并且自己在工作中遇到很多重复代码，自己感觉很垃圾的代码，却找不到好的方法更改的时候，你就看这本书把。你需要对多态非常了解哦。晚绑定啥的。不然看起来也费劲的，俺是C# 书今天刚到， 感觉非常好
•   　　算是第三遍了吧
  　　
  　　第一遍的时候是刚学java的时候看电子书，当时连策略模式都没看明白，看不下去就放弃了。
  　　
  　　第二遍是前段时间看的，大概6月份吧，看的时候比第一次看的时候要顺利很多，明白了挺多的东西，当然也有挺多不明白，反复看也不明白的。但是看到状态模式及往后的时候就多少有点对付事的感觉了，像我在读畅销书时候的读法，大概粗略的扫上一遍就完事了。附录中的剩余的模式根本就没看。
  　　
  　　第三遍是搬到现在住的地方开始看的，果然又比第二遍的时候感觉好了很多。甚至有挺多第二遍没明白的模式，在我翻到目录的时候就想到是怎么回事了，翻开书页一看，果然是我想的那样，感觉很舒服。
  　　
  　　昨天看了状态模式，记得第二遍看的时候觉得挺复杂的，现在倒也觉得没那么复杂了。不知道即将看的代理模式和复合模式会怎么样呢？
  　　
  　　现在的问题是，我看了，但是没太能记住，而且工作中写代码，觉得什么都是可以用，但是又无论如何套不到我看的书里面，怎么办呢？是因为我还没有理解么？还是说因为我只是看了书而没有写代码？
  　　
  　　下次看本别的书辅助一下
  　　
  　　
  　　==============以上是2012年7月26日写的==========
  　　
  　　第四遍(*^__^*)
  　　
  　　最近不知道怎么想的，又把这书翻出来看，貌似又有些新的感觉，记的比以前多了，依然存在的问题是，工作中不知道怎么用，似乎还是处在死记硬背的阶段，咋整？难道是因为我只是看书，而没有实际去画UML类图，也没有写代码的原因么？这确实是个问题，可是，如果真的抱着电脑去写代码，肯定写着写着就变成上网了。。。
  　　=============以上写于2014/2/11==============
  　　
  　　2014/2/23的下午，终于又读完了一遍，看起来有了新的收获。
•   　　【strategy】 defines a family of algorithms, encapsulate each one and make them interchangable. strategy lets the algorithm vary independently from clients that use it.
  　　
  　　【observer】 defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.
  　　
  　　【decorator】 attach additional responsibilities to an object dynamically. decorator provide a flexible alternative to subclssing for extending functionality.
  　　
  　　【abstract factory】 provide an interface for creating famiilies of related or dependent objects without specifing their concrete classes.
  　　
  　　【factory method】 defines in interface for creating an object, but let subclss to decide which class to instantiate. factory method lets a class defer instantiation to the subclasses.
  　　
  　　【singleton】 ensure a class only has one instance and provide a gloval point of access to it.
  　　
  　　【command】 encapsulates a request as a object, thereby letting you parametrize clients with different request, quese or log request, and support undoable operations.
  　　
  　　【adaptor】 converts the interface of a class into another interface that clients expect. lets classes work together that couldn't otherwise because of incompatible interface.
  　　
  　　【facade】 provides a unified interface to a set of interfaces in a subsystem. facade defines a higher-level interface that makes the subsystem easier to use.
  　　
  　　【template】 define the skeleton of an algorithm in an operation, deferring some steps to subclasses. template method lets subclasses redefine certain steps of an algorithm without changing the algorithms' structure
  　　
  　　【iterator】 provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
  　　
  　　【composite】 compose objects into tree structure to represent part-whole hierachies. composite lets client treat individual object and compositions of objects equally.
  　　
  　　【state】 allow an object to alter its behavior when its internal state changes. the object will appear to change its class.
  　　
  　　【proxy】 provides a surrogate or placeholder for another object to control access to it.
  　　
  　　【compound】 i.e. MVC
•   　　1.策略模式(Strategy)
  　　 定义算法，将他们分别封装起来，让他们可以相互替换，让算法变化对客户端透明。
  　　2.观察者模式(Observer)
  　　 解耦一系列对象的通知状态。定义对象之间的一对多依赖，当一端对象发生变换，通知多端。
  　　3.装饰模式(Decorator)
  　　 动态将责任附加到对象上。对扩展开放，对修改封闭。
  　　4.工厂模式(Factory)
  　　工厂方法：定义一个创建对象的接口，由子类实现这个接口决定怎样创建具体类。工厂方法把对象的创建延迟到子类。
  　　抽象工厂：定义一个接口，用于创建相关或依赖对象的家族，而不明确指定具体类。
  　　5.单例模式(Singleton)
  　　 确保一个类只有一个实例，并且提供一个安全的全局访问点。
  　　如果对多线程没有要求，可以直接在静态方法中创建。
  　　如果存在资源竞争，采用“饿汉”方式创建。
  　　如果jdk4之后，可有采用double checked locking
  　　6.命令模式(Command)
  　　 将请求封装成对象，以便使用不同的请求，队列或者日志来参数化其他对象。
  　　7.适配器模式(Adapter)
  　　 改变一个接口成为一个客户端希望的样子。让原本不兼容的接口能够相互合作。
  　　8.外观模式(Facade)
  　　 简化系统接口，对客户端提供一个简单接口。
  　　9.模板方法模式(Template Method)
  　　 在方法中定义一个算法的骨架，而将一些步骤延迟到子类实现。使子类在不改变算法结构的情况下，重新定义算法的某些步骤。
  　　10.迭代器模式(Iterator)
  　　 提供一种方法顺序访问集合中的每个元素，而又不暴露其内部的表示。
  　　11.组合模式(Composite)
  　　 允许你将对象组成树形结构来表现“整体/部分”的层次结构。组合能让客户端以一致的方式处理个别对象和对象组合。
  　　12.状态模式(State)
  　　 允许对象内部状态改变时，改变它的行为，对象看起来就行修改了它的类。
  　　13.代理模式(Proxy)
  　　 为对象提供一个替身或者占位符来访问这个对象。
  　　14.复合模式
  　　 结合多个模式，组成一个解决方案。
  　　 MVC中：
  　　 M：观察者模式
  　　 V：组合模式
  　　 C：策略模式
•   　　第一次读的时候是几年前，就被深深吸引了。当时还是同事买。连续几天都在。那时刚做编程也就是一年多了，在积累到了一定的程度之后，这本书刚好可以为自己打开一扇门。知道了很多设计模式，正式自己苦苦追寻的一种改变。吸收了这些，对自己的架构能力有很大的提升。
  　　同时这本还是比较幽默生动的。代码也很容易理解。而且还有后面的知识总结。谈话。等等，都非常不容错。
  　　非常推荐新手或者有一定基础的人去看。同时也要自己写那些代码。
  　　过了几年再去温习，也是非常有收获的
•   　　 接触这本书之前，我不知道设计模式是什么。但读完这本书之后，让我对于项目的设计充满了兴趣，也理解了为什么有些人一辈子只能够做低级的程序员，一些人的工作年龄只是增加了他的经验，仅是对于某种语言的API更加熟悉。而设计模式，能够增加我们的内在，让我们真正在编写代码的时候，会考虑到OO设计，会考虑到设计对于项目的影响，而促进你去改进自己的设计。
  　　 想要脱离仅仅作为一个程序员的人，感觉先从这入手吧。当然，需要有一些项目经验，才能更好地吸收。
•   　　1.策略模式(Strategy)
  　　 定义算法，将他们分别封装起来，让他们可以相互替换，让算法变化对客户端透明。
  　　2.观察者模式(Observer)
  　　 解耦一系列对象的通知状态。定义对象之间的一对多依赖，当一端对象发生变换，通知多端。
  　　3.装饰模式(Decorator)
  　　 动态将责任附加到对象上。对扩展开放，对修改封闭。
  　　4.工厂模式(Factory)
  　　 * 工厂方法：定义一个创建对象的接口，由子类实现这个接口决定怎样创建具体类。工厂方法把对象的创建延迟到子类。
  　　 * 抽象工厂：定义一个接口，用于创建相关或依赖对象的家族，而不明确指定具体类。
  　　5.单例模式(Singleton)
  　　 确保一个类只有一个实例，并且提供一个安全的全局访问点。
  　　 * 如果对多线程没有要求，可以直接在静态方法中创建。
  　　 * 如果存在资源竞争，采用“饿汉”方式创建。
  　　 * 如果jdk4之后，可有采用double checked locking
  　　6.命令模式(Command)
  　　 将请求封装成对象，以便使用不同的请求，队列或者日志来参数化其他对象。
  　　7.适配器模式(Adapter)
  　　 改变一个接口成为一个客户端希望的样子。让原本不兼容的接口能够相互合作。
  　　8.外观模式(Facade)
  　　 简化系统接口，对客户端提供一个简单接口。
  　　9.模板方法模式(Template Method)
  　　 在方法中定义一个算法的骨架，而将一些步骤延迟到子类实现。使子类在不改变算法结构的情况下，重新定义算法的某些步骤。
  　　10.迭代器模式(Iterator)
  　　 提供一种方法顺序访问集合中的每个元素，而又不暴露其内部的表示。
  　　11.组合模式(Composite)
  　　 允许你将对象组成树形结构来表现“整体/部分”的层次结构。组合能让客户端以一致的方式处理个别对象和对象组合。
  　　12.状态模式(State)
  　　 允许对象内部状态改变时，改变它的行为，对象看起来就行修改了它的类。
  　　13.代理模式(Proxy)
  　　 为对象提供一个替身或者占位符来访问这个对象。
  　　14.复合模式
  　　 结合多个模式，组成一个解决方案。
  　　MVC中：
  　　M：观察者模式
  　　V：组合模式
  　　C：策略模式
  　　
•   　　极易入门的一本书，把设计模式讲的通俗易懂。配合大量图片，整本书显得生动有趣。让人读起来很是享受。
  　　
  　　但是这也使得整本书给人有点“不够夯实”的感觉，尽管书里讲的内容还是很权威的。大量异国文化的例子让人感觉很是陌生（什么鸭子，或者皮萨饼等等）。现编现用的例子给人感觉有点随意。个人觉得设计模式还是在有一定代码量的情况下学习效果更好，更容易让人引起共鸣（Personal View）。
  　　
  　　很适合初学者阅读，强烈推荐。
•   　　这是一本很轻松的书籍, 不属于难啃的学院派风格.
  　　但我还是断断续续看了接近一个月才看完, 工作实在太忙了, 每天只有在地铁上抽出一点时间来阅读. 这期间我总是看着看着就乐了, 就这样开心了一个月, 对设计模式也摸到了门道.
  　　书中介绍的都是一些基本的设计模式, 以附录的形式给出了部分较高级的模式.
  　　看完这本书, GOF的那本经典书籍还是无法绕过的, 而且更关键的是, 需要注意在平时的工作中多思考一些设计和OO原则
•   　　 这本书磕磕碰碰，一路啃下，还是颇有成就感的——第一次读完英文影印版的技术书籍，至少从表面上看这本书还是挺厚的大部头。去年在上个东家实习时起意学习设计模式，之所以选这本书，没有选四人帮那本《设计模式》，源于一同事的推荐。确实这是本好书，在此谢谢这位同事！不过读完这本书也生感慨——以后还是少看英文的，太累了，如果有翻译得不错的译本，还是译本吧——看英文版最明显的好处只是能在星巴克装文艺。
  　　
  　　 当初看这本书的序时，发现作者之一喜欢下围棋，还写过围棋对弈程序，大感亲切，发了封邮件给他欲交流计算机围棋，当然没有收到回件。磕磕碰碰看得不算轻松（六级没过），好在有朋友的鼓励——一位大牛对我说，设计模式是程序员进阶的必由之路，好好学。深然其说。
  　　
  　　 历来有对设计模式的批评，举其两例：
  　　
  　　 1）“设计模式让软件开发生搬硬套现成的模式。”
  　　
  　　 驳：软件需求千变万化，故软件设计的最高境界应当是无招胜有招——视需求变化，或用23种模式，或自创模式，举重若轻，不拘一格。但除非天纵奇才，无师自通，我等凡夫俗子还是需要学习已有的模式来“悟道”，以求更上一层楼。
  　　
  　　 2）“设计模式反映编程语言的缺陷。”
  　　
  　　 驳：对于C++这样的对软件工程支持不佳（我认为确实如此）的古代编程语言，确实需要些设计模式来实现复杂的设计。而对于一些“先进”的语言，很多设计模式显得多余，因为语言本身就包含了，或框架本身就实现了。以我相对熟悉的Objc为例，proxy pattern有着语言层面的支持，不需要那套复杂的结构；observer pattern有着框架层面的实现（Cocoa中的Notification)，也不需要自己写。但设计模式依然值得学习，乃至必须学习——若一直停留在应用层面而不去深究个中道理，那将永远停留在菜鸟阶段。例如我见过一牛人随手用C++写个引用计数的模板（boost库中的shared_ptr也支持引用计数），令我大为佩服——shared_ptr并不妨碍自己写一个引用计数模板。知其然亦知其所以然，应用时方能如鱼得水，驾轻就熟。
  　　
  　　 非常喜欢这本书每章的“套路”，1）给出软件需求，求设计。2）在不断的探讨中引入模式，并介绍该模式。3）为什么要这样设计，道理何在？然后引入一个面向对象原则。大致如此。这样的套路也正好说明，原则是道，模式为术。
  　　
  　　 设计需要溯本求源的思考，绝非23个模式所能囊括。针对本质设计，而非针对功能设计——这是本人极为认同的一句话。以移动开发为例，项目需求千变万化，还“朝三暮四”，唯有看清本质，才能对症下药。
  　　
  　　 “为学日益，为道日损。”
•   　　Head First系列。书的出发点很好，想让你知其然，更知其所以然。也确实做了比较大的努力。所以看起来和“传统的”技术书籍差别很大。遗憾的是，书中举得例子（如披萨店）和叙述、思维方式都是美国式的。如果你熟悉美国文化并具备美国式的交流和思维方式的能力。这本书无疑是非常适合的。但如果你和我一样，可能会稍有些不习惯。觉得还是“传统的”看起来顺一些。但我最后想说的是，认真看，努力跟着书里的思维方式。你会获益良多！
•   　　虽然只是刚看了第一章还没有全部看完，但可以确定的是这是我看过最寓教于乐的技术书籍。作者将要传达的知识点安置在有趣的对话中，让你捧腹大笑的同时思考这些问题将如何解决，正如前言所述这样的方式比起传统报告更容易让我们记忆深刻。
  　　另外值得一提的是书中的插图，它很好的丰富了文字的内涵，有助于我们理解作者要传达的信息。如果所有的技术书籍都能如此，那我们的学习成本将大大下降。
•   　　《Head first design pattern》向读者很好地展现了OOP的基本原则和常见的几种设计模式。对比经典但却晦涩难懂的GoF《设计模式》，可以发现Java比C++能更好解释设计模式，我想这应归功于Java的对象引用机制和interface关键字。当然这也跟本书中的例子浅显易懂，GoF中的例子来源于实际开发项目有关。若是想学习设计模式的话，这本书不可错过。这本书的写作风格与排版也很有创意，值得一看！
  　　
  　　赞同书末尾提到的Keep it simple(KISS)原则。学会了设计模式后不要手里拿着把锤子，看什么都成钉子，一遇到问题就想用设计模式去解决。设计模式是通过引入抽象层来提高代码的灵活性，但抽象层作为间接层在提高了代码的灵活性的同时也增加了复杂性，如果简洁的方案能解决问题就没必要杀鸡用牛刀动用设计模式。If you don't need it now, don't do it now.
  　　
  　　本书可以和GoF的《设计模式》、Bob大叔的《敏捷软件开发》交叉阅读，这几本书在内容上相互补充相得益彰。
  　　
  　　读书笔记：
  　　A Pattern is a solution to a problem in a context.
  　　
  　　Design Principle
  　　1, Identify the aspects of your application that vary and separate them from what stays the same.
  　　2, Program to an interface, not an implementation.
  　　3, Favor composition over inheritance.
  　　4, Strive for loosely coupled designs between objects that interact.(Observer)
  　　5, Classes should be open for extension, but closed for modification.(decorator)
  　　6, Depend upon abstractions. Do not depend upon concrete classes.(Abstract Factory)
  　　7, Least Knowledge Principle: Talk only to your immediate friends(Facade)
  　　8, The Hollywood Principle: Don't call us, we'll call you.(Template Method)
  　　9, Single responsibility Principle: A class should have only one reason to change.
  　　
  　　Strategy Pattern: defines a family of algorithms,encapsulates each one,and makes them interchangeable.Strategy Pattern let the algorithm vary independently from clients that use it.
  　　
  　　Observer Pattern: defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.
  　　
  　　Decorator Pattern: attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.
  　　
  　　Factory Method Pattern: defines an interface for creating an object, but lest subclasses decide which class to instantiate. Factory method lets a class defer instantiation to subclasses.
  　　
  　　Abstract Factory Pattern: provides an interface for creating families of related or dependent objects without specifying their concrete classes.
  　　
  　　Singleton Pattern: ensures a class has only one instance, and provides a global point of access to it.
  　　
  　　Command Pattern: encapsulates a request as an object, thereby letting you parameterize other objects with different requests, queue or log requests, and support undoable operations.
  　　
  　　Adapter Pattern: converts the interface of a class into another interface the clients expects. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
  　　
  　　Facade Pattern: provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher level interface that makes the subsystem easier to use.
  　　
  　　Template Method Pattern: defines the skeleton of an algorithm in a method, deferring some steps to subclass. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.
  　　
  　　Iterator Pattern: provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
  　　
  　　Composite Pattern: allows you to compose objects into tree structures to represents part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
  　　
  　　State Pattern: allows an object to alter its behavior when its internal state changes. The object will appear to changes its class.
  　　
  　　Proxy Pattern: provides a surrogate or placeholder for another object to control access to it.
  　　
•   　　不喜欢中国式教育的那种古板的书，那样很难免会遇到厌读的情绪~~~
  　　
  　　一本书的成功之处就是让人有兴趣并且乐于去读，对于技术类的书籍，能达到这一点是非常棒的。
  　　
  　　要想一次性完全读懂《head first 设计模式》是不可能的，而且个人认为设计模式不能乱用，有些时候用反而会更糟糕，这是初学者容易进入的最大的误区，唉，~~~新手努力起飞中
•   　　346页之后，是307页，一直到322页，然后是363页，咋回事啊？谁能解答？
  　　346页之后，是307页，一直到322页，然后是363页，咋回事啊？谁能解答？
  　　346页之后，是307页，一直到322页，然后是363页，咋回事啊？谁能解答？
  　　346页之后，是307页，一直到322页，然后是363页，咋回事啊？谁能解答？
  　　346页之后，是307页，一直到322页，然后是363页，咋回事啊？谁能解答？
  　　346页之后，是307页，一直到322页，然后是363页，咋回事啊？谁能解答？
  　　346页之后，是307页，一直到322页，然后是363页，咋回事啊？谁能解答？
  　　
•   　　如果是中国人想研究设计模式的话，力荐研磨设计模式（我觉得这本书挺罗嗦的），作者的思维逻辑非常清晰，轻松上手就可以明白透彻。
  　　评论太短了，评论太短了，评论太短了，评论太短了，评论太短了，评论太短了。
  　　还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了，还太短了。
•   我也觉得这本书很有趣