以大话之语，揭秘设计模式之精髓

见解分享

2023-12-23 07:25:53

设计模式：软件开发中的明灯

在浩瀚的软件开发世界中，设计模式犹如夜空中璀璨的星辰，指引着我们编写灵活、可扩展且易于维护的代码。它们为我们在面对复杂的开发场景时提供了经过验证且可重复使用的解决方案。

SOLID原则：代码之基石

SOLID原则是一组黄金准则，为编写健壮、可维护的代码奠定了基础。它们包括：

单一职责原则 (SRP) ：每个类只专注于一项明确的任务。
开放封闭原则 (OCP) ：类对扩展开放，对修改关闭。
里氏替换原则 (LSP) ：子类可以无缝替换其父类。
接口隔离原则 (ISP) ：客户端只依赖于它们需要的接口。
依赖反转原则 (DIP) ：高层模块依赖于抽象，而不是低层模块。

遵循SOLID原则，我们可以构建代码，既能满足当前需求，又能轻松适应未来的变化。

经典设计模式

以下是一些最流行的设计模式，以及它们的用途：

策略模式：应对变化

策略模式允许我们动态地改变算法，无需修改代码。我们只需定义一个策略接口和多个具体策略类，然后在需要时切换策略。

interface Strategy {
  void execute();
}

class ConcreteStrategyA implements Strategy {
  @Override
  public void execute() {
    // 执行算法A
  }
}

class ConcreteStrategyB implements Strategy {
  @Override
  public void execute() {
    // 执行算法B
  }
}

class Context {
  private Strategy strategy;

  public void setStrategy(Strategy strategy) {
    this.strategy = strategy;
  }

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

工厂模式：对象的创建神器

工厂模式将对象的创建过程封装在工厂类中，简化了对象的实例化和管理。

class Factory {
  public Product createProduct(String type) {
    if (type.equals("A")) {
      return new ProductA();
    } else if (type.equals("B")) {
      return new ProductB();
    } else {
      throw new IllegalArgumentException("Invalid product type");
    }
  }
}

单例模式：确保唯一性

单例模式确保整个应用程序中只有一个特定类的实例。这对于控制对象访问和管理资源很有用。

class Singleton {
  private static Singleton instance;

  private Singleton() {
  }

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

装饰器模式：动态添加功能

装饰器模式允许我们动态地向类添加新功能，而无需修改原始类。我们只需创建装饰器类，将原始类包装起来，并添加新的方法。

interface Shape {
  void draw();
}

class Rectangle implements Shape {
  @Override
  public void draw() {
    // 画一个矩形
  }
}

class ColoredShapeDecorator implements Shape {
  private Shape decoratedShape;
  private String color;

  public ColoredShapeDecorator(Shape decoratedShape, String color) {
    this.decoratedShape = decoratedShape;
    this.color = color;
  }

  @Override
  public void draw() {
    decoratedShape.draw();
    System.out.println("绘制颜色：" + color);
  }
}

高级设计模式

除了经典设计模式之外，还有一些高级设计模式值得掌握：

代理模式：访问控制和增强

代理模式提供了一种控制对象访问的方法。代理类可以拦截对目标对象的调用，并执行额外的逻辑，如身份验证或缓存。

interface Target {
  void doSomething();
}

class Proxy implements Target {
  private Target realTarget;

  public Proxy(Target realTarget) {
    this.realTarget = realTarget;
  }

  @Override
  public void doSomething() {
    // 身份验证或缓存逻辑
    realTarget.doSomething();
  }
}

适配器模式：兼容不同接口

适配器模式允许对象与具有不同接口的类一起工作。它通过创建适配器类来转换一个类的接口，使其与另一个类兼容。

interface Target {
  void request();
}

class Adaptee {
  public void specificRequest() {
    // 特定的请求
  }
}

class Adapter implements Target {
  private Adaptee adaptee;

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

  @Override
  public void request() {
    adaptee.specificRequest();
  }
}

观察者模式：松耦合事件通知

观察者模式允许对象松散地耦合在一起，以便当一个对象的状态发生变化时通知其他对象。

interface Subject {
  void attach(Observer observer);
  void detach(Observer observer);
  void notifyObservers();
}

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

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

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

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

interface Observer {
  void update();
}

class ConcreteObserverA implements Observer {
  @Override
  public void update() {
    // 更新逻辑
  }
}