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

Como o acoplamento e a coesão podem levar a um projeto 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 se refere ao que a classe (ou módulo) pode fazer. Baixa coesão significaria que a classe realiza uma grande variedade de ações - é ampla, sem foco no que deve fazer. Coesão alta significa que a classe está focada no que deveria estar fazendo, ou seja, apenas métodos relacionados à intenção da classe.

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 quão relacionadas ou dependentes duas classes / módulos estão entre si. Para classes com baixos acoplamentos, alterar algo importante em uma classe não deve afetar a outra. Um acoplamento alto tornaria difícil alterar e manter seu código; Como as aulas são unidas, fazer uma alteração pode exigir uma reformulação completa do sistema.

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

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

Acoplamento é a indicação dos relacionamentos entre os módulos.

Coesão

• Coesão é a indicação do relacionamento dentro do módulo.
• A coesão mostra a força funcional relativa do módulo.
• Coesão é um grau (qualidade) no qual um componente / módulo se concentra na única coisa.
• Ao projetar, você deve se esforçar para obter alta coesão, ou seja, um componente / módulo coeso, com foco em uma única tarefa (ou seja, obstinação) com pouca interação com outros módulos do sistema.
• Coesão é o tipo de extensão natural de ocultação de dados, por exemplo, classe com todos os membros visíveis com um pacote com visibilidade padrão. Coesão é conceito intra-módulo.

Acoplamento

• Acoplamento é a indicação dos relacionamentos entre os módulos.
• O acoplamento mostra a dependência / interdependência relativa entre os módulos.
• Acoplamento é um grau em que um componente / módulo está conectado aos outros módulos.
• Ao projetar, você deve buscar baixo acoplamento, ou seja, a dependência entre os módulos deve ser menor
• Criar campos privados, métodos privados e classes não públicas fornece acoplamento flexível.
• O acoplamento é um conceito entre módulos.

verifique este link

Coesão alta dentro dos módulos e baixo acoplamento entre módulos são frequentemente considerados relacionados à alta qualidade nas linguagens de programação OO.

Por exemplo, o código dentro de cada classe Java deve ter alta coesão interna, mas deve ser o mais vagamente acoplado possível ao código em outras classes Java.

O Capítulo 3 da Construção de software orientado a objetos da Meyer (2ª edição) é uma ótima descrição desses problemas.

Coesão é uma indicação de quão relacionadas e focadas são as responsabilidades de um elemento de software.

Acoplamento refere-se à força com que um elemento de software está conectado a outros elementos.

O elemento de software pode ser classe, pacote, componente, subsistema ou sistema. E ao projetar os sistemas, é recomendável ter elementos de software com alta coesão e suporte a baixo acoplamento .

A baixa coesão resulta em classes monolíticas difíceis de manter, entender e reduzir a reutilização. Da mesma forma, o High Coupling resulta em classes fortemente acopladas e alterações que tendem a não ser locais, difíceis de alterar e reduzem a reutilização.

Podemos tomar um cenário hipotético em que estamos projetando um monitor típico capaz de executar ConnectionPoolcom os seguintes requisitos. Observe que pode parecer muito para uma classe simples comoConnectionPool mas a intenção básica é apenas demonstrar baixo acoplamento e alta coesão com algum exemplo simples e acho que deve ajudar.

1. suporte para obter uma conexão
2. liberar uma conexão
3. obter estatísticas sobre conexão versus contagem de uso
4. obter estatísticas sobre conexão versus tempo
5. Armazene a recuperação da conexão e libere informações em um banco de dados para gerar relatórios posteriormente.

Com baixa coesão , poderíamos projetar uma ConnectionPoolclasse colocando à força todas essas funcionalidades / responsabilidades em uma única classe, como abaixo. Podemos ver que essa classe única é responsável pelo gerenciamento de conexões, interagindo com o banco de dados e mantendo as estatísticas de conexão.

Com alta coesão , podemos atribuir essas responsabilidades entre as classes e torná-las mais sustentáveis ​​e reutilizáveis.

