【笔记】Head First 设计模式

设计原则汇总

                                                                                   

1. 封装变化；

2. 多用组合，少用继承；

3. 针对接口编程，不针对实现编程；

4. 为交互对象之间的松耦合设计而努力；

5. 对扩展开发，对修改关闭（不宜过度使用）；

6. 依赖抽象，不依赖具体的类；

7. 依赖抽象，不要依赖具体类（依赖倒置原则 Dependency Inversion Principle）；
依赖倒置原则指导方针：
1）变量不可以持有具体类的引用；
2）不要让类派生自具体类；
3）不要覆盖基类中已实现的方法。

8. 最少知识 ( LeastKnowledge) 原则：只和你的密友谈话;
最少知识原则指导方针： 
就任何对象而言，在该对象的方法内，我们只应该调用属于以下范围内的方法：

1) 该对象本身

2) 被当做方法的参数而传递进来的对象

3) 此方法所创建或实例化的任何对象
请注意，这些方针（1.2.3）告诉我们，如果某对象是调用其他的方法的返回结果，不要调用该对象的方法。

4) 对象的任何组件
把“组件”想象成是被实例变量所引用的任何对象，换句话说，把这想象成是“有一个”( HAS-A ) 关系。

9. 好莱坞原则：别找我，我会找你。
防止“依赖腐败”（依赖关系循环交错）的方法，允许底层组件将自己挂钩到系统上，但是高层组件会决定什么时候和怎样使用这些底层组件。换句话说，高层组件对待底层组件的方式是“别调用我们，我们会调用你”。

10. 类应该只有一个改变的理由。

 

设计模式定义 & 要点

                                                                                   

策略模式（Strategy Pattern）

定义算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

 

要点

• 知道OO基础，并不足以让你设计出良好的OO系统。
• 良好的OO设计必须具备可复用性、可扩充、可维护三个特性。
• 模式可以让我们建造出具有良好OO设计质量的系统。
• 模式被认为是历经验证的OO设计经验。
• 模式不是代码，而是针对设计问题的通用解决方案。你可把它们应用到特定的应用中。
• 模式不是被发明，而是被发现。
• 大多数的模式和原则，都着眼于软件变化的主题。
• 大多数的模式都允许系统局部改变独立于其他部分。
• 我们常把系统中会变化的抽出来封装。
• 模式让开发人员之间有共享的语言，能够最大化沟通的价值。

观察者模式（Observer Pattern）

在对象之间定义一 ( 主题Subject ) 对多 ( 观察者Observer )的依赖，这样一来，当一个对象改变状态，依赖它的对象就会收到通知，并自动更新。

要点

• 观察者模式定义了对象之间一对多的关系。
• 主题（也就是可观察者）用一个共同的接口来更新观察者。
• 观察者和可观察者之间用松耦合方式结合（loosecoupling），可观察者不知道观察者的细节，只知道观察者实现了观察者接口。
• 使用此模式时，你可从被观察者处推（push）或拉（pull）数据（然而，推的方式被认为更“正确”）。
• 有多个观察者时，不可以依赖特定的通知次序。
• Java有多种观察者模式的实现，包括了通用的java.util.Observable。
• 要注意java,util.Observable实现上所带来的的一些问题。
• 如果有必要的话，可以实现自己的Observerable，这并不难，不要害怕。
• Swing大量使用观察者模式，许多GUI框架也是如此。
• 此模式也被应用在许多地方，例如：JavaBean、RMI。

装饰者模式（Decorator Pattern）

动态地将责任附加到对象上。想要扩展功能，装饰者提供有别于继承的另一种选择（个人理解：伪嵌套）。

要点

• 继承属于扩展形式之一，但不见得是达到弹性设计的最佳方法。
• 在我们的设计中，应该允许行为可以被扩展，而无须修改现有的代码。
• 组合和委托用于在运行时动态地加上新的行为。
• 除了继承，装饰者模式也可以让我们扩展行为。
• 装饰者模式意味着一群装饰者类，这些类用来包装具体组件。
• 装饰者类反映出被装饰的组件类型（事实上，他们具有相同的类型，都是经过接口或继承实现）。
• 装饰者可以在被装饰者的行为前面与 / 或后面加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的。
• 你可以用无数个装饰者包装一个组件。
• 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。
• 装饰者会导致设计中出现许多小对象，如果过度使用，还会昂程序变得复杂。

 

工厂方法模式 & 抽象工厂模式（Factory MethodPattern & Abstract Factory Pattern）

工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

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

要点

