Différence entre cohésion et couplage

https://stackoverflow.com/questions/3085285

oop
ooad

28-09-2019
|

Question

Quelle est la différence entre cohésion et couplage ?

Comment le couplage et la cohésion peuvent-ils conduire à une bonne ou une mauvaise conception logicielle ?

Quels sont quelques exemples qui illustrent la différence entre les deux et leur impact sur la qualité globale du code ?

La solution

cohésion fait référence à ce que la classe (ou module) peuvent faire. faible cohésion signifierait que la classe ne une grande variété d'actions - il est large, non focalisé sur ce qu'il doit faire. Élevé signifie la cohésion que la classe se concentre sur ce qu'il devrait faire, à savoir que les méthodes relatives à l'intention de la classe.

Exemple de faible cohésion:

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

Exemple de haute cohésion:

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

couplage , il se réfère à deux classes / modules faire liés ou sont dépendants vers l'autre. Pour les classes de faible couplée, en changeant quelque chose d'important dans une classe ne devrait pas affecter l'autre. Couplage élevé, il serait difficile de changer et de maintenir votre code; car les classes sont étroitement enlacés, faire un changement pourrait nécessiter une refonte du système.

Une bonne conception de logiciel a haute cohésion et couplage faible .

Autres conseils

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

Par exemple, le code dans chaque classe Java doit avoir une grande cohésion interne, mais être aussi lâchement couplé possible au code dans d'autres classes Java.

Chapitre 3 Construction Oriented Software Object-Meyer (2e édition) est une grande description de ces questions.

cohésion est l'indication de la relation sein un module.

Couplage est l'indication des relations entre modules.

Cohésion

