¿Cuál es la diferencia entre cohesión y acoplamiento?

¿Cómo puede el acoplamiento y la cohesión conducir a un diseño de software bueno o malo?

¿Cuáles son algunos ejemplos que describen la diferencia entre los dos y su impacto en la calidad general del código?

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 estar haciendo, es decir, solo en 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 la relación o dependencia de dos clases / módulos entre sí. Para las clases de bajo acoplamiento, cambiar algo importante en una clase no debería afectar a la otra. Un acoplamiento elevado dificultaría el cambio y mantenimiento de su código; Dado que las clases están estrechamente unidas, realizar un cambio podría requerir una renovación completa del sistema.

Un buen diseño de software tiene alta cohesión y bajo acoplamiento .

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 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 enfoca 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 única) con poca interacción con otros módulos del sistema.
• La cohesión es el tipo de extensión natural de la ocultación de datos, por ejemplo, la clase tiene todos los miembros visibles con un paquete que tiene visibilidad predeterminada. La cohesión es Intra - Concepto de módulo.

Acoplamiento

• El acoplamiento es la indicación de las relaciones entre módulos.
• El acoplamiento muestra la dependencia / interdependencia relativa entre los módulos.
• El acoplamiento es un grado en el cual un componente / módulo está conectado a los otros módulos.
• Mientras diseña, debe luchar por un bajo acoplamiento, es decir, la dependencia entre los módulos debe ser menor
• Hacer campos privados, métodos privados y clases no públicas proporciona un acoplamiento flexible.
• El acoplamiento es el concepto entre módulos.

mira este enlace

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 Java debe tener una alta cohesión interna, pero debe estar lo más libremente posible acoplado al código en otras clases Java.

El Capítulo 3 de la Construcción de software orientado a objetos de Meyer (segunda edición) es una excelente descripción de estos problemas.

La cohesión es una indicación de cuán 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 al diseñar los sistemas, se recomienda tener elementos de software que tengan alta cohesión y soporte de bajo acoplamiento .

La baja cohesión da como resultado clases monolíticas que son difíciles de mantener, comprender y reduce la reutilización. Del mismo modo, el acoplamiento alto da como resultado clases que están estrechamente acopladas y los cambios no suelen ser no locales, difíciles de cambiar y reducen la reutilización.

Podemos tomar un escenario hipotético en el que estamos diseñando un monitor típico ConnectionPoolcon los siguientes requisitos. Tenga en cuenta que puede parecer demasiado para una clase simple como, ConnectionPoolpero la intención básica es demostrar un bajo acoplamiento y una alta cohesión con algún ejemplo simple y creo que debería ayudar.

1. apoyo para obtener una conexión
2. liberar una conexión
3. obtener estadísticas sobre el recuento de conexión vs uso
4. obtener estadísticas sobre conexión vs tiempo
5. Almacene la información de recuperación y liberación de la conexión en una base de datos para informar más adelante.

Con poca cohesión , podríamos diseñar una ConnectionPoolclase al forzar toda esta funcionalidad / 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, interactuando con la base de datos y manteniendo las estadísticas de conexión.

Con alta cohesión podemos asignar esta responsabilidad en todas las clases y hacerla más sostenible y reutilizable.

Para demostrar el acoplamiento bajo , continuaremos con el ConnectionPooldiagrama de alta cohesión anterior. Si miramos el diagrama anterior aunque admite una alta cohesión, ConnectionPoolestá estrechamente unido a la ConnectionStatisticsclase e PersistentStoreinteractúa con ellos directamente. En lugar de reducir el acoplamiento, podríamos introducir una ConnectionListenerinterfaz y dejar que estas dos clases implementen la interfaz y que se registren con la ConnectionPoolclase. Y ConnectionPooliterará a través de estos oyentes y les notificará sobre los eventos de conexión y descarga y permite 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 donde nuestra aplicación necesita interactuar con múltiples servicios de terceros para completar una transacción: Acoplando directamente nuestro código con los servicios de terceros significaría que cualquier cambio en el servicio de terceros podría dar lugar a cambios en nuestro código en varios lugares, en su lugar podríamos tener Facadeque interactúe con estos servicios múltiples internamente y cualquier cambio en los servicios se vuelva local Facadey obligue a un bajo acoplamiento con el tercero servicios.

El aumento de la cohesión y la disminución del acoplamiento conducen a un buen diseño de software.

Cohesión divide su funcionalidad para que sea concisa y más cercana a los datos relevantes para ella, mientras que el desacoplamiento asegura 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 asegura 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' entre sí a través de la interfaz o interfaces que implementan. La implementación de una interfaz introduce cohesión como una consecuencia natural.

Si bien no es realista en algunos senarios, debería ser un objetivo de diseño para trabajar.

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 }
}

En algún otro lugar de su base de código, podría tener un módulo que procese preguntas independientemente de lo que sean:

