设计模式——3. 抽象工厂模式

已于 2023-10-08 23:00:09 修改
阅读量285 收藏
点赞数 1
分类专栏： 设计模式大全 文章标签： 设计模式 抽象工厂模式 java python golang c++ javascript
于 2023-09-25 11:40:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuang/article/details/133243198
版权

1. 说明

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建一组相关或依赖对象的方式，而无需指定它们的具体类。抽象工厂模式是工厂模式的扩展，它关注于创建一组相关的对象家族，而不仅仅是一个单一的对象。

抽象工厂模式通常涉及以下几个角色：

  1. 抽象工厂（Abstract Factory）：抽象工厂是一个接口或抽象类，它声明了一组工厂方法，每个工厂方法用于创建一个相关的对象家族，包括不同类型的产品。抽象工厂通常与具体工厂相对应。
  2. 具体工厂（Concrete Factory）：具体工厂是抽象工厂的实际实现，它实现了工厂方法，负责创建一组相关的产品对象。每个具体工厂通常与特定的产品家族相对应。
  3. 抽象产品（Abstract Product）：抽象产品是产品家族的抽象，它定义了产品的公共接口，包括不同类型产品的属性和方法。
  4. 具体产品（Concrete Product）：具体产品是抽象产品的具体实现，它们实现了抽象产品定义的接口或继承了抽象产品的基类。

抽象工厂模式的关键思想是将对象的创建与使用分离，同时确保创建的对象家族之间具有一致性。这使得系统更容易扩展，因为可以轻松添加新的产品家族，而不需要修改客户端代码。

2. 使用的场景

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

  1. 需要创建一组相关的产品家族：当一个系统需要创建一组相关的产品对象，而这些产品对象之间有关联或依赖关系时，抽象工厂模式非常有用。例如，一个图形界面库需要创建按钮、文本框和标签等相关的组件。
  2. 需要跨不同产品家族进行配置：如果系统需要在不同的产品家族之间切换，抽象工厂模式是一个好的选择。例如，一个跨平台应用程序可能需要在不同的操作系统上使用不同的用户界面元素，而抽象工厂可以根据当前的操作系统选择合适的工厂来创建界面元素。
  3. 强调一致性：当希望确保创建的对象家族之间具有一致性时，可以使用抽象工厂模式。这有助于确保不同类型的产品对象之间的兼容性。
  4. 系统扩展性：抽象工厂模式支持系统的扩展，可以轻松地添加新的产品家族，而无需修改现有的客户端代码。这有助于保持系统的可维护性和可扩展性。
  5. 隐藏对象的创建细节：抽象工厂模式将对象的创建细节封装在工厂类中，客户端代码无需关心具体对象是如何创建的，从而降低了耦合性。

总的来说，抽象工厂模式适用于需要创建一组相关产品对象，这些产品对象之间存在依赖关系或需要一致性，并且可能需要在不同产品家族之间进行切换或扩展的情况。

3. 应用例子

以下是一个使用Python实现抽象工厂模式的示例，我们将创建不同类型的按钮和文本框，并使用抽象工厂模式封装它们的创建逻辑。

# 抽象工厂接口
class GUIFactory:
    def create_button(self):
        pass

    def create_textbox(self):
        pass

# 具体工厂1：创建Windows风格的按钮和文本框
class WindowsFactory(GUIFactory):
    def create_button(self):
        return WindowsButton()

    def create_textbox(self):
        return WindowsTextbox()

# 具体工厂2：创建Mac风格的按钮和文本框
class MacFactory(GUIFactory):
    def create_button(self):
        return MacButton()

    def create_textbox(self):
        return MacTextbox()

# 抽象产品：按钮
class Button:
    def paint(self):
        pass

# 具体产品1：Windows风格的按钮
class WindowsButton(Button):
    def paint(self):
        return "Windows 风格按钮"

# 具体产品2：Mac风格的按钮
class MacButton(Button):
    def paint(self):
        return "Mac 风格按钮"

# 抽象产品：文本框
class Textbox:
    def display(self):
        pass

