【设计模式】设计模式初窥

设计模式是软件开发中经过验证的解决方案，用于解决常见的设计问题。Java 中常用的设计模式可以分为三大类：创建型模式、结构型模式 和 行为型模式。以下是常见的设计模式及其在 Java 中的应用：

---

一、创建型模式

用于处理对象创建的模式，隐藏对象创建的细节。

1. 单例模式（Singleton）

• 用途：确保一个类只有一个实例，并提供全局访问点。
• 实现：

  public class Singleton {
      private static Singleton instance;
  
      private Singleton() {} // 私有构造方法
  
      public static Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }
  

• 应用场景：数据库连接池、配置文件管理。

2. 工厂模式（Factory）

• 用途：定义一个创建对象的接口，由子类决定实例化哪个类。
• 实现：

  interface Product {
      void use();
  }
  
  class ConcreteProduct implements Product {
      @Override
      public void use() {
          System.out.println("Using ConcreteProduct");
      }
  }
  
  class Factory {
      public Product createProduct() {
          return new ConcreteProduct();
      }
  }
  

• 应用场景：日志记录器、数据库连接工厂。

3. 抽象工厂模式（Abstract Factory）

• 用途：提供一个创建一系列相关或依赖对象的接口。
• 实现：

  interface Button {
      void render();
  }
  
  interface Checkbox {
      void render();
  }
  
  class WindowsButton implements Button {
      @Override
      public void render() {
          System.out.println("Render Windows Button");
      }
  }
  
  class WindowsCheckbox implements Checkbox {
      @Override
      public void render() {
          System.out.println("Render Windows Checkbox");
      }
  }
  
  interface GUIFactory {
      Button createButton();
      Checkbox createCheckbox();
  }
  
  class WindowsFactory implements GUIFactory {
      @Override
      public Button createButton() {
          return new WindowsButton();
      }
  
      @Override
      public Checkbox createCheckbox() {
          return new WindowsCheckbox();
      }
  }
  

• 应用场景：跨平台 UI 组件库。

4. 建造者模式（Builder）

• 用途：将一个复杂对象的构建与其表示分离。
• 实现：

  class Product {
      private String part1;
      private String part2;
  
      public void setPart1(String part1) { this.part1 = part1; }
      public void setPart2(String part2) { this.part2 = part2; }
  }
  
  interface Builder {
      void buildPart1();
      void buildPart2();
      Product getResult();
  }
  
  class ConcreteBuilder implements Builder {
      private Product product = new Product();
  
      @Override
      public void buildPart1() {
          product.setPart1("Part1");
      }
  
      @Override
      public void buildPart2() {
          product.setPart2("Part2");
      }
  
      @Override
      public Product getResult() {
          return product;
      }
  }
  

• 应用场景：构建复杂对象，如 XML 解析器。

5. 原型模式（Prototype）

• 用途：通过复制现有对象来创建新对象。
• 实现：

  class Prototype implements Cloneable {
      private String name;
  
      public Prototype(String name) {
          this.name = name;
      }
  
      @Override
      protected Prototype clone() throws CloneNotSupportedException {
          return (Prototype) super.clone();
      }
  }
  

• 应用场景：对象创建成本较高的场景。

---

二、结构型模式

用于处理类或对象的组合。

1. 适配器模式（Adapter）

• 用途：将一个类的接口转换成客户端期望的另一个接口。
• 实现：

  interface Target {
      void request();
  }
  
  class Adaptee {
      public void specificRequest() {
          System.out.println("Specific Request");
      }
  }
  
  class Adapter implements Target {
      private Adaptee adaptee;
  
      public Adapter(Adaptee adaptee) {
          this.adaptee = adaptee;
      }
  
      @Override
      public void request() {
          adaptee.specificRequest();
      }
  }
  

• 应用场景：兼容旧系统。

2. 装饰器模式（Decorator）

• 用途：动态地为对象添加功能。
• 实现：

  interface Component {
      void operation();
  }
  
  class ConcreteComponent implements Component {
      @Override
      public void operation() {
          System.out.println("ConcreteComponent Operation");
      }
  }
  
  class Decorator implements Component {
      private Component component;
  
      public Decorator(Component component) {
          this.component = component;
      }
  
      @Override
      public void operation() {
          component.operation();
      }
  }
  

• 应用场景：Java I/O 流（如 BufferedReader）。

3. 代理模式（Proxy）

• 用途：为其他对象提供一个代理以控制对这个对象的访问。
• 实现：

  interface Subject {
      void request();
  }
  
  class RealSubject implements Subject {
      @Override
      public void request() {
          System.out.println("RealSubject Request");
      }
  }
  
  class Proxy implements Subject {
      private RealSubject realSubject;
  
      @Override
      public void request() {
          if (realSubject == null) {
              realSubject = new RealSubject();
          }
          realSubject.request();
      }
  }
  

• 应用场景：延迟加载、权限控制。

---

三、行为型模式

用于处理对象之间的职责分配和通信。

1. 观察者模式（Observer）

• 用途：定义对象间的一对多依赖关系，当一个对象改变状态时，所有依赖者都会收到通知。
• 实现：

  interface Observer {
      void update();
  }
  
  class ConcreteObserver implements Observer {
      @Override
      public void update() {
          System.out.println("Observer Updated");
      }
  }
  
  class Subject {
      private List<Observer> observers = new ArrayList<>();
  
      public void addObserver(Observer observer) {
          observers.add(observer);
      }
  
      public void notifyObservers() {
          for (Observer observer : observers) {
              observer.update();
          }
      }
  }
  

• 应用场景：事件处理系统。

2. 策略模式（Strategy）

• 用途：定义一系列算法，将每个算法封装起来并使它们可以互换。
• 实现：

  interface Strategy {
      void execute();
  }
  
  class ConcreteStrategyA implements Strategy {
      @Override
      public void execute() {
          System.out.println("Strategy A");
      }
  }
  
  class Context {
      private Strategy strategy;
  
      public Context(Strategy strategy) {
          this.strategy = strategy;
      }
  
      public void executeStrategy() {
          strategy.execute();
      }
  }
  

• 应用场景：支付方式选择。

---

总结

设计模式是解决软件设计问题的经典方案。掌握这些模式可以帮助你编写更灵活、可维护的代码。建议通过实际项目练习，深入理解每种模式的应用场景和实现方式。