行为型模式

行为型模式关注的是各个类之间的相互作用，将职责划分清楚，使得我们的代码更加地清晰。

策略模式

策略模式太常用了，所以把它放到最前面进行介绍。它比较简单，我就不废话，直接用代码说事吧。

下面设计的场景是，我们需要画一个图形，可选的策略就是用红色笔来画，还是绿色笔来画，或者蓝色笔来画。

首先，先定义一个策略接口： 

  1. public interface Strategy {
  2.    public void draw(int radius, int x, int y);
  3. }

然后我们定义具体的几个策略： 

  1. public class RedPen implements Strategy {
  2.    @Override
  3.    public void draw(int radius, int x, int y) {
  4.       System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
  5.    }
  6. }
  7. public class GreenPen implements Strategy {
  8.    @Override
  9.    public void draw(int radius, int x, int y) {
  10.       System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
  11.    }
  12. }
  13. public class BluePen implements Strategy {
  14.    @Override
  15.    public void draw(int radius, int x, int y) {
  16.       System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
  17.    }
  18. }

使用策略的类： 

  1. public class Context {
  2.    private Strategy strategy;
  4.    public Context(Strategy strategy){
  5.       this.strategy = strategy;
  6.    }
  8.    public int executeDraw(int radius, int x, int y){
  9.       return strategy.draw(radius, x, y);
  10.    }
  11. }

客户端演示： 

  1. public static void main(String[] args) {
  2.     Context context = new Context(new BluePen()); // 使用绿色笔来画
  3.       context.executeDraw(10, 0, 0);
  4. }

放到一张图上，让大家看得清晰些：

​

这个时候，大家有没有联想到结构型模式中的桥梁模式，它们其实非常相似，我把桥梁模式的图拿过来大家对比下：

​

要我说的话，它们非常相似，桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低，结构更复杂一些。

观察者模式

观察者模式对于我们来说，真是再简单不过了。无外乎两个操作，观察者订阅自己关心的主题和主题有数据变化后通知观察者们。

首先，需要定义主题，每个主题需要持有观察者列表的引用，用于在数据变更的时候通知各个观察者： 

  1. public class Subject {
  3.    private List<Observer> observers = new ArrayList<Observer>();
  4.    private int state;
  6.    public int getState() {
  7.       return state;
  8.    }
  10.    public void setState(int state) {
  11.       this.state = state;
  12.       // 数据已变更，通知观察者们
  13.       notifyAllObservers();
  14.    }
  16.    public void attach(Observer observer){
  17.       observers.add(observer);
  18.    }
  20.    // 通知观察者们
  21.    public void notifyAllObservers(){
  22.       for (Observer observer : observers) {
  23.          observer.update();
  24.       }
  25.    }
  26. }

定义观察者接口： 

  1. public abstract class Observer {
  2.    protected Subject subject;
  3.    public abstract void update();
  4. }

其实如果只有一个观察者类的话，接口都不用定义了，不过，通常场景下，既然用到了观察者模式，我们就是希望一个事件出来了，会有多个不同的类需要处理相应的信息。比如，订单修改成功事件，我们希望发短信的类得到通知、发邮件的类得到通知、处理物流信息的类得到通知等。

我们来定义具体的几个观察者类： 

  1. public class BinaryObserver extends Observer {
  3.       // 在构造方法中进行订阅主题
  4.     public BinaryObserver(Subject subject) {
  5.         this.subject = subject;
  6.         // 通常在构造方法中将 this 发布出去的操作一定要小心
  7.         this.subject.attach(this);
  8.     }
  10.       // 该方法由主题类在数据变更的时候进行调用
  11.     @Override
  12.     public void update() {
  13.         String result = Integer.toBinaryString(subject.getState());
  14.         System.out.println("订阅的数据发生变化，新的数据处理为二进制值为：" + result);
  15.     }
  16. }
  18. public class HexaObserver extends Observer {
  20.     public HexaObserver(Subject subject) {
  21.         this.subject = subject;
  22.         this.subject.attach(this);
  23.     }
  25.     @Override
  26.     public void update() {
  27.           String result = Integer.toHexString(subject.getState()).toUpperCase();
  28.         System.out.println("订阅的数据发生变化，新的数据处理为十六进制值为：" + result);
  29.     }
  30. }

