Java学习--设计模式之行为型模式（三）

 

一、空对象模式（Null Object Pattern）

　　1、概念

　　　在空对象模式（Null Object Pattern）中，一个空对象取代 NULL 对象实例的检查。Null 对象不是检查空值，而是反应一个不做任何动作的关系。这样的 Null 对象也可以在数据不可用的时候提供默认的行为。在空对象模式中，我们创建一个指定各种要执行的操作的抽象类和扩展该类的实体类，还创建一个未对该类做任何实现的空对象类，该空对象类将无缝地使用在需要检查空值的地方。

　　2、实例

　　　我们将创建一个定义操作（在这里，是客户的名称）的 AbstractCustomer 抽象类，和扩展了 AbstractCustomer 类的实体类。工厂类 CustomerFactory 基于客户传递的名字来返回 RealCustomer 或 NullCustomer 对象。演示类 NullPatternDemo，我们的演示类使用 CustomerFactory 来演示空对象模式的用法。

　　　　

　　　　（1）、创建一个抽象类

public abstract class AbstractCustomer {
   protected String name;
   public abstract boolean isNil();
   public abstract String getName();
}

　　　　（2）、扩展一个执行操作的实体类

public class RealCustomer extends AbstractCustomer {

   public RealCustomer(String name) {
      this.name = name;        
   }
   
   @Override
   public String getName() {
      return name;
   }
   
   @Override
   public boolean isNil() {
      return false;
   }
}

　　　　（3）、扩展一个不做任何实现的空对象类

public class NullCustomer extends AbstractCustomer {

   @Override
   public String getName() {
      return "Not Available in Customer Database";
   }

   @Override
   public boolean isNil() {
      return true;
   }
}

　　　　（4）、创建 CustomerFactory 类

public class CustomerFactory {
    
   public static final String[] names = {"Rob", "Joe", "Julie"};

   public static AbstractCustomer getCustomer(String name){
      for (int i = 0; i < names.length; i++) {
         if (names[i].equalsIgnoreCase(name)){
            return new RealCustomer(name);
         }
      }
      return new NullCustomer();
   }
}

　　　　（5）、使用 CustomerFactory，基于客户传递的名字，来获取 RealCustomer 或 NullCustomer 对象

public class NullPatternDemo {
   public static void main(String[] args) {

      AbstractCustomer customer1 = CustomerFactory.getCustomer("Rob");
      AbstractCustomer customer2 = CustomerFactory.getCustomer("Bob");
      AbstractCustomer customer3 = CustomerFactory.getCustomer("Julie");
      AbstractCustomer customer4 = CustomerFactory.getCustomer("Laura");

      System.out.println("Customers");
      System.out.println(customer1.getName());
      System.out.println(customer2.getName());
      System.out.println(customer3.getName());
      System.out.println(customer4.getName());
   }
}

　　　　（5）、演示结果

1 Customers
2 Rob
3 Not Available in Customer Database
4 Julie
5 Not Available in Customer Database

二、策略模式（Strategy Pattern）

　　1、概念

　　　在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

　　2、简介

　　　意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

　　　主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

　　　何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

　　　如何解决：将这些算法封装成一个一个的类，任意地替换。

　　　关键代码：实现同一个接口。

　　　优点： 

　　　　（1）、算法可以自由切换。

　　　　（2）、避免使用多重条件判断。

　　　　（3）、扩展性良好。

　　　缺点： 

　　　　（1）、策略类会增多。

　　　　（2）、所有策略类都需要对外暴露。

　　　使用场景： 

　　　　（1）、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

　　　　（2）、一个系统需要动态地在几种算法中选择一种。

　　　　（3）、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

　　　注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

　　3、实例

　　　我们将创建一个定义活动的 Strategy 接口和实现了 Strategy 接口的实体策略类。Context 是一个使用了某种策略的类。演示类 StrategyPatternDemo，我们的演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化。

　　　　

　　　　（1）、创建一个接口

public interface Strategy {
   public int doOperation(int num1, int num2);
}

　　　　（2）、创建接口的实现类

public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

public class OperationSubstract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

　　　　（3）、创建 Context 类

public class Context {
   private Strategy strategy;

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

   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

　　　　（4）、使用 Context 来查看当它改变策略 Strategy 时的行为变化。

public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());        
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationSubstract());        
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

      context = new Context(new OperationMultiply());        
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}

　　　　（5）、演示结果

1 10 + 5 = 15
2 10 - 5 = 5
3 10 * 5 = 50

三、模板模式（Template Pattern）

　　1、概念

　　　在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

　　2、简介

　　　意图：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

　　　主要解决：一些方法通用，却在每一个子类都重新写了这一方法。

　　　何时使用：有一些通用的方法。

　　　如何解决：将这些通用算法抽象出来。

　　　关键代码：在抽象类实现，其他步骤在子类实现。

　　　优点： 

　　　　（1）、封装不变部分，扩展可变部分。

　　　　（2）、提取公共代码，便于维护。

　　　　（3）、行为由父类控制，子类实现。

