Patrón de diseño-Patrón de fábrica (2)

Definición:

El patrón de fábrica sigue siendo un patrón de diseño de creación. Como fábrica, se preocupa por la producción de productos, es decir, la creación de objetos. Utilizamos fábricas para crear objetos sin tener que crearlos nosotros mismos. No necesitamos entender cómo crear objetos. Solo necesita hacer una solicitud a la fábrica y dejar que la fábrica produzca los productos que desea y los objetos correspondientes para usted de acuerdo con sus requisitos. Este modelo se llama modelo de fábrica.

Ventajas del modo de fábrica:

1. Acoplados libremente, los objetos creados son independientes de la implementación de la clase
2. El usuario no necesita conocer la clase del objeto creado, solo la interfaz, los parámetros y los métodos pasados. Luego puede crear los objetos necesarios.
3. Fácil de ampliar. La fábrica agrega otros tipos de tipos de datos, solo necesita modificar los parámetros.

Darse cuenta:

Modo simple de fábrica "1":

de abc import ABCMeta, abstractmethod
 # ABCMeta es una metaclase de Python, utilizada para crear clases base abstractas en programas Python, métodos abstractos declarados en clases base abstractas, decorados con decorador de métodos abstractos. 
clase Coca-Cola (metaclase = ABCMeta): 
    @abstractmethod 
    def drink (self):
         pass 

class Coca (Coke):
     def drink (self):
         print ( ' drink Coca-Cola ' ) 

class Pepsi (Coke):
     def drink (self):
         print ( ' beber Pepsi-Cola ' ) 

clase Fast_food_restaurant ():
     defmake_coke (self, name):
         return eval (name) () 

KCD = Fast_food_restaurant () 
coke = KCD.make_coke ( ' Coca ' ) 
coke.drink () 
# drink Coca-Cola 

eval (nombre de clase) devuelve un tipo de clase Nuestro objetivo es 
crear una clase abstracta de Coca-Cola. Pepsi y Coca-Cola heredan esta clase abstracta. También hemos establecido una clase de restaurante de comida rápida, también conocida como la clase de fábrica, para que produzca Coca-Cola. Cuando el usuario necesite coca cola, solo dígale al restaurante de comida rápida qué marca de coca tiene que hacer, dígale el nombre de la cola del restaurante de comida rápida, y luego el restaurante de comida rápida usa el método make_coke para hacer cola, y devuelve el objeto que necesita: una taza de Coca-Cola, y luego puede Feliz bebiendo cola. .

Ver código

Modo de método de fábrica "2"

from abc import ABCMeta, abstractmethod 

class Coke (metaclass = ABCMeta): 
    @abstractmethod 
    def drink (self):
         pass 

class Coca (Coke):
     def drink (self):
         print ( ' drink Coca-Cola ' ) 

class Pepsi (Coke):
     def drink (self):
         print ( ' drink Pepsi-Cola ' ) 

clase Sfencs (Coca-Cola):
     def drink (self):
         print ( ' drink Sfencs-Cola ') 

clase Fast_food_restaurant (metaclass = ABCMeta): 
    @abstractmethod 
    def make_coke (self):
         pass 

class Coca_produce (Fast_food_restaurant):
     def make_coke (self):
         return Coca () 

class Pepsi_produce (Fast_food_restaurant):
     def make_coke (self):
         return Pepsi () 

clase Sfencs_produce (Fast_food_restaurant):
     def make_coke (self):
         return Sfencs () 

KCD = Sfencs_produce () 
coke = KCD.make_coke () 
coke.drink ()# beber El 


patrón de método de fábrica de Sfencs-Cola convierte la clase de fábrica original en una clase abstracta, se producen diferentes tipos de cola a través de diferentes subclases, es decir, el patrón de método de fábrica define una interfaz para crear objetos, pero qué clase de objetos es creada por La subclase decide que el juicio lógico de esta manera es equivalente a entregar al cliente, es decir, KCD = Sfencs_produce () elegir qué subclase usar, de modo que si aparece un nuevo producto de Coca-Cola, solo necesita escribir una herencia de subclase Clase abstracta de fábrica.

Ver código

Patrón abstracto de fábrica "3"

El objetivo principal del patrón de fábrica abstracto es proporcionar una interfaz para crear una serie de objetos relacionados sin especificar una clase específica. La diferencia entre este patrón y el patrón de método de fábrica es que una subclase de método puede crear una serie de objetos. 

from abc import ABCMeta, abstractmethod 

class Ice_coke (metaclass = ABCMeta): 
    @abstractmethod 
    def drink (self):
         pass 

class Ordinary_coke (metaclass = ABCMeta): 
    @abstractmethod 
    def drink (self):
         pass 

class Coca_ice (Ice_coke):
     def drink (self ):
         print ( ' drink Coca-ice-Cola ' ) 

clase Pepsi_ice (Ice_coke):
     def drink (self):
        print ( ' drink Pepsi-ice-Cola ' ) 

class Coca_ordinary (Ordinary_coke):
     def drink (self):
         print ( ' drink Coca-ordinary-Cola ' ) 

class Pepsi_ordinary (Ordinary_coke):
     def drink (self):
         print ( ' drink Pepsi-ordinary-Cola ' ) 

clase Fast_food_restaurant (metaclass = ABCMeta): 
    @abstractmethod 
    def make_ice_coke (self):
         pass 

    @abstractmethod 
    def make_ordinary_coke (self):
        Pase la 

clase Coca_produce (Fast_food_restaurant):
     def make_ice_coke (self):
         return Coca_ice ()
     def make_ordinary_coke (self):
         return Coca_ordinary () 

class Pepsi_produce (Fast_food_restaurant):
     def make_ice_coke (self):
         return Pepsi_ice ()
     def make_ordinary_coke (
         return Pepsi_ordinary () 

KCD = Coca_produce () 
coke = KCD.make_ice_coke () 
coke.drink () # drink Coca-ice-Cola

Ver código