常用的设计模式

OO原则：

封装变化

多用组合少用继承

针对接口编程，不针对实现编程

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

类应该对扩展开放，对修改关闭

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

只和朋友交谈

不要找我，我会找你(好莱坞原则，超类主控一切，在需要的时候会去调用子类,就像好莱坞一样)

适配者模式：

一个类的接口，转换成客户期望的另一个接口，适配器让原本接口不兼容的类可以合作无间。

装饰者模式：

多次包装一个类，功能层层叠加，如java 的输入输出流

外观模式：

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

模板模式：

模板方法定义了一个算法的步骤，并允许子类为一个或多个步骤提供实现。

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

模板方法的抽象类可以定义算法，具体方法，抽象方法和钩子。

钩子是一种方法，他在抽象类中不做任何事情，或者只做默认的事情，子类可以选择要不要去覆盖他。

为了防止子类修改模板方法中的算法，可以将模板方法声明为final

在现实世界中，模板方法有很多种变体。

/**

*

*/

package template;

/**

* @author mujjiang

*

*/

public abstract class CaffeineBeverageWithHook {

/**
* final提供了保护
*/
final void prepareRecipe(){
boilWater();
//steepTeaBag();
brew();
pourInCup();
//addLemon();
if(customerWantcondiments()){
addCondiments();
}
}

protected abstract void brew();

protected abstract void addCondiments();

public void boilWater(){
System.out.println("boilWater");
}

public void pourInCup(){
System.out.println("pour In Cup");
}

/**
* 钩子，子类可以默认实现
* @return
*/
protected boolean customerWantcondiments(){
return true;
}

}

/**

*

*/

package template;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

/**

* @author mujjiang

*

*/

public class CoffeeWithHook extends CaffeineBeverageWithHook {

protected void brew() {
System.out.println("Dripping Coffee through filter");
}

protected void addCondiments() {
System.out.println("add Sugar And Milk");
}

/* (non-Javadoc)
* @see template.CaffeineBeverageWithHook#customerWantcondiments()
*/
protected boolean customerWantcondiments() {
String answer = getUserInput();

if(answer.toLowerCase().startsWith("y")){
return true;
}else{
return false;
}
}

private String getUserInput(){
String ans = null;

BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

try {
ans = bufferedReader.readLine();
} catch (IOException e) {
e.printStackTrace();
}

if(ans==null){
return "no";
}

return ans;
}

}

java.utils.Arrays里面的sort算法也使用了模板模式

策略模式：

封装易于变化的部分

策略模式和模板模式的对比：

模板模式定义算法的基本结构，具体部分的实现需要子类去实现。而策略模式是由子类去选择需要的算法实现。

模板模式避免重复的代码，效率较高，重复的代码都放到超类中。策略模式使用对象的组合，所以更有弹性，客户可以在运行时改变他们的算法。

模板模式对子类依赖较大。

策略模式使用组合，而模板模式使用继承。

工厂方法是模板方法的一个特殊版本。