java中23中设计模式，你知道多少？

Java设计模式

设计模式是一种被广泛使用的软件开发方法，它提供了一种解决常见问题的标准化方法。Java语言中有23种设计模式，这些模式可以分为三类：创建型模式、结构型模式和行为型模式。

创建型模式

创建型模式用于处理对象的创建过程，它们可以帮助我们在不同的情况下创建对象。以下是Java中的五种创建型模式：

工厂方法模式

工厂方法模式是一种创建型模式，它定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。这种模式使得一个类的实例化延迟到其子类。

例如，我们可以创建一个抽象的Animal类，然后创建两个子类Dog和Cat。我们可以使用工厂方法模式来创建这些对象：

public abstract class Animal {
    public abstract void makeSound();
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public interface AnimalFactory {
    Animal createAnimal();
}

public class DogFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

public class CatFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

抽象工厂模式

抽象工厂模式是一种创建型模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。

例如，我们可以创建一个抽象的Shape类和一个抽象的Color类，然后创建两个子类Circle和Square，以及两个子类Red和Blue。我们可以使用抽象工厂模式来创建这些对象：

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

public interface Color {
    void fill();
}

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with red");
    }
}

public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with blue");
    }
}

public interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

public class RedCircleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }

    @Override
    public Color createColor() {
        return new Red();
    }
}

public class BlueSquareFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }

    @Override
    public Color createColor() {
        return new Blue();
    }
}

单例模式

单例模式是一种创建型模式，它保证一个类只有一个实例，并提供一个访问它的全局点。

例如，我们可以创建一个Logger类，它只有一个实例：

public class Logger {
    private static Logger instance;

    private Logger() {}

    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }

    public void log(String message) {
        System.out.println(message);
    }
}

建造者模式

建造者模式是一种创建型模式，它将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

例如，我们可以创建一个Pizza类，然后使用建造者模式来创建不同类型的披萨：

public class Pizza {
    private String dough;
    private String sauce;
    private String topping;

    public Pizza(String dough, String sauce, String topping) {
        this.dough = dough;
        this.sauce = sauce;
        this.topping = topping;
    }

    public String getDough() {
        return dough;
    }

    public String getSauce() {
        return sauce;
    }

    public String getTopping() {
        return topping;
    }
}

public interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildTopping();
    Pizza getPizza();
}

public class HawaiianPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public HawaiianPizzaBuilder() {
        pizza = new Pizza("", "", "");
    }

    @Override
    public void buildDough() {
        pizza = new Pizza("cross", "", "");
    }

    @Override
    public void buildSauce() {
        pizza = new Pizza("cross", "mild", "");
    }

    @Override
    public void buildTopping() {
        pizza = new Pizza("cross", "mild", "ham+pineapple");
    }

    @Override
    public Pizza getPizza() {
        return pizza;
    }
}

public class Waiter {
    private PizzaBuilder pizzaBuilder;

    public void setPizzaBuilder(PizzaBuilder pizzaBuilder) {
        this.pizzaBuilder = pizzaBuilder;
    }

    public Pizza getPizza() {
        return pizzaBuilder.getPizza();
    }

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildTopping();
    }
}

原型模式

原型模式是一种创建型模式，它允许通过复制现有对象来创建新对象。

例如，我们可以创建一个Person类，然后使用原型模式来创建新的人：

public class Person implements Cloneable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }
}

结构型模式

适配器模式

适配器模式是一种结构型模式，它允许将一个类的接口转换为客户端所期望的另一种接口。适配器模式通常用于将旧的接口转换为新的接口，以便与现有的代码兼容。例如，如果一个类使用一个接口，而另一个类使用另一个接口，适配器模式可以用来将这两个接口连接起来。

public interface MediaPlayer {
   public void play(String audioType, String fileName);
}

public interface AdvancedMediaPlayer {    
   public void playVlc(String fileName);
   public void playMp4(String fileName);
}

public class VlcPlayer implements AdvancedMediaPlayer{
   @Override
   public void playVlc(String fileName) {
      System.out.println("Playing vlc file. Name: "+ fileName);        
   }

   @Override
   public void playMp4(String fileName) {
      //什么也不做
   }
}

public class Mp4Player implements AdvancedMediaPlayer{

   @Override
   public void playVlc(String fileName) {
      //什么也不做
   }

   @Override
   public void playMp4(String fileName) {
      System.out.println("Playing mp4 file. Name: "+ fileName);        
   }
}

