1、备忘录模式

备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象，备忘录模式属于行为型模式。

备忘录模式允许在不破坏封装性的前提下，捕获和恢复对象的内部状态。
实现方式

• 创建备忘录类：用于存储和封装对象的状态。
• 创建发起人角色：负责创建备忘录，并根据需要恢复状态。
• 创建备忘录管理类（可选）：负责管理所有备忘录对象。

2、观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

观察者模式解决的是一个对象状态改变时，如何自动通知其他依赖对象的问题，同时保持对象间的低耦合和高协作性。

2.1、实现方式

• 定义观察者接口：包含一个更新方法。
• 创建具体观察者：实现观察者接口，定义接收到通知时的行为。
• 定义主题接口：包含添加、删除和通知观察者的方法。
• 创建具体主题：实现主题接口，管理观察者列表，并在状态改变时通知它们。

2.2、应用实例

拍卖系统：拍卖师作为主题，竞价者作为观察者，拍卖价格更新时通知所有竞价者。

2.3、优点

• 抽象耦合：观察者和主题之间是抽象耦合的。
• 触发机制：建立了一套状态改变时的触发和通知机制。

2.4、缺点

• 性能问题：如果观察者众多，通知过程可能耗时。
• 循环依赖：可能导致循环调用和系统崩溃。
• 缺乏变化详情：观察者不知道主题如何变化，只知道变化发生。

2.4、使用建议

在需要降低对象间耦合度，并且对象状态变化需要触发其他对象变化时使用。
考虑使用Java内置的观察者模式支持类，如java.util.Observable和java.util.Observer。

2.5、注意事项

避免循环引用：注意观察者和主题之间的依赖关系，避免循环引用。
异步执行：考虑使用异步通知避免单点故障导致整个系统卡壳。

2.6、实现

观察者模式使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。

ObserverPatternDemo，我们的演示类使用 Subject 和实体类对象来演示观察者模式。

步骤 1
创建 Subject 类。

Subject.java
import java.util.ArrayList;
import java.util.List;
 
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();
      }
   }  
}

步骤 2
创建 Observer 类。

Observer.java
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

步骤 3
创建实体观察者类。

BinaryObserver.java
public class BinaryObserver extends Observer{
 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}

OctalObserver.java
public class OctalObserver extends Observer{
 
   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}

HexaObserver.java
public class HexaObserver extends Observer{
 
   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Hex String: " 
      + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

步骤 4
使用 Subject 和实体观察者对象。

ObserverPatternDemo.java
public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();
 
      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);
 
      System.out.println("First state change: 15");   
      subject.setState(15);
      System.out.println("Second state change: 10");  
      subject.setState(10);
   }
}

步骤 5
执行程序，输出结果：

First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010

3、状态模式

在状态模式（State Pattern）中，类的行为是基于它的状态改变的，这种类型的设计模式属于行为型模式。

在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

状态模式允许对象在内部状态改变时改变其行为，使得对象在不同的状态下有不同的行为表现。通过将每个状态封装成独立的类，可以避免使用大量的条件语句来实现状态切换。

3.1、使用场景

当代码中存在大量条件语句，且这些条件语句依赖于对象的状态时。

3.2、使用建议

当对象的行为随状态改变而变化时，考虑使用状态模式。
状态模式适用于替代复杂的条件或分支语句。

3.3、注意事项

状态模式适用于状态数量有限（通常不超过5个）的情况。
谨慎使用，以避免系统变得过于复杂。

4、空对象模式

在空对象模式（Null Object Pattern）中，一个空对象取代 NULL 对象实例的检查。Null 对象不是检查空值，而是反应一个不做任何动作的关系。这样的 Null 对象也可以在数据不可用的时候提供默认的行为。

在空对象模式中，我们创建一个指定各种要执行的操作的抽象类和扩展该类的实体类，还创建一个未对该类做任何实现的空对象类，该空对象类将无缝地使用在需要检查空值的地方。

使用一个空对象代替 null 值，这个空对象实现了相同的接口，但对请求不做任何操作或提供默认操作。

5、策略模式

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

在策略模式定义了一系列算法或策略，并将每个算法封装在独立的类中，使得它们可以互相替换。通过使用策略模式，可以在运行时根据需要选择不同的算法，而不需要修改客户端代码。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

将每个算法封装起来，使它们可以互换使用。

5.1、应用实例

• 锦囊妙计：每个锦囊代表一个策略，包含不同的计策。
• 旅行方式选择：骑自行车、坐汽车等，每种方式都是一个可替换的策略。
• Java AWT的LayoutManager：不同的布局管理器实现了相同的接口，但提供了不同的布局算法。

5.2、优点

• 算法切换自由：可以在运行时根据需要切换算法。
• 避免多重条件判断：消除了复杂的条件语句。
• 扩展性好：新增算法只需新增一个策略类，无需修改现有代码。

5.3、缺点

• 策略类数量增多：每增加一个算法，就需要增加一个策略类。
• 所有策略类都需要暴露：策略类需要对外公开，以便可以被选择和使用。

如果系统中策略类数量过多，考虑使用其他模式或设计技巧来解决类膨胀问题。

6、模板模式

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

在父类中定义了算法的骨架，并允许子类在不改变算法结构的前提下重定义算法的某些特定步骤。

6.1、实现方式

定义抽象父类：包含模板方法和一些抽象方法或具体方法。
实现子类：继承抽象父类并实现抽象方法，不改变算法结构。

6.2、优点

• 封装不变部分：算法的不变部分被封装在父类中。
• 扩展可变部分：子类可以扩展或修改算法的可变部分。
• 提取公共代码：减少代码重复，便于维护。

为了防止恶意修改，模板方法通常使用final关键字修饰，避免被子类重写。

6.3、实现

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

TemplatePatternDemo，我们的演示类使用 Game 来演示模板模式的用法。

步骤 1
创建一个抽象类，它的模板方法被设置为 final。

Game.java
public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();
 
   //模板
   public final void play(){
 
      //初始化游戏
      initialize();
 
      //开始游戏
      startPlay();
 
      //结束游戏
      endPlay();
   }
}

步骤 2
创建扩展了上述类的实体类。

Cricket.java
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!");
   }
}

Football.java
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() 来演示游戏的定义方式。

TemplatePatternDemo.java
public class TemplatePatternDemo {
   public static void main(String[] args) {
 
      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();      
   }
}

步骤 4
执行程序，输出结果：

Cricket Game Initialized! Start playing.
Cricket Game Started. Enjoy the game!
Cricket Game Finished!

Football Game Initialized! Start playing.
Football Game Started. Enjoy the game!
Football Game Finished!

7、访问者模式

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

旨在将数据结构与在该数据结构上执行的操作分离，从而使得添加新的操作变得更容易，而无需修改数据结构本身。

使用场景
当需要对一个对象结构中的对象执行多种不同的且不相关的操作时，尤其是这些操作需要避免"污染"对象类本身。
实现方式
定义访问者接口：声明一系列访问方法，一个访问方法对应数据结构中的一个元素类。
创建具体访问者：实现访问者接口，为每个访问方法提供具体实现。
定义元素接口：声明一个接受访问者的方法。
创建具体元素：实现元素接口，每个具体元素类对应数据结构中的一个具体对象