τTau SolutionsAspectos de calidad

Guía del aspecto: Acoplamiento

Actualizado el 15 de noviembre de 2026

El acoplamiento mide cuánto depende una parte del código de otras. Una clase está acoplada a otra cuando la nombra, la instancia, llama a sus métodos o la extiende. Cada una de esas uniones es un camino por el que un cambio se propaga: si cambia la clase usada, la que la usa puede tener que cambiar también.

La pregunta que contesta el aspecto es práctica: ¿qué se rompe si toco esto, y qué tengo que traerme si quiero usarlo en otro sitio? Un código poco acoplado se entiende por partes, se prueba con pocos dobles y se reutiliza sin arrastrar medio proyecto. Un código muy acoplado obliga a tenerlo todo en la cabeza a la vez.

Para quien empieza. Acoplamiento cero no es la meta: un programa cuyas piezas no se usan entre sí no hace nada. Lo que se busca es que las dependencias sean pocas, vayan en una dirección clara y apunten hacia lo que cambia poco.

Cuatro preguntas que separan unas métricas de otras

Casi todas las métricas de este aspecto cuentan aristas de un mismo grafo: quién depende de quién. Se distinguen por cómo responden a cuatro preguntas, y conviene tenerlas claras antes de comparar dos números.

  • ¿En qué sentido? Las dependencias que salen de un elemento (lo que usa: fan-out, Dcy, Ce) y las que llegan a él (quién lo usa: fan-in, Dpt, Ca) significan cosas distintas. Muchas dependencias salientes indican un elemento expuesto a cambios ajenos; muchas entrantes, un elemento del que el resto se fía y que por eso debe cambiar poco. El CBO de Chidamber y Kemerer junta los dos sentidos en un solo número.
  • ¿Qué se cuenta? Clases distintas (CBO, Dcy), métodos distintos (RFC), llamadas una a una (MPC, CALL) o paquetes (PDcy, PDpt). Una clase que llama doscientas veces a otra suma 1 en CBO y 200 en MPC.
  • ¿A qué distancia? Las dependencias directas (Dcy) o todo lo alcanzable siguiendo la cadena (Dcy*, PDcy*). La versión transitiva mide el radio de impacto real de un cambio; la directa, lo que se ve al leer el código.
  • ¿En qué nivel? Método, clase, paquete o proyecto. El mismo razonamiento se repite en cada nivel con otros nombres: lo que Dcy y Dpt son para una clase, Ce y Ca lo son para un paquete.

Por dónde empezar

Tres métricas cubren lo esencial; son también las que el catálogo de Stau Metro marca como esenciales en este aspecto.

  1. «Acoplamiento entre objetos» (CBO): con cuántas clases está conectada una clase. Es la medida clásica por clase. Stau Metro avisa por encima de 13 y da error por encima de 20.
  2. «Respuesta para la clase» (RFC): cuántos métodos distintos pueden ponerse en marcha al usar la clase. Completa al CBO mirando métodos en lugar de clases. Stau Metro avisa por encima de 50 y da error por encima de 100.
  3. «Número de dependencias cíclicas» (Cyclic), a nivel de paquete: si un paquete forma ciclo con otros. Un ciclo hace que sus miembros solo se puedan entender, probar y publicar juntos. En paquetes, Stau Metro da error por encima de 0.

Con eso localizas las clases más conectadas y los nudos entre paquetes. El siguiente paso suele ser el diseño de paquetes: los «acoplamientos aferentes» (Ca) y «eferentes» (Ce) alimentan la inestabilidad y la distancia a la secuencia principal, que tienen su propia guía en «Diseño de paquetes».

Todas las métricas del aspecto

«Sí» en la última columna quiere decir que Stau Metro la calcula; los umbrales son los de referencia del plugin, que se superan de forma estricta. Las métricas que el plugin no calcula están al final de la tabla.