public class MediaAdapter implements MediaPlayer {

   AdvancedMediaPlayer advancedMusicPlayer;

   public MediaAdapter(String audioType){
      if(audioType.equalsIgnoreCase("vlc") ){
         advancedMusicPlayer = new VlcPlayer();       
      }else if (audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer = new Mp4Player();
      }  
   }

   @Override
   public void play(String audioType, String fileName) {

      if(audioType.equalsIgnoreCase("vlc")){
         advancedMusicPlayer.playVlc(fileName);
      }
      else if(audioType.equalsIgnoreCase("mp4")){
         advancedMusicPlayer.playMp4(fileName);
      }
   }
}

public class AudioPlayer implements MediaPlayer {
   MediaAdapter mediaAdapter; 

   @Override
   public void play(String audioType, String fileName) {    

      //播放 mp3 音乐文件的内置支持
      if(audioType.equalsIgnoreCase("mp3")){
         System.out.println("Playing mp3 file. Name: " + fileName);            
      } 
      //mediaAdapter 提供了播放其他文件格式的支持
      else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
         mediaAdapter = new MediaAdapter(audioType);
         mediaAdapter.play(audioType, fileName);
      }
      else{
         System.out.println("Invalid media. " + audioType + " format not supported");
      }
   }   
}

桥接模式

桥接模式是一种结构型模式，它将抽象部分与实现部分分离，以便两者可以独立地变化。桥接模式通常用于将抽象类与其实现分离，以便可以在运行时动态地选择不同的实现。

public interface DrawAPI {
   public void drawCircle(int radius, int x, int y);
}

public class RedCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: red, radius: " + radius +", x: " +x+", "+ y +"]");
   }
}

public class GreenCircle implements DrawAPI {
   @Override
   public void drawCircle(int radius, int x, int y) {
      System.out.println("Drawing Circle[ color: green, radius: " + radius +", x: " +x+", "+ y +"]");
   }
}

public abstract class Shape {
   protected DrawAPI drawAPI;
   
   protected Shape(DrawAPI drawAPI){
      this.drawAPI = drawAPI;
   }
   public abstract void draw();    
}

public class Circle extends Shape {
   private int x, y, radius;

   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
      super(drawAPI);
      this.x = x;  
      this.y = y;  
      this.radius = radius;
   }

   public void draw() {
      drawAPI.drawCircle(radius,x,y);
   }
}

组合模式

组合模式是一种结构型模式，它允许将对象组合成树形结构，以表示“部分-整体”的层次结构。组合模式通常用于处理具有层次结构的对象，例如文件系统中的文件和文件夹。

public interface Employee {
   public void add(Employee employee);
   public void remove(Employee employee);
   public Employee getChild(int i);
   public String getName();
   public double getSalary();
   public void print();
}

public class Developer implements Employee {
   private String name;
   private double salary;

   public Developer(String name,double salary){
      this.name = name;
      this.salary = salary;
   }

   public void add(Employee employee) {
      //什么也不做，因为这是叶节点
   }

   public Employee getChild(int i) {
      //什么也不做，因为这是叶节点
      return null;
   }

   public String getName() {
      return name;
   }

   public double getSalary() {
      return salary;
   }

   public void print() {
      System.out.println("-------------");
      System.out.println("Name ="+getName());
      System.out.println("Salary ="+getSalary());
      System.out.println("-------------");
   }

   public void remove(Employee employee) {
      //什么也不做，因为这是叶节点
   }

}

public class Manager implements Employee {

   private String name;
   private double salary;

   public Manager(String name,double salary){
      this.name = name;
      this.salary = salary;
   }

   List<Employee> employees = new ArrayList<Employee>();

   public void add(Employee employee) {
      employees.add(employee);
   }

   public Employee getChild(int i) {
      return employees.get(i);
   }

   public String getName() {
      return name;
   }

   public double getSalary() {
      return salary;
   }

   public void print() {
      System.out.println("-------------");
      System.out.println("Name ="+getName());
      System.out.println("Salary ="+getSalary());
      System.out.println("-------------");

      Iterator<Employee> employeeIterator = employees.iterator();
      while(employeeIterator.hasNext()){
         Employee employee = employeeIterator.next();
         employee.print();
      }
   }

   public void remove(Employee employee) {
      employees.remove(employee);
   }
}

装饰器模式(Decorator Pattern)

理论介绍

装饰器模式是一种结构型设计模式，它允许你动态地向对象添加行为，而不会影响其他对象。装饰器模式通常用于需要在运行时扩展对象功能的情况。

