Caractéristiques de l'application:
Lorsque de nombreuses fonctions complexes et petites nécessitent des exigences d'appel, ces appels ont souvent un certain degré de corrélation, c'est-à-dire qu'un appel est une série.
Caractéristiques structurelles:
Planifiez et unifiez les appels à l'origine complexes et nombreux dans une classe d'entrée, puis vous ne pouvez appeler que par cette entrée à partir de maintenant.
Exemple de structure de code:
Class moduleOne (objet): def Create (self): Imprimer 'Créer le module One Instance' Def Delete (self): Imprimer 'Delete Module One Instance' Class moduletwo (Object): Def Create (self): Imprimer 'Create Module Two instance' Def Delete (self): Imprimer 'Delete Module Two Instance' Class FACADE (Object): Def __Init __ (Self): self.Module_One_One = 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 () def delete_module_one (self): self.module_one.delete () def delete_module_two (self): self.module_two.delete () def delete_both (self): self.module_one.delete () self.module_two.delete ()
Il est un peu similaire au mode proxy. La différence est que le mode d'apparence indique non seulement les fonctions de chaque module d'un sous-système, mais s'applique également du point de vue du sous-système et combine les fonctions de chaque module du sous-système pour fournir une interface de niveau supérieur au monde extérieur, répondant ainsi sémantiquement aux besoins du niveau du sous-système.
Au fur et à mesure que les fonctions du système continuent de se développer, lorsque le système doit être divisé en plusieurs sous-systèmes ou sous-modules pour réduire le couplage, réduire la complexité du code du système et améliorer la maintenabilité, le mode proxy présente généralement ses propres avantages.
Jetons un coup d'œil à un autre exemple:
classe small_or_pice1: def __init __ (self): pass def do_small1 (self): imprimer 'do petit 1' class small_or_pice_2: def __init __ (self): pass def do_small2 (self): imprimer 'do petit 2' class small_or_piece_3: def __init __ (self): pass def def do_small3 (sel À l'extérieur: def __init __ (self): self .__ small1 = small_or_pice1 () self .__ small2 = small_or_pice_2 () self .__ small3 = small_or_pice_3 () def méthode1 (self): self .__ small1.do_small1 () ## Si il y a plus de deux fonctions appelées ici, la fonction sera affichée. Vous pouvez effacer la relation d'appel de fonction complexe d'origine et unifier self .__ small2.do_small2 () def Method2 (self): self .__ small2.do_small2 () self .__ small3.do_small3 () if __name__ == '__main__': OSD = Outside () OSD.Method1 () Osd.Method2 ()
résultat:
faire petit 1 faire petit 2 faire petit 2 faire petit 3