python: Abstract Factory Pattern

geovindu

发布于 2026-06-18 12:37:23

290

珠宝行业的 “品牌生产线”：不同品牌（如卡地亚、蒂芙尼）都能生产戒指、项链、耳环，但每个品牌的珠宝材质、工艺、定价规则不同，抽象工厂就是定义 “品牌生产线” 的标准，具体工厂则实现各品牌的生产逻辑。我们需要实现：珠宝实体属性：戒指 / 项链 / 耳环都有基础属性（材质、重量、纯度），不同品牌有差异化属性（如卡地亚主打 18K 金 + 钻石，蒂芙尼主打铂金 + 蓝宝石）；业务流程：包含 “生产珠宝→计算成本→生成质检报告” 的完整流程，不同品牌的成本计算、质检标准不同。

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:15
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Jewelry.py
 
from abc import ABC, abstractmethod
 
# ====================== 第一步：定义珠宝产品抽象类（实体属性+基础业务方法） ======================
class Jewelry(ABC):
    """
    珠宝抽象基类：定义所有珠宝的通用属性和业务方法
    """
 
    def __init__(self, material: str, weight: float, purity: str):
        """
 
        :param material:
        :param weight:
        :param purity:
        """
        # 核心实体属性
        self.material = material  # 材质（18K金/铂金/925银）
        self.weight = weight  # 重量（克）
        self.purity = purity  # 纯度（如18K/PT950/S925）
 
    @abstractmethod
    def calculate_cost(self) -> float:
        """
        抽象方法：计算成本（不同品牌/品类计算规则不同）
        :return:
        """
        pass
 
    @abstractmethod
    def generate_inspection_report(self) -> str:
        """
        抽象方法：生成质检报告（不同品牌质检标准不同）
        :return:
        """
        pass
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:19
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Earrings.py
 
from Model.AbstractFactory.Jewelry import Jewelry
 
# ====================== 第一步：定义珠宝产品抽象类（实体属性+基础业务方法） ======================
 
 
class Earrings(Jewelry):
    """
    具体珠宝品类：耳环（补充品类特有属性）
    """
 
    def __init__(self, material: str, weight: float, purity: str, style: str):
        """
 
        :param material:
        :param weight:
        :param purity:
        :param style:
        """
        super().__init__(material, weight, purity) #super () 是用来解决多重继承问题的
        self.style = style  # 耳环款式
 
    def calculate_cost(self) -> float:
        """
 
        :return:
        """
        return 0.0
 
    def generate_inspection_report(self) -> str:
        """
 
        :return:
        """
        return ""
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:18
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Necklace.py
from Model.AbstractFactory.Jewelry import Jewelry
 
# ====================== 第一步：定义珠宝产品抽象类（实体属性+基础业务方法） ======================
 
class Necklace(Jewelry):
    """
    具体珠宝品类：项链（补充品类特有属性）
    """
 
    def __init__(self, material: str, weight: float, purity: str, chain_length: float):
        """
 
        :param material:
        :param weight:
        :param purity:
        :param chain_length:
        """
        super().__init__(material, weight, purity)#super () 是用来解决多重继承问题的
        self.chain_length = chain_length  # 项链链长
 
    def calculate_cost(self) -> float:
        """
 
        :return:
        """
 
        return 0.0
 
    def generate_inspection_report(self) -> str:
        """
 
        :return:
        """
 
        return ""
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:16
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : Ring.py
from Model.AbstractFactory.Jewelry import Jewelry
 
# ====================== 第一步：定义珠宝产品抽象类（实体属性+基础业务方法） ======================
 
