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