今天在干嘛
设计模式——工厂模式
MoMo Lv5
  2024-06-16 17:18:42   2024-06-16 18:31:19    

简单工厂模式

含义

  • 简单工厂模式又叫静态方法模式（因为工厂类定义了一个静态方法）
  • 现实生活中，工厂是负责生产产品的；同样在设计模式中，简单工厂模式我们可以理解为负责生产对象的一个类，称为“工厂类”。

解决的问题

将“类实例化的操作”与“使用对象的操作”分开，让使用者不用知道具体参数就可以实例化出所需要的“产品”类，从而避免了在客户端代码中显式指定，实现了解耦。

即使用者可直接消费产品而不需要知道其生产的细节

模式原理

模式组成

组成（角色） 关系 作用
抽象产品（Product） 具体产品的父类 描述产品的公共接口
具体产品（Concrete Product） 抽象产品的子类；工厂类创建的目标类 描述生产的具体产品
工厂（Creator） 被外界调用 根据传入不同参数从而创建不同具体产品类的实例

UML类图

image

使用步骤

  • 创建抽象产品类 & 定义具体产品的公共接口；
  • 创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
  • 创建工厂类，通过创建静态方法根据传入不同参数从而创建不同具体产品类的实例；
  • 外界通过调用工厂类的静态方法，传入不同参数从而创建不同具体产品类的实例

实例

实例概况

  • 背景：小成有一个塑料生产厂，用来做塑料加工生意
  • 目的：最近推出了3个产品，小成希望使用简单工厂模式实现3款产品的生产

使用步骤

实现代码如下：

步骤1. 创建抽象产品类，定义具体产品的公共接口

1
2
3
abstract class Product{
    public abstract void Show();
}

步骤2. 创建具体产品类（继承抽象产品类），定义生产的具体产品

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//具体产品类A
class  ProductA extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品类B
class  ProductB extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品C");
    }
}

//具体产品类C
class  ProductC extends  Product{

    @Override
    public void Show() {
        System.out.println("生产出了产品C");
    }
}

步骤3. 创建工厂类，通过创建静态方法从而根据传入不同参数创建不同具体产品类的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class  Factory {
    public static Product Manufacture(String ProductName){
//工厂类里用switch语句控制生产哪种商品；
//使用者只需要调用工厂类的静态方法就可以实现产品类的实例化。
        switch (ProductName){
            case "A":
                return new ProductA();

            case "B":
                return new ProductB();

            case "C":
                return new ProductC();

            default:
                return null;

        }
    }
}

