常用的设计模式

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算法也使用了模板模式

策略模式：
封装易于变化的部分

策略模式和模板模式的对比：
模板模式定义算法的基本结构，具体部分的实现需要子类去实现。而策略模式是由子类去选择需要的算法实现。
模板模式避免重复的代码，效率较高，重复的代码都放到超类中。策略模式使用对象的组合，所以更有弹性，客户可以在运行时改变他们的算法。
模板模式对子类依赖较大。
策略模式使用组合，而模板模式使用继承。
工厂方法是模板方法的一个特殊版本。