真是深入浅出！第一次读Head First时就被这种寓教于乐的风格震撼住了，虽然是英文，但用词很简单，相对GOF的书我更强烈推荐入门看这本。

最容易懂的和最有趣的关于design patterns书

某人硬塞给我的, 对于我这这种傻逼还是挺实用的.

在去哈尔滨滑雪的火车上，看完了这本书。

用“深入浅出”形容太贴切了！

好久不寫代碼，看看Design Patterns好親切。

第一本看完的英文原版～值得纪念

非常好啊，很有趣，有买其它的headfirst系列的冲动了

The Hollywood Principle  Don't call us, we'll call you. > The high-level components give the low-level components a "don't call us, we'll call you" treatment. > The Hollywood Principle gives us a w...

OO principles: Encapsulate what varies. “封装变化”是一条非常好的编程准则，在我看来不但适用于OO语言，也适用于面向过程的编程语言。例如可能会变化的代码封装到函数里面，当然，前提我们需要预见到哪些地...

一、定义：符合模式结合两个或以上的模式，组成一个解决方案，解决一再发生的一般性问题。 二、要点： 1、MVC是复合模式，结合了观察者模式、策略模式和组合模式。 2、模型使用观察者模式，以便观察者更新，同时...

一、定义：为另一个对象提供一个替身或占位符以访问这个对象。 二、要点： 1、代理模式为另一个对象提供代表，以便控制客户对对象的访问。管理访问的方式有许多种。 2、远程代理管理客户端和远程对象之间的交互。...

一、定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。 二、本章要点： 1、状态模式允许一个对象基于内部状态而拥有不同的行为。 2、和程序状态机不同，状态模式用类代表状态。 3、Cont...

本章节中介绍了迭代器与组合模式，还引入了一个新的OO原则：类应该只有一个改变的理由。 一、迭代器模式定义： 提供一种方法顺序访问一个聚合对象中的多个元素，而又不暴露其内部的标识。 二、组合模式定义： 允...

本章节中介绍了一种最常用的模式：模板方法模式，还引入了一个新的OO原则：别找我，我会找你。 一、模板方法模式： 在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算...

一、定义：将请求封装成对象，这可以让你使用不同的请求、队列，或者日志请求来参数化其他对象，命令模式也可以支持撤销操作。 二、要点： 1、命令模式将发出请求的对象和执行请求的对象解耦。 2、在北解耦的两者...

一、定义：确保一个类只有一个实例，并提供全局的访问点。 二、模式适用场景：有一些对象其实我们只需要一个，比方说：线程池、缓存、对话框、处理偏好设置和注册表的对象、日志对象、充当打印机、显卡等设备的驱...

一、OO新原则：依赖抽象，不要依赖具体类。 二、工厂模式章节主要讲解了三种不同的工厂： 1、简单工厂：简单工厂模式是将对象的创建者作为一个参数传入到使用的类当中，将类的创建和使用分开。简单工厂其实不是一...

定义：动态地将责任附加到对象上。想要扩展功能，装饰者提供有别于继承的另一种选择。 要点： 1、继承属于扩展形式之一，但不见得是达到弹性设计的最佳方式。 2、在我们的设计中，应该允许行为可以被扩展，而无须...

定义： 在对象间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。 要点： 1、观察者模式定义了对象之间一对多的关系。 2、主题（也就是可观察者）用一个共同的接口来更...

一、OO基础： 1、抽象 2、封装 3、多态 4、继承 二、设计原则： 1、封装变化：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。 2、针对接口编程，而不是针对实现编程。 3、多...

coffee example cost() function add ingredients Design Principle Classes should be open for extension, but closed for modification. Be careful when choosing the areas of code that need to be extende...

Chap1: introductory duck quack fly Favor composition over inheritance The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the a...

Don't feel alone if you said "whoa" the first (and second and third) time you looked at this API.

Chapter 01 Intro to Design Patterns 第01章 设计模式入门 1. Design Principle Identify the aspects of your application that vary and separate them from what stays the same.  (P9) 设计原则：找出应用中...

本来打算这周看完MVC部分的，看来没时间了，只能等到周一看了！代理模式讲的东西很多，需要一段时间才能消化，总的来说，速度的看了一遍，只能有些模糊的印象，更不要说完全吃透理解了。还欠缺的很。下周找个时间...