步骤4. 外界通过调用工厂类的静态方法，传入不同参数从而创建不同具体产品类的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//工厂产品生产流程
public class SimpleFactoryPattern {
    public static void main(String[] args){
        Factory mFactory = new Factory();

        //客户要产品A
        try {
//调用工厂类的静态方法 & 传入不同参数从而创建产品实例
            mFactory.Manufacture("A").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品B
        try {
            mFactory.Manufacture("B").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品C
        try {
            mFactory.Manufacture("C").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }

        //客户要产品D
        try {
            mFactory.Manufacture("D").Show();
        }catch (NullPointerException e){
            System.out.println("没有这一类产品");
        }
    }
}

结果输出

1
2
3
4
生产出了产品A
生产出了产品C
生产出了产品C
没有这一类产品

优点

  • 将创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建，实现了解耦；
  • 把初始化实例时的工作放到工厂里进行，使代码更容易维护。 更符合面向对象的原则 & 面向接口编程，而不是面向实现编程。

缺点

  • 工厂类集中了所有实例（产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响；
  • 违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。
  • 简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

应用场景

  • 客户如果只知道传入工厂类的参数，对于如何创建对象的逻辑不关心时；
  • 当工厂类负责创建的对象（具体产品）比较少时。

工厂方法模式

简单工厂模式存在一系列问题：

  • 工厂类集中了所有实例（产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响；
  • 违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。
  • 简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

介绍

定义

工厂方法模式，又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。

主要作用

将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化（创建）哪一个类。

解决的问题

工厂一旦需要生产新产品就需要修改工厂类的方法逻辑，违背了“开放 - 关闭原则(即简单工厂模式的缺点)

之所以可以解决简单工厂的问题，是因为工厂方法模式把具体产品的创建推迟到工厂类的子类（具体工厂）中，此时工厂类不再负责所有产品的创建，而只是给出具体工厂必须实现的接口，这样工厂方法模式在添加新产品的时候就不修改工厂类逻辑而是添加新的工厂子类，符合开放封闭原则，克服了简单工厂模式中缺点

模式原理

UML类图

image

模式组成

组成（角色） 关系 作用
抽象产品（Product） 具体产品的父类 描述具体产品的公共接口
具体产品（Concrete Product） 抽象产品的子类；工厂类创建的目标类 描述生产的具体产品
抽象工厂（Creator） 具体工厂的父类 描述具体工厂的公共接口
具体工厂（Concrete Creator） 抽象工厂的子类；被外界调用 描述具体工厂；实现FactoryMethod工厂方法创建产品的实例

使用步骤

步骤1： 创建抽象工厂类，定义具体工厂的公共接口；
步骤2： 创建抽象产品类 ，定义具体产品的公共接口；
步骤3： 创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
步骤5：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

实例

实例概况

  • 背景：小成有一间塑料加工厂（仅生产A类产品）；随着客户需求的变化，客户需要生产B类产品；
  • 冲突：改变原有塑料加工厂的配置和变化非常困难，假设下一次客户需要再发生变化，再次改变将增大非常大的成本；
  • 解决方案：小成决定置办塑料分厂B来生产B类产品；

使用步骤

步骤1： 创建抽象工厂类，定义具体工厂的公共接口

1
2
3
abstract class Factory{
    public abstract Product Manufacture();
}

步骤2： 创建抽象产品类 ，定义具体产品的公共接口；

1
2
3
abstract class Product{
    public abstract void Show();
}

步骤3： 创建具体产品类（继承抽象产品类）， 定义生产的具体产品；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//具体产品A类
class  ProductA extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}

//具体产品B类
class  ProductB extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}

步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//工厂A类 - 生产A类产品
class  FactoryA extends Factory {
    @Override
    public Product Manufacture() {
        return new ProductA();
    }
}

//工厂B类 - 生产B类产品
class  FactoryB extends Factory {
    @Override
    public Product Manufacture() {
        return new ProductB();
    }
}

步骤5：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

1
2
3
4
5
6
7
8
9
10
11
12
//生产工作流程
public class FactoryPattern {
    public static void main(String[] args){
        //客户要产品A
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.Manufacture().Show();

        //客户要产品B
        FactoryB mFactoryB = new FactoryB();
        mFactoryB.Manufacture().Show();
    }
}

结果输出

1
2
生产出了产品A
生产出了产品C

优点

  • 更符合开-闭原则

    • 新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可
    • 简单工厂模式需要修改工厂类的判断逻辑

  • 符合单一职责原则

    • 每个具体工厂类只负责创建对应的产品
    • 简单工厂中的工厂类存在复杂的switch逻辑判断

  • 不使用静态工厂方法，可以形成基于继承的等级结构。

    • 简单工厂模式的工厂类使用静态工厂方法

工厂模式可以说是简单工厂模式的进一步抽象和拓展，在保留了简单工厂的封装优点的同时，让扩展变得简单，让继承变得可行，增加了多态性的体现。

缺点

  • 添加新产品时，除了增加新产品类外，还要提供与之对应的具体工厂类，系统类的个数将成对增加，在一定程度上增加了系统的复杂度；同时，有更多的类需要编译和运行，会给系统带来一些额外的开销；
  • 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
  • 虽然保证了工厂方法内的对修改关闭，但对于使用工厂方法的类，如果要更换另外一种产品，仍然需要修改实例化的具体工厂类；
  • 一个具体工厂只能创建一种具体产品

应用场景

  • 当一个类不知道它所需要的对象的类时
    在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可；
  • 当一个类希望通过其子类来指定创建对象时
    在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。
  • 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

