oop - similitudes - Diferencia entre la cohesión y el acoplamiento
qué diferencia existe entre cohesión y coherencia (13)
¿Cuál es la diferencia entre cohesión y acoplamiento?
¿Cómo puede el acoplamiento y la cohesión llevar a un diseño de software bueno o malo?
¿Cuáles son algunos ejemplos que resumen la diferencia entre los dos y su impacto en la calidad general del código?
Creo que las diferencias se pueden poner de la siguiente manera:
- La cohesión representa el grado en que una parte de una base de código forma una unidad atómica, lógicamente única.
- El acoplamiento representa el grado en que una sola unidad es independiente de otras.
- Es imposible archivar el desacoplamiento completo sin dañar la cohesión, y viceversa.
This escribo sobre esto con más detalle.
En pocas palabras, Cohesión significa que una clase debe representar un solo concepto.
La interfaz pública de una clase es cohesiva si todas las características de la clase están relacionadas con el concepto que representa la clase. Por ejemplo, en lugar de tener la clase CashRegister con características de CoRegister y Coin, la cohesión lo convierte en 2 clases: la clase CashRegister y Coin
En el acoplamiento de una clase depende de otra, ya que utiliza los objetos de la clase.
El problema con el acoplamiento alto es que puede crear efectos secundarios. Un cambio en una clase podría causar un error inesperado en la otra clase y podría romper todo el código.
Generalmente, la alta cohesión y el bajo acoplamiento se consideran OOP de alta calidad
La alta cohesión dentro de los módulos y el bajo acoplamiento entre módulos a menudo se consideran relacionados con la alta calidad en los lenguajes de programación OO.
Por ejemplo, el código dentro de cada clase de Java debe tener una alta cohesión interna, pero debe estar lo más libremente posible acoplado al código en otras clases de Java.
El Capítulo 3 de la Construcción de software orientado a objetos de Meyer (2ª edición) es una excelente descripción de estos problemas.
La mayor cohesión y el menor acoplamiento conducen a un buen diseño del software.
Cohesion divide su funcionalidad de manera que sea concisa y más cercana a los datos relevantes para ella, mientras que el desacoplamiento garantiza que la implementación funcional esté aislada del resto del sistema.
El desacoplamiento le permite cambiar la implementación sin afectar otras partes de su software.
La cohesión garantiza que la implementación sea más específica para la funcionalidad y, al mismo tiempo, más fácil de mantener.
El método más efectivo para disminuir el acoplamiento y aumentar la cohesión es el diseño por interfaz .
Es decir, los objetos funcionales principales solo deben ''conocerse'' unos a otros a través de las interfaces que implementan. La implementación de una interfaz introduce la cohesión como una consecuencia natural.
Si bien no es realista en algunos senarios, debe ser un objetivo de diseño para trabajar.
Ejemplo (muy esquemático):
public interface IQuestion
void SetAnswered(IUserProfile user);
void VoteUp(IUserProfile user);
void VoteDown(IUserProfile user);
}
public class NormalQuestion implements IQuestion {
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 IQuestion {
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 }
}
En algún otro lugar de su base de código podría tener un módulo que procesa las preguntas, independientemente de lo que sean:
public class OtherModuleProcessor {
public void Process(List<IQuestion> questions) {
... process each question.
}
}
La mejor explicación de la cohesión proviene del 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, cuantas más variables manipule un método, más cohesivo será ese método para su clase . Una clase en la que cada variable es utilizada por cada método es cohesiva máxima.
En general, no es aconsejable ni posible crear tales clases cohesivas máximas; por otro lado, nos gustaría que la cohesión fuera alta . Cuando la cohesión es alta, significa que los métodos y las variables de la clase son co-dependientes y se unen como un todo lógico.
La estrategia de mantener funciones pequeñas y mantener listas de parámetros cortas a veces puede llevar a una proliferación de variables de instancia que son utilizadas por un subconjunto de métodos. Cuando esto sucede, casi siempre significa que hay al menos otra clase que intenta salir de la clase más grande. Debe intentar separar las variables y los métodos en dos o más clases, de manera que las nuevas clases sean más cohesivas.
simplemente, Cohesión representa el grado en que una parte de una base de código forma una unidad atómica, lógicamente única. El acoplamiento , por otro lado, representa el grado en que una sola unidad es independiente de las demás. En otras palabras, es el número de conexiones entre dos o más unidades. Cuanto menor sea el número, menor será el acoplamiento.
En esencia, alta cohesión significa mantener partes de una base de código que están relacionadas entre sí en un solo lugar. El acoplamiento bajo, al mismo tiempo, se trata de separar las partes no relacionadas de la base del código tanto como sea posible.
Tipos de código desde una perspectiva de cohesión y acoplamiento:
Lo ideal es el código que sigue la pauta. Está ligeramente acoplado y es altamente cohesivo. Podemos ilustrar dicho código con esta imagen:
Dios Objeto es el resultado de la introducción de una alta cohesión y un alto acoplamiento. Es un antipatrón y básicamente representa una sola pieza de código que hace todo el trabajo a la vez: la selección deficiente tiene lugar cuando los límites entre las diferentes clases o módulos se seleccionan de manera deficiente
El desacoplamiento destructivo es el 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:
lee más here
Acoplamiento = interacción / relación entre dos módulos ... Cohesión = interacción entre dos elementos dentro de un módulo.
Un software consta de muchos módulos. El módulo consta de elementos. Considerar un módulo es un programa. Una función dentro de un programa es un elemento.
En el tiempo de ejecución, la salida de un programa se utiliza como entrada para otro programa. Esto se denomina interacción módulo a módulo o proceso para procesar la comunicación. Esto también se llama como acoplamiento.
Dentro de un solo programa, la salida de una función se pasa a otra función. Esto se llama interacción de elementos dentro de un módulo. Esto también se llama cohesión.
Ejemplo:
Acoplamiento = comunicación entre 2 familias diferentes ... Cohesión = comunicación entre padre-madre-hijo dentro de una familia.
Cohesión (Co-hesion): Co que significa juntos , hesion que significa pegarse . El sistema de pegado de partículas de diferentes sustancias.
Para el ejemplo de la vida real:
img Cortesía
Todo es mayor que la suma de las partes -Aristotle.
La cohesión es un tipo ordinal de medición y generalmente se describe como "alta cohesión" o "baja cohesión". Los módulos con alta cohesión tienden a ser preferibles, ya que la alta cohesión está asociada con varios rasgos deseables del software que incluyen robustez, fiabilidad, reutilización y comprensibilidad. Por el contrario, la cohesión baja se asocia con rasgos indeseables, como ser difíciles de mantener, probar, reutilizar o incluso comprender. wiki
El acoplamiento suele contrastar con la cohesión . El acoplamiento bajo a menudo se correlaciona con una alta cohesión, y viceversa. El acoplamiento bajo es a menudo un signo de un sistema informático bien estructurado y un buen diseño, y cuando se combina con una alta cohesión, apoya los objetivos generales de alta legibilidad y facilidad de mantenimiento. wiki
La cohesión se refiere a lo que la clase (o módulo) puede hacer. La baja cohesión significaría que la clase realiza una gran variedad de acciones: es amplia, no se centra en lo que debe hacer. Alta cohesión significa que la clase se centra en lo que debería hacer, es decir, solo en los métodos relacionados con 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() |
----------------------------
En cuanto al acoplamiento , se refiere a qué tan relacionadas o dependientes están las dos clases / módulos entre sí. En el caso de las clases de bajo acoplamiento, cambiar algo importante en una clase no debería afectar a la otra. Un alto acoplamiento dificultaría cambiar y mantener su código; ya que las clases están muy unidas, hacer un cambio podría requerir una renovación completa del sistema.
El buen diseño del software tiene una alta cohesión y un bajo acoplamiento .
La cohesión en la ingeniería de software es el grado en que los elementos de un determinado módulo pertenecen juntos. Por lo tanto, es una medida de cuán fuertemente relacionada está cada pieza de funcionalidad expresada por el código fuente de un módulo de software.
Acoplarse en palabras simples, es cuánto un componente (de nuevo, imagina una clase, aunque no necesariamente) sabe sobre el funcionamiento interno o los elementos internos de otro, es decir, cuánto conocimiento tiene del otro componente.
Escribí una publicación de blog sobre esto , si desea leer un poco más detalles con ejemplos y dibujos. Creo que responde a la mayoría de tus preguntas.
La cohesión es la indicación de la relación dentro de un módulo.
El acoplamiento es la indicación de las relaciones entre los módulos.
Cohesión
- La cohesión es la indicación de la relación dentro del módulo.
- La cohesión muestra la fuerza funcional relativa del módulo.
- La cohesión es un grado (calidad) en el que un componente / módulo se centra en una sola cosa.
- Mientras diseña, debe esforzarse por lograr una alta cohesión, es decir, un componente / módulo cohesivo centrado en una sola tarea (es decir, una mentalidad simple) con poca interacción con otros módulos del sistema.
- Cohesión es el tipo de extensión natural de la ocultación de datos, por ejemplo, una clase que tiene a todos los miembros visibles con un paquete que tiene visibilidad predeterminada. La cohesión es un concepto intramodular.
Acoplamiento
- El acoplamiento es la indicación de las relaciones entre los módulos.
- El acoplamiento muestra la independencia relativa entre los módulos.
- El acoplamiento es un grado en el cual un componente / módulo está conectado a los otros módulos.
- Al diseñar, debe esforzarse por un acoplamiento bajo, es decir, la dependencia entre los módulos debería ser menor
- Hacer campos privados, métodos privados y clases no públicas proporciona un acoplamiento suelto.
- El acoplamiento es un concepto intermodular.
revisa this enlace
La cohesión es una indicación de la fuerza funcional relativa de un módulo.
- Un módulo cohesivo realiza una sola tarea, requiriendo poca interacción con otros componentes en otras partes de un programa. Dicho simplemente, un módulo cohesivo debería (idealmente) hacer solo una cosa.
View Vista convencional:
La “mentalidad única” de un módulo.
Ver OO:
La cohesión implica que un componente o clase solo encapsula atributos y operaciones que están estrechamente relacionados entre sí y con la clase o componente en sí.
Niveles de cohesión
Funcional
Mayor
Comunicación
EquEsencial
Procedural
Temporal
utilidad
El acoplamiento es una indicación de la interdependencia relativa entre los módulos.
El acoplamiento depende de la complejidad de la interfaz entre los módulos, el punto en el que se realiza la entrada o la referencia a un módulo y los datos que pasan a través de la interfaz.
Vista convencional: el grado en que un componente está conectado a otros componentes y al mundo externo
Vista OO: una medida cualitativa del grado en que las clases están conectadas entre sí
Nivel de acoplamiento
Contenido
común
Control
Stamp
Datos
llamada de rutina
UseTipo de uso
Inclusión o importación
Externo #
La cohesión es una indicación de qué tan relacionadas y enfocadas están las responsabilidades de un elemento de software.
El acoplamiento se refiere a la fuerza con la que un elemento de software está conectado a otros elementos.
El elemento de software podría ser clase, paquete, componente, subsistema o un sistema. Y mientras se diseñan los sistemas, se recomienda tener elementos de software que tengan alta cohesión y soporte de acoplamiento bajo .
La baja cohesión da como resultado clases monolíticas que son difíciles de mantener, entender y reduce la reutilización. De manera similar, los resultados de High Coupling en clases que están estrechamente acoplados y los cambios no suelen ser locales, son difíciles de cambiar y reducen la reutilización.
Podemos tomar un escenario hipotético en el que estamos diseñando un ConnectionPool monitorizable típico con los siguientes requisitos. Tenga en cuenta que puede parecer demasiado para una clase simple como ConnectionPool pero la intención básica es simplemente demostrar un bajo acoplamiento y una alta cohesión con un ejemplo simple y creo que debería ayudar.
- apoyo para conseguir una conexión
- liberar una conexión
- Obtener estadísticas sobre la conexión vs el recuento de uso
- Obtener estadísticas sobre la conexión frente al tiempo
- Almacene la información de recuperación y liberación de la conexión en una base de datos para informarla más tarde.
Con una cohesión baja , podríamos diseñar una clase ConnectionPool rellenando a la fuerza todas estas funciones / responsabilidades en una sola clase como se muestra a continuación. Podemos ver que esta clase única es responsable de la administración de la conexión, la interacción con la base de datos y el mantenimiento de las estadísticas de conexión.
Con una alta cohesión , podemos asignar esta responsabilidad a través de las clases y hacer que sea más fácil de mantener y reutilizar.
Para demostrar el acoplamiento bajo , continuaremos con el diagrama de ConnectionPool alta cohesión anterior. Si observamos el diagrama anterior, aunque admite alta cohesión, ConnectionPool está estrechamente acoplado con la clase ConnectionStatistics y PersistentStore interactúa con ellos directamente. En lugar de reducir el acoplamiento, podríamos introducir una interfaz ConnectionListener y dejar que estas dos clases implementen la interfaz y permitirles registrarse con la clase ConnectionPool . Y ConnectionPool recorrerá estos escuchas y les notificará sobre los eventos de conexión y liberación de la conexión y permitirá un menor acoplamiento.
Nota / Palabra o Precaución: para este escenario simple puede parecer una exageración, pero si imaginamos un escenario en tiempo real en el que nuestra aplicación necesita interactuar con múltiples servicios de terceros para completar una transacción: Acople directamente nuestro código con los servicios de terceros significaría que cualquier cambio en el servicio de terceros podría resultar en cambios a nuestro código en múltiples lugares, en lugar de eso, podríamos tener Facade que interactúe con estos múltiples servicios internamente y cualquier cambio en los servicios se convierta en local a la Facade y imponga un bajo acoplamiento con el Servicios de terceros.