Métrica Sigla Nivel Qué cuenta Stau Metro
«Número de llamadas a métodos» CALL método llamadas y new escritos en el método, cada aparición sí
«Número de veces invocado» CALLED método sitios del proyecto que llaman al método, también a través de sus supertipos sí
«Número de veces invocado en código de producción» CALLEDp método lo mismo, sin las llamadas desde los tests sí
«Acoplamiento entre objetos» CBO clase clases distintas que usa o que la usan; aviso > 13, error > 20 sí
«Acoplamiento entre objetos de una interfaz» CBO interfaz el mismo recuento en una interfaz, donde un valor alto es normal sí
«Respuesta para la clase» RFC clase métodos propios más métodos distintos que llaman; aviso > 50, error > 100 sí
«Acoplamiento por paso de mensajes» MPC clase llamadas a métodos del código de la clase, cada aparición sí
«Número de dependencias» Dcy clase, interfaz clases distintas que nombra directamente sí
«Número de dependientes» Dpt clase, interfaz clases distintas que la nombran sí
«Número de dependencias transitivas» Dcy* clase, interfaz clases alcanzables siguiendo sus dependencias sí
«Número de dependientes transitivos» Dpt* clase, interfaz clases que pueden verse afectadas por un cambio en ella sí
«Número de dependencias de paquete» PDcy clase, interfaz paquetes en los que están sus dependencias sí
«Número de paquetes dependientes» PDpt clase, interfaz paquetes en los que están sus dependientes sí
«Acoplamientos aferentes» Ca paquete clases de fuera que dependen del paquete sí
«Acoplamientos eferentes» Ce paquete clases del paquete que dependen de fuera sí
«Número de dependencias de paquete» PDcy paquete otros paquetes de los que depende sí
«Número de paquetes dependientes» PDpt paquete otros paquetes que dependen de él sí
«Número de dependencias transitivas de paquete» PDcy* paquete paquetes alcanzables a cualquier distancia sí
«Número de paquetes dependientes transitivamente» PDpt* paquete paquetes que llegan a él a cualquier distancia sí
«Número de dependencias cíclicas» Cyclic clase, interfaz, paquete con cuántos elementos forma ciclo; en paquetes, error > 0 sí
«Orden de nivel» Level clase, interfaz, paquete cuántos pisos de dependencias tiene debajo sí
«Orden de nivel ajustado» Level* clase, interfaz, paquete el nivel, con cada ciclo sumando tantos pisos como miembros sí
«Factor de acoplamiento» CF proyecto proporción de las dependencias posibles entre clases que existen, sin herencia sí
«Fan-in y fan-out» método, clase quién llama a quién: la idea general de la que salen muchas de las anteriores no
«Flujo de información de Henry y Kafura» IFC método longitud por el cuadrado de fan-in por fan-out informacionales no
«Acoplamiento por abstracción de datos» DAC clase atributos cuyo tipo es otra clase del sistema no
«Dependencia acumulada de componentes» CCD conjunto de componentes suma de lo que arrastra cada componente para probarse no

Cómo se combinan

Primero el sentido, luego el remedio. Un CBO alto no dice si la clase usa mucho o es muy usada, y los arreglos son opuestos. Léelo junto a Dcy y Dpt: una clase con muchas dependencias suele hacer demasiado y se arregla partiéndola o haciéndola depender de interfaces; una clase con muchos dependientes es una pieza central que tiene que ser estable, y lo que se vigila es cuánto cambia.

Clases, métodos y llamadas. CBO, RFC y MPC miden la misma colaboración con tres unidades. Un MPC alto con un CBO bajo es una clase que habla mucho con pocas; un RFC alto con un CBO bajo suele ser una clase grande o una que usa mucho una biblioteca, porque el RFC cuenta los métodos propios y los de bibliotecas. A nivel de método, CALL y CALLED son el fan-out y el fan-in en sitios de llamada.

Directo frente a transitivo. Dcy dice lo que ves en el código; Dcy*, lo que de verdad arrastras. Una clase con Dcy = 3 puede tener Dcy* = 300 si una de esas tres es la puerta a todo el sistema. Dpt* y PDpt* son la estimación más directa del radio de impacto de un cambio.

