Différence entre cohésion et couplage

Haute cohésion dansmodules et faible couplage entre modules sont souvent considérés comme liés à la haute qualité dans les langages de programmation OO.

Par exemple, le code à l'intérieur de chaque classe Java doit avoir une cohésion interne élevée, mais être aussi faiblement couplé que possible au code dans les autres classes Java.

Le chapitre 3 de la Construction logicielle orientée objet de Meyer (2ème édition) {[10] } est une excellente description de ces problèmes.

La cohésion {[14] } est une indication de la façon dont les responsabilités d'un élément logiciel sont liées et ciblées.

Le couplage {[14] } fait référence à la force avec laquelle un élément logiciel est connecté à d'autres éléments.

L'élément logiciel peut être une classe, un package, Un composant, un sous-système ou un système. Et lors de la conception des systèmes, il est recommandé d'avoir des éléments logiciels qui ont haute cohésion et support faible couplage.

Faible la cohésion aboutit à des classes monolithiques difficiles à maintenir, à comprendre et à réduire la réutilisation. De même couplage élevé résultats dans les classes qui sont étroitement couplés et les changements ont tendance à ne pas être non-local, difficile à changer et réduit la réutilisation.

Nous pouvons prendre un scénario hypothétique où nous concevons un moniteur typique ConnectionPool avec les exigences suivantes. Notez que, cela peut sembler trop pour une classe simple comme ConnectionPool mais l'intention de base est juste démontrer faible couplage et haute cohésion avec un exemple simple et je pense que devrait aider.

1. prise en charge de l'obtention d'une connexion
2. libérer une connexion
3. obtenir des statistiques sur la connexion vs le nombre d'utilisation
4. obtenir des statistiques sur la connexion vs temps
5. stockez les informations de récupération de connexion et de libération dans une base de données pour un rapport ultérieur.

Avec faible cohésion, nous pourrions concevoir un ConnectionPool classe par force bourrer toutes ces fonctionnalités/responsabilités dans une seule classe comme ci-dessous. Nous pouvons voir que cette classe unique est responsable de la gestion des connexions, interagissant avec la base de données et maintenant les statistiques de connexion.

Avec haute cohésion nous pouvons attribuer ces responsabilités à travers les classes et les rendre plus maintenables et réutilisables.

Pour démontrer faible couplage nous allons continuer avec le diagramme de haute cohésion ConnectionPool ci-dessus. Si nous regardons le diagramme ci-dessus bien qu'il supporte une cohésion élevée, le ConnectionPool est étroitement couplé avec la classe ConnectionStatistics et PersistentStore il interagit directement avec eux. Au lieu de cela, pour réduire le couplage, nous pourrions introduire une interface ConnectionListener et laisser ces deux classes implémenter l'interface et les laisser s'inscrire avec la classe ConnectionPool. Et le ConnectionPool parcourra ces écouteurs et les notifiera des événements GET et release de connexion et permettra moins couplage.

Remarque / mot ou mise en garde: pour ce scénario simple, cela peut sembler exagéré, mais si nous imaginons un scénario en temps réel où notre application doit interagir avec plusieurs services tiers pour effectuer une transaction: coupler directement notre code avec les services tiers signifierait que tout changement dans le service tiers pourrait entraîner des modifications de notre code à plusieurs endroits, avec ces multiples services en interne et toute modification des services devient locale au Facade et impose un faible couplage avec les services tiers.

La Cohésion est l'indication de la relation dans est un module.

Couplage est l'indication de la relation entre modules.

La Cohésion

• la cohésion est l'indication de la relation au sein du module.
• la cohésion montre la force fonctionnelle relative du module.
• la cohésion est un degré (qualité) auquel un composant / module se concentre sur seul chose.
• lors de la conception, vous devez vous efforcer d'obtenir une cohésion élevée c'est-à-dire qu'un composant/ module cohérent se concentre sur une seule tâche (c'est-à-dire, l'unicité) avec peu d'interaction avec d'autres modules de la système.
• la cohésion est le genre d'extension naturelle des données cachant pour exemple, classe ayant tous les membres visibles avec un paquet ayant la visibilité par défaut. La cohésion est un Concept Intra – Module.