• 所有的工厂都是用来封装对象的创建
• 简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦。
• 工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象。
• 抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露的方法中。
• 所有的工厂模式都是通过减少应用程序和具体类之间的依赖促进松耦合。
• 工厂方法允许类将实例化延迟到子类进行。
• 抽象工厂创建相关的对象家族，而不需要依赖它们的具体类。
• 依赖倒置原则，指导我们避免依赖具体类型，而要尽量依赖抽象。
• 工厂是很有威力的技巧，帮助我们针对抽象编程，而不是针对具体类编程。

单件模式（Singleton Pattern）

确保一个类只有一个实例，并提供一个全局访问点。

要点

• 单件模式确保程序中一个类只有一个实例。
• 单件模式也提供访问这个实例的全局点。
• 在Java中实现单件模式需要私有构造器、一个静态常量和一个静态方法。
• 确定在性能和资源上的限制，然后小心地选择适当的方案实现单件，以解决多线程问题（我们必须认定所有程序都是多线程）。
• 如果不是采用第五版的Java2，双重检查加锁实现会失效。
• 小心，你是用多个类加载器，可能会导致单件失效而产生多个实例。
• 如果使用JVM 1.2或者之前的版本，你必须建立单件注册表，以免垃圾收集器将单件回收。

 

synchronized解决同步问题

在getInstance( ) 方法前增加关键字synchronized，解决单件模式类的多线程访问问题。

弊端：减低性能，只有第一次执行此方法getInstance( ) 需要同步，一旦进行实例化后，就不需要同步这个方法了，这样变成了累赘。

弊端解决方案：

1、  如果getInstance() 的性能对应用程序不是很关键，就什么都别做；

2、  使用“急切”创建实例，而不用延迟实例化的做法，直接实例化：
privte static Singleton uniqueInstance = new Singleton();

3、  用“双重检查加锁（double-checked locking）”，在getInstance() 中减少使用同步：
private volatilestatic Singleton uniqueInstance; 
//不用添加关键字synchronized，使用延迟实例化
利用双重检查加锁，首先检查是否实例已经创建了，如果尚未创建，“才”进行同步。这样一来，只有第一步会同步，较之synchronized，大大提高了性能。
★ volatile关键字确保：当uniqueInstance变量被初始化为Singleton实例时，多个线程正确地处理uniqueInstance变量。
注意：双重检查加锁不适用于1.4及更早版本的Java！

 

多个类加载器（class loader）问题

每个类加载器都定义了一个命名空间，如果有两个以上的类加载器，不同的类加载器可能会加载同一个类，从整个程序看来，同一个类会被加载多次。因此有可能发生多个单件并存的情况。

解决方案：

自行定义类加载器，并指定同一个类加载器。

Java 1.2及之前的BUG

JVM垃圾收集器有个BUG，会造成单件在没有全局的引用时被当做垃圾清除。下次引用会产生一个新的实例。

命令模式（Command Pattern）

将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

要点

• 命令模式将发出请求的对象和执行请求的对象解耦。
• 在被解耦的两者之间是通过命令对象进行沟通的，命令对象封装了接受者和一个或一组动作。
• 调用者通过调用命令对象的execute() 发出请求，这会使得接受者的动作被调用。
• 调用者可以接受命令当做参数，甚至在运行时动态地运行。
• 命令可以支持撤销，做法是实现用一个undo( ) 方法来回到execute( ) 被执行前的状态。
• 宏命令是命令的一种简单的延伸，允许调用多个命令，宏命令也可以支持撤销。
• 实际操作时，很常见使用“聪明”命令对象，也就是直接实现了请求，而不是将工作委托给接受者。
• 命令模式也可以用来实现日志和事务系统。

 

适配器模式 &外观模式（Adapter Pattern & Facade Pattern）

适配器模式：将一个类的接口，装换陈客户期望的另一个接口。适配器让原本接口部件通的类可以合作无间。

外观模式：提供一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。

要点

• 当需要使用一个现有的类而其接口并不符合你的需求时，就使用适配器。
• 当需要简化并同统一个很大的接口或者一群复杂的接口是，使用外观。
• 适配器改变接口以符合客户的期望。
• 外观将客户从一个复杂的子系统中解耦。
• 实现一个适配器可能需要一番功夫，也可能不费功夫，视目标接口的大小与复杂度而定。
• 实现一个外观，需要将子系统组合进外观中，然后将工作委托给子系统执行。
• 适配器模式有两种形式：对象适配器和类适配器。类适配器需要用到多重继承。
• 你可以为一个子系统实现一个以上的外观。
• 适配器将一个对象包装起来以改变其接口；装饰者将一个对象包装起来以增加新的行为和责任；而外观将一群对象“包装”起来以简化其接口。
• 外观不只是简化了接口，也将客户从组件的子系统中解耦。
• 外观和适配器可以包装许多类，但是外观的意思是简化接口，而适配器的意图是将接口转换成不同接口。

