Recursos de aplicativo:
Quando muitas funções complexas e pequenas exigem requisitos de chamada, essas chamadas geralmente têm um certo grau de correlação, ou seja, uma chamada é uma série.
Características estruturais:
Planeje e unifique as chamadas originalmente complexas e numerosas em uma classe de entrada e, em seguida, você só pode ligar para essa entrada a partir de agora.
Exemplo de estrutura de código:
classe ModuleOne (objeto): def create (self): imprima 'Crie módulo uma instância' DELETE DELETE (self): print 'Excluir módulo Uma instância' Moduletwo (object): def Create (self): print 'criar módulo duas instância' DELETE _): Self): Self. Selft MODOULEM: SelfMew SelfMe. SelfMEn: SelfMEn Module SelfM: SelfM. SelfMew SelfM: SelfMEn: SelfMEn MODEMEN: SelfMeN: Self). = Moduletwo () def create_module_one (self): self.module_one.create () def create_module_two (self): self.module_two.create () def cate_both (self): self.module_one.create () self.module_wwo.crate () uns): self) (self). self.module_one.delete () DE DE DELETE_MODULE_TWO (self): self.module_two.delete () DE DE DELETE_BOTH (self): self.module_one.delete () self.module_two.delete ()
É um pouco semelhante ao modo proxy. A diferença é que o modo de aparência não apenas representa as funções de cada módulo de um subsistema, mas também se destaca da perspectiva do subsistema e combina as funções de cada módulo do subsistema para fornecer uma interface de nível superior ao mundo exterior, atendendo a assim semanticamente às necessidades do subsistema.
À medida que as funções do sistema continuam a se expandir, quando o sistema precisa ser dividido em vários subsistemas ou submódulos para reduzir o acoplamento, reduzir a complexidade do código do sistema e melhorar a manutenção, o modo proxy geralmente tem suas próprias vantagens.
Vamos dar uma olhada em outro exemplo:
classe small_or_piece1: def __init __ (self): passa def do_small1 (self): print 'small 1' classe small_or_piece_2: def __init __ (self): passa def do_small2 (self): imprimir 'small 2' classe small_or_epiece_3: def __init __ (self). __init __ (self): self .__ pequeno1 = small_or_piece1 () self .__ small2 = small_or_piece_2 () self .__ small3 = small_or_piece_3 () def métodos1 (self): self .__ small1.do_small1 () ## Se houver mais de duas funções chamadas, a função será exibida. Você pode limpar o relacionamento original da chamada complexa e unificar auto .__ small2.do_small2 () def métodos2 (self): self .__ small2.do_small2 () self .__ small3.do_small3 () se __name__ == '__main__': osd = fora () osd.method1 () osd.method2
resultado:
o pequeno 1 faça o pequeno 2 fazer pequenos 2 fazer pequenos 3