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

创建型设计模式（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 的实例。