class Ring(Jewelry):
    """
    具体珠宝品类：戒指（继承珠宝抽象类，补充品类特有属性）
    """
 
    def __init__(self, material: str, weight: float, purity: str, ring_size: int):
        """
 
        :param material:
        :param weight:
        :param purity:
        :param ring_size:
        """
        super().__init__(material, weight, purity)#super () 是用来解决多重继承问题的
        self.ring_size = ring_size  # 戒指尺寸
 
 
    def calculate_cost(self) -> float:
        """
        实现抽象方法（基础占位逻辑，工厂中重写）
        :return:
        """
        return 0.0
 
 
    def generate_inspection_report(self) -> str:
        """
        实现抽象方法（基础占位逻辑，工厂中重写）
        :return:
        """
        return ""

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:20
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : JewelryAbstractFactory.py
from abc import ABC, abstractmethod
from Model.AbstractFactory.Necklace import Necklace
from Model.AbstractFactory.Ring import Ring
from Model.AbstractFactory.Earrings import Earrings
 
 
# ====================== 第二步：定义抽象工厂（品牌生产线标准） ======================
class JewelryAbstractFactory(ABC):
    """
    抽象工厂：定义生产戒指、项链、耳环的标准接口
    """
 
    @abstractmethod
    def create_ring(self) -> Ring:
        """
        生产戒指
        :return:
        """
        pass
 
    @abstractmethod
    def create_necklace(self) -> Necklace:
        """
        生产项链
        :return:
        """
        pass
 
    @abstractmethod
    def create_earrings(self) -> Earrings:
        """
        生产耳环
        :return:
        """
        pass



# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:24
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : TiffanyFactory.py
from Interface.AbstractFactory.JewelryAbstractFactory import JewelryAbstractFactory
from Model.AbstractFactory.Necklace import Necklace
from Model.AbstractFactory.Ring import Ring
from Model.AbstractFactory.Earrings import Earrings
 
# ====================== 第三步：实现具体工厂（各品牌生产线） ======================
 
class TiffanyFactory(JewelryAbstractFactory):
    """
    蒂芙尼工厂：实现蒂芙尼品牌珠宝的生产逻辑（属性+业务）
    """
 
    def create_ring(self) -> Ring:
        """
 
        :return:
        """
        ring = Ring("铂金", 2.5, "PT950", 11)
 
        def tiffany_ring_cost():
            return (ring.weight * 800) + 2500
 
        ring.calculate_cost = tiffany_ring_cost
 
        def tiffany_ring_report():
            return (
                f"蒂芙尼戒指质检报告：\n"
                f"- 材质：{ring.material} | 重量：{ring.weight}g | 纯度：{ring.purity}\n"
                f"- 尺寸：{ring.ring_size}号 | 成本：{ring.calculate_cost()}元\n"
                f"- 质检标准：符合蒂芙尼北美珠宝质检标准（编号：TF-20260308）"
            )
 
        ring.generate_inspection_report = tiffany_ring_report
        return ring
 
    def create_necklace(self) -> Necklace:
        """
 
        :return:
        """
        necklace = Necklace("铂金", 7.0, "PT950", 40.0)
 
        def tiffany_necklace_cost():
            return (necklace.weight * 800) + 3500
 
        necklace.calculate_cost = tiffany_necklace_cost
 
        def tiffany_necklace_report():
            return (
                f"蒂芙尼项链质检报告：\n"
                f"- 材质：{necklace.material} | 重量：{necklace.weight}g | 纯度：{necklace.purity}\n"
                f"- 链长：{necklace.chain_length}cm | 成本：{necklace.calculate_cost()}元\n"
                f"- 质检标准：符合蒂芙尼北美珠宝质检标准（编号：TF-20260308）"
            )
 
        necklace.generate_inspection_report = tiffany_necklace_report
        return necklace
 
    def create_earrings(self) -> Earrings:
        """
 
        :return:
        """
        earrings = Earrings("铂金", 4.0, "PT950", "耳钉")
 
        def tiffany_earrings_cost():
            return (earrings.weight * 800) + 3000
 
        earrings.calculate_cost = tiffany_earrings_cost
 
        def tiffany_earrings_report():
            return (
                f"蒂芙尼耳环质检报告：\n"
                f"- 材质：{earrings.material} | 重量：{earrings.weight}g | 纯度：{earrings.purity}\n"
                f"- 款式：{earrings.style} | 成本：{earrings.calculate_cost()}元\n"
                f"- 质检标准：符合蒂芙尼北美珠宝质检标准（编号：TF-20260308）"
            )
 
        earrings.generate_inspection_report = tiffany_earrings_report
        return earrings
 
 
 
# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:22
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : CartierFactory.py
from Interface.AbstractFactory.JewelryAbstractFactory import JewelryAbstractFactory
from Model.AbstractFactory.Necklace import Necklace
from Model.AbstractFactory.Ring import Ring
from Model.AbstractFactory.Earrings import Earrings
 
# ====================== 第三步：实现具体工厂（各品牌生产线） ======================
class CartierFactory(JewelryAbstractFactory):
    """
    卡地亚工厂：实现卡地亚品牌珠宝的生产逻辑（属性+业务）
    """
 
    def create_ring(self) -> Ring:
        """
 
        :return:
        """
        ring = Ring("18K金", 3.0, "18K", 12)
 
        # 重写为卡地亚专属成本计算逻辑
        def cartier_ring_cost():
            return (ring.weight * 500) + 2000
 
        ring.calculate_cost = cartier_ring_cost
 
        # 重写为卡地亚专属质检报告逻辑
        def cartier_ring_report():
            return (
                f"卡地亚戒指质检报告：\n"
                f"- 材质：{ring.material} | 重量：{ring.weight}g | 纯度：{ring.purity}\n"
                f"- 尺寸：{ring.ring_size}号 | 成本：{ring.calculate_cost()}元\n"
                f"- 质检标准：符合卡地亚全球珠宝工艺规范（编号：CT-20260308）"
            )
 
        ring.generate_inspection_report = cartier_ring_report
        return ring
 
    def create_necklace(self) -> Necklace:
        """
 
        :return:
        """
        necklace = Necklace("18K金", 8.0, "18K", 45.0)
 
        def cartier_necklace_cost():
            return (necklace.weight * 500) + 3000
 
        necklace.calculate_cost = cartier_necklace_cost
 
        def cartier_necklace_report():
            return (
                f"卡地亚项链质检报告：\n"
                f"- 材质：{necklace.material} | 重量：{necklace.weight}g | 纯度：{necklace.purity}\n"
                f"- 链长：{necklace.chain_length}cm | 成本：{necklace.calculate_cost()}元\n"
                f"- 质检标准：符合卡地亚全球珠宝工艺规范（编号：CT-20260308）"
            )
 
        necklace.generate_inspection_report = cartier_necklace_report
        return necklace
 
    def create_earrings(self) -> Earrings:
        """
 
        :return:
        """
        earrings = Earrings("18K金", 5.0, "18K", "耳坠")
 
        def cartier_earrings_cost():
            return (earrings.weight * 500) + 2500
 
        earrings.calculate_cost = cartier_earrings_cost
 
        def cartier_earrings_report():
            return (
                f"卡地亚耳环质检报告：\n"
                f"- 材质：{earrings.material} | 重量：{earrings.weight}g | 纯度：{earrings.purity}\n"
                f"- 款式：{earrings.style} | 成本：{earrings.calculate_cost()}元\n"
                f"- 质检标准：符合卡地亚全球珠宝工艺规范（编号：CT-20260308）"
            )
 
        earrings.generate_inspection_report = cartier_earrings_report
        return earrings

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:28
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : JewelryBusiness.py
from Interface.AbstractFactory.JewelryAbstractFactory import JewelryAbstractFactory
 
 
# ====================== 第四步：业务流程调用（生产→计算成本→质检） ======================
 
def jewelry_business_process(factory: JewelryAbstractFactory, jewelry_type: str):
    """
    珠宝业务流程：生产→计算成本→生成质检报告
    :param factory:
    :param jewelry_type:
    :return:
    """
    jewelry = None
    if jewelry_type == "ring":
        jewelry = factory.create_ring()
    elif jewelry_type == "necklace":
        jewelry = factory.create_necklace()
    elif jewelry_type == "earrings":
        jewelry = factory.create_earrings()
    else:
        raise ValueError("仅支持ring/necklace/earrings品类")
 
    # 输出业务流程结果
    print("=" * 50)
    print(f"【{jewelry_type}业务流程完成】")
    print(f"1. 生产完成：{jewelry.material}材质{jewelry_type}")
    print(f"2. 成本计算：{jewelry.calculate_cost()}元")
    print(f"3. 质检报告：\n{jewelry.generate_inspection_report()}")

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：抽象工厂模式 Abstract Factory Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/8 21:25
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : AbstractFactory Bll.py
from AbstractFactoryPattern.JewelryBusiness import jewelry_business_process
from Interface.AbstractFactory.CartierFactory import CartierFactory
from Interface.AbstractFactory.TiffanyFactory import TiffanyFactory
 
