23 Modos de design 20: Java Intermediary Model
Definição: encapsular uma série de interações de objetos com um objeto mediador. O mediador faz com que cada objeto interaja sem exibição, afrouxando assim o acoplamento e alterando independentemente a interação entre eles.
Tipo: padrão comportamental
Diagrama de classe:
A estrutura do modelo intermediário
O modo intermediário também é chamado de modo mediador. Do diagrama de classe, ele é dividido em 3 partes:
Resumo Mediador: Defina a interface entre objetos de classe de colega e objetos mediadores e é usado para comunicação entre cada classe de colega. Geralmente, inclui um ou vários métodos de eventos abstratos e é implementado por subclasses.
Classe de implementação intermediária: herdado de mediadores abstratos e implementa métodos de eventos definidos em mediadores abstratos. Receba mensagens de uma classe de colega e influencie outras classes simultâneas através da mensagem.
Classe de colega: se um objeto afeta outros objetos e também for afetado por outros objetos, esses dois objetos são chamados de classes de colega. No diagrama de classes, há apenas uma aula de colega, que na verdade é uma omissão da realidade. Em aplicações práticas, a classe de colega geralmente é composta por múltiplas e influenciam e dependem um do outro. Quanto mais colegas existem, mais complicados os relacionamentos. Além disso, a classe de colega também pode ser representada como um conjunto de implementações herdando a mesma classe abstrata. No modelo intermediário, a mensagem deve ser transmitida através de intermediários entre colegas.
Por que usar o modelo intermediário
De um modo geral, a relação entre as classes de colega é relativamente complexa. Quando várias aulas de colega estiverem correlacionadas, seu relacionamento aparecerá como uma estrutura complexa de malha. Esta é uma arquitetura excessiva, ou seja, não é propícia à reutilização da classe e não é estável. Por exemplo, na figura abaixo, existem seis objetos semelhantes a colegas. Se o objeto 1 mudar, 4 objetos serão afetados. Se o objeto 2 mudar, 5 objetos serão afetados. Em outras palavras, o design da correlação direta entre colegas não é boa.
Se o modelo intermediário for introduzido, o relacionamento entre as classes de colega se tornará uma estrutura estrela. A partir da figura, podemos ver que as alterações em qualquer classe afetarão apenas a própria classe e o intermediário, o que reduzirá o acoplamento do sistema. Definitivamente, um bom design não encapsulará toda a lógica de processamento de relação de objetos nesta classe, mas usará uma classe especial para gerenciar comportamentos que não pertencem a você.
Vamos usar um exemplo para ilustrar o que é uma aula de colega: existem duas classes A e B, cada uma com um número, e devemos garantir que os números da classe B sejam sempre 100 vezes os números da classe A. Ou seja, ao modificar o número de Classe A, multiplicar o número por 100 e atribuir a classe B e a classe B e a classe B, dividir -se, se dividirem, por meio da classe B, a classe B e a classe B e a classe B, a Classe B por A. O código é o seguinte:
Classe abstrata abstractColleague {Número INT protegido; public int getNumber () {Número de retorno; } public void setNumber (int número) {this.number = número; } // Método abstrato, modifique o objeto associado ao mesmo tempo ao modificar os números public abstrato void setNumber (número int, abstractcolleague coll); } classe colégua estende abstratacolleague {public void setNumber (número int, abstratecolleague coll) {this.number = número; Coll.SetNumber (número*100); }} classe COLEAGEB estende abstrataColleague {public void SetNumber (número int, abstractColleague coll) {this.number = número; Coll.SetNumber (número/100); }} public class Client {public static void main (String [] args) {abstractColleague colla = new coléguéia (); Abstractcolleague collb = new colagueb (); System.out.println ("============================================== ==================================================================== ==================================================================== ===================================================================== ==================================================================== ==================================================================== ==================================================================== ===================================================================== System.out.println ("Valor número de Collb:"+collb.getNumber ()); No código acima, as classes A e B estão relacionadas por meio de associação direta. Se queremos usar o modelo intermediário, as classes A e B não podem ser diretamente relacionadas. Eles devem usar um intermediário para alcançar o objetivo da associação.
Classe abstrata abstractColleague {Número INT protegido; public int getNumber () {Número de retorno; } public void setNumber (int número) {this.number = número; } // Observe que os parâmetros aqui não são mais colegas, mas um conjunto de vazios abstratos públicos intermediários (número int, abstrataMediator AM); } classe colégua estende o abstractcolleague {public void setNumber (número int, abstrateMediAr AM) {this.number = número; am.AaffectB (); }} classe COLEAGEB estende abstrataColleague {@Override public void SetNumber (número int, abstractMediAtor AM) {this.number = número; am.baffecta (); }} classe abstract abstractMediAtor {AbstractColleague a; protegido; AbstractColleague protegido B; public abstractMediAtor (AbstractColleague A, AbstractColleague b) {a = A; B = b; } abstrato público void aaffectB (); Resumo público Void Baffecta (); } classe mediadora estende abstractMediator {public mediator (abstractcolleague A, abstractcolleague b) {super (a, b); } // lida com o impacto de a em b public void aaffectb () {int number = a.getNumber (); B.SetNumber (número*100); } // lida com o impacto de b em um public void baffecta () {int number = b.getNumber (); A.SetNumber (número/100); }} public class Client {public static void main (String [] args) {abstractColleague colla = new coléguéia (); Abstractcolleague collb = new colagueb (); Abstract Mediator AM = novo mediador (Colla, Collb); System.out.println ("======================== ======================================================================================================================================================================================================asse ======================================================================================================================================================================================================asse ===================================================================================================================================== System.out.println ("O valor do número de Colla é:"+colla.getNumber ()); B======================================================================================== ================================================================================================== ================================================================================================== ================================================================================================== System.out.println ("O valor do número de Collb é:"+collb.getNumber ());Embora o código seja relativamente longo, ainda é relativamente fácil de entender. De fato, é reembalar o código que originalmente lida com relacionamentos de objetos em uma classe de mediação e lidar com a relação entre objetos através desta classe de mediação.
Vantagens do modelo intermediário
1. O uso adequado do modelo intermediário pode evitar o acoplamento excessivo entre as classes de colegas, para que cada classe de colega possa ser usada de forma relativamente independente.
2. O uso do padrão do mediador pode transformar as relações um para muitos entre objetos em relacionamentos individuais, facilitando a compreensão e a manutenção dos relacionamentos entre os objetos.
3. O uso do modelo intermediário pode abstrair o comportamento e a colaboração de objetos e pode lidar com interações entre objetos com mais flexibilidade.
Cenários aplicáveis
Na programação orientada a objetos, uma classe dependerá inevitavelmente de outras classes, e classes completamente independentes não têm sentido. Também é bastante comum uma classe confiar em várias classes ao mesmo tempo. Como essa situação existe, isso significa que a dependência um para muitos tem sua racionalidade. O uso apropriado do padrão do mediador pode deixar claro o relacionamento de objeto originalmente confuso, mas se for abusado, pode trazer efeitos negativos. De um modo geral, o modelo mediador é considerado apenas para o relacionamento entre as classes de colegas de trabalho, onde há uma estrutura de malha. A estrutura da malha pode ser transformada em uma estrutura estrela para tornar a relação entre os colegas mais claros.
O modelo intermediário é um modelo relativamente comum e um modelo abusado relativamente fácil de ser. Na maioria dos casos, a relação entre as classes de colega não será complicada a uma estrutura caótica de malha. Portanto, na maioria dos casos, não há problema em encapsular as dependências entre objetos na classe de colega e não há necessidade de introduzir o modelo intermediário. O abuso do modelo intermediário só tornará as coisas mais complicadas.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.