Couplage

• le couplage est l'indication du relations entre les modules.
• le couplage montre l'indépendance relative entre les modules.
• le couplage est un degré auquel un composant / module est connecté aux autres modules.
• lors de la conception, vous devriez vous efforcer d'obtenir un faible couplage, c'est-à-dire que la dépendance entre les modules devrait être moindre
• faire des champs privés, des méthodes privées et des classes non publiques fournit un couplage lâche.
• le couplage est un Concept Inter-Module.

Vérifiez Ce lien

Une cohésion accrue et une diminution du couplage conduisent à une bonne conception logicielle.

Cohesion partitionne votre fonctionnalité afin qu'elle soit concise et la plus proche des données pertinentes, tandis que le découplage garantit que l'implémentation fonctionnelle est isolée du reste du système.

le découplage vous permet de modifier l'implémentation sans affecter d'autres parties de votre logiciel.

cohésion assure que la mise en œuvre plus spécifique à fonctionnalité et en même temps plus facile à maintenir.

La méthode la plus efficace pour diminuer le couplage et augmenter la cohésion est design by interface .

C'est-à-dire que les objets fonctionnels majeurs ne doivent se "connaître" que via l'interface(s) qu'ils implémentent. La mise en œuvre d'une interface introduit la cohésion comme conséquence naturelle.

Bien que ce ne soit pas réaliste dans certains scénarios, il devrait s'agir d'un objectif de conception.

Exemple (très peu précis):

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 }
}

Certains où d'autre dans votre base de code vous pourriez avoir un module qui traite les questions indépendamment de ce qu'elles sont:

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

La meilleure explication de Cohesion vient du code propre de L'oncle Bob:

les Classes doivent avoir un petit nombre de variables d'instance. Chacune des méthodes d'une classe doit manipuler une ou plusieurs de ces variables. en général, plus une méthode manipule de variables, plus elle est cohérente avec sa classe . Une classe dans laquelle chaque variable est utilisée par chaque méthode est entièrement cohérent.

En général, il n'est ni possible ni souhaitable de créer de telles classes de cohésion maximale; d'autre part, Nous aimerions que la cohésion soit élevée . Lorsque la cohésion est élevée, cela signifie que les méthodes et les variables de la classe sont co-dépendantes et s'accrochent comme un tout logique.

la stratégie consistant à garder les fonctions petites et à garder les listes de paramètres courtes peut parfois conduire à une prolifération de variables d'instance utilisées par un sous-ensemble de méthodes. Lorsque cela se produit, cela signifie presque toujours qu'il y en a au moins un autre classe essayant de sortir de la classe plus grande. Vous devriez essayer de séparer les variables et les méthodes en deux classes ou plus afin que les nouvelles classes soient plus cohérentes.

La cohésion en génie logiciel est le degré auquel les éléments d'un certain module appartiennent ensemble. Ainsi, il s'agit d'une mesure de la relation étroite entre chaque élément de fonctionnalité exprimé par le code source d'un module logiciel.

Le couplage en termes simples, c'est combien un composant (encore une fois, imaginez une classe, mais pas nécessairement) connaît le fonctionnement interne ou les éléments internes d'un autre, c'est-à-dire combien de connaissances il a de l'autre composant.

J'ai écrit un billet de blog à propos de ce, si vous voulez lire un peu plus de détails avec des exemples et des dessins. Je pense qu'il répond à la plupart de vos questions.

La Cohésion (Cohésion) : Co qui signifie ensemble, hesion qui signifie coller. Le système de collage des particules de différentes substances.

Pour exemple réel:

img Courtoisie

Entier est supérieur à la somme des parties-Aristote.

