分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net
 
策略模式太常用了，所以把它放到最前面进行介绍。它比较简单，不废话，直接用代码说事吧。
 
下面设计的场景是，我们需要画一个图形，可选的策略就是用红色笔来画，还是绿色笔来画，或者蓝色笔来画。
 
首先，先定义一个策略接口：
 
public interface Strategy {
    public void draw(int radius, int x, int y);
}
 
然后我们定义具体的几个策略：
 
public class RedPen implements Strategy {

    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }

}

public class GreenPen implements Strategy {

    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }

}

public class BluePen implements Strategy {

    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }

}
 
使用策略的类：
 
public class Context {

    private Strategy strategy;

    public Context(Strategy strategy){
        this.strategy = strategy;
    }

    public int executeDraw(int radius, int x, int y){
        return strategy.draw(radius, x, y);
    }

}
 
客户端演示：
 
public static void main(String[] args) {
    Context context = new Context(new BluePen()); // 使用绿色笔来画
    context.executeDraw(10, 0, 0);
}
 
放到一张图上，让大家看得清晰些：
 
 
这个时候，大家有没有联想到结构型模式中的桥梁模式，它们其实非常相似，我们把桥梁模式的图拿过来大家对比下： 
 
 
它们非常相似，桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低，结构更复杂一些。 

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net
 
观察者模式对于我们来说，真是再简单不过了。无外乎两个操作，观察者订阅自己关心的主题和主题有数据变化后通知观察者们。
 
首先，需要定义主题，每个主题需要持有观察者列表的引用，用于在数据变更的时候通知各个观察者：
 
public class Subject {

    private List<Observer> observers = new ArrayList<Observer>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;

        // 数据已变更，通知观察者们
        notifyAllObservers();
    }

    // 注册观察者
    public void attach(Observer observer) {
        observers.add(observer);
    }

    // 通知观察者们
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }

}
 
定义观察者接口：
 
public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}
 
其实如果只有一个观察者类的话，接口都不用定义了，不过，通常场景下，既然用到了观察者模式，我们就是希望一个事件出来了，会有多个不同的类需要处理相应的信息。比如，订单修改成功事件，我们希望发短信的类得到通知、发邮件的类得到通知、处理物流信息的类得到通知等。
 
我们来定义具体的几个观察者类：
 
public class BinaryObserver extends Observer {

    // 在构造方法中进行订阅主题
    public BinaryObserver(Subject subject) {
        this.subject = subject;

        // 通常在构造方法中将 this 发布出去的操作一定要小心
        this.subject.attach(this);
    }

    // 该方法由主题类在数据变更的时候进行调用
    @Override
    public void update() {
        String result = Integer.toBinaryString(subject.getState());
        System.out.println("订阅的数据发生变化，新的数据处理为二进制值为：" + result);
    }

}

public class HexaObserver extends Observer {

    public HexaObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        String result = Integer.toHexString(subject.getState()).toUpperCase();
        System.out.println("订阅的数据发生变化，新的数据处理为十六进制值为：" + result);
    }

}
 
客户端使用也非常简单：
 
public static void main(String[] args) {

    // 先定义一个主题
    Subject subject1 = new Subject();

    // 定义观察者
    new BinaryObserver(subject1);
    new HexaObserver(subject1);

    // 模拟数据变更，这个时候，观察者们的 update 方法将会被调用
    subject.setState(11);
}

// Output：
/*
订阅的数据发生变化，新的数据处理为二进制值为：1011
订阅的数据发生变化，新的数据处理为十六进制值为：B
*/
 
当然，JDK 也提供了相似的支持，具体的可以参考 java.util.Observable 和 java.util.Observer 这两个类。
 
实际生产过程中，观察者模式往往用消息中间件来实现，如果要实现单机观察者模式，笔者建议读者使用 Guava 中的 EventBus，它有同步实现也有异步实现。
 
还有，即使是上面的这个代码，也会有很多变种，大家只要记住核心的部分，那就是一定有一个地方存放了所有的观察者，然后在事件发生的时候，遍历观察者，调用它们的回调函数。

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net
 
我们说一个简单的例子。商品库存中心有个最基本的需求是减库存和补库存，我们看看怎么用状态模式来写。
 
核心在于，我们的关注点不再是 Context 是该进行哪种操作，而是关注这个 Context 会有哪些操作。
 
定义状态接口：
 
public interface State {
    public void doAction(Context context);
}
 
定义减库存的状态：
 
public class DeductState implements State {

    public void doAction(Context context) {
        System.out.println("商品卖出，准备减库存");
        context.setState(this);

        // 执行减库存的具体操作...
    }

    public String toString() {
        return "Deduct State";
    }

}
 
定义补库存状态：
 
public class RevertState implements State {

    public void doAction(Context context) {
        System.out.println("给此商品补库存");
        context.setState(this);

        // 执行补库存的具体操作...
    }

    public String toString() {
        return "Revert State";
    }

}
 
前面用到了 context.setState(this)，我们来看看怎么定义 Context 类：
 
public class Context {

    private State state;
    private String name;
    public Context(String name) {
        this.name = name;
    }

    public void setState(State state) {
        this.state = state;
    }

    public void getState() {
        return this.state;
    }

}
 
我们来看下客户端调用，大家就一清二楚了：
 
public static void main(String[] args) {

    // 我们需要操作的是 iPhone X
    Context context = new Context("iPhone X");

    // 看看怎么进行补库存操作
    State revertState = new RevertState();
    revertState.doAction(context);

    // 同样的，减库存操作也非常简单
    State deductState = new DeductState();
    deductState.doAction(context);

    // 如果需要我们可以获取当前的状态
    context.getState().toString();
}
 
读者可能会发现，在上面这个例子中，如果我们不关心当前 context 处于什么状态，那么 Context 就可以不用维护 state 属性了，那样代码会简单很多。
 
不过，商品库存这个例子毕竟只是个例，我们还是有很多实例是需要知道当前 context 处于什么状态的。

分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net
 
在含有继承结构的代码中，模板方法模式是非常常用的。
 
通常会有一个抽象类：
 
public abstract class AbstractTemplate {

    // 这就是模板方法
    public void templateMethod() {
        init();
        apply(); // 这个是重点
        end(); // 可以作为钩子方法
    }

    protected void init() {
        System.out.println("init 抽象层已经实现，子类也可以选择覆写");
    }

    // 留给子类实现
    protected abstract void apply();

    protected void end() {
    }

}
 
模板方法中调用了 3 个方法，其中 apply() 是抽象方法，子类必须实现它，其实模板方法中有几个抽象方法完全是自由的，我们也可以将三个方法都设置为抽象方法，让子类来实现。也就是说，模板方法只负责定义第一步应该要做什么，第二步应该做什么，第三步应该做什么；至于怎么做，由子类来实现。
 
我们写一个实现类：
 
public class ConcreteTemplate extends AbstractTemplate {

    public void apply() {
        System.out.println("子类实现抽象方法 apply");
    }

    public void end() {
        System.out.println("我们可以把 end 当做钩子方法来使用，需要的时候覆写就可以了");

    }
}
 
客户端调用演示：
 
public static void main(String[] args) {
    AbstractTemplate t = new ConcreteTemplate();

    // 调用模板方法
    t.templateMethod();
}
 
代码其实很简单，基本上看到了就懂了，关键是要学会用到自己的代码中。