Diferença entre coesão e acoplamento

Qual é a diferença entre coesão e acoplamento?

Como o acoplamento e a coesão podem levar a um design de software bom ou ruim?

Quais são alguns exemplos que descrevem a diferença entre os dois e seu impacto na qualidade geral do código?

Coesão refere-se ao que a class (ou módulo) pode fazer. Baixa coesão significaria que a turma faz uma grande variedade de ações – é ampla, sem foco no que deveria fazer. Alta coesão significa que a class está focada no que deveria estar fazendo, ou seja, apenas methods relacionados à intenção da class.

Exemplo de baixa coesão:

------------------- | Staff | ------------------- | checkEmail() | | sendEmail() | | emailValidate() | | PrintLetter() | ------------------- 

Exemplo de alta coesão:

 ---------------------------- | Staff | ---------------------------- | -salary | | -emailAddr | ---------------------------- | setSalary(newSalary) | | getSalary() | | setEmailAddr(newEmail) | | getEmailAddr() | ---------------------------- 

Quanto ao acoplamento , refere-se a como duas classs / módulos relacionados ou dependentes estão um em relação ao outro. Para classs com baixo acoplamento, mudar algo importante em uma class não deve afetar o outro. Alto acoplamento dificultaria a alteração e manutenção do seu código; já que as classs estão intimamente unidas, fazer uma mudança pode exigir uma reformulação completa do sistema.

Um bom design de software possui alta coesão e baixo acoplamento .

A alta coesão dentro dos módulos e o baixo acoplamento entre os módulos são geralmente considerados como relacionados à alta qualidade nas linguagens de programação OO.

Por exemplo, o código dentro de cada class Java deve ter alta coesão interna, mas ser tão fracamente acoplado quanto possível ao código em outras classs Java.

O capítulo 3 da construção de software orientada a object de Meyer (2ª edição) é uma ótima descrição desses problemas.

A coesão é uma indicação de como estão relacionadas e focadas as responsabilidades de um elemento de software.

Acoplamento refere-se a quão fortemente um elemento de software é conectado a outros elementos.

O elemento de software pode ser class, pacote, componente, subsistema ou sistema. E, ao projetar os sistemas, é recomendável ter elementos de software que tenham alta coesão e suportem baixo acoplamento .

A baixa coesão resulta em classs monolíticas difíceis de manter, entender e reduzir a reutilização. Da mesma forma, Alto Acoplamento resulta em classs que são fortemente acopladas e as mudanças tendem a não ser não locais, difíceis de alterar e reduzem a reutilização.

Podemos usar um cenário hipotético em que estamos projetando um ConnectionPool típico, monitorável, com os seguintes requisitos. Note que, pode parecer muito para uma class simples como o ConnectionPool mas a intenção básica é apenas demonstrar baixo acoplamento e alta coesão com algum exemplo simples e acho que deveria ajudar.

  1. suporte para obter uma conexão
  2. liberar uma conexão
  3. obter statistics sobre conexão versus contagem de uso
  4. obter statistics sobre conexão vs tempo
  5. Armazene as informações de recuperação e liberação de conexão em um database para relatórios posteriores.

Com baixa coesão, podemos projetar uma class ConnectionPool colocando todas essas funcionalidades / responsabilidades em uma única class, como abaixo. Podemos ver que essa class única é responsável pelo gerenciamento de conexões, interagindo com o database e também mantendo as statistics de conexão.

Pool de Conexão de Baixa Coesão

Com alta coesão , podemos atribuir essas responsabilidades a todas as classs e torná-las mais fáceis de manter e reutilizar.

Pool de Conexão de Alta Coesão

Para demonstrar o baixo acoplamento , continuaremos com o diagrama ConnectionPool alta coesão acima. Se observarmos o diagrama acima, embora ele suporte alta coesão, o ConnectionPool é fortemente acoplado à class ConnectionStatistics e PersistentStore interage diretamente com eles. Em vez de reduzir o acoplamento, poderíamos introduzir uma interface ConnectionListener e permitir que essas duas classs implementassem a interface e permitissem que elas se registrassem na class ConnectionPool . E o ConnectionPool irá iterar através destes listeners e notificá-los da conexão para obter e liberar events e permite menos acoplamento.