在装饰器模式中，我们定义一个装饰器类，它包含一个指向被装饰对象的引用，并实现与被装饰对象相同的接口。装饰器类可以在运行时添加新的行为，而不会影响被装饰对象的行为。

例子

假设我们有一个 Shape 接口，它有一个 draw() 方法。我们想要创建一个可以在运行时添加颜色的装饰器。我们可以定义一个 ColorDecorator 类，它包含一个指向 Shape 对象的引用，并实现 Shape 接口。ColorDecorator 类可以在 draw() 方法中添加颜色。

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class ColorDecorator implements Shape {
    private Shape shape;
    private String color;

    public ColorDecorator(Shape shape, String color) {
        this.shape = shape;
        this.color = color;
    }

    @Override
    public void draw() {
        shape.draw();
        System.out.println("Adding color " + color);
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        circle.draw();

        Shape redCircle = new ColorDecorator(circle, "red");
        redCircle.draw();

        Shape blueCircle = new ColorDecorator(circle, "blue");
        blueCircle.draw();
    }
}

输出：

Drawing a circle
Drawing a circle
Adding color red
Drawing a circle
Adding color blue

外观模式(Facade Pattern)

理论介绍

外观模式是一种结构型设计模式，它为复杂的子系统提供了一个简单的接口。外观模式隐藏了子系统的复杂性，并提供了一个更简单的接口，使客户端能够更容易地使用子系统。

在外观模式中，我们定义一个外观类，它包含一个指向子系统的引用，并提供一个简单的接口。客户端可以使用外观类来访问子系统，而不必了解子系统的复杂性。

例子

假设我们有一个 Computer 类，它包含了许多子系统，如 CPU、内存、硬盘等。我们想要为客户端提供一个简单的接口，使其能够更容易地使用这些子系统。我们可以定义一个 ComputerFacade 类，它包含一个指向 Computer 对象的引用，并提供一个简单的接口。

class CPU {
    public void processData() {
        System.out.println("Processing data");
    }
}

class Memory {
    public void load() {
        System.out.println("Loading memory");
    }
}

class HardDrive {
    public void readData() {
        System.out.println("Reading data from hard drive");
    }
}

class Computer {
    private CPU cpu;
    private Memory memory;
    private HardDrive hardDrive;

    public Computer() {
        this.cpu = new CPU();
        this.memory = new Memory();
        this.hardDrive = new HardDrive();
    }

    public void start() {
        cpu.processData();
        memory.load();
        hardDrive.readData();
        System.out.println("Computer started");
    }
}

class ComputerFacade {
    private Computer computer;

    public ComputerFacade() {
        this.computer = new Computer();
    }

    public void start() {
        computer.start();
    }
}

public class Main {
    public static void main(String[] args) {
        ComputerFacade computerFacade = new ComputerFacade();
        computerFacade.start();
    }
}

输出：

Processing data
Loading memory
Reading data from hard drive
Computer started

享元模式(Flyweight Pattern)

理论介绍

享元模式是一种结构型设计模式，它通过共享对象来减少内存使用和对象创建的数量。享元模式通常用于需要创建大量相似对象的情况。

在享元模式中，我们定义一个享元工厂，它包含一个对象池，用于存储共享对象。客户端可以从享元工厂获取共享对象，并在需要时将其返回给享元工厂。

例子

假设我们有一个 Shape 接口，它有一个 draw() 方法。我们想要创建许多相似的圆形对象，但是我们不想为每个圆形对象创建一个新的对象。我们可以使用享元模式来共享圆形对象。

interface Shape {
    void draw();
}

class Circle implements Shape {
    private String color;

    public Circle(String color) {
        this.color = color;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " circle");
    }
}

class ShapeFactory {
    private static final Map<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Shape circle = circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Creating a " + color + " circle");
        }

        return circle;
    }
}

public class Main {
    private static final String[] colors = {"red", "green", "blue"};

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            Shape circle = ShapeFactory.getCircle(getRandomColor());
            circle.draw();
        }
    }

    private static String getRandomColor() {
        return colors[(int) (Math.random() * colors.length)];
    }
}

输出：

Creating a red circle
Drawing a red circle
Creating a green circle
Drawing a green circle
Creating a blue circle
Drawing a blue circle
Drawing a red circle
Drawing a green circle
Drawing a blue circle
Drawing a red circle
Drawing a green circle
Drawing a blue circle
Drawing a red circle
Drawing a green circle
Drawing a blue circle
Drawing a red circle
Drawing a green circle
Drawing a blue circle
Drawing a red circle
Drawing a green circle
Drawing a blue circle

