Características de la aplicación:
Cuando muchas funciones complejas y pequeñas requieren requisitos de llamadas, estas llamadas a menudo tienen un cierto grado de correlación, es decir, una llamada es una serie.
Características estructurales:
Planifique y unifique las llamadas originalmente complejas y numerosas en una clase de entrada, y luego solo puede llamar a través de esta entrada a partir de ahora.
Ejemplo de estructura de código:
class ModuleOne (Object): def create (self): imprimir 'Crear módulo una instancia' def eliminar (self): print 'Eliminar módulo una instancia' ModuleTwo (objeto): def create (self): print 'create module dos instancia' defelete (self): print 'Eliminar módulo dos instancia' Facade (objeto): def __init __ (self): self.module_one = modeMeMeNeMeNe » = ModuleTwo () def create_module_one (self): self.module_one.create () def create_module_two (self): self.module_two.create () def create_both (self): self.module_one.create () self.module_two.create () defelete_module (self) self.module_one.delete () def delete_module_two (self): self.module_two.delete () def eliminar_both (self): self.module_one.delete () self.module_two.delete ()
Es un poco similar al modo proxy. La diferencia es que el modo de apariencia no solo proxiona las funciones de cada módulo de un subsistema, sino que también se destaca desde la perspectiva del subsistema y combina las funciones de cada módulo del subsistema para proporcionar una interfaz de nivel superior al mundo exterior, satisfaciendo semánticamente las necesidades del nivel del subsistema.
A medida que las funciones del sistema continúan expandiéndose, cuando el sistema debe dividirse en múltiples subsistemas o submódulos para reducir el acoplamiento, reducir la complejidad del código del sistema y mejorar la mantenibilidad, el modo proxy generalmente tiene sus propias ventajas.
Echemos un vistazo a otro ejemplo:
class small_or_piece1: def __init__(self): pass def do_small1(self): print 'do small 1' class small_or_piece_2: def __init__(self): pass def do_small2(self): print 'do small 2' class small_or_piece_3: def __init__(self): pass def do_small3(self): print 'do small 3' class outside: def __init __ (self): self .__ small1 = small_or_piece1 () self .__ small2 = small_or_piece_2 () self .__ small3 = small_or_piece_3 () def métode1 (self): self .__ small1.do_small1 () ## Si hay más de lo que hay más de dos funciones llamadas aquí, se mostrará la función. Puede borrar la relación de llamada de función compleja original y unificar a sí mismo .__ small2.do_small2 () def métod2 (self): self .__ small2.do_small2 () self .__ small3.do_small3 () if __name__ == '__Main__': osd = oution () osd.method1 () Osd.method2 ()
resultado:
hacer pequeño 1 Do Small 2 Do Small 2 Do Small 3