Définition: un objet devrait en savoir le moins sur les autres objets
Le concept principal de la loi de Dimitri est le découplage entre les classes et le couplage faible. Ce n'est qu'après un couplage faible que la réutilisabilité des classes peut être améliorée.
Une métaphore plus vivante est similaire à: les prisonniers en prison ne doivent pas contacter les personnes à l'extérieur, bien sûr, il peut y avoir des parents en visite. La prison ici est la classe, les prisonniers à l'intérieur sont les informations à l'intérieur de la classe, et les gardiens de la prison de la prison équivalent à l'exécuteur de la loi Dimit.
La loi de Dimit prétend:
(1) En termes de division de classe, les classes à faible couplage doivent être créées;
(2) Dans la conception de la structure de la classe, chaque classe devrait minimiser les droits d'accès des membres;
(3) Dans la conception d'une classe, si possible, une classe doit être conçue comme une classe inchangée;
(4) En termes de références à d'autres classes, les références d'un objet à d'autres objets doivent être minimisées;
(5) Essayez de minimiser les droits d'accès à la classe;
(6) Utiliser la fonction de sérialisation avec prudence;
(7) n'exposez pas les membres de la classe, mais fournissez l'accessoire correspondant (propriétés).
Pour donner un exemple: il existe une société de groupe, et les unités subordonnées ont des succursales et des départements directs. Maintenant, il est nécessaire d'imprimer les ID des employés de toutes les unités subordonnées. Voyons d'abord la conception qui viole la règle Dimit.
// tête de l'employé de classe de chef de chef {ID de chaîne privée; public void setID (String id) {this.id = id; } public String getID () {return id; }} // Branch Employee classe sous-emploie {ID de chaîne privée; public void setID (String id) {this.id = id; } public String getID () {return id; }} class subcompanyManager {public list <Sebemployee> getAlLemployee () {list <subSemployee> list = new ArrayList <Bemployee> (); for (int i = 0; i <100; i ++) {submployee emp = new Subemployee (); // Attribuez un ID au personnel de la branche dans l'ordre emp.setid ("branche" + i); list.add (EMP); } Retour List; }} classe CompanyManager {public List <Lesyee> getAlLemployee () {list <lyeyee> list = new ArrayList <Lesyee> (); pour (int i = 0; i <30; i ++) {Employee EMP = nouvel employé (); // Attribuez un ID au personnel du siège social dans l'ordre EMP.SetID ("Head Company" + I); list.add (EMP); } Retour List; } public void PrintalLemployee (subcompanyManager sub) {list <subSemployee> list1 = sub.getAlLemployee (); pour (sous-emploie e: list1) {System.out.println (e.getId ()); } List <employee> list2 = this.getAlLemployee (); pour (employé e: list2) {System.out.println (e.getId ()); }}} Client de classe publique {public static void main (String [] args) {companyManager e = new CompanyManager (); E.PrintAlLemployee (new SubCompanyManager ()); }} Le principal problème de cette conception est désormais dans CompanyManager. Selon la loi de Dimit, seule la communication avec des amis directs se produit, et la classe des sous-employés n'est pas un ami direct de la classe CompanyManager (le couplage qui apparaît comme des variables locales n'appartient pas à des amis directs). Logiquement parlant, le siège social n'a besoin que d'être associé à sa succursale et n'a aucun lien avec les employés de la succursale. Cette conception ajoute évidemment un couplage inutile. Selon la loi de Dimit, un tel couplage de relations d'amis indirectes doit être évité dans la classe. Le code modifié est le suivant:
class subcompanyManager {public list <sousposloyee> getAlLemployee () {list <subSemployee> list = new ArrayList <Bemployee> (); for (int i = 0; i <100; i ++) {submployee emp = new Subemployee (); // Attribuez un ID au personnel de la branche dans l'ordre emp.setid ("branche" + i); list.add (EMP); } Retour List; } public void PrintEmployee () {list <subssergloyee> list = this.getAlLemployee (); pour (sous-emploie e: list) {System.out.println (e.getId ()); }}} classe CompanyManager {public list <employee> getAlLemployee () {list <employee> list = new ArrayList <Lesyee> (); pour (int i = 0; i <30; i ++) {Employee EMP = nouvel employé (); // Attribuez un ID au personnel du siège social dans l'ordre EMP.SetID ("Head Company" + I); list.add (EMP); } Retour List; } public void printalLemployee (subcompanyManager sub) {sub.printemployee (); List <employee> list2 = this.getAlLemployee (); pour (employé e: list2) {System.out.println (e.getId ()); }}} Après la modification, la méthode d'impression de l'ID du personnel a été ajoutée à la succursale, et le siège social l'a directement appelé à imprimer, évitant ainsi le couplage avec les employés de la succursale.
L'intention d'origine de la loi Dimitter est de réduire le couplage entre les classes. Étant donné que chaque classe réduit les dépendances inutiles, il est en effet possible de réduire les relations de couplage. Mais tout a ses propres normes. Bien qu'il puisse éviter la communication avec des types indirects, afin de communiquer, vous contacterez inévitablement la branche via un "intermédiaire". Par exemple, dans ce cas, le siège social contacte les employés de la succursale par le biais de la succursale comme "intermédiaire". Une utilisation excessive du principe Dimit entraînera un grand nombre de ces classes intermédiaires et de transmission, entraînant une plus grande complexité du système. Par conséquent, lors de l'adoption de la loi de Dimitr, nous devons peser à plusieurs reprises les compromis, ce qui garantit non seulement une structure claire, mais nécessite également une cohésion élevée et un couplage faible.