[JAVA] Aggregation / Kopplung / zyklische Komplexität

Überblick

Hier sind einige Tipps zum Schreiben von Code, der einfach zu warten / zu testen ist.

• Anhäufung
• Grad der Kopplung
• Zirkuläre Komplexität

Die Sprache ist übrigens in Java geschrieben (bitte lesen Sie andere Sprachen)

Möglicherweise verstehen Sie auch, dass der Verbindungsgrad falsch ist. In diesem Fall weisen Sie bitte darauf hin. (Weil es sich von anderen Dingen unterscheidet, die von Büchern und Websites geschrieben wurden ... (´ ・ ω ・ `))

Beschreibung von jedem

Gerinnungsgrad

Wird auch als Modulstärke bezeichnet. Ein Maß dafür, wie sehr sich ein Code auf die Aufteilung der Verantwortlichkeiten für diese Klasse konzentriert. ** Klassen, die nur für eine Rolle existieren (alle Methoden existieren nur für diese Rolle), sind sehr kohärent. ** ** ** Im Gegenteil, die Klassen, die in jeder Methode keine Gemeinsamkeiten haben und verschiedene Rollen spielen, weisen einen geringen Aggregationsgrad auf.

Was ist los mit geringer Agglomeration?

• Schwer zu verstehen, was die Klasse tut
• Schwer zu warten und zu testen
• Schwer wiederzuverwenden

Klassen mit geringer Agglomeration haben tendenziell viele Mitgliedsvariablen

Wenn der Aggregationsgrad niedrig ist, ist die Anzahl der Mitgliedsvariablen tendenziell groß. Da die Mitgliedsvariable der Zustand der Klasse selbst ist, nimmt bei vielen Mitgliedsvariablen das Muster des Zustands, den die Instanz annehmen kann, zu, die Komplexität nimmt zu und die Wartbarkeit wird erheblich verringert. Es macht auch das Testen schwieriger und mehr Muster.

Beispiel für eine sehr zusammenhängende Klasse: String-Klasse

Diese Klasse existiert nur zum "Behandeln von Zeichenfolgen" und hat keine andere Rolle. String-Klasse

Spezifisches Beispiel

Betrachten Sie eine Klasse namens Price. Die Klasse verfügt nur über Methoden, die Preisdaten verarbeiten.

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

   /**Preis hinzufügen*/
   public Price add(Price other) {
       return new Price(this.value + other.value);
   }

   /**Den Preis ausgeben*/
   public Price multiply(int amount) {
       return new Price(this.value * amount);
   }

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

   /**Formatieren Sie den Preis und geben Sie ihn zurück*/
   public String format() {
       return NumberFormat.getCurrencyInstance().format(this.value);
   }

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

//Benutzerseite
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
//Ergänzung:Der Preis ist unveränderlich und der anfänglich eingestellte Wert ändert sich nicht
//Wert beim Aufrufen des letzten Rabattes=Die Berechnung erfolgt bei 1000

Erhöhung des Aggregationsgrades

• Kenntnis des Grundsatzes der Einzelverantwortung
• Erstellen Sie keine unabhängigen Methoden in der Klasse
• Schließen Sie Methoden aus, die sich nicht auf Mitgliedsvariablen beziehen
• Überlegen Sie, ob private Methoden entfernt werden können
• Minimieren Sie Mitgliedsvariablen
• Erwägen Sie die Aufteilung, wenn die Anzahl der Schritte in einer Klasse oder Methode groß ist

Kopplungsgrad

Einfach ausgedrückt: "** Wie viel der Benutzer und die Benutzerklassen und -methoden wissen (von wie viel sie abhängen) **".

Je höher der Kopplungsgrad ist, desto weniger wartbar ist er und desto schwieriger ist es zu testen.

Art der Bindung

Der Kopplungsgrad steigt in der folgenden Reihenfolge an.

Nachrichten verbinden

Es ruft nur Methoden ohne Argumente auf und hat keinen Rückgabewert. Die ideale Form.

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,Wird als 000 angezeigt

Oben teilen sich die Klasse "Main" und die Klasse "Price" keine Daten, und "Main # output ()" hängt nicht von der Implementierung von "print ()" ab.

Die "Price" -Klasse weiß nichts über die "Main" -Klasse, und die "Main" -Klasse kümmert sich auch nicht darum, was "Price # print ()" im Inneren tut. ** Selbst wenn Sie beispielsweise die Implementierung der Methode "print ()" ändern, um eine Zeichenfolge in eine Datei zu drucken, ist es "Main # output" egal, selbst wenn Sie nichts tun. ** ** **

Solche Verknüpfungen werden auch als "Message Passing" bezeichnet, und Interaktionen zwischen solchen Objekten werden als "Messaging" bezeichnet. Es wurde "Messaging" genannt, weil es die Arbeit vollständig an das andere Objekt delegiert und es ist, als würde man jemandem sagen, "das ist endlich erledigt".

• Ergänzung: In dem oben genannten Fall erfordert die Implementierung keine Berichterstellung, aber die Implementierung eines Rückrufs wie "Sagen Sie mir, wann die Arbeit abgeschlossen ist" kann auch die Nachrichtenbindung aufrechterhalten.

Datenverbindung

Übergeben Sie nur einfache Daten.

//Beispiel für Datenverknüpfung

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

Die Kombination mit NameFormatter in Main # printName () oben ist eine Datenkombination. Teilen Sie bei der Datenbindung ** nur "notwendige Informationen" ** mit. Die hier genannten "Informationen" entsprechen den folgenden.

• Methode (Typ anwendbar)
• Aktuelle Daten (Wert gilt)

Die Datenbindung führt immer zu derselben Ausgabe für dieselbe Eingabe. Da nur die erforderlichen Informationen an "NameFormatter" übergeben werden, verwendet "printName ()" nur den Wert, der schließlich vom "NameFormatter # -Format" zurückgegeben wird, und welche Art der Implementierung intern erfolgt. Sie müssen nicht wissen, ob Sie dort sind.

Im Allgemeinen werden Daten zusammengefügt, um Daten als Argument [unveränderlich] zu übergeben (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) oder [Primitiver Typ](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) Oder bezieht sich auf einen Join beim Übergeben einer Schnittstelle (glaube ich). Selbst im Fall der Übergabe eines Objekts vom Referenztyp kann es jedoch einer Datenbindung entsprechen (zum Beispiel werden nur die erforderlichen Informationen durch das aufgerufene Verfahren offenbart).

Stempelkombination

Übergeben Sie eine Datenstruktur (dh eine Instanz mit mehreren Mitgliedsvariablen) als Argument.

public class Item {
    //In dem Körper gibt es einen Konstruktor, Getter und 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("Smash Bra", "Spiel"), new Price(6800))); //Smash Bra:¥6,800

Bei einer Stempelkombination können Daten, die nicht vom Angerufenen verwendet werden, in der Struktur referenziert werden (dh der Angerufene kennt auch unnötige Informationen). Im obigen Fall wird "Gruppe" nicht verwendet, aber wenn Sie dies möchten, können Sie im "CashRegister # -Format" auf eine von ihnen verweisen.

Es spielt keine Rolle, ob es sich nur um eine Referenz handelt, aber in einigen Fällen ist es möglich, den Wert der Daten in der aufgerufenen Methode neu zu schreiben. Also ** Bei einer Stempelkombination, wenn der Anrufer sie korrekt verwenden möchte, gibt es Fälle, in denen es erforderlich ist, bis zu einem gewissen Grad zu wissen, welche Daten in der aufgerufenen Methode verarbeitet werden. ** ** **

Das Obige ist eine Datenkombination mit dem Anrufer, wenn CashRegister wie folgt eingestellt ist. Anrufer und Artikel sowie Anrufer und Preis werden jedoch zusammen gestempelt </ font>

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

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

public class Item {
//In dem Körper gibt es einen Konstruktor, Getter und 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("Smash Bra", 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
   }
}