直击灵魂的设计模式：行为型篇

2023-06-04 09:10:12

掌握行为型设计模式，让你的软件设计更灵活

在软件开发的世界里，设计模式就像一把瑞士军刀，为各种常见的编程问题提供了现成的解决方案。行为型设计模式专注于对象之间的交互，帮助你让它们更有效地协作。

一、策略模式：兵来将挡，水来土掩

策略模式让你可以动态地选择算法或策略，而无需改变现有代码。它就像一个将军，根据不同的战况灵活部署不同的战术。

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

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

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

class Context {
  private Strategy strategy;

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

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

// ...
Context context = new Context(new AddStrategy());
int result = context.executeStrategy(10, 5); // result = 15

二、模板方法模式：循序渐进，有条不紊

模板方法模式提供了一个算法框架，子类可以在不改变算法结构的情况下重定义算法的某些步骤。就像一个菜谱，它定义了烹饪的基本步骤，但允许厨师添加自己独特的配料。

abstract class AbstractClass {
  public void templateMethod() {
    primitiveOperation1();
    primitiveOperation2();
  }

  protected abstract void primitiveOperation1();
  protected abstract void primitiveOperation2();
}

class ConcreteClassA extends AbstractClass {
  @Override
  protected void primitiveOperation1() {
    System.out.println("ConcreteClassA: Operation 1");
  }

  @Override
  protected void primitiveOperation2() {
    System.out.println("ConcreteClassA: Operation 2");
  }
}

class ConcreteClassB extends AbstractClass {
  @Override
  protected void primitiveOperation1() {
    System.out.println("ConcreteClassB: Operation 1");
  }

  @Override
  protected void primitiveOperation2() {
    System.out.println("ConcreteClassB: Operation 2");
  }
}

// ...
AbstractClass classA = new ConcreteClassA();
classA.templateMethod();
// Output:
// ConcreteClassA: Operation 1
// ConcreteClassA: Operation 2

三、观察者模式：千里之外，同心同德

观察者模式建立了一种一对多的依赖关系，多个对象可以同时监听某个对象的事件。就像一群守卫，当旗帜升起时，他们会立即做出反应。

interface Observer {
  void update(String message);
}

class ConcreteObserverA implements Observer {
  @Override
  public void update(String message) {
    System.out.println("ConcreteObserverA: Received message: " + message);
  }
}

class ConcreteObserverB implements Observer {
  @Override
  public void update(String message) {
    System.out.println("ConcreteObserverB: Received message: " + 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);
    }
  }
}

// ...
Subject subject = new Subject();
Observer observerA = new ConcreteObserverA();
Observer observerB = new ConcreteObserverB();
subject.attach(observerA);
subject.attach(observerB);

subject.notifyObservers("Hello World!");
// Output:
// ConcreteObserverA: Received message: Hello World!
// ConcreteObserverB: Received message: Hello World!

四、迭代器模式：漫步其间，游刃有余

迭代器模式提供一种遍历集合的方式，而无需了解集合的内部结构。就像一个向导，它带你浏览集合中的每个元素，而你无需知道集合的幕后工作原理。

interface Iterator {
  boolean hasNext();
  Object next();
}

class ConcreteIterator implements Iterator {
  private Collection<?> collection;
  private int currentIndex = 0;

  public ConcreteIterator(Collection<?> collection) {
    this.collection = collection;
  }

  @Override
  public boolean hasNext() {
    return currentIndex < collection.size();
  }

  @Override
  public Object next() {
    return collection.get(currentIndex++);
  }
}

class Aggregate {
  private Collection<?> collection;

  public Aggregate(Collection<?> collection) {
    this.collection = collection;
  }

  public Iterator createIterator() {
    return new ConcreteIterator(collection);
  }
}

// ...
Collection<String> names = List.of("Alice", "Bob", "Carol");
Aggregate aggregate = new Aggregate(names);

Iterator iterator = aggregate.createIterator();
while (iterator.hasNext()) {
  String name = (String) iterator.next();
  System.out.println(name);
}
// Output:
// Alice
// Bob
// Carol

五、责任链模式：层层递进，逐级处理

责任链模式定义了一个链式处理机制，允许请求在多个对象之间依次传递。就像一个齿轮系统，每个齿轮都承担自己的一部分责任，最终完成任务。

interface Handler {
  boolean handleRequest(Request request);
}

class ConcreteHandlerA implements Handler {
  @Override
  public boolean handleRequest(Request request) {
    if (request.getType() == "TypeA") {
      System.out.println("ConcreteHandlerA: Handling request");
      return true;
    }
    return false;
  }
}

class ConcreteHandlerB implements Handler {
  @Override
  public boolean handleRequest(Request request) {
    if (request.getType() == "TypeB") {
      System.out.println("ConcreteHandlerB: Handling request");
      return true;
    }
    return false;
  }
}

class Request {
  private String type;

  public Request(String type) {
    this.type = type;
  }

  public String getType() {
    return type;
  }
}

class ChainOfResponsibility {
  private List<Handler> handlers = new ArrayList<>();

  public ChainOfResponsibility() {
    handlers.add(new ConcreteHandlerA());
    handlers.add(new ConcreteHandlerB());
  }

  public void handleRequest(Request request) {
    for (Handler handler : handlers) {
      if (handler.handleRequest(request)) {
        return;
      }
    }
    System.out.println("No handler found for request");
  }
}

// ...
ChainOfResponsibility chainOfResponsibility = new ChainOfResponsibility();
Request requestA = new Request("TypeA");
Request requestB = new Request("TypeB");
Request requestC = new Request("TypeC");

chainOfResponsibility.handleRequest(requestA);
chainOfResponsibility.handleRequest(requestB);
chainOfResponsibility.handleRequest(requestC);
// Output:
// ConcreteHandlerA: Handling request
// ConcreteHandlerB: Handling request
// No handler found for request