抽象工厂模式

介绍

定义

抽象工厂模式，即Abstract Factory Pattern，提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。

抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个工厂可以创建多种类的产品；而工厂方法每个工厂只能创建一类

主要作用

允许使用抽象的接口来创建一组相关产品，而不需要知道或关心实际生产出的具体产品是什么，这样就可以从具体产品中被解耦。

解决的问题

每个工厂只能创建一类产品，即工厂方法模式的缺点

模式原理

UML类图

image

模式组成

组成（角色） 关系 作用
抽象产品族（AbstractProduct） 抽象产品的父类 描述抽象产品的公共接口
抽象产品（Product） 具体产品的父类 描述具体产品的公共接口
具体产品（Concrete Product） 抽象产品的子类；工厂类创建的目标类 描述生产的具体产品
抽象工厂（Creator） 具体工厂的父类 描述具体工厂的公共接口
具体工厂（Concrete Creator） 抽象工厂的子类；被外界调用 描述具体工厂；实现FactoryMethod工厂方法创建产品的实例

image

使用步骤

  1. 创建抽象工厂类，定义具体工厂的公共接口；
  2. 创建抽象产品族类 ，定义抽象产品的公共接口；
  3. 创建抽象产品类 （继承抽象产品族类），定义具体产品的公共接口；
  4. 创建具体产品类（继承抽象产品类） & 定义生产的具体产品；
  5. 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
  6. 客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例

实例

实例概况

  • 背景：小成有两间塑料加工厂（A厂仅生产容器类产品；B厂仅生产模具类产品）；随着客户需求的变化，A厂所在地的客户需要也模具类产品，B厂所在地的客户也需要容器类产品；
  • 冲突：没有资源（资金+租位）在当地分别开设多一家注塑分厂
  • 解决方案：在原有的两家塑料厂里增设生产需求的功能，即A厂能生产容器+模具产品；B厂间能生产模具+容器产品。

使用步骤

步骤1： 创建抽象工厂类，定义具体工厂的公共接口

1
2
3
4
abstract class Factory{
   public abstract Product ManufactureContainer();
    public abstract Product ManufactureMould();
}

步骤2： 创建抽象产品族类 ，定义具体产品的公共接口；

1
2
3
abstract class AbstractProduct{
    public abstract void Show();
}

步骤3： 创建抽象产品类 ，定义具体产品的公共接口；

1
2
3
4
5
6
7
8
9
10
11
//容器产品抽象类
abstract class ContainerProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

//模具产品抽象类
abstract class MouldProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

步骤4： 创建具体产品类（继承抽象产品类）， 定义生产的具体产品；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//容器产品A类
class ContainerProductA extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品A");
    }
}

//容器产品B类
class ContainerProductB extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品B");
    }
}

//模具产品A类
class MouldProductA extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品A");
    }
}

//模具产品B类
class MouldProductB extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品B");
    }
}

步骤5：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//A厂 - 生产模具+容器产品
class FactoryA extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductA();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductA();
    }
}

//B厂 - 生产模具+容器产品
class FactoryB extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductB();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductB();
    }
}

步骤6： 客户端通过实例化具体的工厂类，并调用其创建不同目标产品的方法创建不同具体产品类的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//生产工作流程
public class AbstractFactoryPattern {
    public static void main(String[] args){
        FactoryA mFactoryA = new FactoryA();
        FactoryB mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA.ManufactureContainer().Show();
        //A厂当地客户需要模具产品A
        mFactoryA.ManufactureMould().Show();

        //B厂当地客户需要容器产品B
        mFactoryB.ManufactureContainer().Show();
        //B厂当地客户需要模具产品B
        mFactoryB.ManufactureMould().Show();

    }
}

结果输出

1
2
3
4
生产出了容器产品A
生产出了容器产品B
生产出了模具产品A
生产出了模具产品B

