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个或者多个装饰者包装一个对象，也就是动态的附加多个方法或者说功能，因为装饰者和被装饰者用相同的超类，所以在任何时刻需要原始对象的场合(被包装对象)都可以用装饰者代替。