代理模式(Proxy Pattern)

理论介绍

代理模式是一种结构型设计模式，它允许通过创建一个代理对象来控制对另一个对象的访问。代理对象充当客户端和实际对象之间的中介，隐藏了实际对象的复杂性。

代理模式的主要目的是为了提供一种更加灵活的方式来管理和控制对象的访问。它可以用于许多不同的场景，例如：

• 远程代理：允许客户端通过网络访问远程对象。
• 虚拟代理：允许在需要时延迟实际对象的创建。
• 保护代理：允许控制对实际对象的访问权限。

代理模式通常由以下几个角色组成：

• 抽象主题（Subject）：定义了代理和实际对象之间的公共接口。
• 实际主题（Real Subject）：实现了抽象主题接口的实际对象。
• 代理（Proxy）：实现了抽象主题接口，并包含一个指向实际对象的引用。

例子

下面是一个简单的例子，展示了如何使用代理模式来实现虚拟代理。假设我们有一个 Image 接口，它有一个 display() 方法用于显示图像。我们还有一个 RealImage 类，它实现了 Image 接口，并且在创建时需要加载图像文件。我们希望在需要时延迟加载图像文件，因此我们创建了一个 ProxyImage 类，它也实现了 Image 接口，并且在第一次调用 display() 方法时加载实际的 RealImage 对象。

// Image 接口
public interface Image {
    void display();
}

// RealImage 类
public class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    @Override
    public void display() {
        System.out.println("Displaying " + filename);
    }

    private void loadImageFromDisk() {
        System.out.println("Loading " + filename + " from disk");
    }
}

// ProxyImage 类
public class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;

    public ProxyImage(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

// 使用代理模式
Image image = new ProxyImage("test.jpg");
image.display();

在上面的例子中，我们创建了一个 ProxyImage 对象来代理 RealImage 对象。当我们第一次调用 display() 方法时，ProxyImage 对象会创建一个实际的 RealImage 对象，并调用它的 display() 方法。在后续的调用中，ProxyImage 对象会直接调用实际的 RealImage 对象的 display() 方法。这样就实现了延迟加载的效果。

行为型模式

行为型模式是一种设计模式，它关注对象之间的通信和协作，以实现特定的行为。这些模式描述了对象之间的交互方式，以及如何在运行时动态地改变对象的行为。

行为型模式包括以下几种设计模式：

观察者模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时，它的所有依赖者（观察者）都会收到通知并自动更新。

Java代码例子

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void detach(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");
        Observer observer3 = new ConcreteObserver("Observer 3");

        subject.attach(observer1);
        subject.attach(observer2);
        subject.attach(observer3);

        subject.notifyObservers("Hello World!");

        subject.detach(observer2);

        subject.notifyObservers("Goodbye World!");
    }
}

策略模式

策略模式定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用它们的客户端。

Java代码例子

interface Strategy {
    int execute(int a, int b);
}

class AddStrategy implements Strategy {
    @Override
    public int execute(int a, int b) {
        return a + b;
    }
}

class SubtractStrategy implements Strategy {
    @Override
    public int execute(int a, int b) {
        return a - b;
    }
}

class Calculator {
    private Strategy strategy;

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

    public int executeStrategy(int a, int b) {
        return strategy.execute(a, b);
    }
}

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

        calculator = new Calculator(new SubtractStrategy());
        System.out.println("10 - 5 = " + calculator.executeStrategy(10, 5));
    }
}

模板方法模式

模板方法模式定义了一个算法的骨架，将一些步骤延迟到子类中实现。模板方法模式使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

Java代码例子

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

    public final void play() {
        initialize();
        startPlay();
        endPlay();
    }
}

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

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

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

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

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

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

public class TemplatePatternDemo {
    public static void main(String[] args) {
        Game game = new Cricket();
        game.play();

        System.out.println();

        game = new Football();
        game.play();
    }
}

命令模式

命令模式将请求封装成对象，以便可以将请求的不同参数、方法调用或操作放入队列中、记录日志、进行撤销等操作。命令模式可以将请求的发送者和接收者解耦。

Java代码例子

interface Command {
    void execute();
}

class Light {
    public void turnOn() {
        System.out.println("Light is on");
    }

    public void turnOff() {
        System.out.println("Light is off");
    }
}

