抽象工厂设计模式个人简单学习理解

DCDDDDcccc

已于 2024-05-22 22:39:51 修改

阅读量635

点赞数 29

分类专栏：设计模式学习文章标签：设计模式学习

于 2024-05-22 21:15:04 首次发布

本文链接：https://blog.csdn.net/mx132465/article/details/139129309

版权

设计模式学习专栏收录该内容

1 篇文章 0 订阅

订阅专栏

抽象工厂设计模式是一种创建型设计模式。

1.核心思想

1.1概述及类图

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

1.2详细介绍

抽象工厂模式的核心在于将产品的创建进行抽象和集中管理。它认识到在很多实际场景中，存在着一组相关的产品，这些产品之间具有一定的关联性和配套性。比如，一个电脑组件的生产场景中，可能有显卡、主板等不同类型的产品，并且不同系列的显卡和主板可能会形成特定的搭配组合。

通过抽象工厂，将这些产品的创建逻辑进行抽象和封装。抽象工厂定义了创建各种产品的接口方法，而具体工厂则负责具体实现这些方法来创建特定系列的产品。这样做有几个重要意义：

它实现了创建逻辑与使用逻辑的分离。客户端代码不需要知道具体产品是如何创建的，只需要通过抽象工厂获取所需产品即可，降低了客户端与具体产品创建细节的耦合度。

它便于对产品族的管理和扩展。当需要增加一个新的产品族时，可以创建一个新的具体工厂来实现相应的产品创建，而不影响已有的产品族和客户端代码。同时，对于产品族内产品的调整和变化，也只需要在对应的具体工厂内进行修改，保持了系统的相对稳定性。

它确保了产品之间的一致性和协调性。因为是通过统一的抽象工厂来创建相关产品，所以能保证属于同一产品族的产品在功能、特性等方面的匹配和协调，避免出现不兼容的情况。这对于一些需要多个相关产品协同工作的复杂系统尤其重要。

抽象工厂模式的核心思想是通过抽象和集中化的产品创建机制，提高系统的灵活性、可扩展性和可维护性，更好地应对复杂的产品结构和变化需求。

2.主要角色和结构：

2.1抽象工厂（Abstract Factory）

声明一组用于创建不同产品的方法。

这是一个高度抽象的角色，它扮演着产品家族创建者的“蓝图”角色。它明确声明了一系列方法，每个方法都对应着一类产品的创建。这些方法通常是抽象的，不包含具体的实现细节。其意义在于定义了整个产品族所具有的产品类型以及创建这些产品的规范和契约。通过这样的声明，使得具体工厂有了明确的创建任务和目标，也让客户端能够以统一的方式与工厂交互来获取所需的各种产品。

2.2具体工厂（Concrete Factory）

实现抽象工厂中的方法，负责创建具体的产品对象。

具体工厂是抽象工厂的具体实现者。它按照抽象工厂定义的方法和规则，逐一实现每个产品的创建逻辑。一个具体工厂通常专注于创建一个特定系列或品牌的产品。它知道如何实例化属于该系列的具体产品对象，将原材料和生产工艺等具体细节隐藏起来。不同的具体工厂可以创建出不同风格、特性的产品族，从而满足不同的业务需求。当需要切换产品系列时，只需更换具体工厂即可，无需更改客户端代码。

2.3抽象产品（Abstract Product）

定义不同产品的公共接口。

抽象产品定义了某一类产品所共有的属性和行为特征，它是该类产品的公共接口。它规定了这类产品应该具备的基本功能和操作，让所有具体产品都遵循这个规范。抽象产品使得不同的具体产品之间具有了可比性和互换性，同时也方便了客户端对产品的统一处理和使用。它体现了对产品本质特征的抽象和概括。

2.4具体产品（Concrete Product）

具体的产品实现类，实现抽象产品的接口。

具体产品是对抽象产品的具体实现。每个具体产品都根据自身的特点和功能需求，实现了抽象产品所定义的接口。这些具体产品在实际运行中扮演着具体的业务角色，它们具有各自独特的属性和行为。多个具体产品共同构成了一个完整的产品系列，在具体工厂的协调下，共同为客户端提供具体的服务和功能。具体产品的多样性和可定制性，为满足不同用户和业务场景的需求提供了可能。

3.举例说明

// 抽象产品 A
interface ProductA {
    void doSomethingA();
}

// 抽象产品 B
interface ProductB {
    void doSomethingB();
}

// 具体产品 A1
class ConcreteProductA1 implements ProductA {

    @Override
    public void doSomethingA() {
        System.out.println("ConcreteProductA1 is doing something A");
    }
}

// 具体产品 A2
class ConcreteProductA2 implements ProductA {

    @Override
    public void doSomethingA() {
        System.out.println("ConcreteProductA2 is doing something A");
    }
}

// 具体产品 B1
class ConcreteProductB1 implements ProductB {

    @Override
    public void doSomethingB() {
        System.out.println("ConcreteProductB1 is doing something B");
    }
}

// 具体产品 B2
class ConcreteProductB2 implements ProductB {

    @Override
    public void doSomethingB() {
        System.out.println("ConcreteProductB2 is doing something B");
    }
}

// 抽象工厂
interface Factory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂 1
class ConcreteFactory1 implements Factory {

    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂 2
class ConcreteFactory2 implements Factory {

    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

public class Main {
    public static void main(String[] args) {
        Factory factory1 = new ConcreteFactory1();
        Factory factory2 = new ConcreteFactory2();

        Client client1 = new Client(factory1);
        Client client2 = new Client(factory2);

        client1.doWork();
        client2.doWork();
    }
}

//通过构造函数接收一个 Factory 对象，然后在 doWork 方法中利用该工厂来创建相应的产品并执行操作
class Client {
    private Factory factory;

    Client(Factory factory) {
        this.factory = factory;
    }

    public void doWork() {
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();

        productA.doSomethingA();
        productB.doSomethingB();
    }
}