# 具体产品1：Windows风格的文本框
class WindowsTextbox(Textbox):
    def display(self):
        return "Windows 风格文本框"

# 具体产品2：Mac风格的文本框
class MacTextbox(Textbox):
    def display(self):
        return "Mac 风格文本框"

# 客户端代码
def create_gui(factory):
    button = factory.create_button()
    textbox = factory.create_textbox()
    return button, textbox

# 使用Windows风格工厂
windows_factory = WindowsFactory()
windows_button, windows_textbox = create_gui(windows_factory)
print(windows_button.paint())  # 输出：Windows 风格按钮
print(windows_textbox.display())  # 输出：Windows 风格文本框

# 使用Mac风格工厂
mac_factory = MacFactory()
mac_button, mac_textbox = create_gui(mac_factory)
print(mac_button.paint())  # 输出：Mac 风格按钮
print(mac_textbox.display())  # 输出：Mac 风格文本框

在这个示例中：

  • GUIFactory 是抽象工厂接口，定义了两个工厂方法：create_button() 和 create_textbox()，用于创建按钮和文本框。
  • WindowsFactory 和 MacFactory 分别是具体工厂，它们实现了 GUIFactory 接口，负责创建Windows风格和Mac风格的按钮和文本框。
  • Button 和 Textbox 是抽象产品，它们定义了按钮和文本框的公共接口。
  • WindowsButton、MacButton、WindowsTextbox 和 MacTextbox 是具体产品，它们实现了抽象产品的接口，分别表示Windows风格和Mac风格的按钮和文本框。
  • 在客户端代码中，我们可以选择使用不同的具体工厂来创建按钮和文本框，从而获得不同风格的用户界面元素。

这个示例演示了如何使用抽象工厂模式来创建不同类型的相关产品对象，而无需直接关心它们的具体类。这种方式有助于实现一致性的用户界面风格，并支持在不同的工厂之间切换。

4. 实现要素

抽象工厂模式的实现要素包括以下几个关键部分：

  1. 抽象工厂（Abstract Factory）：抽象工厂是一个接口或抽象类，它声明了一组抽象工厂方法，每个工厂方法用于创建一组相关的产品对象。抽象工厂的角色是定义产品家族的创建接口，通常与具体工厂相对应。
  2. 具体工厂（Concrete Factory）：具体工厂是抽象工厂的实际实现，它实现了抽象工厂中声明的工厂方法，负责创建一组相关的具体产品对象。每个具体工厂通常对应于一个产品家族。
  3. 抽象产品（Abstract Product）：抽象产品是产品家族的抽象，它定义了产品的公共接口，包括不同类型产品的属性和方法。抽象产品通常是一个接口或抽象类。
  4. 具体产品（Concrete Product）：具体产品是抽象产品的具体实现，它们实现了抽象产品定义的接口或继承了抽象产品的基类。每个具体产品对应于一个具体工厂。

抽象工厂模式的关键思想是将对象的创建与使用分离，通过抽象工厂和具体工厂来创建一组相关的产品对象。这有助于确保创建的产品对象之间具有一致性，并支持在不同的工厂之间切换，以满足不同需求。

5. Java/golang/javascrip/C++ 等语言实现方式

5.1 Java实现抽象工厂模式

上述例子用Java实现示例如下：

// 抽象产品：按钮
interface Button {
    void paint();
}

// 具体产品1：Windows风格的按钮
class WindowsButton implements Button {
    public void paint() {
        System.out.println("Windows 风格按钮");
    }
}

// 具体产品2：Mac风格的按钮
class MacButton implements Button {
    public void paint() {
        System.out.println("Mac 风格按钮");
    }
}

// 抽象产品：文本框
interface Textbox {
    void display();
}

// 具体产品1：Windows风格的文本框
class WindowsTextbox implements Textbox {
    public void display() {
        System.out.println("Windows 风格文本框");
    }
}

