抽象工厂模式（Abstract Factory Pattern）

最新推荐文章于 2024-04-25 09:25:45 发布

一叶飘零_sweeeet

最新推荐文章于 2024-04-25 09:25:45 发布

阅读量5.8k

点赞数 1

分类专栏： java 文章标签：抽象工厂模式设计模式

本文链接：https://blog.csdn.net/jam_yin/article/details/131687596

版权

java 专栏收录该内容

189 篇文章 4 订阅

订阅专栏

一、抽象工厂模式

介绍

抽象工厂模式是一种创建型设计模式，它提供了一种将一组相关的对象创建过程封装在一个工厂接口中的方式。抽象工厂模式可以创建一系列相互依赖或相互关联的对象，而无需指定其具体的类。

抽象工厂模式通过引入抽象工厂和具体工厂来实现对象的创建和管理。抽象工厂定义了一组创建产品的方法，每个方法对应一个具体的产品族。具体工厂实现了抽象工厂中的方法，负责创建具体的产品对象。

抽象工厂模式可以帮助我们将客户端代码与具体产品的创建过程解耦，使得客户端代码只需关注抽象工厂和抽象产品的接口，而无需关注具体的产品类。这样可以提高代码的可扩展性和可维护性。

结构

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

抽象工厂（Abstract Factory）：声明一组创建产品的方法，每个方法对应一个具体产品族。
具体工厂（Concrete Factory）：实现抽象工厂中的方法，负责创建具体的产品对象。
抽象产品（Abstract Product）：定义产品的共同接口，具体产品类都实现了这个接口。
具体产品（Concrete Product）：实现抽象产品接口的具体产品。

下面是一个简单的类图示例：

+------------------------+
|     AbstractFactory    |
+------------------------+
| + createProductA()     |
| + createProductB()     |
+------------------------+

        ^               ^
        |               |
        
+------------------------+
|   ConcreteFactory1     |
+------------------------+
| + createProductA()     |
| + createProductB()     |
+------------------------+

        ^               ^
        |               |
        
+------------------------+
|   ConcreteFactory2     |
+------------------------+
| + createProductA()     |
| + createProductB()     |
+------------------------+


        ^               ^
        |               |
        
+------------------------+
|     AbstractProductA   |
+------------------------+
| + operation()          |
+------------------------+

        ^               ^
        |               |
        
+------------------------+
|     AbstractProductB   |
+------------------------+
| + operation()          |
+------------------------+

        ^               ^
        |               |
        
+------------------------+
|   ConcreteProductA1    |
+------------------------+
| + operation()          |
+------------------------+

        ^               ^
        |               |
        
+------------------------+
|   ConcreteProductA2    |
+------------------------+
| + operation()          |
+------------------------+

        ^               ^
        |               |
        
+------------------------+
|   ConcreteProductB1    |
+------------------------+
| + operation()          |
+------------------------+

        ^               ^
        |               |
        
+------------------------+
|   ConcreteProductB2    |
+------------------------+
| + operation()          |
+------------------------+

示例

假设我们有一个电子产品工厂，可以生产电视和手机，其中电视分为液晶电视和等离子电视，手机分为智能手机和功能手机。我们可以使用抽象工厂模式来创建这些产品对象。

首先，我们定义抽象产品接口 TV 和 Phone：

public interface TV {
    void display();
}

public interface Phone {
    void call();
}

然后，我们创建具体的产品类，如 LCDTV、PlasmaTV、SmartPhone 和 FeaturePhone，它们分别实现了 TV 和 Phone 接口：

public class LCDTV implements TV {
    @Override
    public void display() {
        System.out.println("显示液晶电视");
    }
}

public class PlasmaTV implements TV {
    @Override
    public void display() {
        System.out.println("显示等离子电视");
    }
}

public class SmartPhone implements Phone {
    @Override
    public void call() {
        System.out.println("拨打智能手机电话");
    }
}

public class FeaturePhone implements Phone {
    @Override
    public void call() {
        System.out.println("拨打功能手机电话");
    }
}

接下来，我们创建抽象工厂接口 ElectronicFactory，其中包含创建电视和手机的方法：

public interface ElectronicFactory {
    TV createTV();
    Phone createPhone();
}

然后，我们创建具体的工厂类，如 SonyFactory 和 SamsungFactory，它们分别实现了 ElectronicFactory 接口，并负责创建具体的电视和手机对象：

