当前位置：首页 > news >正文

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

news 2025/7/9 20:02:41

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