[JAVA] Agrégation / couplage / complexité cyclique

Aperçu

Voici quelques conseils pour écrire du code facile à maintenir / tester.

• Agrégation
• Degré de couplage
• Complexité circulaire

Au fait, le langage est écrit en Java (veuillez lire les autres langages)

En outre, vous pouvez comprendre que le degré de connexion est incorrect. Dans ce cas, veuillez le signaler. (Parce que c'est différent des autres choses écrites par des livres et des sites ... (´ ・ ω ・ `))

Description de chacun

Degré de coagulation

Aussi connu sous le nom de force du module. Une mesure de la quantité de code axée sur la division des responsabilités de la classe. ** Les classes qui n'existent que pour un rôle (toutes les méthodes n'existent que pour ce rôle) sont hautement cohérentes. ** ** Au contraire, les classes qui n'ont pas de points communs dans chaque méthode et jouent différents rôles ont un faible degré d'agrégation.

Quel est le problème avec une faible agglomération

• Difficile de comprendre ce que fait la classe
• Difficile à entretenir et à tester
• Difficile à réutiliser

Les classes à faible agglomération ont tendance à avoir de nombreuses variables membres

Lorsque le degré d'agrégation est faible, le nombre de variables membres a tendance à être important. Étant donné que la variable membre est l'état de la classe elle-même, s'il existe de nombreuses variables membres, le modèle de l'état que l'instance peut prendre augmente, la complexité augmente et la maintenabilité est considérablement réduite. Cela rend également les tests plus difficiles et plus de modèles.

Exemple de classe hautement cohésive: classe String

Cette classe n'existe que pour la "gestion des chaînes" et n'a aucun autre rôle. Classe de chaîne

Exemple spécifique

Prenons une classe appelée Price. La classe n'a que des méthodes qui gèrent les données de prix.

public class Price {
   private final int value;
   public Price(int value) {
      this.value = value;
   }
   public Price() {
      this(0);
   }

   /**Ajouter un prix*/
   public Price add(Price other) {
       return new Price(this.value + other.value);
   }

   /**Dépenser le prix*/
   public Price multiply(int amount) {
       return new Price(this.value * amount);
   }

   /**Remise*/
   public Price discount(double percentage) {
      return new Price(this.value * percentage);
   }

   /**Formater et retourner le prix*/
   public String format() {
       return NumberFormat.getCurrencyInstance().format(this.value);
   }

   public void print() {
       System.out.println(this.format());
   }
}

//Côté utilisateur
Price price = new Price(1000);
price.print(); // ¥1,000
System.out.println(price.format()); // ¥1,000
System.out.println(price.add(new Price(500)).format());  // ¥1,500
System.out.println(price.discount(0.9).format()); // ¥900
//Supplément:Le prix est immuable et la valeur initialement définie ne change pas
//Valeur lors de l'appel de la dernière remise=Le calcul se fait à 1000

Pour augmenter le degré d'agrégation

• Conscient du principe de responsabilité unique
• Ne créez pas de méthodes indépendantes dans la classe
• Exclure les méthodes qui ne font pas référence aux variables membres
• Vérifiez si les méthodes privées peuvent être supprimées
• Minimiser les variables membres
• Pensez à diviser si le nombre d'étapes dans une classe ou une méthode est important

Degré de couplage

En termes simples, "** Ce que savent les utilisateurs et les classes et méthodes d'utilisateurs (de combien ils dépendent) **".

Plus le degré de couplage est élevé, moins il est maintenable et plus il est difficile à tester.

Type de liaison

Le degré de couplage augmente dans l'ordre suivant.

Joindre un message

Il appelle uniquement des méthodes sans arguments et n'a pas de valeur de retour. La forme idéale.

public class Main {
   private final Price price;
   
   public Main(Price price) {
      this.price = price;
   }

   public void output() {
      this.price.print();
   }
}

Price price = new Price(1000);
Main main = new Main(price);
main.output(); // ¥1,Est affiché comme 000

Dans ce qui précède, la classe Main et la classe Price ne partagent pas de données, etMain # output ()ne dépend pas de l'implémentation de print ().

La classe Price ne sait rien de la classe Main, pas plus que la classe Main ne se soucie de ce quePrice # print () ʻ fait à l'intérieur. ** Par exemple, même si vous modifiez l'implémentation de la méthodeprint ()pour imprimer une chaîne dans un fichier, même si vous ne faites rien,Main # output` s'en fiche. ** **

De telles jointures sont également appelées ** transmission de messages **, et les interactions entre ces objets sont appelées ** messagerie **. Il a été nommé "messagerie" parce qu'il délègue complètement le travail à l'autre objet, et c'est comme dire à quelqu'un "c'est enfin fait".

• Supplément: Dans le cas ci-dessus, l'implémentation ne nécessite pas de reporting, mais l'implémentation d'un callback tel que "Dites-moi quand le travail est terminé" peut également maintenir la liaison du message.