客户端使用也非常简单： 

  1. public static void main(String[] args) {
  2.     // 先定义一个主题
  3.       Subject subject1 = new Subject();
  4.       // 定义观察者
  5.       new BinaryObserver(subject1);
  6.       new HexaObserver(subject1);
  8.       // 模拟数据变更，这个时候，观察者们的 update 方法将会被调用
  9.       subject.setState(11);
  10. }

output: 

  1. 订阅的数据发生变化，新的数据处理为二进制值为：1011
  2. 订阅的数据发生变化，新的数据处理为十六进制值为：B

当然，jdk 也提供了相似的支持，具体的大家可以参考 java.util.Observable 和 java.util.Observer 这两个类。

实际生产过程中，观察者模式往往用消息中间件来实现，如果要实现单机观察者模式，笔者建议读者使用 Guava 中的 EventBus，它有同步实现也有异步实现，本文主要介绍设计模式，就不展开说了。

责任链模式

责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了，后面会自动流转下去。比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了。

有这么一个场景，用户参加一个活动可以领取奖品，但是活动需要进行很多的规则校验然后才能放行，比如首先需要校验用户是否是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。设定的规则都通过后，才能让用户领走奖品。

如果产品给你这个需求的话，我想大部分人一开始肯定想的就是，用一个 List 来存放所有的规则，然后 foreach 执行一下每个规则就好了。不过，读者也先别急，看看责任链模式和我们说的这个有什么不一样？

首先，我们要定义流程上节点的基类： 

  1. public abstract class RuleHandler {
  3.       // 后继节点
  4.     protected RuleHandler successor;
  6.     public abstract void apply(Context context);
  8.     public void setSuccessor(RuleHandler successor) {
  9.         this.successor = successor;
  10.     }
  11.     public RuleHandler getSuccessor() {
  12.         return successor;
  13.     }
  14. }

接下来，我们需要定义具体的每个节点了。

校验用户是否是新用户： 

  1. public class NewUserRuleHandler extends RuleHandler {
  3.     public void apply(Context context) {
  4.         if (context.isNewUser()) {
  5.               // 如果有后继节点的话，传递下去
  6.             if (this.getSuccessor() != null) {
  7.                 this.getSuccessor().apply(context);
  8.             }
  9.         } else {
  10.             throw new RuntimeException("该活动仅限新用户参与");
  11.         }
  12.     }
  14. }

校验用户所在地区是否可以参与： 

  1. public class LocationRuleHandler extends RuleHandler {
  2.     public void apply(Context context) {
  3.         boolean allowed = activityService.isSupportedLocation(context.getLocation);
  4.           if (allowed) {
  5.             if (this.getSuccessor() != null) {
  6.                 this.getSuccessor().apply(context);
  7.             }
  8.         } else  {
  9.             throw new RuntimeException("非常抱歉，您所在的地区无法参与本次活动");
  10.         }
  11.     }
  12. }

校验奖品是否已领完： 

  1. public class LimitRuleHandler extends RuleHandler {
  2.     public void apply(Context context) {
  3.           int remainedTimes = activityService.queryRemainedTimes(context); // 查询剩余奖品
  4.         if (remainedTimes > 0) {
  5.             if (this.getSuccessor() != null) {
  6.                 this.getSuccessor().apply(userInfo);
  7.             }
  8.         } else {
  9.             throw new RuntimeException("您来得太晚了，奖品被领完了");
  10.         }
  11.     }
  12. }

客户端： 

  1. public static void main(String[] args) {
  2.     RuleHandler newUserHandler = new NewUserRuleHandler();
  3.       RuleHandler locationHandler = new LocationRuleHandler();
  4.       RuleHandler limitHandler = new LimitRuleHandler();
  6.       // 假设本次活动仅校验地区和奖品数量，不校验新老用户
  7.       locationHandler.setSuccessor(limitHandler);
  8.       locationHandler.apply(context);
  9. }