Ciclos y niveles. Cyclic dice si un elemento está en un ciclo y con cuántos. Level ordena el código en pisos, de lo que no depende de nada hacia arriba, y trata cada ciclo como un solo piso; Level* le suma el tamaño del ciclo, así que la diferencia entre los dos muestra cuánto pesan los ciclos. Un ciclo grande también dispara los valores transitivos: cada miembro alcanza a todos los demás.

Del elemento al sistema. CF resume el proyecto en una proporción. No dice dónde está el problema; para eso se baja a Dcy, Dpt y CBO. Como su denominador crece con el cuadrado del número de clases, sirve para seguir un mismo proyecto en el tiempo, no para comparar proyectos de tamaños muy distintos.

Con otros aspectos. El acoplamiento se lee casi siempre junto a la «cohesión»: una clase poco cohesionada suele estar muy acoplada, porque cada una de sus responsabilidades trae sus propias dependencias. Y junto al «tamaño»: las clases grandes tienen más de todo, también dependencias.

Los mismos nombres no cuentan lo mismo

Pocas siglas cambian tanto de una herramienta a otra como las de este aspecto. Antes de aplicar un umbral publicado o de comparar dos informes, comprueba qué cuenta cada uno. Las diferencias más frecuentes, todas descritas en las páginas de cada métrica:

  • CBO en uno o en dos sentidos. La definición de 1994 une las clases usadas y las usuarias. La herramienta CK de Aniche da un CBO de solo salientes y otro, CBO Modified, en los dos sentidos; la regla CouplingBetweenObjects de PMD cuenta solo los tipos de atributos, variables locales y tipos de retorno; ClassFanOutComplexity de Checkstyle cuenta solo salientes e ignora java.lang y otras clases corrientes. Stau Metro usa los dos sentidos.
  • Ca y Ce en clases o en paquetes. Martin contaba clases; JDepend cuenta paquetes. Lo que JDepend llama Ca y Ce es lo que aquí se llama PDpt y PDcy. El Ce de NDepend por ensamblado cuenta los tipos de fuera que se usan, no las clases propias que los usan.
  • Qué es una dependencia. Unas herramientas cuentan cualquier mención de un tipo (campos, parámetros, new, conversiones, anotaciones, argumentos genéricos); otras, solo declaraciones o solo llamadas. Unas leen el código fuente y otras el bytecode, que incluye o no las bibliotecas según los filtros.
  • Qué alcance. El lado de los dependientes depende de lo que se analiza: el CBO en dos sentidos, Dpt o Ca de una clase cambian si se mide un módulo solo o el proyecto entero.

En Stau Metro, las métricas de paquete (Ca, Ce, PDcy, PDpt y sus transitivas, Cyclic y Level de paquete) dejan fuera las dependencias desde o hacia clases de test, mientras que las de clase (CBO, Dcy, Dpt) sí cuentan las clases de test que estén en el ámbito analizado. Ninguna de las métricas de dependencias (CBO, Dcy, Dpt, Ca, Ce y sus derivadas) cuenta las clases de bibliotecas compiladas; RFC y MPC, en cambio, sí cuentan las llamadas a métodos de bibliotecas.

Qué no miden

  • El acoplamiento que no está escrito en el código. Reflexión, inyección de dependencias configurada fuera del código, mensajes por nombre, contratos de una API remota o un esquema de base de datos compartido unen piezas que ningún análisis estático ve. Bajar el CBO a base de Object, Map<String, Object> o reflexión esconde el acoplamiento sin quitarlo.
  • El acoplamiento que solo se ve en el historial. Dos ficheros que cambian siempre juntos están acoplados aunque no se nombren. Eso lo mide el «acoplamiento de cambio», del aspecto «Evolución del código».
  • La calidad de la dependencia. Depender de una interfaz estable y depender de una clase concreta que cambia cada semana suman lo mismo. La dirección respecto a la estabilidad la miran las métricas de «Diseño de paquetes».
  • La intensidad, salvo en las que cuentan llamadas. CBO, Dcy y sus parientes cuentan clases distintas: una mención y doscientas pesan igual.
  • La herencia como mecanismo. CF la excluye a propósito; para medirla están las métricas de «Herencia y polimorfismo».

Para profundizar