> In general, think of the Strategy Pattern as a flexible alternative to subclassing; if you are use inheritance to define the behavior of a class, then you're stuck with that behavior even if you ...

The State Pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class. > This is because the pattern encapsulate state into separate c...

Design Principle A class should have only one reason to change. Cohesion is a term  used as a measure of how closely a class or a module supports a single purpose or responsibility. We say a module...

The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. > The Iterator Patterns allows traversal of the elemen...

A hook is a method that is declared in the abstract class, but only given an empty or default implementation. This gives subclasses the ability to "hook into" the algorithm at various points, if th...

The Template Method Pattern defines a of an algorithm in a method, deferring some steps to subclasses. Template Methods lets subclasses redefine certain steps of an algorithm without changing the a...

The 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. The Principle of Least Knowled...

The 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. > This acts to ...

The command Pattern encapsulates a request as an object, thereby letting you parameterize objects with different requests, queue or log requests, and support undoable operations. The class diagram ...

public static synchronized Singleton getInstance(); By adding the synchronized keyword before getInstance(), we force every thread to wait its turn before it can enter the method. That is, no two t...

The concise definition of the pattern: > The Singleton Pattern ensures a class has only one instance, and provides global point of access to it. > What's really going on here ? We're taking a class...

Pattern Definitions: > The Factory Method Pattern defines an interface for creating an object, but lets subclasses decide whitch class to instantiate. Factory Method lets a class defer instantiatio...

The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes. > The AbstractFactory defines the interface that ...

No variable should hold a reference to a concrete class. > If you use new, you'll be holding a reference to a concrete class. Use a factory to get around that. No class should derive from a concret...

Design Principle   Depend upon abstraction. Do not depend upon concrete classes. > The dependency Inversion Principle makes and stronger statement about abstraction. Its suggests that our high-leve...

The Factory Method pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses. > As wi...

All factory patterns encapsulate object creation. The factory Method Pattern encapsulates object creation by letting subclasses decide what objects to create.

A factory method handles object creation and encapsulates it in a subclass. This decouples the client code in the super class from the object creation code in the subclass. abstract Product factory...

The Simple Factory isn't actually a Design Pattern; it's more of a programming idiom.

The Decorator Pattern attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

Design Principle: Classes should be open for extension, but closed for modification. > Our goal is to allow classes to be easily extended to incorporate new behavior without modifying existing code...

OO Basics > Abstraction、Ecapsulation、Polymorphsim、Inheritance. OO Principles > Encapsulate what varies. > Favor composition over inheirtance. > Program to interface, not implementation. > Strive...

針對接口編程，而不是針對實現編程

The Hollywood Principle  Don't call us, we'll call you.

> The high-level components give the low-level components a "don't call us, we'll call you" treatment.

> The Hollywood Principle gives us a way to prevent "dependency rot". (依赖腐败)

The connection between the Hollywood Principle and the Template Method Pattern is probably somewhat apparent: when we design with the Template Method Pattern, we're telling subclasses, "don't call us, we'll call you."

分开变化和不会变化的部分
针对接口（超类型）编程，而不是针对实现编程

开放-关闭原则：类应该对扩展开放，对修改关闭。

系統中的某部分改變不會影響其他部分

觀察者模式 = 出版者 + 訂閱者。

設計原則三：爲了交互對象之間的松耦合設計而努力。

設計原則四：類應該對擴展開放，對修改關閉。

A factory method handles object creation and encapsulates it in a subclass. This decouples the client code in the super class from the object creation code in the subclass.

abstract Product factoryMethod(Arguments args)

> 1. A factory method is abstract, so the subclasses are counted on to handle object creation.

> 2. A factory method returns a Product that is typically used within methods defined in the supercalss.

> 3. A factory method isolates the client (the code in the superclass, like orderPizza()) from knowing what kind of concrete Product is actually created.

> 4. A factory method may be parameterized (or not) to select among several vaiations of a Product.

The Factory Method pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