Jointure de données

Ne transmettez que des données simples.

//Exemple de jointure de données

public class NameFormatter {
    public String format(String firstName , String familyName) {
        return new StringBuilder().add(familyName).add(" ").add(firstName).toString();
    }
}
public class Main {
   private final String firstName;
   private final String familyName;

   public Main(String firstName, String familyName) {
      this.firstName = firstName;
      this.familyName = familyName;
   }

   public void printName() {
      NameFormatter formatter = new NameFormatter();
      System.out.println(formatter.format(this.firstName, this.familyName)); 
   }
}

Main main = new Main("Kazuki", "Oda");
main.printName(); //Kazuki Oda

La combinaison avec NameFormatter dans` Main # printName () ʻ ci-dessus est une combinaison de données. Dans la liaison de données, ** ne partagez que les «informations nécessaires» **. Les «informations» auxquelles il est fait référence ici correspondent aux suivantes.

• Méthode (type applicable)
• Données réelles (la valeur est applicable)

La liaison de données aboutit toujours à la même sortie pour la même entrée. De plus, puisque seules les informations nécessaires sont passées à NameFormatter, dans printName (), il est seulement nécessaire d'utiliser la valeur finalement retournée par NameFormatter # format, et quel type d'implémentation est fait en interne. Vous n'avez pas besoin de savoir si vous y êtes.

En général, les jointures de données transmettent les données en tant qu'argument [immuable](https://ja.wikipedia.org/wiki/%E3%82%A4%E3%83%9F%E3%83%A5%E3%83 % BC% E3% 82% BF% E3% 83% 96% E3% 83% AB) ou [Type primitif](https://ja.wikipedia.org/wiki/%E3%83%97%E3%83% AA% E3% 83% 9F% E3% 83% 86% E3% 82% A3% E3% 83% 96% E5% 9E% 8B) Ou fait référence à une jointure lors du passage d'une interface (je pense). Cependant, même dans le cas du passage d'un objet de type référence, il peut correspondre à une liaison de données (par exemple, seules les informations nécessaires sont divulguées par le procédé appelé).

Combinaison de timbres

Passez une structure de données (c'est-à-dire une instance avec plusieurs variables membres) comme argument.

public class Item {
    //Dans le corps, il y a respectivement un constructeur, un getter et un setter
    private String name;
    private String group;
}

public class CashRegister {
    public String format(Item item, Price price) {
        return item.getName() + ":" + price.format();
    }
}

CashRegister regi = new CashRegister();
System.out.println(regi.format(new Item("Soutien-gorge Smash", "Jeu"), new Price(6800))); //Soutien-gorge Smash:¥6,800

Dans le cas d'une combinaison de tampons, les données qui ne sont pas utilisées par l'appelé peuvent être référencées dans la structure (c'est-à-dire que l'appelé connaît également des informations inutiles). Dans le cas ci-dessus, «group» n'est pas utilisé, mais si vous voulez le faire, vous pouvez vous référer à l'un d'entre eux au format «CashRegister #».

Peu importe s'il s'agit simplement d'une référence, mais dans certains cas, il est possible de réécrire la valeur des données dans la méthode appelée. Donc ** Dans le cas d'une combinaison de tampons, lorsque l'appelant veut l'utiliser correctement, il y a des cas où il est nécessaire de savoir (savoir) dans une certaine mesure quelles données sont traitées dans la méthode appelée. ** **

Ce qui précède est une combinaison de données avec l'appelant si CashRegister est défini comme suit. Cependant, l'appelant et l'élément, ainsi que l'appelant et le prix sont estampillés ensemble </ font>

public class CashRegister {
    public String format(String item, int price) {
        return item + ":" + price;
    }
}

CashRegister regi = new CashRegister();
Item item = new Item("Soutien-gorge Smash", "Jeu");
Price price = new Price(6800);
System.out.println(regi.format(item.getName(), price.format())); //Soutien-gorge Smash:¥6,800

public class Item {
//Dans le corps, il y a respectivement un constructeur, un getter et un setter
   private String name;
   private Price unitPrice;
}

public class SaleService {
   public Price fixPrice(Item item, int amount, boolean discount) {
       Price newPrice = item.getUnitPrice().multiply(amount);
       if (discount == false) {
           return newPrice;
       }
       return newPrice.discount(0.90);
   }
}

Item item = new Item("Soutien-gorge Smash", new Price(6800));
SaleService service = new SaleService();
System.out.prinln(service.fixPrice(item, 2, false)); // ¥13,600
System.out.prinln(service.fixPrice(item, 2, true)); // ¥12,240

public void hogehoge(int test) {
   if (test > 5 ) {
       // doSomething1
   } else if (test < 1) {
       // doSomething2
   }
   for (int i = 0; i < 5; i++) {
       // doSomething3
   }
}