public class OtherModuleProcessor {
    public void Process(List<IStackoverflowQuestion> 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 máximamente cohesiva.

En general, no es aconsejable ni posible crear tales clases de máxima cohesión; Por otro lado, nos gustaría que la cohesión sea 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 las funciones pequeñas y mantener las listas de parámetros cortas a veces puede conducir 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 tratando de salir de la clase más grande. Debe intentar separar las variables y los métodos en dos o más clases, de modo que las nuevas clases sean más coherentes.

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 otras. 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, la 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, consiste en 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:

Ideal es el código que sigue la directriz. Está suelto y altamente cohesivo. Podemos ilustrar dicho código con esta imagen:

God Object es el resultado de introducir 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: mal seleccionado tiene lugar cuando los límites entre diferentes clases o módulos se seleccionan mal

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 foco:

lee más aquí

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.

Acoplando en palabras simples, es cuánto sabe un componente (de nuevo, imagine una clase, aunque no necesariamente) 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 quieres leer un poco más detalles con ejemplos y dibujos. Creo que responde la mayoría de tus preguntas.

la cohesión se refiere a cómo se diseña una sola clase La cohesión es el principio orientado a objetos más estrechamente asociado a garantizar que una clase esté diseñada con un único propósito bien enfocado. Cuanto más enfocada está una clase, más cohesiva es esa clase. Las ventajas de la alta cohesión es que tales clases son mucho más fáciles de mantener (y cambian con menos frecuencia) que las clases con baja cohesión. Otro beneficio de la alta cohesión es que las clases con un propósito bien enfocado tienden a ser más reutilizables que otras clases.

En la imagen de arriba, podemos ver que en baja cohesión, solo una clase es responsable de ejecutar muchos trabajos que no son comunes, lo que reduce la posibilidad de reutilización y mantenimiento. Pero en alta cohesión hay una clase separada para todos los trabajos para ejecutar un trabajo específico, lo que resulta en una mejor usabilidad y mantenimiento.

Cohesión ( Cohesión ): Co que significa juntos , hesion que significa pegarse . El sistema de pegado de 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.

• La cohesión es un tipo de medida ordinal y generalmente se describe como "alta cohesión" o "baja cohesión". Los módulos con alta cohesión tienden a ser preferibles, porque la alta cohesión está asociada con varios rasgos deseables de software, incluyendo robustez, confiabilidad, reutilización y comprensibilidad. En contraste, la baja cohesión se asocia con rasgos indeseables, como ser difíciles de mantener, probar, reutilizar o incluso comprender. wiki

• El acoplamiento generalmente se contrasta con la cohesión . El bajo acoplamiento a menudo se correlaciona con una alta cohesión, y viceversa. El bajo acoplamiento a menudo es un signo de un sistema informático bien estructurado y un buen diseño, y cuando se combina con una alta cohesión, respalda los objetivos generales de alta legibilidad y facilidad de mantenimiento. wiki

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.

En esta publicación de blog escribo sobre ello con más detalle.

La cohesión es una indicación de la fuerza funcional relativa de un módulo.

• Un módulo cohesivo realiza una única tarea, que requiere poca interacción con otros componentes en otras partes de un programa. En pocas palabras, un módulo cohesivo debería (idealmente) hacer solo una cosa.

• Vista convencional:

  la "mentalidad única" de un módulo

• OO vista:

  La cohesión implica que un componente o clase encapsula solo atributos y operaciones que están estrechamente relacionados entre sí y con la clase o componente en sí.

• Niveles de cohesión

  Funcional

  Capas

  Comunicacional

  Secuencial

  Procedimiento

  Temporal

  utilidad

El acoplamiento es una indicación de la relativa interdependencia entre 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 referencia a un módulo y qué datos 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

  Sellos

  Datos

   Llamada de rutina

  Uso de tipo

  Inclusión o importación

  Externo #

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. Considere que 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 usa como entrada para otro programa. Esto se llama 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.

En pocas palabras, la cohesión significa que una clase debe representar un concepto único.

La interfaz pública de una clase es coherente 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, tener las características CashRegister y Coin lo convierte en 2 clases: CashRegister y Coin.

En el acoplamiento , una clase depende de otra, ya que utiliza los objetos de la clase.

El problema con el alto acoplamiento 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.

En general, la alta cohesión y el bajo acoplamiento se consideran OOP de alta calidad.

El término cohesión es, de hecho, un poco contrario a la intuición de lo que significa en el diseño de software.

El significado común de cohesión es que algo que se une bien, está unido, que se caracterizan por un fuerte vínculo como la atracción molecular. Sin embargo, en el diseño de software, significa luchar por una clase que idealmente solo haga una cosa, de modo que ni siquiera intervienen múltiples submódulos.

Quizás podamos pensarlo de esta manera. Una parte tiene la mayor cohesión cuando es la única parte (solo hace una cosa y no puede desglosarse más). Esto es lo que se desea en el diseño de software. La cohesión simplemente es otro nombre para "responsabilidad única" o "separación de preocupaciones".

El término acoplamiento en la mano es bastante intuitivo, lo que significa que cuando un módulo no depende de muchos otros módulos y aquellos con los que se conecta se pueden reemplazar fácilmente, por ejemplo, obedeciendo el principio de sustitución de liskov .

Diferencia teórica

Cohesión

• La cohesión es una indicación de la fuerza funcional relativa del módulo.
• Un módulo cohesivo realiza una única tarea, que requiere poca interacción con otros componentes en otras partes del programa.
• Se dice que un módulo que tiene alta cohesión y bajo acoplamiento es funcionalmente independiente de otro módulo.

Clasificación de la cohesión

1.Coincidental 2.Lógico 3.Temporal 4.Procedural 5.Comunicación 6.Secuencial 7.Funcional

Acoplamiento

• El acoplamiento es una indicación de la relativa interdependencia entre los módulos.
• El grado de acoplamiento entre dos módulos depende de la complejidad de su interfaz.