代码其实很简单，就是先定义好一个链表，然后在通过任意一节点后，如果此节点有后继节点，那么传递下去。

至于它和我们前面说的用一个 List 存放需要执行的规则的做法有什么异同，留给读者自己琢磨吧。

模板方法模式

在含有继承结构的代码中，模板方法模式是非常常用的，这也是在开源代码中大量被使用的。

通常会有一个抽象类： 

  1. public abstract class AbstractTemplate {
  2.     // 这就是模板方法
  3.       public void templateMethod(){
  4.         init();
  5.         apply(); // 这个是重点
  6.         end(); // 可以作为钩子方法
  7.     }
  8.     protected void init() {
  9.         System.out.println("init 抽象层已经实现，子类也可以选择覆写");
  10.     }
  11.       // 留给子类实现
  12.     protected abstract void apply();
  13.     protected void end() {
  14.     }
  15. }

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

我们写一个实现类： 

  1. public class ConcreteTemplate extends AbstractTemplate {
  2.     public void apply() {
  3.         System.out.println("子类实现抽象方法 apply");
  4.     }
  5.       public void end() {
  6.         System.out.println("我们可以把 method3 当做钩子方法来使用，需要的时候覆写就可以了");
  7.     }
  8. }

客户端调用演示： 

  1. public static void main(String[] args) {
  2.     AbstractTemplate t = new ConcreteTemplate();
  3.       // 调用模板方法
  4.       t.templateMethod();
  5. }

代码其实很简单，基本上看到就懂了，关键是要学会用到自己的代码中。

状态模式

update: 2017-10-19

废话我就不说了，我们说一个简单的例子。商品库存中心有个最基本的需求是减库存和补库存，我们看看怎么用状态模式来写。

核心在于，我们的关注点不再是 Context 是该进行哪种操作，而是关注在这个 Context 会有哪些操作。

定义状态接口： 

  1. public interface State {
  2.    public void doAction(Context context);
  3. }

定义减库存的状态： 

  1. public class DeductState implements State {
  3.    public void doAction(Context context) {
  4.       System.out.println("商品卖出，准备减库存");
  5.       context.setState(this);
  7.       //... 执行减库存的具体操作
  8.    }
  10.    public String toString(){
  11.       return "Deduct State";
  12.    }
  13. }

定义补库存状态： 

  1. public class RevertState implements State {
  2.     public void doAction(Context context) {
  3.         System.out.println("给此商品补库存");
  4.           context.setState(this);
  6.           //... 执行加库存的具体操作
  7.     }
  8.       public String toString() {
  9.         return "Revert State";
  10.     }
  11. }

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

  1. public class Context {
  2.     private State state;
  3.       private String name;
  4.       public Context(String name) {
  5.         this.name = name;
  6.     }
  8.       public void setState(State state) {
  9.         this.state = state;
  10.     }
  11.       public void getState() {
  12.         return this.state;
  13.     }
  14. }

