O que significa 'baixo acoplamento e alto coesão'

Tenho problemas para entender a afirmação low in coupling and high in cohesion. Eu pesquisei e li muito sobre isso, mas ainda acho difícil de entender.

Para o que eu entendo High cohesion, significa que devemos ter classes especializadas para desempenhar uma função específica. Espero que isso esteja correto? Como uma classe de validação de cartão de crédito, especializada para validar apenas cartões de crédito.

E ainda não entendo o que significa baixo acoplamento?

O que eu acredito é isso:

Coesão refere-se ao grau em que os elementos de um módulo / classe pertencem um ao outro, sugere-se que o código relacionado esteja próximo um do outro, portanto, devemos procurar alta coesão e vincular todo o código relacionado o mais próximo possível. Tem a ver com os elementos dentro do módulo / classe.

O acoplamento refere-se ao grau em que os diferentes módulos / classes dependem um do outro, sugere-se que todos os módulos sejam independentes o máximo possível, por isso o baixo acoplamento. Tem a ver com os elementos entre diferentes módulos / classes.

Para visualizar toda a imagem será útil:

A captura de tela foi tirada do Coursera .

Coesão na engenharia de software, como na vida real, é o quanto os elementos que constituem um todo (no nosso caso, digamos, uma classe) podem ser considerados que realmente pertencem um ao outro. Portanto, é uma medida de quão fortemente relacionada cada parte da funcionalidade expressa pelo código fonte de um módulo de software está.

Uma maneira de observar a coesão em termos de OO é se os métodos da classe estão usando algum dos atributos privados.

Agora a discussão é maior do que isso, mas a alta coesão (ou o melhor tipo de coesão - a coesão funcional) ocorre quando partes de um módulo são agrupadas porque todas elas contribuem para uma única tarefa bem definida do módulo.

Acoplando em palavras simples, é quanto um componente (novamente, imagine uma classe, embora não necessariamente) saiba sobre o funcionamento interno ou os elementos internos de outro, ou seja, quanto conhecimento ele tem sobre o outro componente.

O acoplamento frouxo é um método de interconectar os componentes em um sistema ou rede para que esses componentes dependam um do outro na menor extensão possível na prática…

Eu escrevi um post sobre isso. Ele discute tudo isso com muitos detalhes, com exemplos etc. Ele também explica os benefícios dos motivos pelos quais você deve seguir esses princípios.

No design de software, alta coesão significa que a classe deve fazer uma coisa e uma coisa muito bem. A alta coesão está intimamente relacionada ao princípio da responsabilidade única .

Um baixo acoplamento sugere que a classe deve ter menos dependências possíveis. Além disso, as dependências que devem existir devem ser dependências fracas - preferem a dependência na interface do que a dependência na classe concreta ou preferem a composição à herança.

Coesão alta e baixo acoplamento nos fornecem um código melhor projetado e mais fácil de manter.

Resposta curta e clara

• Coesão alta : elementos dentro de uma classe / módulo devem pertencer funcionalmente juntos e fazer uma coisa em particular.
• Acoplamento fraco : entre diferentes classes / módulos deve haver dependência mínima.

O baixo acoplamento está no contexto de dois ou muitos módulos. Se uma alteração em um módulo resultar em muitas alterações em outro módulo, elas são consideradas altamente acopladas. É aqui que a programação baseada em interface ajuda. Qualquer alteração no módulo não afetará o outro módulo, pois a interface (o meio de interação) entre eles não mudou.

Coesão alta - junte as coisas semelhantes. Portanto, uma classe deve ter métodos ou comportamentos para realizar tarefas relacionadas. Apenas para dar um exemplo ruim exagerado: Uma implementação da interface List não deve ter operação relacionada a String. A classe String deve ter métodos, campos relevantes para String e, da mesma forma, a implementação da List deve ter itens correspondentes.

Espero que ajude.

Para encurtar a história, o baixo acoplamento, como eu entendi, significava que os componentes podem ser trocados sem afetar o funcionamento adequado de um sistema. Modular basicamente o seu sistema em componentes funcionais que podem ser atualizados individualmente sem interromper o sistema

Você tem um smartphone? Existe um grande aplicativo ou muitos pequenos? Um aplicativo responde ao outro? Você pode usar um aplicativo durante a instalação, atualização e / ou desinstalação de outro? O fato de cada aplicativo ser independente é de alta coesão. O fato de cada aplicativo ser independente dos outros é de baixo acoplamento. O DevOps favorece essa arquitetura porque significa que você pode fazer uma implantação contínua e discreta sem interromper o sistema inteiro.

Herança ou generalização é um exemplo de alto acoplamento (ou seja, alta interdependência). O que eu quis dizer com isso é que, em herança, geralmente a classe pai define funcionalidades básicas que são usadas por sua classe filho e a mudança nos métodos da classe pai afeta diretamente suas classes filho. Portanto, podemos dizer que há um maior grau de interdependência entre as classes.

A realização ou utilização da interface é um exemplo de alta coesão (isto é, baixa interdependência). O que isso significa é que uma interface apresenta um contrato para qualquer classe que a implemente, mas cada classe tem o direito de implementar métodos declarados na interface de sua própria maneira e as alterações no método declarado em uma classe não afetam nenhuma outra classe.

