深入浅出：设计模式精粹

2024-01-24 19:28:49

设计模式：代码库中的必备工具

作为开发者，掌握设计模式至关重要。它们为常见编程问题提供通用解决方案，助力您编写更健壮、更易维护的代码。现在，让我们揭开设计模式的神秘面纱。

创建型模式

顾名思义，创建型模式专注于创建对象。它们允许您以灵活且可重用的方式实例化对象。

工厂模式： 隐藏对象创建细节，以便在不同情况下使用不同工厂创建不同类型的对象。

class Factory {
  public Product createProduct(String type) {
    switch (type) {
      case "A": return new ProductA();
      case "B": return new ProductB();
      default: throw new IllegalArgumentException();
    }
  }
}

抽象工厂模式： 创建一系列相关的对象，而无需指定具体类。

interface ShapeFactory {
  Shape createShape(String type);
}

class CircleFactory implements ShapeFactory {
  @Override
  public Shape createShape(String type) {
    if (type.equals("CIRCLE")) {
      return new Circle();
    } else {
      return null;
    }
  }
}

单例模式： 确保类只有一个实例，并提供全局访问点。

class Singleton {
  private static Singleton instance;

  private Singleton() {}

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

建造者模式： 分步构建复杂对象，分离构建过程和对象表示。

class CarBuilder {
  private Car car;

  public CarBuilder() {
    car = new Car();
  }

  public CarBuilder withEngine(Engine engine) {
    car.setEngine(engine);
    return this;
  }

  public CarBuilder withWheels(int numWheels) {
    car.setWheels(numWheels);
    return this;
  }

  public Car build() {
    return car;
  }
}

结构型模式

结构型模式组织对象，让您创建复杂结构并灵活地与它们交互。

适配器模式： 将一个对象的接口转换为另一个接口，实现不兼容对象之间的协作。

interface Target {
  void doSomething();
}

class Adaptee {
  void specificDoSomething() { /* ... */ }
}

class Adapter implements Target {
  private Adaptee adaptee;

  public Adapter(Adaptee adaptee) {
    this.adaptee = adaptee;
  }

  @Override
  public void doSomething() {
    adaptee.specificDoSomething();
  }
}

桥接模式： 分离抽象和实现，允许独立修改它们。

interface Implementor {
  void operation();
}

class ConcreteImplementorA implements Implementor {
  @Override
  public void operation() {
    /* ... */
  }
}

class RefinedAbstraction {
  protected Implementor implementor;

  public RefinedAbstraction(Implementor implementor) {
    this.implementor = implementor;
  }

  public void operation() {
    implementor.operation();
  }
}

组合模式： 将对象排列成树形结构，一致处理单个对象和组合对象。

interface Component {
  void operation();
}

class Leaf implements Component {
  @Override
  public void operation() {
    /* ... */
  }
}

class Composite implements Component {
  private List<Component> children;

  public Composite() {
    children = new ArrayList<>();
  }

  @Override
  public void operation() {
    for (Component child : children) {
      child.operation();
    }
  }
}

装饰器模式： 动态地为对象添加功能，无需修改底层代码。

interface Shape {
  void draw();
}

class Circle implements Shape {
  @Override
  public void draw() {
    /* ... */
  }
}

class Decorator implements Shape {
  private Shape shape;

  public Decorator(Shape shape) {
    this.shape = shape;
  }

  @Override
  public void draw() {
    shape.draw();
    /* Add extra functionality */
  }
}

行为型模式

行为型模式定义对象之间的通信和交互方式，帮助您定义和实现行为。

策略模式： 定义算法族，并让客户端在运行时选择一个算法。

interface Strategy {
  void execute();
}

class ConcreteStrategyA implements Strategy {
  @Override
  public void execute() {
    /* ... */
  }
}

class ConcreteStrategyB implements Strategy {
  @Override
  public void execute() {
    /* ... */
  }
}

class Context {
  private Strategy strategy;

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

  public void executeStrategy() {
    strategy.execute();
  }
}

观察者模式： 当一个对象发生变化时，通知多个观察者。

interface Observable {
  void addObserver(Observer observer);
  void removeObserver(Observer observer);
  void notifyObservers();
}

class ConcreteObservable implements Observable {
  private List<Observer> observers;

  public ConcreteObservable() {
    observers = new ArrayList<>();
  }

  @Override
  public void addObserver(Observer observer) {
    observers.add(observer);
  }

  @Override
  public void removeObserver(Observer observer) {
    observers.remove(observer);
  }

  @Override
  public void notifyObservers() {
    for (Observer observer : observers) {
      observer.update();
    }
  }
}

interface Observer {
  void update();
}

class ConcreteObserver implements Observer {
  @Override
  public void update() {
    /* ... */
  }
}

模板方法模式： 定义操作的一般步骤，允许子类重新定义某些步骤。

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

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

  protected void hook() { /* ... */ }
}

class ConcreteClass extends AbstractClass {
  @Override
  protected void primitiveOperation1() {
    /* ... */
  }

  @Override
  protected void primitiveOperation2() {
    /* ... */
  }

  @Override
  protected void hook() {
    /* ... */
  }
}

迭代器模式： 提供一种方法来顺序访问集合中的元素，无需公开集合的内部表示。

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

class ConcreteIterator implements Iterator {
  private Collection collection;
  private int index;

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

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

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

享元模式： 使用少量共享对象来表示大量相似对象，减少内存使用量。

class FlyweightFactory {
  private Map<String, Flyweight> flyweights;

  public Flyweight getFlyweight(String key) {
    if (flyweights == null) {
      flyweights = new HashMap<>();
    }
    if (!flyweights.containsKey(key)) {
      flyweights.put(key, new Flyweight(key));
    }
    return flyweights.get(key);
  }
}

class Flyweight {
  private String key;

  public Flyweight(String key) {
    this.key = key;
  }

  public String getKey() {
    return key;
  }
}