简单工厂模式、工厂模式与抽象工厂模式详解

于 2024-05-18 00:10:54 发布
阅读量906 收藏 11
点赞数 22
分类专栏： 设计模式 文章标签： 简单工厂模式 抽象工厂模式 设计模式 uml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77758423/article/details/139014302
版权

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。用工厂方式代替new操作的一种模式。

目录

前言

        设计模式是一套被反复使用、多数人认可的、经过分类编目的、代码设计经验的总结。它们为软件设计提供了一定的指导和最佳实践。特别是在创建对象时，简单工厂、工厂模式和抽象工厂模式这三种创建型模式经常被提及和应用。

一、简单工厂模式（Simple Factory）

1.什么是简单工厂模式

        简单工厂模式是一种创建型设计模式，它通过一个单一的工厂类来负责创建一系列相关的对象。这个工厂类根据传入的参数来决定实例化哪一个具体类的实例。客户端在使用时不需要知道具体的类名，只需要提供必要的信息给工厂。

2.简单工厂的核心角色

  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（Concrete Product）：实现或继承抽象产品接口的类。每一种产品都有各自的特点。
  • 简单工厂（Simple Factory）：根据传入的参数来决定创建哪一个具体类的实例。

3.具体实现

1）抽象产品

代码如下（示例）：

// 抽象产品
interface Product {
    void show();
}

2）具体产品 

 代码如下（示例）：

// 具体产品A
class ConcreteProductA implements Product {
    public void show() {
        System.out.println("This is product A.");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public void show() {
        System.out.println("This is product B.");
    }
}

3）简单工厂 

 代码如下（示例）：

// 简单工厂
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type == null) {
            return null;
        }
        if (type.equalsIgnoreCase("A")) {
            return new ConcreteProductA();
        } else if (type.equalsIgnoreCase("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

4）客户端调用

 代码如下（示例）：

// 客户端调用
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.show(); // 输出 "This is product A."
        
        Product productB = SimpleFactory.createProduct("B");
        productB.show(); // 输出 "This is product B."
    }
}

        在这个例子中，我们定义了一个抽象产品接口Product和两个具体产品类ConcreteProductA和ConcreteProductB。然后，我们创建了一个简单的工厂类SimpleFactory，它根据传入的类型参数来创建相应的具体产品实例。最后，在客户端代码中，我们使用简单工厂来创建并显示不同类型的产品。 

4.简单工厂的适用性

  1. 当对象的创建过程相对集中，并且客户端对于如何创建对象不感兴趣时，简单工厂可以封装这些创建细节。

  2. 如果产品的种类相对较少，并且不太可能发生变化，简单工厂可以减少系统的复杂性。

  3. 当希望避免客户端代码直接实例化对象，而是通过一个统一的接口来创建对象时，简单工厂可以提供这样的接口。

  4. 简单工厂更适合那些创建逻辑比较简单的情况，如果创建过程涉及复杂的逻辑判断或者条件分支，可能需要考虑其他工厂模式，如工厂方法或抽象工厂。

  5. 当客户端代码不依赖于产品的具体类，而只需要知道产品的接口或抽象类时，简单工厂可以帮助客户端与具体类解耦。

二、工厂模式（Factory Method）

1.什么是工厂模式

        工厂模式属于创建型模式，它在创建对象时提供了一种封装机制，将实际创建对象的代码与使用代码分离。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

2.工厂模式的核心角色

  • 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（Concrete Product）：实现或继承抽象产品接口的类。每一种产品都有各自的特点。
  • 抽象工厂（Factory）：声明了创建抽象产品的接口，但由它的子类来确定要实例化的具体产品类。
  • 具体工厂（Concrete Factory）：实现抽象工厂接口，并返回一个等级结构中的具体产品实例。

3.具体实现 

1）抽象产品

代码如下（示例）：

// 抽象产品
interface Animal {
    void speak();
}

2）具体产品

代码如下（示例）：

// 具体产品A
class Dog implements Animal {
    public void speak() {
        System.out.println("汪汪汪!");
    }
}

// 具体产品B
class Cat implements Animal {
    public void speak() {
        System.out.println("喵喵喵!");
    }
}

3）抽象工厂

代码如下（示例）：

// 工厂接口
interface AnimalFactory {
    Animal createAnimal();
}

4）具体工厂

代码如下（示例）：

/ 具体工厂A
class DogFactory implements AnimalFactory {
    public Animal createAnimal() {
        return new Dog();
    }
}