> As with every factory, the Factory Method Pattern gives us a way to encapsulate the instantiations of concrete types. Looking at the class diagram below, you can see that the abstract Creator gives you an interface with a method for creating objects, also known as "factory method." Any other method implemented in the abstract Creator are written to operate on products produced by the factory method. Only subclasses actually implement the factory method and create products.

Design Principle   Depend upon abstraction. Do not depend upon concrete classes.

> The dependency Inversion Principle makes and stronger statement about abstraction. Its suggests that our high-level components should not depend on our low-level components; rather, they should both depend on abstraction. ( A "high-level" component is a class with behavior defined in terms of other, "low-level" components.)

No variable should hold a reference to a concrete class.
> If you use new, you'll be holding a reference to a concrete class. Use a factory to get around that.

No class should derive from a concrete class.
> If you derive from a concrete class, you're depending on a concrete class. Derive from an abstraction, like an interface or an abstraction class.

No method should override an implemented method of any of its base classes.
> If you override an implemented method, then your base class wasn't really an abstraction to start with. Those methods implemented in the base class are meant to be shared by all your subclass..

The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

The concise definition of the pattern:
> The Singleton Pattern ensures a class has only one instance, and provides global point of access to it.

> What's really going on here ? We're taking a class and letting it manager a single instance of itself. We're also preventing any other class form creating a new instance on its own. To get an instance, you've got to go through the class itself.

>We're also providing a global access point to the instance: whenever you need an instance, just query the class and it will hand you back the single instance. As you've seen, we can implement this so that the Singleton is created in a lazy manner, which is especially important for resource intensive objects.

By adding the synchronized keyword before getInstance(), we force every thread to wait its turn before it can enter the method. That is, no two threads may entry the method at the same time.
……it looks fairly expensive to synchronize the getInstance() method. And the following is some way to fixed it.

1. Do nothing if the performance of getInstance() isn't critial to your application.

2. Move to an eagerly created instance rather than a lazily.

Head First Design Patterns

本影印版刚拿到手,感觉沉甸甸的,第一印象就不错，网上评价也很好。恰巧快到春节，于是在书架一大堆的书籍中，我只选择这本比较厚重的，塞到我的行李包中。  翻开一看,真如Erich Camma所说,简直欲罢不能.本书是Oreilly的Head First系列中的一本，本系列书籍的特点是采用大量的插...

Head First Design Patterns让设计模式走向大众

写得很有趣，图文并茂，比起四人帮的那本，好懂了不知道多少倍。  计算机世界的head first系列让我想起了阿呆系列，话说新的一集the big bang theory里面lennerd学习橄榄球的时候也有一本阿呆啊，哈哈，跑题了  不过只看书学明白设计模式是不可能的，这些只是前人的总结，我们...

入门看这本书的话很不错

读这本书不仅仅是学习知识，而是在学习一种思考的方法，学习一种认知的技巧，学习一种成长的阶梯。  总之，用你闲暇的时间来读这本书，并不亚于你专注的工作或学习。

值得每一位程序员阅读的书

1.策略模式(Strategy)      定义算法，将他们分别封装起来，让他们可以相互替换，让算法变化对客户端透明。 2.观察者模式(Observer)      解耦一系列对象的通知状态。定义对象之间的一对多依赖，当一端对象发生变换，通知多端。 3.装饰模式(Decorator)      动态将责任附加到对...

做个简短的笔记

这本书没有辜负这个名字。作者说他们把原本属于设计模式的来源还给设计模式的学习和应用过程。他们确实这样做到了。让读者能够从生活中的例子随着论述的展开，逐步深入设计模式的核心，这个确实是在目前的设计模式教程里面比较少见的，这个也是这本书能够不负其初衷的重要原因。

深入浅出

这可以说是我看完的唯一一本英文电子书（那个时候还没有东南的影印版），当然看完的一部分是因为这本书是教材。书里以很浅显的语言以及生动的例子讲授了部分的设计模式，而一些配图也十分的有趣。与之相比，GoF的书晦涩难懂，虽然内容为经典中的经典，但对一些经验较浅的人...

不愧深入浅出

看书之前本来仰慕已久，不过看完了稍显失望。 怎么说呢，这种非常轻松的东西倒是很好，就是有点过于分散了点。另外有的模式对我来说简直是惊世骇俗，但是有的实在是非常符合一般规律，能够直接根据OO的原则想出来的。 还有一点不太满意就是习题有的有点弱智，有的又跑得太远…...