Conexão de baixo acoplamentoPool

Nota / Palavra ou Cuidado: Para este cenário simples, pode parecer um exagero, mas se imaginarmos um cenário em tempo real em que nosso aplicativo precisa interagir com vários serviços de terceiros para concluir uma transação: Acoplando diretamente nosso código com os serviços de terceiros significaria que quaisquer alterações no serviço de terceiros poderiam resultar em alterações em nosso código em vários lugares, em vez disso poderíamos ter o Facade que interage com esses múltiplos serviços internamente e quaisquer alterações nos serviços se tornem locais para o Facade e impor baixo acoplamento com o serviços terceirizados.

Maior coesão e menor acoplamento levam a um bom design de software.

O Cohesion particiona sua funcionalidade para que seja concisa e mais próxima dos dados relevantes para ela, enquanto o desacoplamento garante que a implementação funcional seja isolada do restante do sistema.

O desacoplamento permite que você altere a implementação sem afetar outras partes do seu software.

A coesão garante que a implementação seja mais específica para a funcionalidade e, ao mesmo tempo, mais fácil de manter.

O método mais eficaz de diminuir o acoplamento e aumentar a coesão é o design por interface .

Esses são os principais objects funcionais que devem apenas “conhecer” uns aos outros através da (s) interface (s) que eles implementam. A implementação de uma interface introduz coesão como consequência natural.

Embora não seja realista em alguns senários, deve ser uma meta de design para funcionar.