Para demonstrar o baixo acoplamento , continuaremos com o ConnectionPooldiagrama de alta coesão acima. Se observarmos o diagrama acima, embora ele suporte alta coesão, ele ConnectionPoolestá fortemente associado à ConnectionStatisticsclasse e PersistentStoreinterage diretamente com eles. Em vez de reduzir o acoplamento, poderíamos introduzir uma ConnectionListenerinterface e permitir que essas duas classes implementassem a interface e que registrassem na ConnectionPoolclasse. E ConnectionPooleles percorrerão esses ouvintes e os notificarão sobre os eventos de obtenção e lançamento de conexões e permitirão menos acoplamentos.

Nota / Palavra ou Cuidado: Para esse cenário simples, pode parecer um exagero, mas se imaginarmos um cenário em tempo real em que nosso aplicativo precisará interagir com vários serviços de terceiros para concluir uma transação: Acoplar diretamente nosso código aos serviços de terceiros significaria que qualquer alteração no serviço de terceiros poderia resultar em alterações em nosso código em vários locais. Em vez disso, poderíamos Facadeinteragir com esses vários serviços internamente e quaisquer alterações nos serviços se tornarem locais Facadee impor um baixo acoplamento a terceiros. Serviços.

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

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

A dissociação permite alterar a implementação sem afetar outras partes do seu software.

A coesão garante que a implementação seja mais específica à 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 objetos funcionais que devem "se conhecer" apenas através da (s) interface (s) que eles implementam. A implementação de uma interface introduz a coesão como uma conseqüência natural.

Embora não seja realista em alguns casos, deve ser um objetivo de design a ser cumprido.

Exemplo (muito superficial):

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 da sua base de código, você pode ter um módulo que processa perguntas, independentemente do que sejam:

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

A melhor explicação para a coesão vem do Clean Code do tio Bob:

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

Em geral, não é aconselhável nem possível criar essas classes maximamente coesas; por outro lado, gostaríamos que a coesão fosse alta . Quando a coesão é alta, isso significa que os métodos e variáveis ​​da classe são co-dependentes e permanecem juntos como um todo lógico.

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

simplesmente, Coesão representa o grau em que uma parte de uma base de código forma uma unidade atômica logicamente única. O acoplamento , por outro lado, representa o grau em que uma única unidade é independente das outras. Em outras palavras, é o número de conexões entre duas ou mais unidades. Quanto menor o número, menor o acoplamento.

Em essência, alta coesão significa manter partes de uma base de código relacionadas entre si em um único local. Baixo acoplamento, ao mesmo tempo, é sobre a separação de partes não relacionadas da base de código, tanto quanto possível.

Tipos de código de uma perspectiva de coesão e acoplamento:

Ideal é o código que segue a diretriz. É fracamente acoplado e altamente coeso. Podemos ilustrar esse código com esta figura:

Deus Objeto é o resultado da introdução de alta coesão e alto acoplamento. É um antipadrão e basicamente representa um único pedaço de código que faz todo o trabalho de uma só vez: mal selecionado ocorre quando os limites entre diferentes classes ou módulos são mal selecionados.

A dissociação destrutiva é a mais interessante. Às vezes, ocorre quando um programador tenta dissociar tanto uma base de código que o código perde completamente o foco:

leia mais aqui

Coesão na engenharia de software é o grau em que os elementos de um determinado módulo pertencem. Portanto, é uma medida de quão fortemente relacionada cada parte da funcionalidade expressa pelo código fonte de um módulo de software está.

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.

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

coesão se refere a como uma única classe é projetada. Coesão é o princípio Orientado a Objetos mais intimamente associado a garantir que uma classe seja projetada com um único objetivo bem focado. Quanto mais focada é uma classe, maior a coesão dessa classe. As vantagens da alta coesão é que essas classes são muito mais fáceis de manter (e menos frequentemente alteradas) do que as classes com baixa coesão. Outro benefício da alta coesão é que as classes com um objetivo bem focado tendem a ser mais reutilizáveis ​​que as outras.

Na imagem acima, podemos ver que, em baixa coesão, apenas uma classe é responsável por executar muitos trabalhos que não são comuns, o que reduz a chance de reutilização e manutenção. Mas em alta coesão, há uma classe separada para todos os trabalhos para executar um trabalho específico, o que resulta em melhor usabilidade e manutenção.

Coesão (Co-hesion): Co que significa junto , hesion que significa manter . O sistema de aderência de partículas de diferentes substâncias.

Para exemplo da vida real: img Cortesia