# ======================5 测试示例 ======================
 
class AbstractFactoryBll(object):
    """
    抽象工厂模式 Abstract Factory Pattern
    """
    def demo(self):
        """
        抽象工厂模式 Abstract Factory Pattern
 
        :return:
        """
        # 1. 卡地亚品牌：生产戒指
        cartier_factory = CartierFactory()
        jewelry_business_process(cartier_factory, "ring")
 
        # 2. 蒂芙尼品牌：生产项链
        tiffany_factory = TiffanyFactory()
        jewelry_business_process(tiffany_factory, "necklace")

# encoding: utf-8
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：计模式 Design Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2024.3.6 python 3.11
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/3/4 21:47
# User      :  geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : CheckPatterns.py
'''
创建型模式 Creational Patterns
抽象工厂Abstract Factory
简单工厂模式 Simple Factory Pattern
生成器 Builder
工厂方法 Factory Method
原型 Prototype
单例 Singleton
 
结构型模式 Structural Patterns
适配器Adapter
桥接Bridge
组合Composite
装饰Decorator
外观Facade
享元Flyweight
代理Proxy
 
 
行为模式 Behavioral Patterns
责任链Chain of Responsibility
迭代器Iterator
备忘录Memento
状态State
模板方法Template Method
命令Command
中介者Mediator
观察者Observer
策略Strategy
访问者Visitor
 
null object Pattern
 
'''
 
from enum import Enum, auto  # 导入枚举相关模块
# 行为模式 Behavioral Patterns  10
import bll.ChainofResponsibilityBll
import bll.MementoBll
import bll.CommandBll
import bll.StateBll
import bll.TemplateMethodBll
import bll.VisitorBll
import bll.StrategyBll
import bll.ObserveBll
import bll.MediatorBll
import bll.IteratorBll
 
 
#结构型模式 Structural Patterns 7
import bll.ProxyBll
import bll.FlyweightBll
import bll.FacadeBll
import bll.DecoratorBll
import bll.CompositeBll
import bll.BridgeBll
import bll.AdapterBll
 
# 创建型模式 Creational Patterns 6
import bll.AbstractFactoryBll
import bll.SingletonBll
import bll.PrototypeBll
import bll.BuilderBll
import bll.FactoryBll
import bll.SimpleFactoryBll
import bll.FactoryMethodBll
import bll.NullObjectBll
 
 
# ====================== 7。 枚举类定义：管理所有设计模式示例 ======================
 