class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }
}

class RemoteControl {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}

public class CommandPatternDemo {
    public static void main(String[] args) {
        Light light = new Light();
        Command lightOnCommand = new LightOnCommand(light);
        Command lightOffCommand = new LightOffCommand(light);

        RemoteControl remoteControl = new RemoteControl();
        remoteControl.setCommand(lightOnCommand);
        remoteControl.pressButton();

        remoteControl.setCommand(lightOffCommand);
        remoteControl.pressButton();
    }
}

迭代器模式（Iterator Pattern）

理论介绍

迭代器模式是一种行为型设计模式，它允许客户端通过迭代器按顺序访问一个聚合对象中的元素，而不必暴露聚合对象的内部表示。迭代器模式将遍历算法与聚合分离，使得聚合对象的实现和遍历算法的实现可以独立变化。

迭代器模式包含以下角色：

• 抽象迭代器（Iterator）：定义访问和遍历聚合对象中元素的接口。
• 具体迭代器（ConcreteIterator）：实现抽象迭代器接口，对聚合对象进行遍历。
• 抽象聚合（Aggregate）：定义创建迭代器对象的接口。
• 具体聚合（ConcreteAggregate）：实现抽象聚合接口，创建具体迭代器对象。

Java代码例子

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IteratorPatternExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

职责链模式（Chain of Responsibility Pattern）

理论介绍

职责链模式是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。职责链模式将请求沿着处理链传递，直到有一个对象处理它为止。

职责链模式包含以下角色：

• 抽象处理者（Handler）：定义处理请求的接口，并维护一个指向下一个处理者的引用。
• 具体处理者（ConcreteHandler）：实现抽象处理者接口，处理它所负责的请求，如果不能处理，则将请求传递给下一个处理者。
• 客户端（Client）：创建处理链，并向链头的处理者发送请求。

Java代码例子

public abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(int request);
}

