《Head First设计模式》笔记

设计原则

1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

2.针对接口编程，而不是针对实现编程。

3.多用组合（has-a interface），少用继承(extend interface)。

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

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

一、策略模式

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

二、观察者模式

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

• 主题（也就是可观察者observable）用一个共同的接口来更新观察者
• 观察者和可观察者之间用松耦合方式结合(loosecoupling),可观察者不知道观察者是先的细节，只知道观察者实现了观察者接口

观察者模式类图.png

//主题接口
public interface Subject {
  public void registerObserver(Observer o);  
  public void removeObserver(Observer o);
  public void notifyObservers();
}

//观察者接口
public interface Observer {
  public void update(int value);
}

//主题的简单实现
public class SimpleSubject implements Subject {
    private ArrayList observers;  //在构造器中建立列表，记录观察者
    private int value = 0;
    
    public SimpleSubject() {
        observers = new ArrayList();
    }
    
    public void registerObserver(Observer o) {
        observers.add(o);
    }
    
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }
    
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(value);
        }
    }
    
    public void setValue(int value) {
        this.value = value;
        notifyObservers();
    }
}

//观察者的简单实现
public class SimpleObserver implements Observer {
    private int value;
    private Subject simpleSubject;
    
      //构造器需要simpleSubject对象作为注册使用
    public SimpleObserver(Subject simpleSubject) {
        this.simpleSubject = simpleSubject;
        simpleSubject.registerObserver(this);
    }
    
    public void update(int value) {
        this.value = value;
        display();
    }
    
    public void display() {
        System.out.println("Value: " + value);  
    }
}

//简单示例
public class Example {

    public static void main(String[] args) {
        SimpleSubject simpleSubject = new SimpleSubject();
    
        SimpleObserver simpleObserver = new SimpleObserver(simpleSubject);

        simpleSubject.setValue(80);  //输出： Value: 80
    }
}

三、装饰者模式

装饰者模式动态地奖责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

装饰者模式类图

• 装饰者模式意味着一群装饰者类，这些类用来包装具体组件
• 装饰者类反映出被装饰的组件类型（他们具有相同的类型，都经过接口或继承实现）
• 装饰者可以在被装饰者的行为前面/或后面加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的。
• 可以用无数个装饰者包装一个组件
• 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。
• 装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂

//抽象组件
public abstract class Beverage {
    String description = "Unknown Beverage";
  
    public String getDescription() {
        return description;
    }
 
    public abstract double cost();
}

//抽象装饰者
public abstract class CondimentDecorator extends Beverage {
    Beverage beverage;
    public abstract String getDescription();
}

//具体组件
public class Espresso extends Beverage {
  
    public Espresso() {
        description = "Espresso";
    }
  
    public double cost() {
        return 1.99;
    }
}

//具体装饰者
public class Milk extends CondimentDecorator {
    public Milk(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", Milk";
    }

    public double cost() {
        return .10 + beverage.cost();
    }
}

//示例
public class StarbuzzCoffee {
 
    public static void main(String args[]) {
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription() 
                + " $" + beverage.cost());  //Espresso $1.99

 
        Beverage beverage2 = new DarkRoast();
        beverage2 = new Mocha(beverage2);
        beverage2 = new Mocha(beverage2);
        beverage2 = new Whip(beverage2);
        System.out.println(beverage2.getDescription() 
                + " $" + beverage2.cost());  //Dark Roast Coffee, Mocha, Mocha, Whip $1.49

 
        Beverage beverage3 = new HouseBlend();
        beverage3 = new Soy(beverage3);
        beverage3 = new Mocha(beverage3);
        beverage3 = new Whip(beverage3);
        System.out.println(beverage3.getDescription() 
                + " $" + beverage3.cost());  //House Blend Coffee, Soy, Mocha, Whip $1.34
    }
}