我们来看下客户端调用，大家就一清二楚了： 

  1. public static void main(String[] args) {
  2.     // 我们需要操作的是 iPhone X
  3.     Context context = new Context("iPhone X");
  5.     // 看看怎么进行补库存操作
  6.       State revertState = new RevertState();
  7.       revertState.doAction(context);

行为型模式

行为型模式关注的是各个类之间的相互作用，将职责划分清楚，使得我们的代码更加地清晰。

策略模式

策略模式太常用了，所以把它放到最前面进行介绍。它比较简单，我就不废话，直接用代码说事吧。

下面设计的场景是，我们需要画一个图形，可选的策略就是用红色笔来画，还是绿色笔来画，或者蓝色笔来画。

首先，先定义一个策略接口： 

  1. public interface Strategy {
  2.    public void draw(int radius, int x, int y);
  3. }

然后我们定义具体的几个策略： 

  1. public class RedPen implements Strategy {
  2.    @Override
  3.    public void draw(int radius, int x, int y) {
  4.       System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
  5.    }
  6. }
  7. public class GreenPen implements Strategy {
  8.    @Override
  9.    public void draw(int radius, int x, int y) {
  10.       System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
  11.    }
  12. }
  13. public class BluePen implements Strategy {
  14.    @Override
  15.    public void draw(int radius, int x, int y) {
  16.       System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
  17.    }
  18. }

使用策略的类： 

  1. public class Context {
  2.    private Strategy strategy;
  4.    public Context(Strategy strategy){
  5.       this.strategy = strategy;
  6.    }
  8.    public int executeDraw(int radius, int x, int y){
  9.       return strategy.draw(radius, x, y);
  10.    }
  11. }

客户端演示： 

  1. public static void main(String[] args) {
  2.     Context context = new Context(new BluePen()); // 使用绿色笔来画
  3.       context.executeDraw(10, 0, 0);
  4. }

放到一张图上，让大家看得清晰些：

​

这个时候，大家有没有联想到结构型模式中的桥梁模式，它们其实非常相似，我把桥梁模式的图拿过来大家对比下：

​

要我说的话，它们非常相似，桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低，结构更复杂一些。

观察者模式

观察者模式对于我们来说，真是再简单不过了。无外乎两个操作，观察者订阅自己关心的主题和主题有数据变化后通知观察者们。

首先，需要定义主题，每个主题需要持有观察者列表的引用，用于在数据变更的时候通知各个观察者： 

  1. public class Subject {
  3.    private List<Observer> observers = new ArrayList<Observer>();
  4.    private int state;
  6.    public int getState() {
  7.       return state;
  8.    }
  10.    public void setState(int state) {
  11.       this.state = state;
  12.       // 数据已变更，通知观察者们
  13.       notifyAllObservers();
  14.    }
  16.    public void attach(Observer observer){
  17.       observers.add(observer);
  18.    }
  20.    // 通知观察者们
  21.    public void notifyAllObservers(){
  22.       for (Observer observer : observers) {
  23.          observer.update();
  24.       }
  25.    }
  26. }

定义观察者接口： 

  1. public abstract class Observer {
  2.    protected Subject subject;
  3.    public abstract void update();
  4. }

其实如果只有一个观察者类的话，接口都不用定义了，不过，通常场景下，既然用到了观察者模式，我们就是希望一个事件出来了，会有多个不同的类需要处理相应的信息。比如，订单修改成功事件，我们希望发短信的类得到通知、发邮件的类得到通知、处理物流信息的类得到通知等。

我们来定义具体的几个观察者类： 

  1. public class BinaryObserver extends Observer {
  3.       // 在构造方法中进行订阅主题
  4.     public BinaryObserver(Subject subject) {
  5.         this.subject = subject;
  6.         // 通常在构造方法中将 this 发布出去的操作一定要小心
  7.         this.subject.attach(this);
  8.     }
  10.       // 该方法由主题类在数据变更的时候进行调用
  11.     @Override
  12.     public void update() {
  13.         String result = Integer.toBinaryString(subject.getState());
  14.         System.out.println("订阅的数据发生变化，新的数据处理为二进制值为：" + result);
  15.     }
  16. }
  18. public class HexaObserver extends Observer {
  20.     public HexaObserver(Subject subject) {
  21.         this.subject = subject;
  22.         this.subject.attach(this);
  23.     }
  25.     @Override
  26.     public void update() {
  27.           String result = Integer.toHexString(subject.getState()).toUpperCase();
  28.         System.out.println("订阅的数据发生变化，新的数据处理为十六进制值为：" + result);
  29.     }
  30. }

客户端使用也非常简单： 

  1. public static void main(String[] args) {
  2.     // 先定义一个主题
  3.       Subject subject1 = new Subject();
  4.       // 定义观察者
  5.       new BinaryObserver(subject1);
  6.       new HexaObserver(subject1);
  8.       // 模拟数据变更，这个时候，观察者们的 update 方法将会被调用
  9.       subject.setState(11);
  10. }

output: 

  1. 订阅的数据发生变化，新的数据处理为二进制值为：1011
  2. 订阅的数据发生变化，新的数据处理为十六进制值为：B

当然，jdk 也提供了相似的支持，具体的大家可以参考 java.util.Observable 和 java.util.Observer 这两个类。

实际生产过程中，观察者模式往往用消息中间件来实现，如果要实现单机观察者模式，笔者建议读者使用 Guava 中的 EventBus，它有同步实现也有异步实现，本文主要介绍设计模式，就不展开说了。

责任链模式

责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了，后面会自动流转下去。比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了。

有这么一个场景，用户参加一个活动可以领取奖品，但是活动需要进行很多的规则校验然后才能放行，比如首先需要校验用户是否是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。设定的规则都通过后，才能让用户领走奖品。

如果产品给你这个需求的话，我想大部分人一开始肯定想的就是，用一个 List 来存放所有的规则，然后 foreach 执行一下每个规则就好了。不过，读者也先别急，看看责任链模式和我们说的这个有什么不一样？

首先，我们要定义流程上节点的基类： 

  1. public abstract class RuleHandler {
  3.       // 后继节点
  4.     protected RuleHandler successor;
  6.     public abstract void apply(Context context);
  8.     public void setSuccessor(RuleHandler successor) {
  9.         this.successor = successor;
  10.     }
  11.     public RuleHandler getSuccessor() {
  12.         return successor;
  13.     }
  14. }

接下来，我们需要定义具体的每个节点了。

校验用户是否是新用户： 

  1. public class NewUserRuleHandler extends RuleHandler {
  3.     public void apply(Context context) {
  4.         if (context.isNewUser()) {
  5.               // 如果有后继节点的话，传递下去
  6.             if (this.getSuccessor() != null) {
  7.                 this.getSuccessor().apply(context);
  8.             }
  9.         } else {
  10.             throw new RuntimeException("该活动仅限新用户参与");
  11.         }
  12.     }
  14. }

校验用户所在地区是否可以参与： 

  1. public class LocationRuleHandler extends RuleHandler {
  2.     public void apply(Context context) {
  3.         boolean allowed = activityService.isSupportedLocation(context.getLocation);
  4.           if (allowed) {
  5.             if (this.getSuccessor() != null) {
  6.                 this.getSuccessor().apply(context);
  7.             }
  8.         } else  {
  9.             throw new RuntimeException("非常抱歉，您所在的地区无法参与本次活动");
  10.         }
  11.     }
  12. }

校验奖品是否已领完： 

  1. public class LimitRuleHandler extends RuleHandler {
  2.     public void apply(Context context) {
  3.           int remainedTimes = activityService.queryRemainedTimes(context); // 查询剩余奖品
  4.         if (remainedTimes > 0) {
  5.             if (this.getSuccessor() != null) {
  6.                 this.getSuccessor().apply(userInfo);
  7.             }
  8.         } else {
  9.             throw new RuntimeException("您来得太晚了，奖品被领完了");
  10.         }
  11.     }
  12. }

客户端： 

  1. public static void main(String[] args) {
  2.     RuleHandler newUserHandler = new NewUserRuleHandler();
  3.       RuleHandler locationHandler = new LocationRuleHandler();
  4.       RuleHandler limitHandler = new LimitRuleHandler();
  6.       // 假设本次活动仅校验地区和奖品数量，不校验新老用户
  7.       locationHandler.setSuccessor(limitHandler);
  8.       locationHandler.apply(context);
  9. }

代码其实很简单，就是先定义好一个链表，然后在通过任意一节点后，如果此节点有后继节点，那么传递下去。

至于它和我们前面说的用一个 List 存放需要执行的规则的做法有什么异同，留给读者自己琢磨吧。

模板方法模式

在含有继承结构的代码中，模板方法模式是非常常用的，这也是在开源代码中大量被使用的。

通常会有一个抽象类： 

  1. public abstract class AbstractTemplate {
  2.     // 这就是模板方法
  3.       public void templateMethod(){
  4.         init();
  5.         apply(); // 这个是重点
  6.         end(); // 可以作为钩子方法
  7.     }
  8.     protected void init() {
  9.         System.out.println("init 抽象层已经实现，子类也可以选择覆写");
  10.     }
  11.       // 留给子类实现
  12.     protected abstract void apply();
  13.     protected void end() {
  14.     }
  15. }

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

我们写一个实现类： 

  1. public class ConcreteTemplate extends AbstractTemplate {
  2.     public void apply() {
  3.         System.out.println("子类实现抽象方法 apply");
  4.     }
  5.       public void end() {
  6.         System.out.println("我们可以把 method3 当做钩子方法来使用，需要的时候覆写就可以了");
  7.     }
  8. }

客户端调用演示： 

  1. public static void main(String[] args) {
  2.     AbstractTemplate t = new ConcreteTemplate();
  3.       // 调用模板方法
  4.       t.templateMethod();
  5. }

代码其实很简单，基本上看到就懂了，关键是要学会用到自己的代码中。

状态模式

update: 2017-10-19

废话我就不说了，我们说一个简单的例子。商品库存中心有个最基本的需求是减库存和补库存，我们看看怎么用状态模式来写。

核心在于，我们的关注点不再是 Context 是该进行哪种操作，而是关注在这个 Context 会有哪些操作。

定义状态接口： 

  1. public interface State {
  2.    public void doAction(Context context);
  3. }

定义减库存的状态： 

  1. public class DeductState implements State {
  3.    public void doAction(Context context) {
  4.       System.out.println("商品卖出，准备减库存");
  5.       context.setState(this);
  7.       //... 执行减库存的具体操作
  8.    }
  10.    public String toString(){
  11.       return "Deduct State";
  12.    }
  13. }

定义补库存状态： 

  1. public class RevertState implements State {
  2.     public void doAction(Context context) {
  3.         System.out.println("给此商品补库存");
  4.           context.setState(this);
  6.           //... 执行加库存的具体操作
  7.     }
  8.       public String toString() {
  9.         return "Revert State";
  10.     }
  11. }

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

  1. public class Context {
  2.     private State state;
  3.       private String name;
  4.       public Context(String name) {
  5.         this.name = name;
  6.     }
  8.       public void setState(State state) {
  9.         this.state = state;
  10.     }
  11.       public void getState() {
  12.         return this.state;
  13.     }
  14. }

我们来看下客户端调用，大家就一清二楚了： 

  1. public static void main(String[] args) {
  2.     // 我们需要操作的是 iPhone X
  3.     Context context = new Context("iPhone X");
  5.     // 看看怎么进行补库存操作
  6.       State revertState = new RevertState();
  7.       revertState.doAction(context);
  9.     // 同样的，减库存操作也非常简单
  10.       State deductState = new DeductState();
  11.       deductState.doAction(context);
  13.       // 如果需要我们可以获取当前的状态
  14.     // context.getState().toString();
  15. }

读者可能会发现，在上面这个例子中，如果我们不关心当前 context 处于什么状态，那么 Context 就可以不用维护 state 属性了，那样代码会简单很多。

不过，商品库存这个例子毕竟只是个例，我们还有很多实例是需要知道当前 context 处于什么状态的。

行为型模式总结

行为型模式部分介绍了策略模式、观察者模式、责任链模式、模板方法模式和状态模式，其实，经典的行为型模式还包括备忘录模式、命令模式等，但是它们的使用场景比较有限，而且本文篇幅也挺大了，我就不进行介绍了。

总结

学习设计模式的目的是为了让我们的代码更加的优雅、易维护、易扩展。这次整理这篇文章，让我重新审视了一下各个设计模式，对我自己而言收获还是挺大的。我想，文章的最大收益者一般都是作者本人，为了写一篇文章，需要巩固自己的知识，需要寻找各种资料，而且，自己写过的才最容易记住，也算是我给读者的建议吧。

（全文完）

转自https://javadoop.com/post/design-pattern

更多内容请关注微信公众号【Java技术江湖】

这是一位阿里 Java 工程师的技术小站，作者黄小斜，专注 Java 相关技术：SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程，偶尔讲点Docker、ELK，同时也分享技术干货和学习经验，致力于Java全栈开发！（关注公众号后回复”资料“即可领取 3T 免费技术学习资源以及我我原创的程序员校招指南、Java学习指南等资源）

​ 

  3.     // 同样的，减库存操作也非常简单
  4.       State deductState = new DeductState();
  5.       deductState.doAction(context);
  7.       // 如果需要我们可以获取当前的状态
  8.     // context.getState().toString();
  9. }

