创建型设计模式与面向接口编程

创建型设计模式（Creational Patterns）的主要目的之一就是帮助实现面向接口编程，避免直接创建实现类的实例。通过这些模式，可以将对象的创建过程封装起来，使得客户端代码不需要知道具体的实现类，从而提高代码的灵活性和可维护性。

以下是创建型设计模式的详细说明及其如何支持面向接口编程：

1. 单例模式（Singleton Pattern）

• 目的：确保一个类只有一个实例，并提供一个全局访问点。
• 面向接口编程：虽然单例模式通常不涉及接口的使用，但它通过控制实例的创建，避免了客户端直接创建实例。
• 示例：

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

  客户端代码只能通过 getInstance() 方法获取实例，无法直接实例化 Singleton 类。

2. 工厂方法模式（Factory Method Pattern）

• 目的：定义一个创建对象的接口，但将实例化的具体类延迟到子类中实现。
• 面向接口编程：客户端代码通过工厂接口创建对象，而不需要知道具体的实现类。
• 示例：

  interface Product {
      void doSomething();
  }
  
  class ConcreteProductA implements Product {
      @Override
      public void doSomething() {
          System.out.println("Product A");
      }
  }
  
  interface Factory {
      Product createProduct();
  }
  
  class ConcreteFactoryA implements Factory {
      @Override
      public Product createProduct() {
          return new ConcreteProductA();
      }
  }
  
  // 客户端代码
  Factory factory = new ConcreteFactoryA();
  Product product = factory.createProduct();
  product.doSomething();
  

  客户端代码只与 Factory 接口和 Product 接口交互，不直接创建 ConcreteProductA 的实例。

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

• 目的：提供一个接口，用于创建一系列相关或依赖的对象，而不指定具体的类。
• 面向接口编程：客户端代码通过抽象工厂接口创建一组相关对象，而不需要知道具体的实现类。
• 示例：

  interface Button {
      void paint();
  }
  
  class WinButton implements Button {
      @Override
      public void paint() {
          System.out.println("Windows Button");
      }
  }
  
  interface GUIFactory {
      Button createButton();
  }
  
  class WinFactory implements GUIFactory {
      @Override
      public Button createButton() {
          return new WinButton();
      }
  }
  
  // 客户端代码
  GUIFactory factory = new WinFactory();
  Button button = factory.createButton();
  button.paint();
  

  客户端代码只与 GUIFactory 接口和 Button 接口交互，不直接创建 WinButton 的实例。

4. 建造者模式（Builder Pattern）

• 目的：将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
• 面向接口编程：客户端代码通过建造者接口构建对象，而不需要知道具体的实现类。
• 示例：

  class Product {
      private String partA;
      private String partB;
      // 构造函数和方法省略
  }
  
  interface Builder {
      void buildPartA();
      void buildPartB();
      Product getProduct();
  }
  
  class ConcreteBuilder implements Builder {
      private Product product = new Product();
  
      @Override
      public void buildPartA() {
          product.setPartA("Part A");
      }
  
      @Override
      public void buildPartB() {
          product.setPartB("Part B");
      }
  
      @Override
      public Product getProduct() {
          return product;
      }
  }
  
  class Director {
      private Builder builder;
  
      public Director(Builder builder) {
          this.builder = builder;
      }
  
      public Product construct() {
          builder.buildPartA();
          builder.buildPartB();
          return builder.getProduct();
      }
  }
  
  // 客户端代码
  Builder builder = new ConcreteBuilder();
  Director director = new Director(builder);
  Product product = director.construct();
  

  客户端代码只与 Builder 接口和 Director 类交互，不直接创建 Product 的实例。

5. 原型模式（Prototype Pattern）

• 目的：通过克隆现有对象来创建新对象，而不是通过标准构造函数。
• 面向接口编程：客户端代码通过原型接口克隆对象，而不需要知道具体的实现类。
• 示例：

  interface Prototype {
      Prototype clone();
  }
  
  class ConcretePrototype implements Prototype {
      @Override
      public Prototype clone() {
          return new ConcretePrototype();
      }
  }
  
  // 客户端代码
  Prototype prototype = new ConcretePrototype();
  Prototype clone = prototype.clone();
  

  客户端代码只与 Prototype 接口交互，不直接创建 ConcretePrototype 的实例。

总结

创建型设计模式通过封装对象的创建过程，实现了面向接口编程，避免了客户端代码直接依赖具体的实现类。这种方式提高了代码的灵活性、可维护性和可扩展性，是实现面向对象设计原则的重要手段。

原文地址：https://blog.csdn.net/joshua0137/article/details/143779850

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！