Qu'est-ce que la haute cohésion et comment l'utiliser / la créer ?

Question

Je suis en train d'apprendre la programmation informatique et je suis tombé à plusieurs reprises sur le concept de cohésion. Je comprends qu'il est souhaitable qu'un logiciel ait une "forte cohésion", mais qu'est-ce que cela signifie ? Je suis un programmeur Java, C et Python qui apprend le C++ à partir du livre C++ Primer qui mentionne la cohésion sans l'avoir dans l'index, pourriez-vous m'indiquer des liens sur ce sujet ? Je n'ai pas trouvé la page wikipedia sur la cohésion informatique informative car elle dit simplement qu'il s'agit d'une mesure qualitative et ne donne pas d'exemples de code réel.

Answer 1

La cohésion est élevée lorsque vous disposez d'une classe qui effectue un travail bien défini. La cohésion est faible lorsqu'une classe effectue un grand nombre de tâches qui n'ont pas grand-chose en commun.

Prenons l'exemple suivant :

Vous avez une classe qui additionne deux nombres, mais cette même classe crée une fenêtre affichant le résultat. Il s'agit d'une classe peu cohésive car la fenêtre et l'opération d'addition n'ont pas grand-chose en commun. La fenêtre est la partie visuelle du programme et la fonction d'addition est la logique qui la sous-tend.

Pour créer une solution très cohérente, vous devez créer une classe Fenêtre et une classe Somme. La fenêtre appellera la méthode Sum pour obtenir le résultat et l'afficher. De cette manière, vous développerez séparément la logique et l'interface graphique de votre application.

Answer 2

Une explication de ce qu'il est dans le site de Steve McConnell Code complet :

La cohésion fait référence à la proximité de toutes les routines d'une classe ou de toutes les routines d'un groupe. code d'une routine soutenir un objectif central . Les classes qui contiennent fonctionnalité fortement liée sont décrits comme ayant une forte cohésion, et l'objectif heuristique est de rendre la cohésion aussi forte que possible. possible. La cohésion est un outil utile pour gérer la complexité car plus le code d'une classe soutient un objectif central, plus il est facile de plus facilement votre cerveau se souviendra de tout ce que fait le code.

Un moyen d'y parvenir à partir de l'oncle Bob Code propre :

Les classes doivent avoir un petit nombre de variables d'instance . Chacune des d'une classe doit manipuler une ou plusieurs de ces variables. En général, les méthodes d'une classe doivent manipuler une ou plusieurs de ces variables. plus une méthode manipule de variables, plus elle est cohésive cette méthode est à sa classe. Une classe dans laquelle chaque variable est utilisée par chaque méthode est maximalement cohésive.

En général, il n'est pas conseillé ni possible de créer de telles classes maximalement cohésives. 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 codépendantes et sont interdépendantes et forment un tout logique.

La notion de cohésion est étroitement liée à la notion de couplage ; il existe également un principe fondé sur l'heuristique d'une cohésion élevée, appelé principe de la responsabilité unique (le S de SOLID).

Answer 3

La haute cohésion est un concept de génie logiciel. En gros, cela signifie qu'une classe ne doit faire que ce qu'elle est censée faire, et qu'elle doit le faire entièrement. Ne la surchargez pas avec des fonctions qu'elle n'est pas censée faire, et tout ce qui lui est directement lié ne doit pas non plus apparaître dans le code d'une autre classe.

L'exemple est assez subjectif, car il faut aussi tenir compte de l'échelle. Un programme simple ne doit pas être trop modulaire sous peine d'être fragmenté, tandis qu'un programme complexe peut nécessiter plus de niveaux d'abstraction pour prendre en charge la complexité.

par exemple, la classe de courrier électronique. Elle doit contenir les membres de données to, from, cc, bcc, subject, body, et peut contenir les méthodes saveAsDraft(), send(), discardDraft(). Mais login() ne devrait pas se trouver ici, puisqu'il existe un certain nombre de protocoles de courrier électronique, et devrait être implémenté séparément.

Answer 4

La cohésion est généralement mesurée à l'aide de l'une des mesures LCOM (manque de cohésion). La mesure LCOM originale a été élaborée par Chidamber et Kemerer. Voir par exemple : http://www.computing.dcu.ie/~renaat/ca421/LCOM.html

Un exemple plus concret : Si une classe a, par exemple, un champ privé et trois méthodes, lorsque les trois méthodes utilisent ce champ pour effectuer une opération, la classe est très cohérente.

Pseudo-code d'une classe cohésive :

class FooBar {
  private SomeObject _bla = new SomeObject();

  public void FirstMethod() {
    _bla.FirstCall();
  }

  public void SecondMethod() {
    _bla.SecondCall();
  }

  public void ThirdMethod() {
    _bla.ThirdCall();
  }
}

Si une classe possède, par exemple, trois champs privés et trois méthodes, et que les trois méthodes n'utilisent qu'un seul des trois champs, la classe est peu cohésive.

Pseudo-code d'une classe peu cohésive :

class FooBar {
  private SomeObject _bla = new SomeObject();
  private SomeObject _foo = new SomeObject();
  private SomeObject _bar = new SomeObject();

  public void FirstMethod() {
    _bla.Call();
  }

  public void SecondMethod() {
    _foo.Call();
  }

  public void ThirdMethod() {
    _bar.Call();
  }
}

Le principe de la classe qui fait une chose est le Principe de responsabilité unique qui provient de Robert C. Martin et qui est l'un des plus grands projets de l'Union européenne. SOLIDE principes. Le principe prescrit qu'une classe ne doit avoir qu'une seule raison de changer.

Rester proche du principe de la responsabilité unique pourrait éventuellement permettre d'obtenir un code plus cohérent, mais à mon avis, il s'agit de deux choses différentes.

Answer 5

C'est un exemple de faible cohésion :

class Calculator
{

     public static void main(String args[])
     {

          //calculating sum here
          result = a + b;
          //calculating difference here
          result = a - b;
          //same for multiplication and division
     }
}

Mais une cohésion élevée implique que les fonctions des classes fassent ce qu'elles sont censées faire (comme elles sont nommées). Et non pas qu'une fonction fasse le travail d'une autre fonction. Ainsi, ce qui suit peut être un exemple de cohésion élevée :

class Calculator
{

     public static void main(String args[])
     {

          Calculator myObj = new Calculator();
          System.out.println(myObj.SumOfTwoNumbers(5,7));
      }

     public int SumOfTwoNumbers(int a, int b)
     {

          return (a+b);
     }

     //similarly for other operations

}