优点

  • 降低耦合：抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展；
  • 更符合开-闭原则： 新增一种产品类时，只需要增加相应的具体产品类和相应的工厂子类即可
  • 符合单一职责原则 每个具体工厂类只负责创建对应的产品
  • 不使用静态工厂方法：可以形成基于继承的等级结构。

缺点

抽象工厂模式很难支持新种类产品的变化。
这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。

对于新的产品族符合开-闭原则；对于新的产品种类不符合开-闭原则，这一特性称为开-闭原则的倾斜性。

应用场景

  • 一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。
  • 这个系统有多个系列产品，而系统中只消费其中某一系列产品
  • 系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。
  1. 1. 简单工厂模式
    1. 1.1. 含义
    2. 1.2. 解决的问题
    3. 1.3. 模式原理
      1. 1.3.1. 模式组成
      2. 1.3.2. UML类图
      3. 1.3.3. 使用步骤
    4. 1.4. 实例
      1. 1.4.1. 实例概况
      2. 1.4.2. 使用步骤
      3. 1.4.3. 结果输出
    5. 1.5. 优点
    6. 1.6. 缺点
    7. 1.7. 应用场景
  2. 2. 工厂方法模式
    1. 2.1. 介绍
      1. 2.1.1. 定义
      2. 2.1.2. 主要作用
      3. 2.1.3. 解决的问题
    2. 2.2. 模式原理
      1. 2.2.1. UML类图
      2. 2.2.2. 模式组成
      3. 2.2.3. 使用步骤
    3. 2.3. 实例
      1. 2.3.1. 实例概况
      2. 2.3.2. 使用步骤
      3. 2.3.3. 结果输出
    4. 2.4. 优点
    5. 2.5. 缺点
    6. 2.6. 应用场景
  3. 3. 抽象工厂模式
    1. 3.1. 介绍
      1. 3.1.1. 定义
      2. 3.1.2. 主要作用
      3. 3.1.3. 解决的问题
    2. 3.2. 模式原理
      1. 3.2.1. UML类图
      2. 3.2.2. 模式组成
      3. 3.2.3. 使用步骤
    3. 3.3. 实例
      1. 3.3.1. 实例概况
      2. 3.3.2. 使用步骤
      3. 3.3.3. 结果输出
    4. 3.4. 优点
    5. 3.5. 缺点
    6. 3.6. 应用场景
© 2023 - 2025    MoMo
Powered by Hexo & Theme Keep
Unique Visitor Page View
  1. 1. 简单工厂模式
    1. 1.1. 含义
    2. 1.2. 解决的问题
    3. 1.3. 模式原理
      1. 1.3.1. 模式组成
      2. 1.3.2. UML类图
      3. 1.3.3. 使用步骤
    4. 1.4. 实例
      1. 1.4.1. 实例概况
      2. 1.4.2. 使用步骤
      3. 1.4.3. 结果输出
    5. 1.5. 优点
    6. 1.6. 缺点
    7. 1.7. 应用场景
  2. 2. 工厂方法模式
    1. 2.1. 介绍
      1. 2.1.1. 定义
      2. 2.1.2. 主要作用
      3. 2.1.3. 解决的问题
    2. 2.2. 模式原理
      1. 2.2.1. UML类图
      2. 2.2.2. 模式组成
      3. 2.2.3. 使用步骤
    3. 2.3. 实例
      1. 2.3.1. 实例概况
      2. 2.3.2. 使用步骤
      3. 2.3.3. 结果输出
    4. 2.4. 优点
    5. 2.5. 缺点
    6. 2.6. 应用场景
  3. 3. 抽象工厂模式
    1. 3.1. 介绍
      1. 3.1.1. 定义
      2. 3.1.2. 主要作用
      3. 3.1.3. 解决的问题
    2. 3.2. 模式原理
      1. 3.2.1. UML类图
      2. 3.2.2. 模式组成
      3. 3.2.3. 使用步骤
    3. 3.3. 实例
      1. 3.3.1. 实例概况
      2. 3.3.2. 使用步骤
      3. 3.3.3. 结果输出
    4. 3.4. 优点
    5. 3.5. 缺点
    6. 3.6. 应用场景