Coesão - quão intimamente relacionado tudo está um com o outro.
Acoplamento - como tudo está conectado um ao outro.

Vamos dar um exemplo - queremos projetar um carro autônomo.

(1) Precisamos que o motor funcione corretamente.

(2) Precisamos do carro para dirigir por conta própria.

Todas as classes e funções em (1) iniciam o motor e fazem com que ele funcione muito bem juntos, mas não ajudam o carro a dirigir. Então, colocamos essas classes atrás de um controlador de mecanismo.

Todas as classes e funções em (2) funcionam muito bem para fazer o carro dirigir, acelerar e frear. Eles não ajudam o carro a dar partida ou mandam gasolina para os pistões. Portanto, colocamos essas classes atrás de seu próprio controlador de direção.

Esses controladores são usados ​​para se comunicar com todas as classes e funções disponíveis. Os controladores então se comunicam apenas entre si. Isso significa que não posso chamar uma função na classe de pistão da classe do pedal do acelerador para acelerar o carro.

A classe de pedais precisa pedir ao Controlador de Condução para falar com o Controlador do Motor, que então instrui a classe de pistão a ir mais rápido. Isso permite que os programadores encontrem problemas e combinemos programas grandes sem se preocupar. Isso ocorre porque o código estava funcionando por trás do controlador.

Baixo acoplamento e alta coesão é um fenômeno recomendado.

Acoplamento significa até que ponto vários módulos são interdependentes e como os outros módulos são afetados ao alterar algumas / consideráveis ​​funcionalidades de um módulo. O baixo acoplamento é enfatizado, pois a dependência precisa ser mantida baixa, para que sejam feitas alterações mínimas / desprezíveis em outros módulos.

Um exemplo pode ser útil. Imagine um sistema que gera dados e os coloca em um repositório de dados, um arquivo em disco ou um banco de dados.

A alta coesão pode ser obtida separando o código de armazenamento de dados do código de produção de dados. (e de fato separando o armazenamento em disco do armazenamento do banco de dados).

O baixo acoplamento pode ser alcançado, garantindo que a produção de dados não tenha nenhum conhecimento desnecessário do armazenamento de dados (por exemplo, não pergunte ao armazenamento de dados sobre nomes de arquivos ou conexões db).

Aqui está uma resposta de um ângulo teórico abstrato do gráfico:

Vamos simplificar o problema observando apenas gráficos de dependência (direcionados) entre objetos com estado.

Uma resposta extremamente simples pode ser ilustrada considerando dois casos limitadores de gráficos de dependência:

O primeiro caso limitante : um cluster de gráficos .

Um gráfico de cluster é a realização mais perfeita de um gráfico de dependência de alta coesão e baixo acoplamento (dado um conjunto de tamanhos de cluster).

A dependência entre clusters é máxima (totalmente conectada) e a dependência entre clusters é mínima (zero).

Esta é uma ilustração abstrata da resposta em um dos casos limitantes .

O segundo caso limitante é um gráfico totalmente conectado, onde tudo depende de tudo.

A realidade está algures no meio, quanto mais próximo do gráfico de agrupamentos melhor, na minha humilde compreensão.

De outro ponto de vista : ao olhar para um gráfico de dependência direcionado, idealmente ele deve ser acíclico; caso contrário, os ciclos formam os menores agrupamentos / componentes.

Um passo acima / abaixo da hierarquia corresponde a "uma instância" de acoplamento flexível, coesão rígida em um software, mas é possível visualizar esse princípio de acoplamento flexível / coesão rígida como um fenômeno repetitivo em diferentes profundidades de um gráfico direcionado acíclico (ou em uma de suas árvores de abrangência).

Essa decomposição de um sistema em uma hierarquia ajuda a superar a complexidade exponencial (digamos que cada cluster possui 10 elementos). Então, em 6 camadas, já são 1 milhão de objetos:

10 clusters formam 1 superaglomerado, 10 superaglomerados formam 1 hiperaglomerado e assim por diante ... sem o conceito de coesão forte, acoplamento flexível, uma arquitetura hierárquica não seria possível.

Portanto, essa pode ser a real importância da história e não apenas o baixo acoplamento de alta coesão em apenas duas camadas. A real importância fica clara ao considerar abstrações de nível superior e suas interações.

Eu acho que você tem muitas definições vermelhas, mas, no caso de você ainda ter dúvidas ou se você é iniciante em programação e deseja aprofundar isso, sugiro que assista a este vídeo, https://youtu.be/HpJTGW9AwX0 É apenas uma referência para obter mais informações sobre polimorfismo ... Espero que você entenda melhor isso

Baixo acoplamento: - Manterá muito simples. Se você mudar seu módulo, como isso afeta outros módulos.

Exemplo: - Se sua API de serviço for exposta como JAR, qualquer alteração na assinatura do método interromperá a chamada da API (acoplamento alto / apertado).

Se o seu módulo e outro módulo se comunicar via mensagens assíncronas. Contanto que você receba mensagens, sua assinatura de alteração de método será local no seu módulo (baixo acoplamento).

Fora do curso, se houver alteração no formato da mensagem, o cliente de chamada precisará fazer algumas alterações.