拿了Jolt大奖的东西

第一次看到这样得技术书，以图为主，还有很多得手写体文字，看着很舒服，讲得也好，浅显易懂！这才应该是技术书要走得路线～让每个读者都能看懂！

的确是欲罢不能得一本书

这本书写得挺好的，通俗易懂。以前买了那本GoF的书，试图看了几遍也没看完几个模式。每页的信息量不大，书特别厚，所以看完以后会有一种错觉：看完了好厚一本书！ 这本书把设计模式讲清楚的同时把一些OO思想也解释得很清楚，至少在合上书的时候”多用组合，少用继承“这个原则...

写得挺好的

第一次接触Head First系列的时候是，head first web，刚开始并不是很感冒，那本书是中文版。这次偶然地从图书馆借了本 Head First Design Patterns （英文版），一下子被里面的英语表达方式吸引住了。对，我是从喜欢读书中的英文句子转而喜欢上该系列的书的。而且，在阅读的过...

很滑稽、很搞笑的专业书

名不副实的一本书，类似皇帝新装。 设计模式理论本身并非多么困难（其难点在于如何应用，而这只可能从实践中习得），根本无需用如此多故作轻松（甚至是哗众取宠）的漫画、对话来降低难度，更何况这也稀释了重点，比如策略模式和观察者模式讲了近百页还让我云里雾里。 建议想学...

看完有些失望

最近看完了《HeadFirst设计模式》，GOF的《设计模式——可复用面向对象软件的基础》的创建型模式也读完了，经历了从一无所知到茅塞顿开再到充满迷惑的过程。  　　不得不说《HeadFirst设计模式》是一本非常好的入门书，每一章都是先提出问题，然后讨论、分析，引导出相应的设计...

对学习设计模式的一些想法

大概上一次我学习设计模式的时候，是大三的时候了吧，当时我就感觉得到这门课程不一样的重要性，以前的软件工程只是说明解耦的必要性，我在大二的时候编写过8000行的C语言的程序，我清楚模块化，把握好代码粒度给程序整体复用率带来非常好效果，软件工程这门课程中总结出来的...

观摩程序员的艺术

2010年开始接触设计模式，当时看的是《大话设计模式》，翻完，没啥实质领悟。也许是当年修行不够悟道不深。之后几年里设计模式对于我还是一个自认为不能理解好的领域，买了四人帮的书也丢在一边。因为工作中主要用C，而模式多用面向对象语言描述。我一直在思考如何在C中采用面...

实践出真知

【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 c...

Summary

这是一本很轻松的书籍, 不属于难啃的学院派风格. 但我还是断断续续看了接近一个月才看完, 工作实在太忙了, 每天只有在地铁上抽出一点时间来阅读. 这期间我总是看着看着就乐了, 就这样开心了一个月, 对设计模式也摸到了门道. 书中介绍的都是一些基本的设计模式, 以附录的形式给...

如果你想学习设计模式, 又看不进去传统的设计书籍, 那就买一本Head FIRST DESIGN PATTERNS吧

老话了，没有人能写出没有BUG的的程序。这本经典好书也不例外，书中的例子用到很多设计模式，源码更是精彩，但相对的对于没一定基础的程序员来说比较难理解的，如果用到书中的例子时碰到BUG了就不好解决了。  附上 《HandFirst Desgin Pattern》Class Coverage   参考：http://...

关于书中源码的BUG

特地給這本書留了“讀過的第一百本書”的特殊位置，就是為了突出這本書對我的價值。   設計模式從他誕生之後，就迅速上昇為軟件開發世界的顯學，一時間軟件開發必談模式，各種書籍也是汗牛充棟，以致後來翻譯書籍名字裏都喜歡帶“模式”一詞以提高銷量就可見一斑。   但是設...

不在（再）浮沙筑高臺

O'Reilly Head First系列（中译本）

这本书最特别之处，不在于它讲了多少种设计模式，而在于它如何让人真正记住并会用。它把认知科学和神经生物学的研究成果搬进技术写作，用对话、漫画和循序渐进的练习，把抽象的模式一点点

深入浅出设计模式（影印版）