class DesignPattern(Enum):
    """
    设计模式枚举 - 每个枚举成员对应一个设计模式的示例函数
    """
    Memento = auto()
    """
    备忘录模式
    """
    Command = auto()  #
    """
    命令模式
    """
    State = auto()  #
    """
    状态模式
    """
    TemplateMethod=auto() #
    """
    模板方法模式
    """
    Visitor=auto() #
    """
    访问者模式
    """
    Strategy=auto() #
    """
    策略模式
    """
    Observe=auto() #
    """
    观察者模式
    """
    Mediator=auto() #
    """
    中介者模式
    """
    Iterator=auto() #
    """
    迭代器模式
    """
    ChainofResponsibility=auto() #
    """
    责任链模式
    """
    Proxy=auto() #
    """
    代理模式
    """
    Flyweight=auto()
    """
    享元模式
    """
    Facade=auto
    """
    外观模式
    """
    Decorator=auto()
    """
    装饰器模式
    """
    Composite=auto()
    """
    组合模式
    """
    Singleton=auto()
    """
    单例模式
    """
    Prototype=auto()
    """
    原型模式
    """
    Bridge=auto()
    """
    桥接模式
    """
    Adapter=auto()
    """
    适配器模式
    """
    Builder=auto()
    """
    生成器模式
    """
    AbstractFactory=auto()
    """
     抽象工厂模式
    """
    Factory=auto()
    """
    工厂模式
    """
    SimpleFactory=auto()
    """
    简单工厂模式
    """
    FactoryMethod=auto()
    """
    工厂方法模式
    """
    NullObject=auto()
    """
    空对象模式
    """
 
    def show_example(self):
        """
        枚举成员方法：根据当前枚举值执行对应的示例函数
        :return:
        """
        pattern_handlers = {
            DesignPattern.Memento:lambda:(bll.MementoBll.MementoBll().demo()),
            DesignPattern.Command:lambda:(bll.CommandBll.CommandBll().demo()),
            DesignPattern.State:lambda:(bll.StateBll.StateBll().demo()),
            DesignPattern.TemplateMethod:lambda:(bll.TemplateMethodBll.TemplateMethodBll().demo()),
            DesignPattern.Visitor:lambda:(bll.VisitorBll.VisitorBll().demo()),
            DesignPattern.Strategy:lambda:(bll.StrategyBll.StrategyBll().demo()),
            DesignPattern.Observe:lambda:(bll.ObserveBll.ObserveBll().demo()),
            DesignPattern.Mediator:lambda:(bll.MediatorBll.MediatorBll().demo()),
            DesignPattern.Iterator:lambda:(bll.IteratorBll.IteratorBll().demo()),
            DesignPattern.ChainofResponsibility:lambda:(bll.ChainofResponsibilityBll.ChainofResponsibilityBll().dudemo()),
            DesignPattern.Proxy:lambda:(bll.ProxyBll.ProxyBll().demo()),
            DesignPattern.Flyweight:lambda:(bll.FlyweightBll.FlyweightBll().demo()),
            DesignPattern.Facade:lambda :(bll.FacadeBll.FacadeBll().demo()),
            DesignPattern.Decorator:lambda :(bll.DecoratorBll.DecoratorBll().demo()),
            DesignPattern.Composite:lambda:(bll.CompositeBll.CompositeBll().demo()),
            DesignPattern.Singleton:lambda:(bll.SingletonBll.SingletonBll().demo()),
            DesignPattern.Prototype:lambda:(bll.PrototypeBll.PrototypeBll().demo()),
            DesignPattern.Bridge:lambda:(bll.BridgeBll.BridgeBll().demo()),
            DesignPattern.Adapter:lambda:(bll.AdapterBll.AdapterBll().demo()),
            DesignPattern.Builder:lambda:(bll.BuilderBll.BuilderBll().demo()),
            DesignPattern.AbstractFactory:lambda:(bll.AbstractFactoryBll.AbstractFactoryBll().demo()),
            DesignPattern.Factory:lambda:(bll.FactoryBll.FactoryBll().demo()),
            DesignPattern.SimpleFactory:lambda:(bll.SimpleFactoryBll.SimpleFactoryBll().demo()),
            DesignPattern.FactoryMethod:lambda:(bll.FactoryMethodBll.FactoryMethodBll().demo()),
            DesignPattern.NullObject:lambda:(bll.NullObjectBll.NullObjectBll().demo()),
 
 
 
        }
        # 获取当前枚举对应的示例函数并执行
        handler = pattern_handlers.get(self)
        if handler:
            print(f"\n===== 展示【{self.name}（{self._name_to_cn(self.name)}）】示例 =====")
            handler()
        else:
            print(f"❌ 暂未实现{self.name}的示例")
 
    @staticmethod
    def _name_to_cn(name: str) -> str:
        """
        枚举名称转中文，提升可读性
        :param name:
        :return:
        """
        cn_map = {
            "Memento": "备忘录模式",
            "Command": "单例模式",
            "State": "命令模式",
            "TemplateMethod": "模板方法模式",
            "Visitor": "模板方法模式",
            "Strategy": "策略模式",
            "Observe": "观察者模式",
            "Mediator": "中介者模式",
            "Iterator": "迭代器模式",
            "ChainofResponsibility": "责任链模式",
            "Proxy": "代理模式",
            "Flyweight": "享元模式",
            "Facade":"外观模式",
            "Decorator":"装饰器模式",
            "Composite": "组合模式",
            "Singleton":"单例模式",
            "Prototype":"原型模式",
            "Bridge":"桥接模式",
            "Adapter":"适配器模式",
            "Builder":"生成器模式",
            "AbstractFactory":"抽象工厂模式",
            "Factory":"工厂模式",
            "SimpleFactory":"简单工厂模式",
            "FactoryMethod":"工厂方法模式",
            "NullObject":"空对象模式",
 
        }
        return cn_map.get(name, name)

