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

创建型设计模式（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 {@Overridepublic void doSomething() {System.out.println("Product A");}
  }interface Factory {Product createProduct();
  }class ConcreteFactoryA implements Factory {@Overridepublic 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 {@Overridepublic void paint() {System.out.println("Windows Button");}
  }interface GUIFactory {Button createButton();
  }class WinFactory implements GUIFactory {@Overridepublic 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();@Overridepublic void buildPartA() {product.setPartA("Part A");}@Overridepublic void buildPartB() {product.setPartB("Part B");}@Overridepublic 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 {@Overridepublic Prototype clone() {return new ConcretePrototype();}
  }// 客户端代码
  Prototype prototype = new ConcretePrototype();
  Prototype clone = prototype.clone();
  

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

总结

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