// 具体工厂B
class CatFactory implements AnimalFactory {
    public Animal createAnimal() {
        return new Cat();
    }
}

4）客户端调用

 代码如下（示例）： 

// 客户端调用
public class Client {
    public static void main(String[] args) {
        AnimalFactory dogFactory = new DogFactory();
        Animal dog = dogFactory.createAnimal();
        dog.speak(); // 输出 "汪汪汪!"
        
        AnimalFactory catFactory = new CatFactory();
        Animal cat = catFactory.createAnimal();
        cat.speak(); // 输出 "喵喵喵!"
    }
}

       在这个例子中，我们定义了一个抽象产品接口Animal和两个具体产品类Dog和Cat。然后，我们创建了一个工厂接口AnimalFactory和两个具体工厂类DogFactory和CatFactory，它们分别负责创建具体的动物实例。最后，在客户端代码中，我们使用不同的工厂来创建并显示不同类型的动物。

 4.工厂模式的适用性

  1. 如果一个对象的创建过程需要多个步骤，或者涉及到复杂的逻辑判断和条件分支，那么使用工厂模式可以将这些复杂性封装在工厂类中，客户端只需要调用工厂类的接口即可获取所需的对象。

  2. 工厂模式通过将对象的创建和使用分离，降低了客户端和具体类之间的耦合度。客户端不需要知道具体的类名，只需要知道工厂类的接口，这有助于提高代码的可维护性和扩展性。

  3. 工厂模式提供了一个创建对象的接口，使得客户端可以根据需要动态地创建对象。这种灵活性在很多应用场景中非常有用。

  4. 工厂模式可以在真正需要对象的时候才创建它，而不是在程序启动时就创建所有的对象。这有助于减少系统的内存占用和启动时间。

  5. 工厂模式遵循了面向对象设计中的开闭原则，即对扩展开放，对修改封闭。当需要添加新的产品类型时，只需添加新的具体工厂类和具体产品类，无需修改现有的代码。

三、抽象工厂模式（Abstract Factory）

1.什么是抽象工厂模式

        抽象工厂模式提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。它是一种比简单工厂和工厂方法更高层次的设计模式。它围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。

2.抽象工厂的核心角色

  • 抽象产品（Abstract Product）：定义了产品的规范，描述了产品的主要特性和功能。
  • 具体产品（Concrete Product）：实现或继承抽象产品接口的类。每一种产品都有各自的特点。
  • 抽象工厂（Abstract Factory）：声明了创建抽象产品的接口，由子类确定要生成的具体产品类。
  • 具体工厂（Concrete Factory）：实现抽象工厂接口，并返回一系列具体产品的实例。

3.具体实现 

1）抽象产品

代码如下（示例）：

// 抽象产品A
interface ProductA {
    void show();
}
// 抽象产品B
interface ProductB {
    void show();
}

2）具体产品

代码如下（示例）：

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    public void show() {
        System.out.println("This is product A1.");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    public void show() {
        System.out.println("This is product A2.");
    }
}
// 具体产品B1
class ConcreteProductB1 implements ProductB {
    public void show() {
        System.out.println("This is product B1.");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    public void show() {
        System.out.println("This is product B2.");
    }
}

3）抽象工厂

代码如下（示例）：

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

4）具体工厂

代码如下（示例）：

// 具体工厂A
class ConcreteFactoryA implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂B
class ConcreteFactoryB implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

4）客户端调用

 代码如下（示例）：

public class Client {
    public static void main(String[] args) {
        AbstractFactory factoryA = new ConcreteFactoryA();
        ProductA productA1 = factoryA.createProductA();
        productA1.show(); // 输出 "This is product A1."
        ProductB productB1 = factoryA.createProductB();
        productB1.show(); // 输出 "This is product B1."
        
        AbstractFactory factoryB = new ConcreteFactoryB();
        ProductA productA2 = factoryB.createProductA();
        productA2.show(); // 输出 "This is product A2."
        ProductB productB2 = factoryB.createProductB();
        productB2.show(); // 输出 "This is product B2."
    }
}

        在这个例子中，我们定义了两个抽象产品接口ProductA和ProductB，以及它们各自的具体产品类。然后，我们创建了一个抽象工厂接口AbstractFactory和两个具体工厂类ConcreteFactoryA和ConcreteFactoryB，它们分别负责创建具体的产品实例。最后，在客户端代码中，我们使用不同的工厂来创建并显示不同类型的产品。

4.抽象工厂的适用性

