• Python: Abstract Factory Pattern


    AbstractFactory.py
    ## 抽象工厂模式 Abstract Factory Pattern
    
    from __future__ import annotations
    from abc import ABC, abstractmethod
    
    class AbstractFactory(ABC):
        """
        The Abstract Factory interface declares a set of methods that return
        different abstract products. These products are called a family and are
        related by a high-level theme or concept. Products of one family are usually
        able to collaborate among themselves. A family of products may have several
        variants, but the products of one variant are incompatible with products of
        another.
        """
        @abstractmethod
        def create_product_a(self) -> AbstractProductA:
            pass
    
        @abstractmethod
        def create_product_b(self) -> AbstractProductB:
            pass
    
    
    class ConcreteFactory1(AbstractFactory):
        """
        Concrete Factories produce a family of products that belong to a single
        variant. The factory guarantees that resulting products are compatible. Note
        that signatures of the Concrete Factory's methods return an abstract
        product, while inside the method a concrete product is instantiated.
        """
    
        def create_product_a(self) -> AbstractProductA:
            return ConcreteProductA1()
    
        def create_product_b(self) -> AbstractProductB:
            return ConcreteProductB1()
    
    
    class ConcreteFactory2(AbstractFactory):
        """
        Each Concrete Factory has a corresponding product variant.
        """
    
        def create_product_a(self) -> AbstractProductA:
            return ConcreteProductA2()
    
        def create_product_b(self) -> AbstractProductB:
            return ConcreteProductB2()
    
    
    class AbstractProductA(ABC):
        """
        Each distinct product of a product family should have a base interface. All
        variants of the product must implement this interface.
        """
    
        @abstractmethod
        def useful_function_a(self) -> str:
            pass
    
    
    """
    Concrete Products are created by corresponding Concrete Factories.
    """
    
    
    class ConcreteProductA1(AbstractProductA):
        def useful_function_a(self) -> str:
            return "The result of the product A1."
    
    
    class ConcreteProductA2(AbstractProductA):
        def useful_function_a(self) -> str:
            return "The result of the product A2."
    
    
    class AbstractProductB(ABC):
        """
        Here's the the base interface of another product. All products can interact
        with each other, but proper interaction is possible only between products of
        the same concrete variant.
        """
        @abstractmethod
        def useful_function_b(self) -> None:
            """
            Product B is able to do its own thing...
            """
            pass
    
        @abstractmethod
        def another_useful_function_b(self, collaborator: AbstractProductA) -> None:
            """
            ...but it also can collaborate with the ProductA.
    
            The Abstract Factory makes sure that all products it creates are of the
            same variant and thus, compatible.
            """
            pass
    
    
    """
    Concrete Products are created by corresponding Concrete Factories.
    """
    
    
    class ConcreteProductB1(AbstractProductB):
        def useful_function_b(self) -> str:
            return "The result of the product B1."
    
        """
        The variant, Product B1, is only able to work correctly with the variant,
        Product A1. Nevertheless, it accepts any instance of AbstractProductA as an
        argument.
        """
    
        def another_useful_function_b(self, collaborator: AbstractProductA) -> str:
            result = collaborator.useful_function_a()
            return f"The result of the B1 collaborating with the ({result})"
    
    
    class ConcreteProductB2(AbstractProductB):
        def useful_function_b(self) -> str:
            return "The result of the product B2."
    
        def another_useful_function_b(self, collaborator: AbstractProductA):
            """
            The variant, Product B2, is only able to work correctly with the
            variant, Product A2. Nevertheless, it accepts any instance of
            AbstractProductA as an argument.
            """
            result = collaborator.useful_function_a()
            return f"The result of the B2 collaborating with the ({result})"
    
    
    def client_code(factory: AbstractFactory) -> None:
        """
        The client code works with factories and products only through abstract
        types: AbstractFactory and AbstractProduct. This lets you pass any factory
        or product subclass to the client code without breaking it.
        """
        product_a = factory.create_product_a()
        product_b = factory.create_product_b()
    
        print(f"{product_b.useful_function_b()}")
        print(f"{product_b.another_useful_function_b(product_a)}", end="")
    

      

    调用:

    main.py

    import AbstractFactory
    
    if __name__ == '__main__':
    
    
            ## 抽象工厂模式 Abstract Factory Pattern
            print("Client: Testing client code with the first factory type:")
            AbstractFactory.client_code(AbstractFactory.ConcreteFactory1())
    
            print("\n")
    
            print("Client: Testing the same client code with the second factory type:")
            AbstractFactory.client_code(AbstractFactory.ConcreteFactory2());
    

      

    输出:

    Client: Testing client code with the first factory type:
    The result of the product B1.
    The result of the B1 collaborating with the (The result of the product A1.)
    
    Client: Testing the same client code with the second factory type:
    The result of the product B2.
    The result of the B2 collaborating with the (The result of the product A2.)
    Process finished with exit code 0
    

      

  • 相关阅读:
    阿里云技术专家杨泽强:弹性计算云上可观测能力构建
    云服务器ECS老用户专享,10余款实例新购低至3.6折
    重磅大咖来袭!阿里云生命科学与智能计算峰会精彩内容剧透
    阿里云技术专家秦隆:可靠性保障必备——云上如何进行混沌工程?
    《分布式云最佳实践》分论坛,8 月 11 日深圳见
    阿里云技术专家郝晨栋:云上可观测能力——问题的发现与定位实践
    十分钟生成影视级室内设计效果,红星美凯龙设计云如何升级传统家居行业
    阿里云技术专家邓青琳:云上跨可用区容灾和异地多活最佳实践
    本地化、低时延、绿色低碳:阿里云正式启用福州数据中心
    Triangle(bitset)
  • 原文地址:https://www.cnblogs.com/geovindu/p/16804242.html
Copyright © 2020-2023  润新知