Origen. Los conceptos de acoplamiento y cohesión vienen del diseño estructurado. Constantine los desarrolló a mediados de los años sesenta y los publicó por primera vez en 1968; el artículo «Structured Design» de Stevens, Myers y Constantine (1974) los explicó de forma más completa y es el que se cita como origen. Las métricas de fan-in y fan-out de Yourdon y Constantine y la complejidad de flujo de información de Henry y Kafura (1981) son de esa misma época, sobre procedimientos. Con la orientación a objetos llegaron el CBO y el RFC de «Chidamber y Kemerer» (1991, 1994), el MPC y el DAC de «Li y Henry» (1993), el CF de «MOOD» (1994-1995) y las métricas de paquetes de «Martin» (1994). Lakos (1996) aportó la nivelación y la CCD, centradas en cuánto hay que construir y probar junto.

Un marco para ordenarlas. Briand, Daly y Wüst (1999) revisaron las medidas de acoplamiento orientadas a objetos publicadas hasta entonces, les dieron una terminología y un formalismo comunes y las clasificaron en un marco unificado. Una de sus observaciones es que muchas no estaban definidas de forma operativa, es decir, con detalle suficiente para que dos personas las calculen igual. De su formalización salen variantes que aparecen en las páginas de métrica, como el CBO′ sin herencia o el RFC′ que sigue las llamadas a cualquier profundidad.

Evidencia empírica. Basili, Briand y Melo (1996) encontraron que el CBO y el RFC eran predictores significativos de las clases con fallos en ocho sistemas en C++ hechos por equipos de estudiantes. El Emam, Benlarbi, Goel y Rai (2001) mostraron después que, en sus datos, la asociación de las métricas de Chidamber y Kemerer con los fallos desaparecía al controlar el tamaño de la clase. La consecuencia para el uso diario: lee el acoplamiento junto a una medida de tamaño y sospecha cuando las dos señalan las mismas clases. Las páginas de cada métrica recogen el detalle de estos estudios.

Referencias

  • Stevens, W. P., Myers, G. J. y Constantine, L. L. (1974). «Structured Design». IBM Systems Journal, 13(2), 115-139.
  • IEEE Computer Society, «Larry L. Constantine» (origen y primera publicación de acoplamiento y cohesión): https://history.computer.org/pioneers/constantine.html
  • Yourdon, E. y Constantine, L. L. (1979). Structured Design: Fundamentals of a Discipline of Computer Program and Systems Design. Prentice-Hall (1.ª ed., Yourdon Press, 1975).
  • Henry, S. y Kafura, D. (1981). «Software Structure Metrics Based on Information Flow». IEEE Transactions on Software Engineering, SE-7(5), 510-518. https://doi.org/10.1109/TSE.1981.231113
  • Chidamber, S. R. y Kemerer, C. F. (1994). «A Metrics Suite for Object Oriented Design». IEEE Transactions on Software Engineering, 20(6), 476-493. https://doi.org/10.1109/32.295895
  • Li, W. y Henry, S. (1993). «Object-Oriented Metrics that Predict Maintainability». Journal of Systems and Software, 23(2), 111-122. https://doi.org/10.1016/0164-1212(93)90077-B
  • Martin, R. C. (1994). «OO Design Quality Metrics: An Analysis of Dependencies». Artículo fechado el 14 de agosto de 1994.
  • Lakos, J. (1996). Large-Scale C++ Software Design. Addison-Wesley.
  • Briand, L. C., Daly, J. W. y Wüst, J. K. (1999). «A Unified Framework for Coupling Measurement in Object-Oriented Systems». IEEE Transactions on Software Engineering, 25(1), 91-121. https://doi.org/10.1109/32.748920
  • Basili, V. R., Briand, L. C. y Melo, W. L. (1996). «A Validation of Object-Oriented Design Metrics as Quality Indicators». IEEE Transactions on Software Engineering, 22(10), 751-761.
  • El Emam, K., Benlarbi, S., Goel, N. y Rai, S. N. (2001). «The Confounding Effect of Class Size on the Validity of Object-Oriented Metrics». IEEE Transactions on Software Engineering, 27(7), 630-650.