设计模式思考

designpattern.png

记得大三的时候第一次接触设计模式，觉得很cool，当时把head first 设计模式看了一遍，才知道原来代码还能这样设计。但是当时对于整个软件系统的架构和认识还不足，经过快两年的打磨，自己对于整体架构又有了新的收获。这两天再把大学时看过的head first 设计模式拿出来看看，发现一切都是那么优美。

• 策略模式
  策略模式定义了算法族，分别封装起来，让他们之间可以互换，这个模式让算法的变化独立于使用算法的客户。有三个重点，第一，把代码中变化的部分抽离出来集中维护，第二，面向接口编程，这样可以动态增加服务，第三，多用组合，少用继承。一般客户代码中不是去继承某个类型，而是运用组合添加一个变量，在构造方法或者通过set方法进行构造这个对象，当然这个对象一般是一个接口或者基类，注入时注入的是对应的实现，这样就可以动态的替换算法。
  接下来我们用书上的例子来看一下，策略模式的应用。

  
  image.png

image.png image.png image.png

//鸭子类都有个display方法
public abstract class Duck {
    public abstract void display();
}

//飞行接口
public interface Flyable {
    void fly();
}

//飞的慢
public class SlowFly implements Flyable{
    @Override
    public void fly() {
        System.out.println("slow fly");
    }
}

//飞的快
public class QuickFly implements Flyable {
    @Override
    public void fly() {
        System.out.println("quick fly");
    }
}

//叫接口
public interface Quackable {
    void quack();
}

//温柔的叫
public class GentleQuack implements Quackable {

    @Override
    public void quack() {
        System.out.println("warm quack");
    }

}

//尖锐的叫
public class HarshQuack implements Quackable {
    @Override
    public void quack() {
        System.out.println("harsh quack");
    }
}

//一般的鸭子都会叫
public class GeneralDuck extends Duck {

    public GeneralDuck(Quackable quackable) {
        this.quackable = quackable;
    }

    private Quackable quackable;

    public void setQuackable(Quackable quackable) {
        this.quackable = quackable;
    }

    @Override
    public void display() {
        System.out.println("gentle display");
    }

    public void quack(){
        quackable.quack();
    }

}

//特殊的鸭子不仅会叫还会飞
public class SpecialDuck extends Duck {

    public SpecialDuck(Quackable quackable, Flyable flyable) {
        this.quackable = quackable;
        this.flyable = flyable;
    }

    public void setQuackable(Quackable quackable) {
        this.quackable = quackable;
    }

    public void setFlyable(Flyable flyable) {
        this.flyable = flyable;
    }

    private Quackable quackable;

    private Flyable flyable;

    @Override
    public void display() {
        System.out.println("special display");
    }

    public void quack(){
        quackable.quack();
    }

    public void fly(){
        flyable.fly();
    }
}

//测试
  public static void main(String[] args) {
        //这种new 创建对象一般都是面向实现编程
        //后续我们会用到工厂方法来对客户端代码解耦
        //把会变化的代码部分提取出来 独立变化
        Quackable gentleQuack = new GentleQuack();
        Quackable  harshQuack = new HarshQuack();
        Flyable slowFly = new SlowFly();
        Flyable quickFly = new QuickFly();
        GeneralDuck generalDuck = new GeneralDuck(gentleQuack);
        generalDuck.display();
        generalDuck.quack();
        SpecialDuck specialDuck = new SpecialDuck(gentleQuack,slowFly);
        specialDuck.display();
        specialDuck.fly();
        specialDuck.quack();

        System.out.println("------");
        specialDuck.display();
        specialDuck.setFlyable(quickFly);
        specialDuck.setQuackable(harshQuack);
        specialDuck.quack();
        specialDuck.fly();

    }

----- 输出
gentle display
warm quack
special display
slow fly
warm quack
------
special display
harsh quack
quick fly
上面可以看到特殊的鸭子既会飞 也会叫 ，飞 和 叫都有两种方式
我们通过set不同的实现到特殊鸭子类就可以动态的改变特殊鸭子的行为，这就是策略模式

• 观察者模式
  观察者模式就是很多订阅者像主题进行订阅，当主题状态发生变化的时候会通知所有的订阅者，要实现这样的设计就需要面向接口编程，不能面向实现，这样当新增一个订阅者，这个订阅者只是实现订阅者接口，然后向主题进行注册就行了，主题状态变化只是去遍历订阅者集合，去发送通知就ok了，这是一种松耦合的设计，面向接口编程，为交互对象之间的松耦合设计而努力。

• 装饰者模式
  装饰者模式动态的把责任附加到对象上，若要扩展功能装饰者提供了比继承更有弹性的替代方案。首先，装饰者和被装饰者有相同的超类，我们可以使1个或者多个装饰者包装一个对象，也就是动态的附加多个方法或者说功能，因为装饰者和被装饰者用相同的超类，所以在任何时刻需要原始对象的场合(被包装对象)都可以用装饰者代替。