读者可能会发现，在上面这个例子中，如果我们不关心当前 context 处于什么状态，那么 Context 就可以不用维护 state 属性了，那样代码会简单很多。

不过，商品库存这个例子毕竟只是个例，我们还有很多实例是需要知道当前 context 处于什么状态的。

行为型模式总结

行为型模式部分介绍了策略模式、观察者模式、责任链模式、模板方法模式和状态模式，其实，经典的行为型模式还包括备忘录模式、命令模式等，但是它们的使用场景比较有限，而且本文篇幅也挺大了，我就不进行介绍了。

总结

学习设计模式的目的是为了让我们的代码更加的优雅、易维护、易扩展。这次整理这篇文章，让我重新审视了一下各个设计模式，对我自己而言收获还是挺大的。我想，文章的最大收益者一般都是作者本人，为了写一篇文章，需要巩固自己的知识，需要寻找各种资料，而且，自己写过的才最容易记住，也算是我给读者的建议吧。

（全文完）

转自https://javadoop.com/post/design-pattern

初探Java设计模式2：结构型模式（代理模式，适配器模式等）的更多相关文章

  1. 【设计模式】结构型01代理模式（Proxy Pattern）

    代理模式(Proxy Pattern) 定义:顾名思义,增加中间层,为其他对象提供一种代理以控制对这个对象的访问.核心在于代理二字. 1.和适配器模式的区别:适配器模式主要改变所考虑对象的接口,而代理 ...

  2. 【设计模式】结构型03外观模式（Facade Pattern）

    [设计模式]结构型02装饰模式(Decorator Pattern) 意图:为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用. 主要解决:降低访问 ...

  3. java设计模式（一）动态代理模式，JDK与CGLIB分析

    -本想着这个知识点放到Spring Aop说说可能更合适一点,但因为上一篇有所提到就简单分析下,不足之处请多多评论留言,相互学习,有所提高才是关键! 什么是代理模式: 记得有本24种设计模式的书讲到代 ...

  4. JAVA设计模式 5【结构型】代理模式的理解与使用

    今天要开始我们结构型 设计模式的学习,设计模式源于生活,还是希望能通过生活中的一些小栗子去理解学习它,而不是为了学习而学习这些东西. 结构型设计模式 结构型设计模式又分为 类 结构型 对象 结构型 前 ...

  5. python设计模式---结构型之代理模式

    主要想着nginx:) from abc import ABCMeta, abstractmethod # 结构型设计模式---代理模式 class Actor: def __init__(self) ...

  6. Java设计模式之结构型模式

    结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 一.适配器模式: 意图: 将一个类的接口转换成客户希望的另外一个接口.Adapter 模式使得原本由于接 ...

  7. 【java设计模式】（3）---代理模式（案例解析）

    设计模式之代理模式 一.概述 1.什么是代理模式? 解释第一遍:代理模式主要由三个元素共同构成: 1)一个接口,接口中的方法是要真正去实现的. 2)被代理类,实现上述接口,这是真正去执行接口中方法的类 ...

  8. 结构型：代理模式 Vs 适配器模式 Vs 门面模式(外观模式)

    先上UML图 代理模式: 适配器模式: 门面模式(外观模式): 打了例子……呃……举个比方 代理模式: 水浒街,西门庆看上潘金莲,想和她嘿咻嘿咻,但是自己有不能去找潘金莲去说,于是他找到了金牌代理人王 ...

  9. Java设计模式（八）Proxy代理模式

    一.场景描述 代理在生活中并不少见,租房子需要找中介,打官司需要找律师,很多事情我们需要找专业人士代理我们做,另一方面,中介和律师也代理了房东.法律程序与我们打交道. 当然,设计模式中的代理与广义的代 ...

  10. 【设计模式】结构型05组合模式（Composite Pattern）

    组合模式(Composite Pattern) 意图:将对象组合成树形结构以表示"部分-整体"的层次结构.组合模式使得用户对单个对象和组合对象的使用具有一致性. 主要解决:它在我们 ...