Todo é Maior que a Soma das Partes - Aristóteles.

• Coesão é um tipo ordinal de medição e é geralmente descrito como "alta coesão" ou "baixa coesão". Módulos com alta coesão tendem a ser preferíveis, porque alta coesão está associada a várias características desejáveis ​​do software, incluindo robustez, confiabilidade, reutilização e compreensibilidade. Por outro lado, a baixa coesão está associada a características indesejáveis, como dificuldade em 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 geralmente é um sinal de um sistema de computador bem estruturado e de um bom design, e quando combinado com alta coesão, suporta os objetivos gerais de alta legibilidade e 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 logicamente única.
• O acoplamento representa o grau em que uma única unidade é independente das outras.
• É impossível arquivar a dissociação completa sem danificar a coesão e vice-versa.

Neste post , escrevo sobre isso com mais detalhes.

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

• Um módulo coeso executa uma única tarefa, exigindo pouca interação com outros componentes em outras partes de um programa. Em termos simples, um módulo coeso deve (idealmente) fazer apenas uma coisa.

• ViewVista convencional:

  a "obstinação" de um módulo

• ViewOO ver:

   coesão implica que um componente ou classe encapsule apenas atributos e operações intimamente relacionados entre si e com a própria classe ou componente

• Níveis de coesão

  Funcional

  Layer

  MunicComunicação

  EquSequencial

  Procedimento

  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 entrada ou referência é feita a um módulo e quais dados passam pela interface.

• Visão convencional: o grau em que um componente está conectado a outros componentes e ao mundo externo

• Visão OO: uma medida qualitativa do grau em que as classes estão conectadas umas às outras

• Nível de acoplamento

   Conteúdo

  Comum

  Controle

  Carimbo

  Dados

  Call Chamada de rotina

  UseDigite o uso

  ClusInclusão ou importação

  Exterior #

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

Um software consiste em muitos módulos. Módulo consiste em elementos. Considere que um módulo é um programa. Uma função dentro de um programa é um elemento.

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

Dentro de um único programa, a saída de uma função é passada para outra função. 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-filho dentro de uma família.

Simplificando, coesão significa que uma classe deve representar um único conceito.

A interface pública de uma classe é coesa se todos os recursos da classe estiverem relacionados ao conceito que a classe representa. Por exemplo, em vez de ter a classe CashRegister, a coesão dos recursos CashRegister e Coin o torna em duas classes - CashRegister e Coin.

No acoplamento , uma classe depende da outra, pois usa os objetos da classe.

O problema do acoplamento alto é que ele pode criar efeitos colaterais. Uma alteração em uma classe pode causar um erro inesperado na outra classe e pode quebrar o código inteiro.

Geralmente, alta coesão e baixo acoplamento são considerados POO de alta qualidade.

O termo coesão é de fato um pouco contra-intuitivo para o que significa design de software.

O significado comum da coesão é que algo que se une bem é unido, caracterizado por forte ligação como atração molecular. No entanto, no design de software, significa lutar por uma classe que idealmente faça apenas uma coisa; portanto, vários submódulos nem sequer estão envolvidos.

Talvez possamos pensar dessa maneira. Uma parte tem mais coesão quando é a única parte (faz apenas uma coisa e não pode ser mais detalhada). É isso que é desejado no design de software. Coesão é simplesmente outro nome para "responsabilidade única" ou "separação de interesses".

O termo acoplamento na mão é bastante intuitivo, o que significa que quando um módulo não depende de muitos outros módulos e aqueles com os quais ele se conecta podem ser facilmente substituídos, por exemplo, obedecendo ao princípio de substituição liskov .

Diferença da teoria

Coesão

• Coesão é uma indicação da força funcional relativa do módulo.
• Um módulo coeso executa uma única tarefa, exigindo pouca interação com outros componentes em outras partes do programa.
• Um módulo com alta coesão e baixo acoplamento é considerado funcionalmente independente de outro módulo.

Classificação de Coesão

1.Coincidental 2.Lógico 3.Temporal 4.Procedural 5.Comunicação 6.Sequencial 7.Funcional

Acoplamento

• O acoplamento é uma indicação de interdependência relativa entre os módulos.
• O grau de acoplamento entre dois módulos depende da complexidade da interface.