  1. 当需要强调一系列相关的产品对象时，这些产品对象通常是同一个产品族的一部分，并且经常一起使用。例如，一个软件包可能包含多个组件，如编辑器、编译器和调试器，它们可以作为一个整体来使用。
  2. 抽象工厂模式适用于提供产品类的库，所有的产品都以同样的接口出现，这样客户端就不依赖于具体的实现。这有助于在添加新产品时，不需要修改现有的客户端代码。
  3. 当客户端不关心产品实例如何被创建，以及实现的具体细节时，可以使用抽象工厂模式。这样，客户端只需通过工厂接口来请求所需的产品，而无需了解产品的创建过程。
  4. 如果系统的产品有多于一个的产品族，而系统只消费其中某一族的产品，那么抽象工厂模式可以用来定义多个产品，并在一个工厂里聚合多个同类产品。
  5. 抽象工厂模式主要解决的是接口选择的问题，即提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

总结

        这三种模式都是用于创建对象的设计模式，但它们的重点和适用场景有所不同。简单工厂适用于简单的对象创建场景，工厂方法适用于产品等级结构复杂的情况，而抽象工厂则适用于多产品族和产品系列的场景。

九千七
关注
  • 22
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式之抽象工厂模式实例详解
08-29
Java设计模式之抽象工厂模式实例详解 Java设计模式之抽象工厂模式实例详解是指在软件设计中，通过提供一个创建一系列相关或相互依赖对象的接口，且无需指定它们具体的类别的方式来生成这些对象的模式。抽象工厂模式...
PHP实现设计模式中的抽象工厂模式详解
12-18
**抽象工厂模式详解** 抽象工厂模式是设计模式中的一种，主要目的是为了提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。这种模式遵循“开闭原则”，即对扩展开放，对修改关闭，允许在不修改...
简单工厂、工厂方法、抽象工厂设计模式详解+实例分析+笔记分享
沙罗沙罗的博客
06-21 1181
简单工厂、工厂方法、抽象工厂三种设计模式都属于创建型设计模式，根据作用范围划分，简单工厂、工厂方法属于类模式；抽象工厂属于对象模式；由于简单工厂只是对类的创建进行同一的管理（用工厂类进行抉择创建什么对象）是一种编码的调整，所以简单工厂并不属于GoF 23种设计模式之一。
《设计模式详解》创建型模式 - 工厂模式
萌宅鹿的技术小屋
01-05 1772
《设计模式详解》4.2 工厂模式4.2.1 概述4.2.2 简单工厂模式4.2.2.1 结构4.2.2.2 实现4.2.2.3 优缺点4.2.2.4 扩展 - 静态工厂4.2.3 工厂方法模式4.2.3.1 概念4.2.3.2 结构4.2.3.3 实现4.2.3.4 优缺点4.2.4 抽象工厂模式4.2.4.1 概念4.2.4.2 结构4.2.4.2 实现4.2.4.3 优缺点4.2.4.4 使用场景4.2.5 扩展：简单工厂 + 配置文件4.2.6 JDK源码 - Collection.iterator
简单工厂模式、工厂模式以及抽象工厂模式
m0_51797179的博客
09-22 669
工厂方法模式：工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。一、简单工厂模式：实例化对象的时候不再使用 new Object()形式，可以根据用户的选择条件来实例化相关的类。对于客户端来说，去除了具体的类的依赖。只需要给出具体实例的描述给工厂，工厂就会自动返回具体的实例对象。具体实现如下：1. 定义一个操作接口：}2. 定义具体的操作类：// 加法计算}}// 减法计算。
简单工厂模式、工厂模式和抽象工厂模式区别及优缺点
larance的挨踢生活
05-14 2755
各位小伙伴好，今天给大家主要介绍一下简单工厂模式、工厂模式和抽象工厂模式的区别及各自的优缺点。 （本文实现语言为Python3） 【前言】 众所周知今天所讲的内容是设计模式的一类；对于设计模式这个概念，我想首先请大家问问自己：1、什么是设计模式 2、我们为什么要了解并学习设计模式？ 从我上学的时候我相信大家跟我一样也接触过设计模式的课程，当时可能懵懵懂懂只是知其然，当时还会想明明可以直接写出来为什么要搞成这样的形式，我就算学会了它到底什么时候能用呢？一系列的问题...Emm算了到时候再想想（lazy
设计模式之简单工厂模式和抽象工厂模式
用键盘与世界交流
01-28 187
场景问题 　　举个生活中常见的例子——组装电脑，我们在组装电脑的时候，通常需要选择一系列的配件，比如CPU、硬盘、内存、主板、电源、机箱等。为讨论使用简单点，只考虑选择CPU和主板的问题。 　　事实上，在选择CPU的时候，面临一系列的问题，比如品牌、型号、针脚数目、主频等问题，只有把这些问题都确定下来，才能确定具体的CPU。 　　同样，在选择主板的时候，也有一系列问题，比如品牌、芯片组、集成芯片、总线频率等问题，也只有这些都确定了，才能确定具体的主板。 　　选择不同的CPU和主板，是每个客户在组装电
设计模式之工厂模式
热门推荐
aaa31203的博客
09-13 16万+
工厂模式 1、简单工厂模式 1.1、定义 简单工厂模式（Simple Factory Pattern）是指有一个工厂对象决定创建出哪一种产品类的实例，不属于23种设计模式。 简单工厂是产品的工厂 1.2、应用场景 简单工厂模式适用于工厂类创建的对象较少的场景，且客户端只需要传入工厂参数，对如何创建对象的逻辑不需要关心。 1.3、缺点 工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背了开闭原则。 不易于扩展过于复杂的产品结构。 1.4、实例 支付接口规范： public interface
简单工厂模式
Charge8的博客
12-14 4174
在日常开发中，凡是需要生成复杂对象的地方，都可以尝试考虑使用工厂模式来代替。 复杂对象指的是类的构造函数参数过多等对类的构造有影响的情况，因为类的构造过于复杂，如果直接在其他业务类内使用，则两者的耦合过重，后续业务更改，就需要在任何引用该类的源代码内进行更改，光是查找所有依赖就很消耗时间了，更别说要一个一个修改了。 工厂模式的定义： 是指定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。 按实际业务场景划分，工厂模式
设计模式创建型——工厂模式
tszc95的博客
04-04 4245
工程模式是通过工厂获取一个一个的新对象。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
Android编程设计模式之抽象工厂模式详解
08-28
【抽象工厂模式详解】 在Android编程中，设计模式是一种重要的软件设计原则，它提供了一种在不断变化的需求中保持代码可维护性和可扩展性的方法。其中，抽象工厂模式（Abstract Factory Pattern）是一种创建型设计...
Python设计模式之抽象工厂模式原理与用法详解
01-20
本文实例讲述了Python设计模式之抽象工厂模式原理与用法。分享给大家供大家参考，具体如下： 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的类 下面是一个...
「聊设计模式」之简单工厂模式（Simple Factory）
最新发布
**My Coding Family**
09-18 490
简单工厂模式属于创建型模式，它提供了一种创建对象的方式，将对象的创建过程封装在工厂中，客户端只需要调用工厂的创建方法即可得到所需对象。简单工厂模式可以根据传入参数的不同返回不同的对象实例，这种方式属于静态工厂方法，因为它使用了静态方法来创建对象。
简单工厂模式（静态工厂方法模式）
weixin_49107940的博客
05-11 3847
概述： 简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。不是23种模式中的一种，是一种编码习惯。 优点 1.工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象。 2.客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。 3.通过引入配置文
简单工厂模式 Simple Method Pattern
木易
06-16 617
一、简单工厂模式 简单工厂模式不属于23中设计模式，它的缺点是增加新产品时会违背“开闭原则”。简单工厂一般分为：普通简单工厂、多方法简单工厂、静态方法简单工厂。 二、工厂方法模式 模式的结构 工厂方法模式的主要角色如下。 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。 具体工厂（Concret...
【设计模式】简单工厂模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-22 3441
一、简单工厂模式简介、 二、简单工厂模式适用场景、 三、简单工厂模式优缺点、 四、简单工厂模式代码示例、 1、抽象类、 2、子类对象 1、 3、子类对象 2、 4、工厂类、 5、测试类、
工厂模式详解：简单工厂、抽象工厂与工厂方法
- 定义：抽象工厂模式提供一个创建对象族的接口，而不指定它们的具体类。 - 应用：适用于有多个产品族，且产品族内的产品需要一起使用的情况。 - 优点：隔离了产品创建，客户端只使用接口，无需关心实现细节；...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值