public class ConcreteHandler1 extends Handler {
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println(this.getClass().getSimpleName() + " handled request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

public class ConcreteHandler2 extends Handler {
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println(this.getClass().getSimpleName() + " handled request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

public class ConcreteHandler3 extends Handler {
    public void handleRequest(int request) {
        if (request >= 20 && request < 30) {
            System.out.println(this.getClass().getSimpleName() + " handled request " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

public class ChainOfResponsibilityPatternExample {
    public static void main(String[] args) {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        h1.setSuccessor(h2);
        h2.setSuccessor(h3);

        int[] requests = {2, 5, 14, 22, 18, 3, 27, 20};

        for (int request : requests) {
            h1.handleRequest(request);
        }
    }
}

状态模式（State Pattern）

理论介绍

状态模式是一种行为型设计模式，它允许对象在内部状态发生改变时改变它的行为。状态模式将对象的行为封装在不同的状态对象中，使得对象在不同状态下具有不同的行为。

状态模式包含以下角色：

• 抽象状态（State）：定义一个接口，用于封装与上下文对象的特定状态相关的行为。
• 具体状态（ConcreteState）：实现抽象状态接口，定义与上下文对象的特定状态相关的行为。
• 上下文（Context）：维护一个对抽象状态对象的引用，定义一个接口，用于与客户端交互。
• 客户端（Client）：创建上下文对象，并将请求发送给上下文对象。

Java代码例子

public interface State {
    void doAction(Context context);
}

public class StartState implements State {
    public void doAction(Context context) {
        System.out.println("Player is in start state");
        context.setState(this);
    }

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

public class StopState implements State {
    public void doAction(Context context) {
        System.out.println("Player is in stop state");
        context.setState(this);
    }

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

public class Context {
    private State state;

    public Context() {
        state = null;
    }

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

    public State getState() {
        return state;
    }
}

public class StatePatternExample {
    public static void main(String[] args) {
        Context context = new Context();

        StartState startState = new StartState();
        startState.doAction(context);

        System.out.println(context.getState().toString());

        StopState stopState = new StopState();
        stopState.doAction(context);

        System.out.println(context.getState().toString());
    }
}

访问者模式（Visitor Pattern）

理论介绍

访问者模式是一种行为型设计模式，它允许你将算法与其所作用的对象分离开来。通过这种方式，算法可以在不改变对象结构的情况下被添加到对象中。

该模式的核心思想是将数据结构和数据操作分离开来，使得数据结构可以独立于数据操作而变化。访问者模式的实现方式是在数据结构中定义一个 accept 方法，该方法接受一个访问者对象作为参数，然后让访问者对象对数据结构进行操作。

Java代码例子

下面是一个简单的访问者模式的 Java 代码例子：

// 定义一个访问者接口
interface Visitor {
    void visit(ElementA element);
    void visit(ElementB element);
}

// 定义一个元素接口
interface Element {
    void accept(Visitor visitor);
}

// 具体元素 A
class ElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 具体元素 B
class ElementB implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 具体访问者
class ConcreteVisitor implements Visitor {
    @Override
    public void visit(ElementA element) {
        System.out.println("访问元素 A");
    }

    @Override
    public void visit(ElementB element) {
        System.out.println("访问元素 B");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Element elementA = new ElementA();
        Element elementB = new ElementB();

        Visitor visitor = new ConcreteVisitor();

        elementA.accept(visitor);
        elementB.accept(visitor);
    }
}

备忘录模式（Memento Pattern）

理论介绍

备忘录模式是一种行为型设计模式，它允许你在不暴露对象实现细节的情况下保存和恢复对象之前的状态。

该模式的核心思想是将对象的状态保存到备忘录对象中，然后在需要恢复对象状态时，从备忘录对象中获取之前保存的状态。备忘录模式的实现方式是在原始对象中定义一个 createMemento 方法，该方法返回一个备忘录对象，然后在需要恢复状态时，调用备忘录对象的 restore 方法。

Java代码例子

下面是一个简单的备忘录模式的 Java 代码例子：

// 备忘录类
class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

// 原始类
class Originator {
    private String state;

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

    public String getState() {
        return state;
    }

    public Memento createMemento() {
        return new Memento(state);
    }

    public void restore(Memento memento) {
        state = memento.getState();
    }
}

// 管理者类
class Caretaker {
    private Memento memento;

    public void saveMemento(Memento memento) {
        this.memento = memento;
    }

    public Memento getMemento() {
        return memento;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();

        originator.setState("State 1");
        caretaker.saveMemento(originator.createMemento());

        originator.setState("State 2");
        caretaker.saveMemento(originator.createMemento());

        originator.restore(caretaker.getMemento());
        System.out.println(originator.getState());

        originator.restore(caretaker.getMemento());
        System.out.println(originator.getState());
    }
}

解释器模式（Interpreter Pattern）

理论介绍

解释器模式是一种行为型设计模式，它允许你定义语言的文法，并且使用该语言来解释和执行特定的操作。

该模式的核心思想是将语言的文法表示为一个抽象语法树，然后使用该语法树来解释和执行特定的操作。解释器模式的实现方式是定义一个抽象表达式类，该类定义了解释器的接口，然后定义具体的表达式类，实现解释器的具体操作。

Java代码例子

下面是一个简单的解释器模式的 Java 代码例子：

// 抽象表达式类
interface Expression {
    boolean interpret(String context);
}

// 具体表达式类 A
class ExpressionA implements Expression {
    @Override
    public boolean interpret(String context) {
        return context.contains("A");
    }
}

// 具体表达式类 B
class ExpressionB implements Expression {
    @Override
    public boolean interpret(String context) {
        return context.contains("B");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Expression expressionA = new ExpressionA();
        Expression expressionB = new ExpressionB();

        String context = "A B";

        System.out.println(expressionA.interpret(context));
        System.out.println(expressionB.interpret(context));
    }
}

解释器模式（Interpreter Pattern）

理论介绍

解释器模式是一种行为型设计模式，它允许你定义语言的文法，并且使用该语言来解释和执行特定的操作。

该模式的核心思想是将语言的文法表示为一个抽象语法树，然后使用该语法树来解释和执行特定的操作。解释器模式的实现方式是定义一个抽象表达式类，该类定义了解释器的接口，然后定义具体的表达式类，实现解释器的具体操作。

Java代码例子

下面是一个简单的解释器模式的 Java 代码例子：

// 抽象表达式类
interface Expression {
    boolean interpret(String context);
}

// 具体表达式类 A
class ExpressionA implements Expression {
    @Override
    public boolean interpret(String context) {
        return context.contains("A");
    }
}

// 具体表达式类 B
class ExpressionB implements Expression {
    @Override
    public boolean interpret(String context) {
        return context.contains("B");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Expression expressionA = new ExpressionA();
        Expression expressionB = new ExpressionB();

        String context = "A B";

        System.out.println(expressionA.interpret(context));
        System.out.println(expressionB.interpret(context));
    }
}