// 具体产品2：Mac风格的文本框
class MacTextbox implements Textbox {
    public void display() {
        System.out.println("Mac 风格文本框");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        GUIFactory windowsFactory = new WindowsFactory();
        Button windowsButton = windowsFactory.createButton();
        Textbox windowsTextbox = windowsFactory.createTextbox();

        windowsButton.paint();      // 输出：Windows 风格按钮
        windowsTextbox.display();   // 输出：Windows 风格文本框

        GUIFactory macFactory = new MacFactory();
        Button macButton = macFactory.createButton();
        Textbox macTextbox = macFactory.createTextbox();

        macButton.paint();          // 输出：Mac 风格按钮
        macTextbox.display();       // 输出：Mac 风格文本框
    }
}

5.2 Golang实现抽象工厂模式

在Go中，由于语言的特性和面向对象编程模式的不同，抽象工厂模式的实现方式与传统的面向对象语言有所不同。Go语言没有类和继承，但我们可以使用接口和函数来实现抽象工厂模式。以下是一个使用Go实现上述例子的示例:

package main

import "fmt"

// 抽象产品：按钮
type Button interface {
        Paint()
}

// 具体产品1：Windows风格的按钮
type WindowsButton struct{}

func (b WindowsButton) Paint() {
        fmt.Println("Windows 风格按钮")
}

// 具体产品2：Mac风格的按钮
type MacButton struct{}

func (b MacButton) Paint() {
        fmt.Println("Mac 风格按钮")
}

// 抽象产品：文本框
type Textbox interface {
        Display()
}

// 具体产品1：Windows风格的文本框
type WindowsTextbox struct{}

func (t WindowsTextbox) Display() {
        fmt.Println("Windows 风格文本框")
}

// 具体产品2：Mac风格的文本框
type MacTextbox struct{}

func (t MacTextbox) Display() {
        fmt.Println("Mac 风格文本框")
}

// 抽象工厂接口
type GUIFactory interface {
        CreateButton() Button
        CreateTextbox() Textbox
}

// 具体工厂1：创建Windows风格的按钮和文本框
type WindowsFactory struct{}

func (f WindowsFactory) CreateButton() Button {
        return WindowsButton{}
}

func (f WindowsFactory) CreateTextbox() Textbox {
        return WindowsTextbox{}
}

// 具体工厂2：创建Mac风格的按钮和文本框
type MacFactory struct{}

func (f MacFactory) CreateButton() Button {
        return MacButton{}
}

func (f MacFactory) CreateTextbox() Textbox {
        return MacTextbox{}
}

// 客户端代码
func main() {
        windowsFactory := WindowsFactory{}
        windowsButton := windowsFactory.CreateButton()
        windowsTextbox := windowsFactory.CreateTextbox()

        windowsButton.Paint()       // 输出：Windows 风格按钮
        windowsTextbox.Display()    // 输出：Windows 风格文本框

        macFactory := MacFactory{}
        macButton := macFactory.CreateButton()
        macTextbox := macFactory.CreateTextbox()

        macButton.Paint()           // 输出：Mac 风格按钮
        macTextbox.Display()        // 输出：Mac 风格文本框
}

5.3 Javascript实现抽象工厂模式

在JavaScript中，抽象工厂模式的实现方式与其他面向对象编程语言不同，因为JavaScript是一门动态语言，没有类和接口的概念。但我们可以使用对象和函数来模拟抽象工厂模式。以下是一个使用JavaScript实现上述例子的示例：

// 抽象产品：按钮
function Button() {}

Button.prototype.paint = function () {
    console.log("Button");
};

// 具体产品1：Windows风格的按钮
function WindowsButton() {}

WindowsButton.prototype = Object.create(Button.prototype);

WindowsButton.prototype.paint = function () {
    console.log("Windows 风格按钮");
};

// 具体产品2：Mac风格的按钮
function MacButton() {}

MacButton.prototype = Object.create(Button.prototype);

MacButton.prototype.paint = function () {
    console.log("Mac 风格按钮");
};

// 抽象产品：文本框
function Textbox() {}

Textbox.prototype.display = function () {
    console.log("Textbox");
};

// 具体产品1：Windows风格的文本框
function WindowsTextbox() {}