随机推荐

  1. linux中sogou输入法崩溃重启

    经常在linux中搜狗输入法用着用着就崩溃了,无法输入中文,又不想重启电脑,照着下面在终端输入命令可以重启输入法: 1.先关闭fcitx(小企鹅输入法,提供了良好的中文输入法环境) # killall ...

  2. RSP小组——团队冲刺博客六

    RSP小组--团队冲刺博客六 冲刺日期:2018年12月18日 前言 各成员今日(12.18)完成的任务 李闻洲,赵乾宸代码合并 马瑞蕃图形后续支持,编写博客,燃尽图 蒋子行会议记录 各个成员的任务安 ...

  3. 数据分析——pyecharts

    导入类库 from pyecharts import Pie, Bar, Gauge, EffectScatter, WordCloud, Map, Grid, Line, Timeline impo ...

  4. H5测试点总结-UI测试、功能测试、兼容性测试、体验相关（弱网、资源、手机操作等）、安全性测试、性能测试

    一.概述 1.1 什么是H5 H5 即 HTML5,是最新的 Web 端开发语言版本,现如今,大多数手机 APP 页面会用 H5 实现,包括 PC Web 站点也会用它开发实现.所以 Web 的通用测 ...

  5. Java-IO流之转换流的使用和编码与解码原理

    一.理论: 1.字符流和字节流区别是什么? 字符流=字节流+编码集,在实际读取的时候其实字符流还是按照字节来读取,但是会更具编码集进行查找编码集字典解析相应的字节,使得一次读取出一个字符: 2.什么是 ...

  6. 让数字变化炫酷起来，数字滚动Text组件[Unity]

    让数字滚动起来 上周我的策划又提了样需求,当玩家评分发生变动时,屏幕出现人物评分浮层UI,播放评分数字滚动动画.这类数字滚动需求非常常见,我就按一般思路,将startvalue与endvalue每隔一 ...

  7. gym 101628

    前几天感冒了三天没怎么写题...今天好很多了打个三星场找点手感. 不行啊我好菜啊.只会8个..补题的话,再说吧.G题感觉值得一补. 补了G,K不想写B不会. 说实话这个三星场还是很新人向的,知识点也蛮 ...

  8. PageHelper分页插件及通用分页js

     分页概述 1.物理分页 物理分页依赖的是某一物理实体,这个物理实体就是数据库,比如MySQL数据库提供了limit关键字,程序员只需要编写带有limit关键字的SQL语句,数据库返回的就是分页结果. ...

  9. Vue v-for循环添加表单v-model不重复变动的注意事项！

    正常添加,v-model,修改所有循环会得到一样的结果! 定义一个users[]的数组,不要定义全局的user,而是要在Vue里面的方法里定义局部的变量添加.

  10. 实战深度学习（上）OpenCV库

    在如今人工智能的浪潮下,无数模拟机器学习和深度学习的开发者工具倍出,其中在计算机图形学和计算机视觉里面最流行的一个库就是OpenCV库了.计算机图形学和计算机视觉学在我们的自动驾驶和仿生机器人当中有着 ...