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

工厂方法设计模式

🚩什么是工厂方法设计模式？
🚩工厂方法模式的特点
🚩工厂方法模式的结构
🚩工厂方法模式的优缺点
🚩抽象工厂模式的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{@Overridepublic 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 {@Overridepublic 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{@Overridepublic 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 {@Overridepublic 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。客户端代码通过调用工厂方法来创建具体的产品对象，而无需关心具体的实现细节。