WindowsTextbox.prototype = Object.create(Textbox.prototype);

WindowsTextbox.prototype.display = function () {
    console.log("Windows 风格文本框");
};

// 具体产品2：Mac风格的文本框
function MacTextbox() {}

MacTextbox.prototype = Object.create(Textbox.prototype);

MacTextbox.prototype.display = function () {
    console.log("Mac 风格文本框");
};

// 抽象工厂
function GUIFactory() {}

GUIFactory.prototype.createButton = function () {
    throw new Error("Abstract method createButton() must be overridden.");
};

GUIFactory.prototype.createTextbox = function () {
    throw new Error("Abstract method createTextbox() must be overridden.");
};

// 具体工厂1：创建Windows风格的按钮和文本框
function WindowsFactory() {}

WindowsFactory.prototype = Object.create(GUIFactory.prototype);

WindowsFactory.prototype.createButton = function () {
    return new WindowsButton();
};

WindowsFactory.prototype.createTextbox = function () {
    return new WindowsTextbox();
};

// 具体工厂2：创建Mac风格的按钮和文本框
function MacFactory() {}

MacFactory.prototype = Object.create(GUIFactory.prototype);

MacFactory.prototype.createButton = function () {
    return new MacButton();
};

MacFactory.prototype.createTextbox = function () {
    return new MacTextbox();
};

// 客户端代码
const windowsFactory = new WindowsFactory();
const windowsButton = windowsFactory.createButton();
const windowsTextbox = windowsFactory.createTextbox();

windowsButton.paint();       // 输出：Windows 风格按钮
windowsTextbox.display();   // 输出：Windows 风格文本框

const macFactory = new MacFactory();
const macButton = macFactory.createButton();
const macTextbox = macFactory.createTextbox();

macButton.paint();           // 输出：Mac 风格按钮
macTextbox.display();        // 输出：Mac 风格文本框

5.4 C++实现抽象工厂模式

#include <iostream>

// 抽象产品：按钮
class Button {
public:
    virtual void paint() = 0;
};

// 具体产品1：Windows风格的按钮
class WindowsButton : public Button {
public:
    void paint() override {
        std::cout << "Windows 风格按钮" << std::endl;
    }
};

// 具体产品2：Mac风格的按钮
class MacButton : public Button {
public:
    void paint() override {
        std::cout << "Mac 风格按钮" << std::endl;
    }
};

// 抽象产品：文本框
class Textbox {
public:
    virtual void display() = 0;
};

// 具体产品1：Windows风格的文本框
class WindowsTextbox : public Textbox {
public:
    void display() override {
        std::cout << "Windows 风格文本框" << std::endl;
    }
};

// 具体产品2：Mac风格的文本框
class MacTextbox : public Textbox {
public:
    void display() override {
        std::cout << "Mac 风格文本框" << std::endl;
    }
};

// 抽象工厂接口
class GUIFactory {
public:
    virtual Button* createButton() = 0;
    virtual Textbox* createTextbox() = 0;
};

// 具体工厂1：创建Windows风格的按钮和文本框
class WindowsFactory : public GUIFactory {
public:
    Button* createButton() override {
        return new WindowsButton();
    }

    Textbox* createTextbox() override {
        return new WindowsTextbox();
    }
};

// 具体工厂2：创建Mac风格的按钮和文本框
class MacFactory : public GUIFactory {
public:
    Button* createButton() override {
        return new MacButton();
    }

    Textbox* createTextbox() override {
        return new MacTextbox();
    }
};

int main() {
    // 使用Windows风格工厂
    GUIFactory* windowsFactory = new WindowsFactory();
    Button* windowsButton = windowsFactory->createButton();
    Textbox* windowsTextbox = windowsFactory->createTextbox();

    windowsButton->paint();     // 输出：Windows 风格按钮
    windowsTextbox->display();  // 输出：Windows 风格文本框

    // 使用Mac风格工厂
    GUIFactory* macFactory = new MacFactory();
    Button* macButton = macFactory->createButton();
    Textbox* macTextbox = macFactory->createTextbox();

    macButton->paint();         // 输出：Mac 风格按钮
    macTextbox->display();      // 输出：Mac 风格文本框

    // 释放资源
    delete windowsButton;
    delete windowsTextbox;
    delete windowsFactory;
    delete macButton;
    delete macTextbox;
    delete macFactory;

    return 0;
}