　　　缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

　　　使用场景： 

　　　　（1）、有多个子类共有的方法，且逻辑相同。

　　　　（2）、重要的、复杂的方法，可以考虑作为模板方法。

　　　注意事项：为防止恶意操作，一般模板方法都加上 final 关键词。

　　3、实例

　　　我们将创建一个定义操作的 Game 抽象类，其中，模板方法设置为 final，这样它就不会被重写。Cricket 和 Football 是扩展了 Game 的实体类，它们重写了抽象类的方法。演示类 TemplatePatternDemo，我们的演示类使用 Game 来演示模板模式的用法。

　　　　

　　　　（1）、创建一个抽象类，将他的模板方法设置为 final

public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();

   //模板
   public final void play(){

      //初始化游戏
      initialize();

      //开始游戏
      startPlay();

      //结束游戏
      endPlay();
   }
}

　　　　（2）、创建实体游戏类

public class Cricket extends Game {

   @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }

   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }

   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}

public class Football extends Game {

   @Override
   void endPlay() {
      System.out.println("Football Game Finished!");
   }

   @Override
   void initialize() {
      System.out.println("Football Game Initialized! Start playing.");
   }

   @Override
   void startPlay() {
      System.out.println("Football Game Started. Enjoy the game!");
   }
}

　　　　（3）、使用 Game 的模板方法 play() 来演示游戏的定义方式。

public class TemplatePatternDemo {
   public static void main(String[] args) {

      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();        
   }
}

　　　　（4）、演示结果

1 Cricket Game Initialized! Start playing.
2 Cricket Game Started. Enjoy the game!
3 Cricket Game Finished!
4 
5 Football Game Initialized! Start playing.
6 Football Game Started. Enjoy the game!
7 Football Game Finished!

四、访问者模式（Visitor Pattern）

　　1、概念

　　　在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

　　2、简介

　　　意图：主要将数据结构与数据操作分离。

　　　主要解决：稳定的数据结构和易变的操作耦合问题。

　　　何时使用：需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。

　　　如何解决：在被访问的类里面加一个对外提供接待访问者的接口。

　　　关键代码：在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。

　　　应用实例：您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。

　　　优点： 

　　　　（1）、符合单一职责原则。

　　　　（2）、优秀的扩展性。

　　　　（3）、灵活性。

　　　缺点： 

　　　　（1）、具体元素对访问者公布细节，违反了迪米特原则。

　　　　（2）、具体元素变更比较困难。

　　　　（3）、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。

　　　使用场景： 

　　　　（1）、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。

　　　　（2）、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。

　　　注意事项：访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。

　　3、实例

　　　我们将创建一个定义接受操作的 ComputerPart 接口。Keyboard、Mouse、Monitor 和 Computer 是实现了 ComputerPart 接口的实体类。我们将定义另一个接口 ComputerPartVisitor，它定义了访问者类的操作。Computer 使用实体访问者来执行相应的动作。演示类 VisitorPatternDemo，我们的演示类使用 Computer、ComputerPartVisitor 类来演示访问者模式的用法。

　　　　

　　　　（1）、定义一个表示元素的接口

public interface ComputerPart {
   public void accept(ComputerPartVisitor computerPartVisitor);
}

　　　　（2）、扩展不同访问的实体类

public class Keyboard  implements ComputerPart {

   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}

public class Monitor  implements ComputerPart {

   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}

public class Mouse  implements ComputerPart {

   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}

public class Computer implements ComputerPart {
    
   ComputerPart[] parts;

   public Computer(){
      parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()};        
   } 


   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      for (int i = 0; i < parts.length; i++) {
         parts[i].accept(computerPartVisitor);
      }
      computerPartVisitor.visit(this);
   }
}

　　　　（3）、定义一个表示访问者的接口

public interface ComputerPartVisitor {
    public void visit(Computer computer);
    public void visit(Mouse mouse);
    public void visit(Keyboard keyboard);
    public void visit(Monitor monitor);
}

　　　　（4）、创建实现了上述类的实体访问者

public class ComputerPartDisplayVisitor implements ComputerPartVisitor {

   @Override
   public void visit(Computer computer) {
      System.out.println("Displaying Computer.");
   }

   @Override
   public void visit(Mouse mouse) {
      System.out.println("Displaying Mouse.");
   }

   @Override
   public void visit(Keyboard keyboard) {
      System.out.println("Displaying Keyboard.");
   }

   @Override
   public void visit(Monitor monitor) {
      System.out.println("Displaying Monitor.");
   }
}

　　　　（5）、使用 ComputerPartDisplayVisitor 来显示 Computer 的组成部分。

public class VisitorPatternDemo {
   public static void main(String[] args) {

      ComputerPart computer = new Computer();
      computer.accept(new ComputerPartDisplayVisitor());
   }
}

　　　　（6）、演示结果

1 Displaying Mouse.
2 Displaying Keyboard.
3 Displaying Monitor.
4 Displaying Computer.

行为型模式的介绍就到这里了，如有误，还请各位大佬指正；