• Cohésion est un type ordinal de mesure et est généralement décrit comme "haute cohésion" ou "faible cohésion". Les Modules à forte cohésion ont tendance à être préférables, car une forte cohésion est associée à plusieurs caractéristiques souhaitables du Logiciel, y compris la robustesse, la fiabilité, la réutilisabilité et la compréhensibilité. En revanche, une faible cohésion est associée à des traits indésirables tels qu'être difficile à maintenir, tester, réutiliser ou même comprendre. wiki

• Couplage est généralement contraste avec cohésion. Faible couplage souvent en corrélation avec une forte cohésion, et vice versa. Un faible couplage est souvent le signe d'un système informatique bien structuré et d'une bonne conception, et lorsqu'il est combiné avec une cohésion élevée, il soutient les objectifs généraux de haute lisibilité et de maintenabilité. wiki

Je pense que les différences peuvent être mises comme suit:

• la cohésion représente le degré auquel une partie d'une base de code forme une unité atomique logiquement unique.
• le couplage représente le degré d'indépendance d'une unité par rapport aux autres.
• il est impossible d'archiver le découplage complet sans nuire à la cohésion, et vice versa.

Dans ce blog, je écrire à ce sujet plus en détail.

La Cohésion est une indication de la force fonctionnelle d'un module.

• un module cohésif effectue une seule tâche, nécessitant peu interaction avec d'autres composants dans d'autres parties d'un programme. Énoncer simplement, un module cohésif devrait (idéalement) faire une seule chose.

• vue conventionnelle:

  La "singularité" d'un module

• oo vue:

  {[0]cohesion la cohésion implique qu'un composant ou une classe encapsule uniquement les attributs et les opérations qui sont étroitement liées les unes aux autres et à la classe ou au composant lui-même

• Niveaux de cohésion

  Functional fonctionnel

  couche

  communicatif

  {[0]Sequential séquentiel

  de Procédure

  Temporal temporel

  utilitaire

Le couplage est une indication de l'interdépendance relative entre les modules.

• Le couplage dépend de la complexité de l'interface entre les modules, point de l'entrée ou la référence est faite à un module, et quelles données passez à travers l'interface.

• Vue Conventionnelle : Le degré auquel un composant est connecté à d'autres composants et au monde extérieur

• Vue OO: mesure qualitative du degré de connexion des classes

• Niveau de couplage

  contenu

  Common commun

  de Contrôle

  Stamp TIMBRE

  données

  Routine Routine appel

  Type utiliser

  Inclusion ou importation

  externe #

Couplage = interaction / relation entre deux modules... cohésion = interaction entre deux éléments au sein d'un module.

Un logiciel est composé de plusieurs modules. Module se compose d'éléments. Considérons un module est un programme. Une fonction dans un programme est un élément.

Au moment de l'exécution, la sortie d'un programme est utilisé comme entrée pour un autre programme. C'est ce qu'on appelle l'interaction module à module ou la communication processus à processus. Ceci est également appelé comme Couplage.

Dans un seul programme, la sortie d'une fonction est passée à une autre fonction. C'est ce qu'on appelle l'interaction des éléments dans un module. C'est aussi ce qu'on appelle la cohésion.

Exemple:

Couplage = communication entre les 2 familles différentes... Cohésion = communication entre père-mère-enfant au sein d'une famille.

En termes simples, la cohésion signifie qu'une classe doit représenter un concept unique.

L'interface publique d'une classe est cohérente si toutes les fonctionnalités de la classe sont liées au concept que la classe représente. Par exemple - au lieu d'avoir une classe CashRegister ayant des caractéristiques CashRegister et Coin, la cohésion en fait 2 classes-CashRegister et Coin class

En couplant une classe dépend d'une autre car elle utilise les objets de la classe.

Le problème avec high le couplage est qu'il peut créer des effets secondaires. Un changement dans une classe peut causer une erreur inattendue dans l'autre classe et pourrait casser le code entier.

Généralement une cohésion élevée et un faible couplage sont considérés comme une Poo de haute qualité