6. 练习题

假设你正在设计一个电子产品制造工厂，该工厂可以生产不同品牌（例如，Apple和Samsung）的电子产品，包括手机和笔记本电脑。每个品牌都有自己的手机和笔记本电脑型号。使用抽象工厂模式来实现这个电子产品工厂。

要求：

  1. 创建一个抽象工厂接口 ElectronicFactory，它包括两个抽象方法：createPhone 和 createLaptop，分别用于创建手机和笔记本电脑。
  2. 创建两个具体工厂类：AppleFactory 和 SamsungFactory，它们实现了 ElectronicFactory 接口，并分别负责生产Apple和Samsung品牌的电子产品。
  3. 创建抽象产品类 Phone 和 Laptop，它们包含抽象方法来描述不同品牌的手机和笔记本电脑特性。
  4. 创建具体产品类：ApplePhone、SamsungPhone、AppleLaptop 和 SamsungLaptop，它们分别继承自 Phone 和 Laptop，并实现具体品牌的特性。
  5. 在客户端代码中，使用抽象工厂模式来创建不同品牌的手机和笔记本电脑，并展示它们的特性。
  6. 确保在客户端代码中可以轻松地切换不同的工厂以生产不同品牌的产品。

你可以在评论区里或者私信我回复您的答案，这样我或者大家都能帮你解答，期待着你的回复~