public class SonyFactory implements ElectronicFactory {
    @Override
    public TV createTV() {
        return new LCDTV();
    }

    @Override
    public Phone createPhone() {
        return new SmartPhone();
    }
}

public class SamsungFactory implements ElectronicFactory {
    @Override
    public TV createTV() {
        return new PlasmaTV();
    }

    @Override
    public Phone createPhone() {
        return new FeaturePhone();
    }
}

最后，我们可以使用抽象工厂来创建和使用电视和手机对象：

public class Main {
    public static void main(String[] args) {
        ElectronicFactory sonyFactory = new SonyFactory();
        TV sonyTV = sonyFactory.createTV();
        Phone sonyPhone = sonyFactory.createPhone();
        sonyTV.display(); // 输出：显示液晶电视
        sonyPhone.call(); // 输出：拨打智能手机电话

        ElectronicFactory samsungFactory = new SamsungFactory();
        TV samsungTV = samsungFactory.createTV();
        Phone samsungPhone = samsungFactory.createPhone();
        samsungTV.display(); // 输出：显示等离子电视
        samsungPhone.call(); // 输出：拨打功能手机电话
    }
}

优点和适用场景

抽象工厂模式具有以下优点：

将对象的创建逻辑推迟到具体工厂类中实现，使得客户端代码与具体产品的创建过程解耦。
可以通过切换具体工厂类来创建不同的产品族，实现了产品族的变化而不影响客户端代码。
具体工厂类可以根据需要返回不同的具体产品对象，实现了多态性。

抽象工厂模式适用于以下场景：

需要创建一系列相互依赖或相互关联的对象。
需要在运行时动态决定具体对象的类型。
客户端不需要知道对象的具体创建过程，只需要知道抽象工厂和抽象产品的接口即可。

二、简单工厂模式、工厂方法模式和抽象工厂模式的比较

简单工厂模式

定义

简单工厂模式是一种创建型设计模式，它通过一个工厂类来创建不同类型的对象，而无需直接暴露对象的创建逻辑给客户端。

结构

简单工厂模式包含以下几个角色：

工厂类（Factory）：负责创建对象的工厂类，根据客户端的请求创建相应的对象。
产品类（Product）：具体的产品类，实现了工厂类定义的接口或继承了工厂类的抽象类。

工作原理

简单工厂模式的工作原理如下：

客户端通过调用工厂类的静态方法或实例方法来请求创建某个产品对象。
工厂类根据客户端的请求，内部使用条件语句或其他方式判断应该创建哪个具体产品对象。
工厂类创建相应的产品对象并返回给客户端。

优点

将对象的创建逻辑封装在工厂类中，客户端只需通过工厂类来创建对象，无需关心对象的具体创建过程。
简化客户端代码，降低了客户端与具体产品类的耦合度。

缺点

工厂类负责创建所有产品对象，当产品种类较多时，工厂类的代码会变得复杂，违反了开闭原则。
如果需要添加新的产品，需要修改工厂类的代码，违反了开闭原则。

工厂方法模式

定义

工厂方法模式是一种创建型设计模式，它将对象的创建延迟到子类中进行，子类根据需要重写工厂方法来创建具体的对象。

结构

工厂方法模式包含以下几个角色：

抽象工厂（Abstract Factory）：声明创建产品的工厂方法，子类必须实现这个方法来创建具体的产品对象。
具体工厂（Concrete Factory）：实现抽象工厂中的工厂方法，负责创建具体的产品对象。
抽象产品（Abstract Product）：定义产品的共同接口，具体产品类都实现了这个接口。
具体产品（Concrete Product）：实现抽象产品接口的具体产品。

工作原理

工厂方法模式的工作原理如下：

抽象工厂定义了一个工厂方法，用于创建产品对象，该方法返回一个抽象产品类型。
具体工厂继承抽象工厂，并实现工厂方法，根据需要重写工厂方法来创建具体的产品对象。
客户端通过调用具体工厂的工厂方法来创建产品对象。

优点

将对象的创建延迟到子类中进行，符合开闭原则，新增产品时只需创建对应的具体工厂和产品类，无需修改已有代码。
客户端只需关心抽象工厂和抽象产品的接口，无需关心具体的工厂和产品类。

缺点

每新增一个产品，都需要创建对应的具体工厂和产品类，导致类的个数增加。