Diferencia entre la cohesión y acoplamiento
https://stackoverflow.com/questions/3085285
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Cuál es la diferencia entre la cohesión y el acoplamiento?
¿Cómo se puede acoplar a la cohesión y el plomo, ya sea buena o pobre diseño de software?
¿Cuáles son algunos ejemplos que resumen la diferencia entre los dos, y su impacto en la calidad del código general?
Solución
Cohesión se refiere a lo que la clase (o módulo) pueden hacer. Baja cohesión significaría que la clase hace un gran variedad de acciones - es amplio, fuera de foco sobre lo que debe hacer. medios de cohesión altas que la clase se centra en lo que debería estar haciendo, es decir, sólo los métodos relativos a la intención de la clase.
Ejemplo de baja cohesión:
-------------------
| Staff |
-------------------
| checkEmail() |
| sendEmail() |
| emailValidate() |
| PrintLetter() |
-------------------
Ejemplo de alta cohesión:
----------------------------
| Staff |
----------------------------
| -salary |
| -emailAddr |
----------------------------
| setSalary(newSalary) |
| getSalary() |
| setEmailAddr(newEmail) |
| getEmailAddr() |
----------------------------
Como para acoplamiento , se refiere a cómo relacionada o dependiente dos clases / módulos son uno hacia el otro. Para las clases bajas acoplada, cambiando algo importante en una clase no debe afectar a la otra. Alta acoplamiento haría difícil de cambiar y mantener su código; ya que las clases están estrechamente entrelazados, por lo que un cambio podría requerir toda una renovación del sistema.
Un buen diseño de software ha alta cohesión y bajo acoplamiento .
Otros consejos
alta cohesión en módulos y bajo acoplamiento entre módulos son a menudo considerados como relacionados con la alta calidad en los lenguajes de programación orientados a objetos.
Por ejemplo, el código dentro de cada clase de Java debe tener una alta cohesión interna, pero puede acoplar tan libremente como sea posible para el código en otras clases Java.
Object-Oriented Software de construcción de Meyer (2ª edición) es una gran descripción de estos problemas.
Cohesión es la indicación de la relación dentro de un módulo.
Acoplamiento es la indicación de las relaciones entre módulos.
Cohesión
- Cohesión es la indicación de la relación dentro del módulo.
- Cohesión muestra la fuerza funcional relativa del módulo.
- La cohesión es un grado (calidad) a la que un componente / módulo se centra en la una cosa.
- Si bien el diseño que usted debe esforzarse para alta cohesión es decir, un componente cohesiva / módulo de enfoque en una sola tarea (es decir, Pensamiento único) con poca interacción con otros módulos de la sistema.
- La cohesión es el tipo de extensión natural de ocultación de datos para ejemplo, la clase que todos los miembros visibles con un envase que tiene visibilidad predeterminada. La cohesión es intra -. Concepto de módulo
Acoplamiento
- Acoplamiento es la indicación de las relaciones entre módulos.
- Acoplamiento muestra la relativa dependencia / interdependencia entre los módulos.
- acoplamiento es un grado en el que un componente / módulo está conectado a los otros módulos.
- Si bien el diseño que usted debe esforzarse para baja dependencia de acoplamiento es decir, entre los módulos debe ser menor
- Hacer campos privados, métodos privados y públicos clases no proporciona el acoplamiento débil.
- El acoplamiento es Inter -Módulo Concepto.
Cohesión es una indicación de cómo relacionadas y enfocadas las responsabilidades de un elemento de software son.
Acoplamiento se refiere a la fuerza con un elemento de software se conecta a otros elementos.
El elemento de software podría ser clase, Paquete, componente, subsistema o un sistema. Y mientras que el diseño de los sistemas que se recomienda disponer de elementos de software que tiene alta cohesión y el apoyo Bajo acoplamiento .
baja cohesión Resultados de clases monolíticas que son difíciles de mantener, comprender y reduce la re-usablity. Del mismo modo Acoplamiento de alta los resultados en clases que son de estructura rígida y cambios tienden a no ser que no es local, difíciles de cambiar y reduce la reutilización.
puede tener un escenario hipotético en el que estamos diseñando un ConnectionPool típico monitor de poder con los siguientes requisitos. Tenga en cuenta que, podría parecer demasiado para una clase simple como ConnectionPool pero la intención básica es sólo para demostrar acoplamiento bajo y alta cohesión con algún ejemplo sencillo y creo que deberían ayuda .
- Soporte de conseguir una conexión
- liberar una conexión
- obtener estadísticas sobre la conexión de uso frente a recuento
- obtener estadísticas sobre la conexión en función del tiempo
- almacenar la información de recuperación de la conexión y la liberación de una base de datos para la presentación de informes más tarde.
baja cohesión podríamos diseñar una clase ConnectionPool por el relleno enérgicamente toda esta funcionalidad / responsabilidades en una sola clase de la siguiente manera. Podemos ver que esta única clase es responsable de la gestión de conexiones, la interacción con la base de datos, así el mantenimiento de las estadísticas de conexión.
alta cohesión podemos asignar éstos responsabilidad a través de las clases y hacer que sea más fácil de mantener y reutilizable.
Para demostrar Bajo acoplamiento vamos a continuar con el diagrama ConnectionPool alta cohesión anteriormente. Si nos fijamos en el diagrama anterior a pesar de que es compatible con alta cohesión, la ConnectionPool está estrechamente unida con la clase ConnectionStatistics y PersistentStore interactúa directamente con ellos. En lugar de reducir el acoplamiento podríamos introducir una interfaz ConnectionListener y dejar que estas dos clases implementan la interfaz y dejar que se registra en la clase ConnectionPool. Y el ConnectionPool se repetirá a través de estos oyentes y notificarles de obtener y quitar eventos de conexión y permite menos de acoplamiento.
Nota / Word o Precaución: En este escenario simple que puede parecer una exageración, pero si nos imaginamos un escenario en tiempo real, donde nuestras necesidades de aplicación para interactuar con múltiples servicios de terceros para completar una transacción : acoplar directamente a nuestro código con los servicios de terceros que significaría que cualquier cambio en el servicio de terceros podrían dar lugar a cambios en nuestro código en múltiples lugares, en vez podríamos tener Facade que interactúa con estos múltiples servicios internos y cualquier cambio en los servicios se vuelven local a la Facade y hacer cumplir bajo acoplamiento con los servicios de terceros.
El aumento de la cohesión y la disminución de acoplamiento de plomo tareas para el buen diseño de software.
Los tabiques de Cohesión su funcionalidad para que sea concisa y más cercano a los datos correspondientes a la misma, mientras que el desacoplamiento asegura que la aplicación funcional está aislado del resto del sistema.
El desacoplamiento le permite cambiar la aplicación sin afectar a otras partes de su software.
Cohesión asegura que la aplicación más específica a la funcionalidad y al mismo tiempo más fácil de mantener.
El método más eficaz de disminuir el acoplamiento y el aumento de la cohesión es diseño de interfaz .
Eso es principales objetos funcionales sólo deben 'saber' entre sí a través de la interfaz (s) que se implementan. La implementación de una interfaz de cohesión introduce como una consecuencia natural.
Si bien no es realista en algunos senarios que debería ser un objetivo de diseño para el trabajo de.
Ejemplo (muy incompleto):
public interface IStackoverFlowQuestion
void SetAnswered(IUserProfile user);
void VoteUp(IUserProfile user);
void VoteDown(IUserProfile user);
}
public class NormalQuestion implements IStackoverflowQuestion {
protected Integer vote_ = new Integer(0);
protected IUserProfile user_ = null;
protected IUserProfile answered_ = null;
public void VoteUp(IUserProfile user) {
vote_++;
// code to ... add to user profile
}
public void VoteDown(IUserProfile user) {
decrement and update profile
}
public SetAnswered(IUserProfile answer) {
answered_ = answer
// update u
}
}
public class CommunityWikiQuestion implements IStackoverflowQuestion {
public void VoteUp(IUserProfile user) { // do not update profile }
public void VoteDown(IUserProfile user) { // do not update profile }
public void SetAnswered(IUserProfile user) { // do not update profile }
}
Algunos dónde si no en su base de código que podría tener un módulo que procesa las preguntas, independientemente de lo que son:
public class OtherModuleProcessor {
public void Process(List<IStackoverflowQuestion> questions) {
... process each question.
}
}
mejor explicación de Cohesión proviene de un código limpio del tío Bob:
Las clases deben tener un pequeño número de variables de instancia. Cada uno de los métodos de una clase debe manipular una o más de esas variables. En general, los más variables un método que manipula los más cohesivos que método es su clase . Una clase en la que cada variable es usada por cada método es máximamente cohesiva.
En general, es aconsejable ni posible crear este tipo de clases al máximo cohesivos; por el contrario, nos gustaría cohesión a ser alto . Cuando la cohesión es alto, significa que los métodos y las variables de la clase son co-dependiente y cuelgan juntos como una lógica conjunto.
La estrategia de mantener funciones pequeño y mantener listas de parámetros corta a veces puede llevar a una proliferación de las variables de instancia que son utilizados por un subconjunto de métodos. Cuando esto sucede, es casi siempre significa que hay al menos otra clase tratando de salir de la clase más grande. Usted debe tratar de separar las variables y métodos en dos o más clases de tal manera que las nuevas clases son más cohesiva.
Cohesión en la ingeniería de software es el grado en el que los elementos de un módulo determinado pertenecen juntos. Por lo tanto, es una medida de cuán fuertemente relacionado cada pieza de funcionalidad expresada por el código fuente de un módulo de software es.
Acoplamiento en palabras sencillas, es la cantidad de componente de uno (de nuevo, imaginar una clase, aunque no necesariamente) sabe sobre el funcionamiento interno o elementos interiores de otro, es decir, la cantidad de conocimiento que tiene de el otro componente.
escribí un post sobre este , si desea leer en un poco más detalles con ejemplos y dibujos. Creo que responde a la mayoría de sus preguntas.
simplemente, Cohesión representa el grado en que una parte de una base de código forma una sola unidad lógica, atómica. Acoplamiento , por el contrario, representa el grado en que una sola unidad es independiente de los demás. En otras palabras, es el número de conexiones entre dos o más unidades. Cuanto menor sea el número, menor es el acoplamiento.
En esencia, los medios de alta cohesión de mantenimiento de partes de una base de código que están relacionados entre sí en un solo lugar. acoplamiento bajo, al mismo tiempo, se trata de la separación de partes no relacionadas de la base de código tanto como sea posible.
Tipos de código de una cohesión y perspectiva de acoplamiento:
Ideal es el código que sigue la directriz. Es imprecisa y altamente cohesivo. Podemos ilustrar dicho código con esta imagen: 
Dios Object es el resultado de la introducción de alta cohesión y de alta acoplamiento. Es un anti-patrón y, básicamente, significa una sola pieza de código que hace todo el trabajo a la vez:
mal seleccionado tiene lugar cuando los límites entre las diferentes clases o módulos se seleccionan mal < img src = "https://i.stack.imgur.com/OGJ5W.png" alt = "introducir descripción de la imagen aquí">
desacoplamiento destructivo es la más interesante. A veces ocurre cuando un programador intenta desacoplar una base de código tanto que el código pierde completamente su enfoque: < img src = "https://i.stack.imgur.com/ZiA3f.png" alt = "introducir descripción de la imagen aquí">
cohesión se refiere todo acerca de cómo se ha diseñado una sola clase. La cohesión es el principio orientada a objetos más estrechamente asociado con asegurarse de que una clase está diseñado con un solo propósito, bien enfocada. Cuanto más enfocado a una clase es, la cohesión de esa clase es más. Las ventajas de la alta cohesión es que estas clases son mucho más fáciles de mantener (y menos frecuentemente cambiado) que las clases con baja cohesión. Otro de los beneficios de la alta cohesión es que las clases con un propósito bien enfocada tienden a ser más reutilizable que otras clases.
En la imagen anterior, podemos ver que en la baja cohesión sólo una clase es responsable de ejecutar una gran cantidad de trabajo que no están en común, que reduce la posibilidad de reutilización y mantenimiento. Pero en alta cohesión existe una clase separada para todos los puestos de trabajo para ejecutar un trabajo específico, que dan mayor facilidad de uso y mantenimiento.
Cohesión (cohesión): Co que medios juntos , HESION que medios a stick . El sistema de pegado de las partículas de diferentes sustancias.
Por ejemplo en la vida real:
img Cortesía
todo es mayor que la suma de las partes Aristóteles.
-
Cohesión es un tipo ordinal de medición y por lo general se describe como “alta cohesión” o “baja cohesión”. Los módulos con alta cohesión tienden a ser preferible, porque la alta cohesión se asocia con varios rasgos deseables de software incluyendo robustez, fiabilidad, capacidad de reutilización, y comprensibilidad. En contraste, la baja cohesión se asocia con rasgos indeseables tales como ser difíciles de mantener, prueba, reutilización, o incluso de entender. wiki
-
Acoplamiento es por lo general en contraste con cohesión . acoplamiento de baja frecuencia se correlaciona con alta cohesión, y viceversa. acoplamiento baja es a menudo una señal de un sistema informático bien estructurada y un buen diseño, y cuando se combina con una alta cohesión, es compatible con los objetivos generales de alta legibilidad y mantenibilidad. wiki
Creo que las diferencias se pueden poner como el siguiente:
- Cohesión representa el grado en que una parte de una base de código forma una sola unidad lógica, atómica.
- Acoplamiento representa el grado en que una sola unidad es independiente de los demás.
- Es imposible archivar desacoplamiento total sin dañar la cohesión, y viceversa.
En esta entrada del blog escribo sobre ello con más detalle .
Cohesión es una indicación de la fuerza funcional relativa de un módulo.
- Un módulo cohesivos realiza una sola tarea, que requiere poco interacción con otros componentes en otras partes de un programa. Fijado simplemente, un módulo de cohesión debe (idealmente) hacer una sola cosa.
-
vista ?Conventional:
el “single-mente” de un módulo
-
vista ?OO:
?cohesion implica que un componente o clase encapsula únicos atributos y operaciones que están estrechamente relacionados entre sí y con la clase o el propio componente
-
?Levels de cohesión
?Functional
?Layer
?Communicational
?Sequential
?Procedural
?Temporal
?utility
Acoplamiento es una indicación de la interdependencia relativa entre los módulos.
-
El acoplamiento depende de la complejidad de interfaz entre los módulos, la punto en el que la entrada o se hace referencia a un módulo, y qué datos pasar a través de la interfaz.
-
Convencional Ver: El grado en que un componente está conectado a otros componentes y con el mundo exterior
-
vista OO: una medida cualitativa del grado en que las clases están conectados el uno al otro
-
Nivel de acoplamiento
?Content
?Common
?Control
?Stamp
?Data
?Routine llamada
uso ?Type
?Inclusion o importación
?External #
Acoplamiento = interacción / relación entre dos módulos ... Cohesión = interacción entre dos elementos dentro de un módulo.
A software está consistiendo de muchos módulos. Módulo consta de elementos. Considere un módulo es un programa. Una función dentro de un programa es un elemento.
En tiempo de ejecución, la salida de un programa se utiliza como entrada para otro programa. Esto se llama módulo a la interacción módulo o proceso para la comunicación proceso. Esto también se llama como el acoplamiento.
Dentro de un mismo programa, la salida de una función se pasa a otra función. Esto se llama interacción de los elementos dentro de un módulo. Esto también se llama como la cohesión.
Ejemplo:
Acoplamiento = comunicación entre 2 familias diferentes ... Cohesión = comunicación entre padre-madre-hijo dentro de una familia.
En pocas palabras, cohesión significa que una clase debe representar un solo concepto.
La interfaz pública de una clase es coherente si todas las características de clase están relacionados con el concepto de que la clase representa. Por ejemplo, en lugar de tener la clase CashRegister, teniendo CashRegister y moneda representa la cohesión hace en 2 clases -. CashRegister y la moneda clase
En acoplamiento , una clase depende de otro, ya que utiliza los objetos de la clase.
El problema con alta acoplamiento es que puede crear efectos secundarios. Un cambio en una clase podría causar un error inesperado en la otra clase y se puede romper todo el código.
Generalmente, alta cohesión y bajo acoplamiento se considera OOP alta calidad.
El término cohesión es de hecho un poco intuitiva contador para lo que significa en el diseño de software.
Cohesión significado común es que algo que se pega bien juntos, está unida, que se caracterizan por unión fuerte como atracción molecular. Sin embargo, en el diseño de software, significa esforzarse para una clase que, idealmente, sólo hace una cosa, por lo que varios sub-módulos no están aún implicados.
Tal vez podemos pensar de esta manera. Una parte tiene el mayor cohesión cuando es la única parte (hace una sola cosa y no puede dividirse aún más). Esto es lo que se desea en el diseño de software. Cohesión simplemente es otro nombre de "responsabilidad única" o "separación de intereses".
El término acoplamiento en la mano es bastante intuitiva que significa que cuando un módulo no depende de muchos otros módulos y las que se conecta con puede ser reemplazado fácilmente por ejemplo obedecer Liskov sustitución principio .