guohuang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式——JAVA.docx
04-03
JAVA设计模式总结之23种设计模式 一：设计模式之六大原则 总原则：开闭原则（Open Close Principle） 开闭原则就是说对扩展开放，对修改关闭。...1.Abstract Factory（抽象工厂模式） 2.Adapter（适配器模式）......
（创建模式 上）设计模式——工厂、抽象工厂 C++/Python3实现
01-20
简介 设计模式是为了解决一些出现的问题设计的解决方案。是长时间经验的总结，是根据...工厂模式 在类中实现一个接口创建指定对象，使一个类的实例化延迟到了子类。简单来说把类的创建都封装起来，只需要调用一个子类
设计模式创建型——抽象工厂模式
tszc95的博客
04-06 8101
抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
设计模式——抽象工厂
y小川的专栏
06-19 1087
抽象工厂是一种创建型的设计模式，它允许您生成一系列相关的对象而无需指定它们的具体类。
设计模式——抽象工厂模式
qq_56412380的博客
10-08 1029
抽象工厂入门
常用设计模式——抽象工厂模式
weixin_45676761的博客
03-08 3634
本篇博客给大家介绍常用设计模式中的抽象工厂模式。本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族。
23种设计模式——抽象工厂模式
qq_51165184的博客
05-01 6838
抽象工厂本质：选择产品族的实现
Scala设计模式Part I. 创建模式——1.抽象工厂
肖飞figo的云计算专栏
05-23 900
Part I. 创建模式1. 抽象工厂描述 抽象工厂的目的是为创建一系列相关或者依赖的对象提供一个接口，而不用指定具体的类 例如我们要开发一个可以兼容不同OS平台GUI库，为了能够为图形窗口提供统一的视觉感受，在维护能跨OS运行的代码时，只能暴露window的接口给使用户用。通常窗口由多个挂件（菜单，按钮）组成，其中有些挂件与平台绑定。事实上不同平台上窗口的具体创建代码通过抽象工厂进行了分离。这
C#设计模式——抽象工厂（Abstract Factory Pattern）
qq_57198771的博客
12-28 1815
抽象工厂模式是一个创建型设计模式，本文讲解抽象工厂模式相关知识、抽象类和接口知识、C#中实现简单的抽象工厂模式，并展示扩展产品族和产品等级的情况。
设计模式——5、抽象工厂模式
pshdhx的博客
02-28 5826
前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。 同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如农场里既养动物又种植物，电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。 本节要介绍的抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，图 1 所示的是海尔工厂和 TCL
Java23种设计模式——4.创建型模式之抽象工厂模式
胖子胖子大胖子的博客
01-05 1430
Java中除去有设计原则之外，还有23中设计模式。（设计模式我们主要来将思想和精髓的地方，除去Java还有其他的语言也可以适用） 这些模式都是前辈们一点一点积累下来，一直在改进，一直在优化的，这些设计模式可以解决一些特定的问题。 这些模式中，可以说是将语言的使用提现的淋漓尽致，我们今天要学习第一种设计模式，抽象工厂模式！ 抽象工厂模式： 大家可以发现啊，这个之前我们说了这个工厂模式，但是现...
创建型设计模式——抽象工厂模式
胜天半子祁同伟
02-11 6159
创建型设计模式——抽象工厂模式
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与应用，特别是针对刘伟教授的相关课程的课后习题及模拟试题的解答。 设计模式分为三大类：创建型、结构型和行为型模式。...
设计模式实现——抽象工厂模式结构实现
09-03
抽象工厂模式是设计模式中的一种创建型模式，它提供了一种创建对象集合的接口，而无需指定具体的类。这种模式允许客户端使用一个通用接口来创建一组相关或相互依赖的对象，而无需关心它们的具体实现。在Java或其他...
软件设计模式——抽象工厂
05-17
抽象工厂模式是一种重要的软件设计模式，它属于创建型模式，主要解决的是当系统需要创建一系列相关或相互依赖的对象时，而这些对象的类在运行时可能不确定的问题。在这个模式中，我们通过一个抽象工厂接口来定义创建...
设计模式-责任链模式
明戈戈的博客
07-04 920
在该函数中为了实现对下家的引用，必须继承自 AbstractHandler，以实现对下家的引用，并提供getter/setter函数实现对该引用的取得和修改操作，这就是责任链的核心。由流管道的责任链模式也可以得出，凡是具有过滤和管道特征的应用都属于责任链器模式，例如 Java EE 中的 Filter 过滤器、UNIX中的管道符等，都属于责任链模式。因此，Java I/O 库中的所有输入流、输出流的类都采用了责任链模式，它们可以无限次地进行装饰转换，转换的目标就是得到自己想要的数据类型的流对象。
设计模式-模板方法模式
明戈戈的博客
07-02 1147
因为 HtpServlet.service()方法会检查请求方法是否调用了适当的处理方法，不必要覆盖 service()方法，只需覆盖相应的 do 方法就可以了。模板方法模式的使用方法：定义一个abstract的Class，在这个抽象类中，至少包括一个实现模板方法的不可被子类改写的public方法(需声明为final)，在这个公共方法中，实现模板方法的业务处理逻辑，同时，在这个方法中，还包括一些对本类中的抽象方法的调用：再根据业务的需要，定义各种不同的子类，并实现模板方法类的所有抽象方法。
Java中的设计模式在实际项目中的应用
最新发布
微赚淘客开发者博客
07-05 386
设计模式是解决软件设计中常见问题的经验总结，它们提供了一种标准的解决方案，能够帮助开发人员设计出灵活、可扩展和易于维护的代码。在Java中，设计模式尤为重要，因为Java是一种面向对象的语言，设计模式可以帮助开发人员更好地利用面向对象编程的特性。通过合理应用设计模式，可以提高代码的复用性、灵活性和可维护性，降低项目的开发和维护成本，同时提升系统的可靠性和性能。观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。对象，隐藏了对象的创建细节。
设计模式之单例模式
07-03 456
单例模式（Singleton Pattern）是一种常用的软件设计模式，它确保一个类仅有一个实例，并提供一个全局访问点来获取该实例。这个模式在多种场景下都非常有用，比如配置文件的读取、数据库连接、线程池等，这些资源通常只需要一个实例来管理，以避免资源浪费或数据不一致。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

guohuang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值