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

23种设计模式-工厂方法(Factory Method)设计模式

news 来源：原创 2025/5/16 20:34:16

工厂方法设计模式

🚩什么是工厂方法设计模式？
🚩工厂方法模式的特点
🚩工厂方法模式的结构
🚩工厂方法模式的优缺点
🚩抽象工厂模式的Java实现
🚩代码总结
🚩总结

🚩什么是工厂方法设计模式？

工厂方法设计模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但将具体的实例化过程延迟到子类中。工厂方法模式通过让子类决定实例化哪个类，来解耦对象的创建与使用。这种模式的核心思想是将对象的创建过程封装在工厂方法中，客户端只需要依赖抽象接口，而不需要关心具体的实现类。

工厂方法模式是抽象工厂模式的基础，它适用于需要创建单一对象的场景，而抽象工厂模式则适用于创建一系列相关对象的场景。

🚩工厂方法模式的特点

解耦：工厂方法模式将对象的创建与使用分离，客户端只需要依赖抽象接口，而不需要知道具体的实现类。
扩展性：当需要增加新的产品时，只需增加新的工厂子类和产品子类，符合开闭原则。
单一职责：每个工厂类只负责创建一种产品，符合单一职责原则。
灵活性：工厂方法模式可以根据不同的条件或配置创建不同的对象，增强了系统的灵活性。

🚩工厂方法模式的结构

抽象工厂模式通常包含以下几个角色：

抽象产品（Product）：定义产品的接口，是所有具体产品的父类或接口。
具体产品（Concrete Product）：实现抽象产品接口，是工厂方法创建的具体对象。
抽象工厂（Creator）：定义工厂方法接口，返回抽象产品类型的对象。
具体工厂（Concrete Creator）：实现抽象工厂接口，负责创建具体的产品对象。

🚩工厂方法模式的优缺点

优点：

解耦：客户端代码与具体产品类解耦，客户端只需要依赖抽象接口。
扩展性：增加新的产品时，只需增加新的工厂子类和产品子类，无需修改现有代码。
单一职责：每个工厂类只负责创建一种产品，职责清晰。

缺点：

类的数量增加：每增加一个产品，就需要增加一个工厂类，可能会导致类的数量过多。
复杂性增加：对于简单的对象创建场景，使用工厂方法模式可能会增加不必要的复杂性。

🚩抽象工厂模式的Java实现

代码地址：GitHub

首先定义抽象产品（Product）,此处用抽象类也可以，打开注释代码，里面有info方法

/**
 * @author hanson.huang
 * @version V1.0
 * @InterfaceName Product
 * @Description 抽象产品
 * @date 2025/3/21 16:59
 **/
//public abstract class Product {
public interface Product {

//    public abstract void info();
    public void info();
}

定义抽象工厂（Creator），用于创建产品

/**
 * @author hanson.huang
 * @version V1.0
 * @InterfaceName Factory
 * @Description 工厂接口
 * @date 2025/3/21 16:58
 **/
public interface Factory {

    public Product createProduct();
}

现在创建具体产品（Concrete Product），实现产品接口或者继承抽象产品类，重写info方法

ProductA

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName ProductA
 * @Description 产品实现类A
 * @date 2025/3/21 17:01
 **/
//public class ProductA extends Product{
public class ProductA implements Product{

    @Override
    public void info() {
        System.out.println("产品的信息：A");
    }
}

ProductB

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName ProductB
 * @Description 产品实现类B
 * @date 2025/3/21 17:01
 **/
//public class ProductB extends Product {
public class ProductB implements Product {

    @Override
    public void info() {
        System.out.println("产品的信息：B");
    }
}

创建具体工厂（Concrete Creator）来去实现抽象工厂接口，负责创建具体的对象，现在让工厂A创建产品A，让工厂B创建产品B

FactoryA

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName FactoryA
 * @Description 工厂A
 * @date 2025/3/21 17:01
 **/
public class FactoryA implements Factory{

    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

FactoryB

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName FactoryB
 * @Description 工厂B
 * @date 2025/3/21 17:01
 **/
public class FactoryB implements Factory {

    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

客户端调用

/**
 * @author hanson.huang
 * @version V1.0
 * @ClassName FactoryMethod
 * @Description FactoryMethod Main
 * @date 2025/3/21 16:56
 **/
public class FactoryMethod {
    public static void main(String[] args) {

        // 父类 对象名 = new 子类();
        Factory factoryA = new FactoryA();

        Product productA = factoryA.createProduct();
//         Product productA = new ProductA();
        productA.info();

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.info();
    }
}

在这里插入图片描述

🚩代码总结

在这个示例中，我们定义了一个抽象产品接口 Product，并实现了两种具体产品：ProductA和 ProductB。然后，我们定义了一个抽象工厂接口 Factory，并实现了两个具体工厂类：FactoryA 和 FactoryB，分别用于创建ProductA和ProductB。客户端代码通过调用工厂方法来创建具体的产品对象，而无需关心具体的实现细节。