Exemplo (muito esboçado):

 public interface IStackoverFlowQuestion void SetAnswered(IUserProfile user); void VoteUp(IUserProfile user); void VoteDown(IUserProfile user); } public class NormalQuestion implements IStackoverflowQuestion { protected Integer vote_ = new Integer(0); protected IUserProfile user_ = null; protected IUserProfile answered_ = null; public void VoteUp(IUserProfile user) { vote_++; // code to ... add to user profile } public void VoteDown(IUserProfile user) { decrement and update profile } public SetAnswered(IUserProfile answer) { answered_ = answer // update u } } public class CommunityWikiQuestion implements IStackoverflowQuestion { public void VoteUp(IUserProfile user) { // do not update profile } public void VoteDown(IUserProfile user) { // do not update profile } public void SetAnswered(IUserProfile user) { // do not update profile } } 

Em algum outro lugar na sua base de código, você pode ter um módulo que processa questões, independentemente do que elas sejam:

 public class OtherModuleProcessor { public void Process(List questions) { ... process each question. } } 

Coesão é a indicação do relacionamento dentro de um módulo.

Acoplamento é a indicação das relações entre os módulos.

insira a descrição da imagem aqui

verifique este link

A melhor explicação de Coesão vem do Código Limpo do Tio Bob:

Classes devem ter um pequeno número de variables ​​de instância. Cada um dos methods de uma class deve manipular uma ou mais dessas variables. Em geral, quanto mais variables ​​um método manipula, mais coeso esse método é para sua class . Uma class na qual cada variável é usada por cada método é maximamente coesa.

Em geral, não é aconselhável nem possível criar classs tão coesas e maximamente; por outro lado, gostaríamos que a coesão fosse alta . Quando a coesão é alta, isso significa que os methods e variables ​​da class são co-dependentes e estão juntos como um todo lógico.

A estratégia de manter funções pequenas e manter curtas as listas de parâmetros pode levar a uma proliferação de variables ​​de instância que são usadas por um subconjunto de methods. Quando isso acontece, quase sempre significa que há pelo menos uma outra class tentando sair da class maior. Você deve tentar separar as variables ​​e os methods em duas ou mais classs, de forma que as novas classs sejam mais coesas.

A coesão na engenharia de software é o grau em que os elementos de um determinado módulo estão juntos. Assim, é uma medida de quão fortemente relacionado cada peça de funcionalidade expressa pelo código-fonte de um módulo de software é.

Acoplamento em palavras simples, é o quanto um componente (novamente, imagine uma class, embora não necessariamente) sabe sobre o funcionamento interno ou elementos internos de outro, ou seja, quanto conhecimento ele tem do outro componente.

Eu escrevi um post sobre isso , se você quiser ler um pouco mais detalhes com exemplos e desenhos. Eu acho que responde a maioria das suas perguntas.

Coesão (Co-hesion): Co que significa juntos , hesion que significa ficar . O sistema de colagem de partículas de diferentes substâncias.

Para o exemplo da vida real:
insira a descrição da imagem aqui
img Cortesia

Todo é maior que a sum das partes – Aristóteles.

  • A coesão é um tipo ordinal de medição e é geralmente descrita como “alta coesão” ou “baixa coesão”. Módulos com alta coesão tendem a ser preferíveis, porque a alta coesão está associada a vários traços desejáveis ​​de software, incluindo robustez, confiabilidade, capacidade de reutilização e capacidade de compreensão. Em contraste, a baixa coesão está associada a traços indesejáveis, como a dificuldade de manter, testar, reutilizar ou até mesmo entender. wiki

  • O acoplamento é geralmente contrastado com a coesão . O baixo acoplamento geralmente se correlaciona com alta coesão e vice-versa. O baixo acoplamento é frequentemente um sinal de um sistema de computador bem estruturado e um bom design, e quando combinado com alta coesão, suporta os objectives gerais de alta legibilidade e facilidade de manutenção. wiki

Eu acho que as diferenças podem ser colocadas da seguinte forma:

  • Coesão representa o grau em que uma parte de uma base de código forma uma unidade atômica única e lógica.
  • O acoplamento representa o grau em que uma única unidade é independente das outras.
  • É impossível arquivar o desacoplamento total sem danificar a coesão e vice-versa.

Neste post eu escrevo sobre isso em mais detalhes.

A coesão é uma indicação da força funcional relativa de um módulo.

  • Um módulo coeso realiza uma única tarefa, exigindo pouca interação com outros componentes em outras partes de um programa. Em suma, um módulo coeso deveria (idealmente) fazer apenas uma coisa.
  • Concepção convencional:

    a “mentalidade única” de um módulo

  • OO vista:

    Coerência implica que um componente ou class encapsula apenas atributos e operações que estão intimamente relacionados entre si e com a própria class ou componente.

  • Níveis de coesão

    Funcional

     Camada

    Communicational

    Sequencial

    Procedural

    Temporal

    utilidade

O acoplamento é uma indicação da interdependência relativa entre os módulos.

  • O acoplamento depende da complexidade da interface entre os módulos, do ponto em que a input ou referência é feita em um módulo e de quais dados passam pela interface.

  • Visão Convencional: O grau em que um componente é conectado a outros componentes e ao mundo externo

  • OO view: uma medida qualitativa do grau em que as classs estão conectadas entre si

  • Nível de acoplamento

    Conteúdo

    Comum

    Controle

     Estampado

    Data

     Chamada de rotina

    Tipo de uso

    Inclusão ou importação

     externo #

Acoplamento = interação / relacionamento entre dois módulos … Coesão = interação entre dois elementos dentro de um módulo.

Um software é composto por vários módulos. Módulo consiste em elementos. Considere um módulo é um programa. Uma function dentro de um programa é um elemento.

No tempo de execução, a saída de um programa é usada como input para outro programa. Isso é chamado de interação módulo a módulo ou processo para comunicação de processo. Isso também é chamado de acoplamento.

Dentro de um único programa, a saída de uma function é passada para outra function. Isso é chamado de interação de elementos dentro de um módulo. Isso também é chamado de coesão.

Exemplo:

Acoplamento = comunicação entre duas famílias diferentes … Coesão = comunicação entre pai-mãe-criança dentro de uma família.

    Intereting Posts