cohésion est l'indication de la relation dans le module.
cohésion montre la force fonctionnelle relative du module.
cohésion est un degré (qualité) à laquelle un composant / module se concentre sur la une seule chose.
Pendant que vous la conception devrait viser la cohésion élevée à-dire un foyer cohérent composant / module sur une seule tâche (à savoir, simple d'esprit) avec peu d'interaction avec d'autres modules de la système.
cohésion est le genre d'extension naturelle de dissimulation de données pour exemple, la classe ayant tous les membres visibles avec un paquet ayant la visibilité par défaut. La cohésion est intra -. Concept Module

Couplage

Le couplage est l'indication des relations entre les modules.
Accouplement montre la dépendance / l'interdépendance relative entre les modules.
couplage est un degré auquel est relié aux autres modules composant / module.
Alors que vous devez vous efforcer de la conception de la dépendance faible couplage entre les modules à savoir doit être inférieur
Faire des champs privés, des méthodes privées et des classes non publiques fournit un couplage lâche.
Le couplage est Inter -Module Concept.

ce lien

cohésion est une indication de la façon dont liés et ont porté les responsabilités d'un élément logiciel sont.

Couplage fait référence à la force avec un élément logiciel est connecté à d'autres éléments.

L'élément logiciel peut être classe, package, composant, sous-système ou d'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 le soutien faible couplage .

faible cohésion les résultats dans les classes monolithiques qui sont difficiles à maintenir, à comprendre et à nouveau réduit qui concerne l'ergonomie. De même Haut couplage résultats dans les classes qui sont étroitement couplées et les changements ont tendance pas non locale, difficile de changer et réduit la réutilisation.

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

obtenir une connexion
libérer une connexion
obtenir des statistiques sur la connexion vs utilisation
obtenir des statistiques sur la connexion en fonction du temps
Stockez les informations de récupération de connexion et le rejet dans une base de données pour les rapports plus tard.

faible cohésion nous pourrions concevoir une classe ConnectionPool en bourrant avec force toutes ces fonctionnalités / responsabilités en une seule classe comme ci-dessous. Nous pouvons voir que cette classe unique est responsable de la gestion de connexion, en interaction avec la base de données et maintenir les statistiques de connexion.

haute cohésion nous pouvons attribuer ces responsabilités entre les classes et le rendre plus maintenable et réutilisable.

Pour démontrer faible couplage nous continuerons avec le diagramme de ConnectionPool haute cohésion ci-dessus. Si nous regardons le schéma ci-dessus même si elle soutient la cohésion élevée, le ConnectionPool est étroitement lié à la classe ConnectionStatistics et PersistentStore interagit directement avec eux. Au lieu de réduire le couplage, nous pourrions introduire une interface ConnectionListener et laisser ces deux classes implémentent l'interface et laissez-les enregistrer auprès de classe ConnectionPool. Et le ConnectionPool itérera par ces auditeurs et les informer des événements et la libération get connexion et permet moins de couplage.

Remarque / Word ou Attention: Pour ce scénario simple, il peut ressembler à un surpuissant mais si l'on imagine un scénario en temps réel où nos besoins d'applications d'interagir avec plusieurs services de tiers pour effectuer une transaction : couplage direct notre code avec les services tiers signifierait que toute modification du service tiers pourraient entraîner des changements à notre code à plusieurs endroits, au lieu que nous pourrions avoir Facade qui interagit avec ces multiples services à l'interne et toute modification des services deviennent local au Facade et appliquer un couplage faible avec les services tiers.

cohésion accrue et une diminution de couplage plomb do à la conception de logiciels.

partitionne cohésion votre fonctionnalité afin qu'il soit concis et le plus proche des données correspondantes, tout découplage assure que la mise en œuvre fonctionnelle est isolé du reste du système.

Découplage vous permet de modifier la mise en œuvre sans affecter les autres parties de votre logiciel.

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

La méthode la plus efficace de diminuer le couplage et la cohésion croissante est la conception par l'interface .

C'est les principaux objets fonctionnels ne devraient « connaître » les uns des autres à travers l'interface (s) qu'ils mettent en œuvre. La mise en œuvre d'une interface de cohésion introduit comme une conséquence naturelle.

Alors que pas réaliste dans certains senarios il devrait être un objectif de conception au travail par.

Exemple (très sommaire):

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

Quelque part d'autre dans votre base de code que vous pourriez avoir un module qui traite des questions, quel que soit ce qu'ils sont:

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

meilleure explication de cohésion vient du code propre de l'oncle Bob:

Les classes devraient 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, les plusieurs variables d'une méthode manipule plus de cohésion que la méthode est à sa classe . Une classe dans laquelle chaque variable est utilisée par chaque méthode est au maximum de cohésion.

En général, il est ni possible ni souhaitable de créer ces classes au maximum de cohésion; d'autre part, nous souhaitons cohésion élevé . Lorsque la cohésion est élevée, cela signifie que les méthodes et les variables de la classe sont co-dépendants et tenir ensemble comme logique entier.

La stratégie de maintien des fonctions petites et maintenir des listes de paramètres court peut parfois conduire à une prolifération de variables d'instance qui sont utilisés par un sous-ensemble de méthodes. Lorsque cela se produit, cela signifie presque toujours qu'il ya au moins une autre classe en essayant de sortir de la plus grande classe. Vous devriez essayer de séparer les variables et les méthodes en deux ou plusieurs classes telles que les nouvelles classes sont plus cohésive.

cohésion dans l'ingénierie du logiciel est le degré auquel les éléments d'un certain module de appartiennent ensemble. Ainsi, il est une mesure de la façon dont chaque élément fortement associé de fonctionnalités exprimées par le code source d'un module logiciel est.

Couplage dans des mots simples, est de savoir combien un composant (encore une fois, imaginez une classe, mais pas nécessairement) connaît sur le fonctionnement interne ou les éléments internes d'un autre, à savoir la quantité de connaissances qu'il a de l'autre composant.

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

simplement cohésion représente le degré auquel une partie d'un code de base forme une logique unique, l'unité atomique. Couplage , d'autre part, représente le degré auquel une seule unité est indépendante des autres. En d'autres termes, il est le nombre de connexions entre deux unités ou plus. Plus le nombre est élevé, plus le couplage.

En substance, des moyens de haute cohésion parties d'un maintien de la base de code qui sont liés les uns aux autres en un seul endroit. couplage faible, en même temps, est de séparer les parties non apparentées de la base de code, autant que possible.

Types de code d'une cohésion et une perspective de couplage:

Idéal est le code qui suit la ligne directrice. Il est couplé de façon lâche et très cohérent. Nous pouvons illustrer ce code avec cette image:

Dieu Objet est le résultat de l'introduction d'une forte cohésion et le couplage élevé. Il est un anti-modèle et se essentiellement pour un seul morceau de code qui fait tout le travail à la fois: mal choisi a lieu lorsque les frontières entre les différentes classes ou modules sont sélectionnés mal < img src = "https://i.stack.imgur.com/OGJ5W.png" alt = "entrer image description ici">

découplage Destructive est la plus intéressante. Il se produit parfois quand un programmeur tente de découpler une base de code tant que le code perd complètement son objectif: < img src = "https://i.stack.imgur.com/ZiA3f.png" alt = "entrer image description ici">

la cohésion

fait référence tout au sujet de la façon dont une seule classe est conçue. La cohésion est le principe orienté objet le plus étroitement associé à faire en sorte qu'une classe est conçue avec un seul but bien ciblé. Plus concentré une classe est, la cohésion de cette classe est plus. Les avantages d'une grande cohésion est que ces classes sont beaucoup plus faciles à entretenir (et moins fréquemment changé) que les classes à faible cohésion. Un autre avantage d'une grande cohésion est que les classes avec un but bien ciblé ont tendance à être plus réutilisables que les autres classes.

Dans l'image ci-dessus, nous pouvons voir que dans une faible cohésion qu'une seule classe est responsable d'exécuter beaucoup de travail qui ne sont pas en commun ce qui réduit les risques de réutilisation et de maintenance. Mais la cohésion élevé, il est une catégorie distincte pour tous les travaux à exécuter une tâche spécifique, ce qui entraîne une meilleure facilité d'utilisation et d'entretien.

cohésion (cohésion): Co qui moyens ensemble , hésion qui moyen bâton . Le système de collage des particules de substances différentes.

Par exemple la vie réelle:
img Courtesy

tout est plus grand que la somme des parties -Aristote.

cohésion est un type de mesure ordinal et est habituellement décrite comme « cohésion élevée » ou « faible cohésion ». Les modules à forte cohésion ont tendance à être préférable, car une forte cohésion est associée à plusieurs caractéristiques souhaitables de logiciels, y compris la robustesse, la fiabilité, la réutilisabilité, et la compréhensibilité. En revanche, la faible cohésion est associée à des caractéristiques indésirables comme être difficile à maintenir, test, réutilisation, ou même de comprendre. wiki
Couplage est généralement contraste avec cohésion . couplage faible corrélation souvent avec une forte cohésion, et vice versa. couplage faible est souvent un signe d'un système informatique bien structuré et une bonne conception, et lorsqu'il est combiné avec une forte cohésion, soutient les objectifs généraux de haute lisibilité et la maintenabilité. wiki

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

cohésion représente le degré auquel une partie d'un code de base forme une logique unique, l'unité atomique.
Le couplage représente le degré auquel une seule unité est indépendante des autres.
Il est impossible d'archiver un découplage complet sans endommager la cohésion, et vice versa.

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

Cohésion est une indication de la force fonctionnelle relative d’un module.

Un module cohérent effectue une seule tâche, nécessitant peu de l’interaction avec d’autres composantes dans d’autres parties d’un programme.A déclaré Simplement, un module cohérent devrait (idéalement) ne faire qu’une seule chose.
Vue conventionnelle :

la « détermination » d’un module
OO vue :

cohésion implique qu'un composant ou une classe encapsule uniquement des attributs et des opérations étroitement liés les uns aux autres et à la classe ou au composant lui-même
Niveaux de cohésion

Fonctionnel

Couche

Communication

Séquentiel

Procédural

Temporel

utilitaire

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, du point auquel l'entrée ou la référence est faite à un module, et quelles données traversent l'interface.
Vue conventionnelle :Le degré auquel un composant est connecté aux autres composants et au monde extérieur
Vue OO :une mesure qualitative du degré auquel les classes sont connectées les unes aux autres
Niveau de couplage

Contenu

Commun

Contrôle

Tampon

Données

Appel de routine

Type d'utilisation

Inclusion ou importation

#Externe

Couplage = interaction / relation entre deux modules ... cohésion = interaction entre deux éléments à l'intérieur d'un module.

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

Lors de l'exécution, la sortie d'un programme est utilisé comme entrée pour un autre programme. Ceci est appelé module interaction module ou processus de communication de processus. Ceci est aussi appelé couplage.

Dans un seul programme, la sortie d'une fonction est transmise à une autre fonction. On appelle cela l'interaction des éléments dans un module. Ceci est aussi appelé la cohésion.

Exemple:

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

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

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

couplage , une classe dépend d'une autre car il utilise les objets de la classe.

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

En général, une forte cohésion et un faible couplage est considéré comme OOP de haute qualité.

Le terme cohésion est en effet un peu contre-intuitif pour ce que cela signifie dans la conception du logiciel.

cohésion sens commun est que quelque chose qui colle bien ensemble, est unie, qui se caractérisent par une forte liaison comme l'attraction moléculaire. Cependant, dans la conception de logiciels, cela signifie lutte pour une classe qui ne idéalement qu'une seule chose, si plusieurs sous-modules ne sont même pas impliqués.

Peut-être que nous pouvons penser de cette façon. Une partie a le plus de cohésion quand il est la seule partie (ne fait qu'une seule chose et ne peut être rompu plus bas). C'est ce que l'on souhaite dans la conception de logiciels. La cohésion est tout simplement un autre nom pour la « responsabilité unique » ou « séparation des préoccupations ».

Le terme couplage sur la main est assez intuitive qui signifie que lorsque un module ne dépend pas de trop d'autres modules et ceux qui le relie avec peut être facilement remplacé par exemple obéissant Liskov principe de substitution .

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow