【设计模式】工厂模式
目录
什么是工厂模式
工厂模式是一种设计模式，用于创建对象的过程与对象使用者解耦，从而提高代码的灵活性和可维护性。在工厂模式中，将对象的创建过程封装在一个工厂类中，使用者不需要直接实例化对象，而是通过工厂类来获取所需的对象实例。
简单来说就是，封装工厂类，工厂类获取实例。
工厂模式变体
-
简单工厂模式（Simple Factory Pattern）： 简单工厂模式由一个工厂类负责创建所有对象实例，使用者通过调用工厂类的静态方法来获取对象实例。这种模式简单易懂，但违背了开放-封闭原则，因为每次新增一个产品都需要修改工厂类。
-
工厂方法模式（Factory Method Pattern）： 工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。这样可以将实例化的过程延迟到子类中，符合开放-封闭原则，但需要为每个具体产品定义一个工厂类。
-
抽象工厂模式（Abstract Factory Pattern）： 抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。它将一组具有相似主题的工厂封装起来，对于增加新的产品族很方便，但是难以增加新的产品等级结构。
工厂模式优缺点
优点
- 降低耦合性： 使用者只需要知道工厂类及其接口，无需关心具体的产品实现，降低了对象之间的耦合性。
- 提高可维护性： 当需要更改产品类时，只需修改工厂类的代码，而不需要修改使用者的代码。
- 增加扩展性： 可以根据需求轻松添加新的产品类，而无需更改现有代码。
缺点
- 增加了类的数量： 引入了额外的工厂类，可能会增加类的数量，使得代码结构变得复杂。
- 增加了系统的抽象性和理解难度： 对于初学者来说，理解工厂模式的思想和实现可能会比较困难，特别是在涉及多层次的抽象工厂时。
简单工厂模式的实现
代码实现
/**
* @description:
* @author: 黎剑
* @create: 2024-04-16 22:32
**/
// 定义产品接口
interface Product {
void operation();
}
// 具体产品类A
class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("具体产品A的操作");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("具体产品B的操作");
}
}
// 简单工厂类
class SimpleFactory {
// 根据参数创建对应的产品实例
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ConcreteProductA();
} else if ("B".equals(type)) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Unsupported product type: " + type);
}
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 使用工厂类创建产品实例
Product productA = SimpleFactory.createProduct("A");
Product productB = SimpleFactory.createProduct("B");
// 调用产品实例的操作方法
productA.operation();
productB.operation();
}
} 在这个示例中，Product 是一个产品接口，定义了产品的操作方法。ConcreteProductA 和 ConcreteProductB 是具体的产品类，实现了 Product 接口。
SimpleFactory 是工厂类，负责根据传入的参数来创建具体的产品实例。在 Client 类中，通过调用工厂类的 createProduct 方法来获取所需的产品实例，并调用产品实例的操作方法。
这样，客户端代码与具体产品类之间解耦，客户端只需要与工厂类打交道，可以根据需要轻松切换不同的产品类型。
工厂模式方法的实现
工厂方法模式的核心思想是定义一个抽象的工厂类，该工厂类包含一个抽象方法，用于创建产品对象。具体的产品类需要实现这个抽象方法，以创建具体的产品实例。
工厂方法模式通常包括以下角色：
-
抽象产品（Abstract Product）： 定义了产品的接口，描述了产品的特性和行为。
-
具体产品（Concrete Product）： 实现了抽象产品接口，定义了具体产品的具体行为。
-
抽象工厂（Abstract Factory）： 定义了一个抽象方法，用于创建产品对象，客户端通过调用这个方法来获取产品对象。
-
具体工厂（Concrete Factory）： 实现了抽象工厂接口，负责创建具体的产品对象。
代码实现
/**
* @description:
* @author: 黎剑
* @create: 2024-04-16 22:32
**/
// 定义抽象产品接口
interface Product {
void operation();
}
// 具体产品类A
class ConcreteProductA implements Product {
@Override
public void operation() {
System.out.println("具体产品A的操作");
}
}
// 具体产品类B
class ConcreteProductB implements Product {
@Override
public void operation() {
System.out.println("具体产品B的操作");
}
}
// 抽象工厂接口
interface Factory {
Product createProduct();
}
// 具体工厂类A
class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
// 具体工厂类B
class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建具体工厂实例
Factory factoryA = new ConcreteFactoryA();
Factory factoryB = new ConcreteFactoryB();
// 使用具体工厂创建产品实例
Product productA = factoryA.createProduct();
Product productB = factoryB.createProduct();
// 调用产品实例的操作方法
productA.operation();
productB.operation();
}
}
在这个示例中，Product 是抽象产品接口，定义了产品的操作方法。ConcreteProductA 和 ConcreteProductB 是具体的产品类，分别实现了 Product 接口。
Factory 是抽象工厂接口，定义了一个抽象方法 createProduct()，用于创建产品实例。ConcreteFactoryA 和 ConcreteFactoryB 是具体的工厂类，分别实现了 Factory 接口，并实现了 createProduct() 方法以创建具体的产品实例。
在客户端代码 Client 中，通过创建具体工厂实例，并调用其 createProduct() 方法来获取产品实例，然后调用产品实例的操作方法。
这样，客户端代码与具体产品类之间解耦，客户端只需要与抽象工厂打交道，可以根据需要轻松切换不同的具体工厂和产品类型。
抽象工厂模式的实现
抽象工厂模式的主要目的是提供一个接口，用于创建相关对象的家族，而不需要指定具体的类。
在抽象工厂模式中，有两个关键的抽象概念：
-
抽象产品（Abstract Product）： 定义了一系列产品的接口，描述了产品的特性和行为。
-
抽象工厂（Abstract Factory）： 定义了一个用于创建一系列产品的接口，包括创建产品的方法。
抽象工厂模式通常包括以下角色：
-
抽象产品接口（Abstract Product）： 定义了一系列产品的接口，描述了产品的特性和行为。
-
具体产品类（Concrete Product）： 实现了抽象产品接口，定义了具体产品的具体行为。
-
抽象工厂接口（Abstract Factory）： 定义了一个用于创建一系列产品的接口，包括创建产品的方法。
-
具体工厂类（Concrete Factory）： 实现了抽象工厂接口，负责创建一系列相关的产品。
抽象工厂模式的核心思想是提供一个接口，用于创建一系列相关的产品对象，而不需要指定具体的类。客户端通过调用抽象工厂的方法来获取产品对象，从而实现了客户端代码与具体产品类之间的解耦。
代码实现
// 定义抽象产品接口A
interface AbstractProductA {
void operationA();
}
// 具体产品类A1
class ConcreteProductA1 implements AbstractProductA {
@Override
public void operationA() {
System.out.println("具体产品A1的操作");
}
}
// 具体产品类A2
class ConcreteProductA2 implements AbstractProductA {
@Override
public void operationA() {
System.out.println("具体产品A2的操作");
}
}
// 定义抽象产品接口B
interface AbstractProductB {
void operationB();
}
// 具体产品类B1
class ConcreteProductB1 implements AbstractProductB {
@Override
public void operationB() {
System.out.println("具体产品B1的操作");
}
}
// 具体产品类B2
class ConcreteProductB2 implements AbstractProductB {
@Override
public void operationB() {
System.out.println("具体产品B2的操作");
}
}
// 定义抽象工厂接口
interface AbstractFactory {
AbstractProductA createProductA();
AbstractProductB createProductB();
}
// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
// 创建具体工厂实例
AbstractFactory factory1 = new ConcreteFactory1();
AbstractFactory factory2 = new ConcreteFactory2();
// 使用具体工厂创建产品实例
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
// 调用产品实例的操作方法
productA1.operationA();
productB1.operationB();
productA2.operationA();
productB2.operationB();
}
}在这个示例中，AbstractProductA 和 AbstractProductB 是抽象产品接口，定义了产品的操作方法。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是具体的产品类，分别实现了 AbstractProductA 和 AbstractProductB 接口。
AbstractFactory 是抽象工厂接口，定义了创建一系列产品的方法。ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类，分别实现了 AbstractFactory 接口，并实现了 createProductA() 和 createProductB() 方法以创建具体的产品实例。
在客户端代码 Client 中，通过创建具体工厂实例，并调用其 createProductA() 和 createProductB() 方法来获取产品实例，然后调用产品实例的操作方法。
这样，客户端代码与具体产品类之间解耦，客户端只需要与抽象工厂打交道，可以根据需要轻松切换不同的具体工厂和产品类型。
原文地址：https://blog.csdn.net/qq_22193961/article/details/137843093
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！