调用：

# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： 设计模式 Design Patterns
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : PyCharm 2023.1 python 3.11
# OS        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  oracle 21c Neo4j
# Datetime  : 2026/2/18 20:58
# User      : geovindu
# Product   : PyCharm
# Project   : pydesginpattern
# File      : main.py
# explain   : 学习
 
import Controller.CheckPatterns
 
 
def select_design_pattern() -> tuple[int, Controller.CheckPatterns.DesignPattern | None]:
    """
    返回 (序列号, 选中的枚举对象)，退出则返回 (0, None)
    :return:
    """
    print("\n=== 方式3：用户选择展示 ===")
    print("可选设计模式（输入0或q退出）：")
    for idx, pattern in enumerate(Controller.CheckPatterns.DesignPattern, 1):
        print(f"{idx}. {pattern._name_to_cn(pattern.name)}（{pattern.name}）")
    print("0. 退出")
 
    while True:
        user_input = input("\n请输入序号选择要展示的设计模式（输入0/q退出）：").strip()
        if user_input in ("0", "q", "Q"):
            print("👋 退出选择流程")
            return (0, None)
 
        try:
            choice = int(user_input)
            if 1 <= choice <= len(Controller.CheckPatterns.DesignPattern):
                selected_pattern = list(Controller.CheckPatterns.DesignPattern)[choice - 1]
                print(f"✅ 你选择了序号：{choice}（对应{selected_pattern._name_to_cn(selected_pattern.name)}）")
                return (choice, selected_pattern)  # 返回(序列号, 枚举对象)
            else:
                print(f"❌ 输入无效！请输入1-{len(Controller.CheckPatterns.DesignPattern)}之间的数字，或0/q退出")
        except ValueError:
            print("❌ 输入无效！请输入数字序号，或0/q退出")
 
def ask_continue() -> bool:
    """
    询问用户是否继续选择，返回True（继续）/False（退出）
    """
    while True:
        user_choice = input("\n是否继续选择其他设计模式？(y/n)：").strip().lower()
        if user_choice == "y":
            return True
        elif user_choice == "n":
            print("👋 感谢使用，程序结束！")
            return False
        else:
            print("❌ 输入无效！请输入 y（继续）或 n（退出）")
 
 
if __name__ == '__main__':
 
    # 方式1：用户输入选择展示（交互版）
    '''
    print("\n=== 方式1：用户选择展示 ===")
    print("可选设计模式：")
    for idx, pattern in enumerate( bll.CheckPatterns.DesignPattern, 1):
        print(f"{idx}. {pattern._name_to_cn(pattern.name)}（{pattern.name}）")
 
    try:
        choice = int(input("\n请输入序号选择要展示的设计模式："))
        selected_pattern = list( bll.CheckPatterns.DesignPattern)[choice - 1]
        selected_pattern.show_example()
    except (ValueError, IndexError):
        print("❌ 输入无效，请输入正确的序号！")
    '''
    # 2
 
    print("🎉 设计模式示例展示程序")
    while True:
        # 1. 选择设计模式
        selected_num, selected_pattern = select_design_pattern()
 
        # 2. 判断是否直接退出（输入0/q）
        if selected_num == 0:
            print("👋 程序结束！")
            break
 
        # 3. 执行选中的示例
        selected_pattern.show_example()
        print(f"\n📌 本次选择的序列号是：{selected_num}")
 
        # 4. 询问是否继续
        if not ask_continue():
            break  # 用户选择不继续，终止循环
 
    print('hi,welcome geovindu.')

输出：