Definición: Un objeto debe mantener la menor comprensión de otros objetos.
El origen del problema: la relación entre las clases es acercarse cada vez más, y el acoplamiento es cada vez mayor. Cuando una clase cambia, cuanto mayor sea el impacto en otra clase.
Solución: minimice el acoplamiento entre las clases tanto como sea posible.
Desde que entramos en contacto con la programación, hemos conocido los principios generales del diseño de software, el bajo acoplamiento y la alta cohesión. Ya sea que esté orientado a objetos o orientado al proceso, el grado de acoplamiento debe ser lo más bajo posible para mejorar la tasa de reutilización del código. ¿Pero cómo programar un acoplamiento bajo?
No importa cuán compleja sea la lógica, para las clases dependientes, intente encapsular la lógica dentro de la clase y no divulgar ninguna información en el exterior, excepto los métodos públicos proporcionados. También hay una definición más simple: solo comunicarse con amigos directos. Primero, expliquemos qué es un amigo directo; Cada objeto se combinará con otros objetos. Digamos que hay una relación de acoplamiento entre estos dos objetos. Digamos que estos dos objetos tienen una relación de amigos. Hay muchas formas en que se produce el acoplamiento, como la dependencia, la asociación, la composición, la agregación, etc. Entre ellas, llamamos a la clase que aparece variables miembros, parámetros del método y valores de retorno del método llamados amigos directos, mientras que la clase que aparece en las variables locales no son amigos directos. Es decir, es mejor no aparecer dentro de la clase como variables locales;
Por ejemplo, en una escuela, hay varios maestros, numerados en secuencia. Hay varios estudiantes a continuación, numerados a la vez. Ahora solicite imprimir todas las identificaciones de maestros y estudiantes.
Primero, viole el principio de bajo acoplamiento y alta cohesión
El código es el siguiente.
paquete test1; import java.util.arrayList; import java.util.list; class maestro {privateString id; publicVoidSetId (String id) {this.id = id;} Publicstring getId () {return id;}} class string {private string id; public void setid (string id) {this.id = id;} public string getId ()}}}}}}}}}}} string id) {this.id = id;} public string getId ()}}}}}}}}}}}} class. StudentManage {publicList <Sentude> getAllStudent () {list <diet> list = newArrayList <drement> (); for (int i = 0; i <100; i ++) {student student = new student (); student.SetId ("Student Student Number es"+i); list.add (Student);} Lista de regreso;} Class de la clase TrainseManage {PublicLiSt <verververser es "+i); list.add (Student);} {List <firector> list = newArrayList <firector> (); for (inti = 0; i <100; i ++) {maestro maestro = nuevo maestro (); maestro.setid ("número de maestro"+i); list.add (maestro);} return list;} public void imprime (estudianteManagestentManager) {list <diDing> list = studentmanger.getallstudent () () para () para () para (); {System.out.println (s.getid ());} list <firector> list2 = this.getallTeacher (); for (maestro t: list2) {system.out.println (t.getid ());}}} Public ClassClient {publicstaticVoidMain (String [] args) {maestroManagetm = newteachermanage (); tm.printallperson (new StudentManage ());}} El principal problema de este diseño ahora aparece en la clase de Teachermanage. Según la baja ley de acoplamiento y alta cohesión, solo se comunica con amigos directos. La clase de estudiantes no es un amigo directo en la clase de maestros de maestros. Tal acoplamiento de relación de amigos no directos debe evitarse en la clase.
Después de la modificación, el código es el siguiente:
package test2;import java.util.ArrayList;import java.util.List;class Teacher{privateString id;publicvoidsetId(String id) {this.id=id;}publicString getId() {return id;}}class Student{private String id;public void setId(String id) {this.id=id;}public String getId() {return id;}}class StudentManage {PublicList <entude> getAllStudent () {list <diet> list = newArrayList <dudent> (); for (int i = 0; i <100; i ++) {student student = new student (); student.setid ("El número de estudiante es"+i); list.add (student);} return List;} public void imprimeLstudent () {List <Student> list1 = this.getAllStudent (); for (Student s: List1) {System.out.println (s.getid ());}}} class maestroManage {publicList <firector> getAllteacher () {List <firector> list = newArrayList <firector> (); para (inti = 0; i <00; i++++) Maestro (); maestro.setid ("número de maestro"+i); list.add (maestro);} lista de retorno;} publicVoidPrintallTeacher () {list <firector> list2 = this.getallTeacher (); para (maestro t: list2) {system.out.println (t.getid ());}}} public ClassClient {StraticVoidMain (String [] {MaestroManagetm = newteachermanage (); tm.printallTeacher (); studentManagesm = newStudentManage (); sm.printallStudent ();}}Después de la modificación, el estudiante ha agregado un nuevo método de identificación del estudiante y el maestro puede llamarlo directamente. Esto evita el acoplamiento con los estudiantes. La intención original del principio de bajo acoplamiento y alta cohesión es reducir el acoplamiento entre clases. Dado que cada clase reduce las dependencias innecesarias, de hecho es posible reducir la relación de acoplamiento. Sin embargo, todo tiene un título. Aunque se puede evitar la comunicación con clases indirectas, para comunicarse, las relaciones inevitablemente ocurrirán a través de un "intermediario". El uso de esta regla puede lograr una estructura clara, alta cohesión y bajo acoplamiento,
El acoplamiento y la cohesión son dos estándares cualitativos para la independencia del módulo. Al dividir los sistemas de software en módulos, trate de lograr una alta cohesión y un bajo acoplamiento tanto como sea posible para mejorar la independencia del módulo y sentar las bases para diseñar estructuras de software de alta calidad.
Hay un ejemplo que es fácil de entender: un programa tiene 50 funciones, y este programa se ejecuta muy bien; Sin embargo, una vez que modifica una de las funciones, las otras 49 funciones deben modificarse, lo cual es la consecuencia del alto acoplamiento.
Resumir
Lo anterior es todo el contenido de este artículo sobre el análisis del código del código de ejemplo de alta cohesión y baja ley de acoplamiento. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!