模板方法模式（Template Method Pattern）

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

 

要点

• “模板方法”定义了算法的步骤，把这些步骤的实现延迟到子类。
• 模板方法模式为我们提供了一种代码复用的重要技巧。
• 模板方法的抽象类可以定义具体方法、抽象方法和钩子。
• 抽象方法由子类实现。
• 钩子是一种方法，它在抽象类中不做事，或者只做默认的事情，子类可以选择要不要去覆盖它。
• 为了防止子类改变模板方法中的算法，可以将模板方法声明为final。
• 好莱坞原则告诉我们，将决策权放在高层模块中，以便决定如何以及何时调用底层模块。
• 你将在真实世界代码中看到模板方法模式的许多变体，不要期待它们全都是一眼就可以被你认出来的。
• 策略模式和模板方法模式都封装算法，前者用组合，后者用继承。
• 工厂模板就是模板方法的一个变体。

迭代器模式 &组合模式（Iterator Pattern & Composite Pattern）

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

组合模式：允许你将对象组成树形结构来表现“整体/部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。

要点

• 迭代器允许访问聚合的元素，而不需要暴露它的内部结构。
• 迭代器将遍历聚合的工作封装进一个对象中。
• 当使用迭代器的时候，我们依赖聚合提供遍历。
• 迭代器提供一个通用的接口，让我们遍历聚合的项，当我们编码使用聚合的项时，就可以使用多态的机制。
• 我们应该努力使一个类只分配一个责任。
• 组合模式提供一个结构，可同时包容个别对象和组合对象。
• 组合模式允许客户对个别对象和组合对象一视同仁。
• 组合结构内的任意对象称为组件，组件可以是组合，也可以是叶节点。
• 在实现组合模式时，有许多设计上的折衷。你要根据需求平衡透明性和安全性。

状态模式（State Pattern）

允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

要点

• 状态模式允许一个对象基于内部状态而拥有不同的类行为。
• 和程序状态机（PSM）不同，状态模式用类代表状态。
• Context会将行为委托给当前状态对象。
• 通过将每个状态封装进一个类，我们把以后需要做的任何改变局部化了。
• 状态模式和策略模式有相同的类图，但是它们的意图是不同的。
• 策略模式通常会使用行为或算法来配置Context类。
• 状态模式允许Context随着状态的改变而改变行为。
• 状态类可以由State类或Context类控制转换。
• 使用状态模式通常会导致设计中类的数目大量增加。
• 状态类可以被多个Context实例共享。

代理模式（Proxy Pattern）

为另一个对象提供一个替身或者占位符以访问这个对象。

要点

• 代理模式为另一个对象提供代表，以便控制客户对对象的访问，管理访问的方式有许多种。
• 远程代理管理客户和远程对象间的交互。
• 虚拟代理控制访问实例化开销大的对象。
• 保护代理基于调用者控制对对象方法的访问。
• 代理模式有许多变体，例如：缓存代理、同步代理、防火墙代理和写入时复制代理。
• 代理在结构上类似装饰者，但是目的不同。
• 装饰者模式为对象加上行为，而代理这是控制访问。
• Java内置的代理支持，可是根据需要建立动态代理，并将所有调用分配到所选的处理器。
• 就和其他的包装者（wrapper）一样，代理会造成你设计中类的数目增加。

复合模式（Compound Pattern）

复合模式结合两个或以上的模式，组成一个解决方案，解决一再发生的一般性问题。

要点

• MVC是复合模式，结合了观察者模式、策略模式和组合模式。
• 模型使用观察者模式，以便观察者更新，同时保持两者之间的解耦。
• 控制器是视图的策略，视图可以使用不同的控制器实现，得到不同的行为。
• 视图使用组合模式实现用户界面，用户界面通常结合了嵌套的组件，像面板、框架和按钮。
• 这些模式携手合作，把MVC模型的三层解耦，这样可以保持设计干净又有弹性。
• 适配器模式用来将新的模型适配成已有的已有的视图和控制器。
• Model 2是MVC在WEB上的应用。
• 在Model 2中，控制器实现成Servlet，而JSP/HTML实现视图。