Acoplamiento entre objetos

Actualizado el 15 de noviembre de 2026

Sigla CBO
Aspecto «Acoplamiento»
Se mide en clase
Tipo de valor entero, mínimo 0: número de clases distintas acopladas con la clase
Dirección más alto es peor
Umbrales de referencia aviso por encima de 13, error por encima de 20 (Stau Metro)
Origen Shyam R. Chidamber y Chris F. Kemerer, 1994
Familia «Métricas de Chidamber y Kemerer»
Stau Metro CouplingBetweenObjectsClass

En pocas palabras

Cuenta con cuántas otras clases está conectada una clase: las que usa y las que la usan a ella. Cada clase cuenta una sola vez, aunque se use cien veces. Una clase con un CBO alto es difícil de cambiar, de probar y de reutilizar sola, porque arrastra a muchas otras y muchas otras dependen de ella.

Qué mide

Mide el acoplamiento de una clase: lo enredada que está con el resto del sistema. Dos clases están acopladas cuando una actúa sobre la otra, es decir, cuando una llama a métodos de la otra, lee sus campos o la usa como tipo.

El acoplamiento importa por tres razones prácticas:

  • Cambio. Si una clase depende de muchas, cualquier cambio en una de ellas puede obligar a tocarla. Si muchas dependen de ella, cambiarla tiene un efecto amplio.
  • Tests. Para probar una clase de forma aislada hay que sustituir, o al menos construir, las clases que usa. Cada dependencia es un doble de test más o un objeto más que preparar.
  • Comprensión y reutilización. Para entender una clase hay que entender, al menos por encima, aquello con lo que habla. Una clase muy acoplada no se puede sacar de su contexto.

Para quien empieza. Una dependencia de una clase A es otra clase que aparece en su código: como tipo de un campo o de un parámetro, en un new, en una llamada. Un dependiente de A es una clase en cuyo código aparece A. El CBO es el número de clases que son una cosa, la otra o las dos.

Cómo se calcula

Chidamber y Kemerer definieron el CBO de una clase como el número de otras clases con las que está acoplada. En su formulación, un objeto está acoplado a otro si uno de los dos actúa sobre el otro, es decir, si los métodos de uno usan métodos o variables de instancia del otro. La relación se mira en los dos sentidos, pero cada clase se cuenta una sola vez (así la formalizan también Briand, Daly y Wüst, 1999):

CBO(C)=∣Dependencias(C)∪Dependientes(C)∣CBO(C) = \left| \text{Dependencias}(C) \cup \text{Dependientes}(C) \right|

donde Dependencias(C)\text{Dependencias}(C) son las clases que CC usa y Dependientes(C)\text{Dependientes}(C), las que usan a CC. La propia clase no entra.

Lo que la definición deja abierto o ha cambiado, y donde las herramientas se separan, es:

  • Qué es «usar». Solo llamadas y acceso a campos, o cualquier mención del tipo (declaraciones, extends, conversiones, anotaciones, argumentos genéricos).
  • Herencia. La primera versión (1991) contaba solo los acoplamientos no relacionados con la herencia; la de 1994 quita esa restricción y, según Briand, Daly y Wüst, incluye de forma expresa el acoplamiento debido a la herencia. Unas herramientas cuentan la superclase como una clase acoplada más y otras la excluyen.
  • Sentido. Muchas herramientas solo cuentan las dependencias (el fan-out) y llaman a eso CBO.
  • Bibliotecas. Si String o List cuentan como clases acopladas.

Ejemplo

class Customer { }

class Order {
    Order(Customer customer) { }
}

interface OrderRepository {
    void save(Order order);
}

class OrderService {
    private final OrderRepository repository;      // usa OrderRepository

    OrderService(OrderRepository repository) {
        this.repository = repository;
    }

    Order place(Customer customer, String note) {  // usa Order y Customer; String no cuenta
        Order order = new Order(customer);
        repository.save(order);
        return order;
    }
}

class OrderController {
    private final OrderService service;            // OrderController usa OrderService
    OrderController(OrderService service) { this.service = service; }
}

Para OrderService:

  • dependencias: OrderRepository, Order, Customer (3);
  • dependientes: OrderController (1);
  • String es una clase del JDK: Stau Metro no la cuenta.

Total: 3 + 1 = 4. Si Order tuviera también un campo de tipo OrderService, el valor seguiría siendo 4: Order ya estaba contada.

Cómo interpretarla

Un valor alto dice que la clase está conectada con muchas otras. No dice en qué sentido: compara con el «número de dependencias» y el «número de dependientes» para saberlo, porque el remedio es distinto.

  • Muchas dependencias (la clase usa mucho): suele ser una clase que hace demasiado, un orquestador que conoce todos los detalles o un método largo que lo resuelve todo en línea.
  • Muchos dependientes (la clase es muy usada): es lo esperable en una clase de utilidad, un tipo de valor (Money, UserId) o una entidad central del dominio. No es malo por sí mismo, pero esa clase tiene que ser estable.

Stau Metro usa como referencia aviso por encima de 13 y error por encima de 20. Ninguno de los dos procede de una fuente publicada; compara también el valor con el del resto del proyecto. Las cifras que traen otras herramientas no son comparables sin más, porque miden otra cosa (ver «En las herramientas»).

Qué hacer con un valor alto:

  • Divide la clase por responsabilidades. Si los métodos usan grupos de clases distintos, cada grupo es candidato a una clase propia; la «falta de cohesión» suele señalar lo mismo.
  • Depende de abstracciones. Una interfaz pequeña en lugar de varias clases concretas reduce el número de clases conocidas y facilita los dobles de test.
  • Mueve el comportamiento junto a los datos. Una clase que lee campos de muchas otras para decidir algo suele tener lógica que pertenece a esas otras.

Cuándo un valor alto es aceptable. Las clases de composición (las que construyen y conectan los objetos de la aplicación), los controladores de entrada y los tipos de dominio muy usados tienen un CBO alto por su función.

Ojo. Bajar el CBO a base de usar Object, Map<String, Object> o reflexión esconde el acoplamiento sin quitarlo: la dependencia sigue ahí, pero ya no la ve ni la herramienta ni el compilador.

Para profundizar

Cuenta clases, no intensidad. Una clase que llama doscientas veces a otra suma lo mismo que una que la menciona una vez. Para el volumen de llamadas está el «acoplamiento por paso de mensajes» (MPC); para el acoplamiento a través de los tipos de los atributos, el «acoplamiento por abstracción de datos» (DAC).

Variantes. En la práctica conviven al menos tres lecturas:

  • Solo salientes (fan-out): las clases que la clase usa. Es la más común en las herramientas.
  • En los dos sentidos: unión de usadas y usuarias, como en la definición de 1994.
  • Sin herencia: excluye los ancestros, como la versión de 1991, para no mezclar acoplamiento y herencia, que ya mide la «profundidad del árbol de herencia». Briand, Daly y Wüst la llaman CBO′.

Como el lado de los dependientes depende de qué se analiza, el CBO en los dos sentidos de una clase cambia si se mide un módulo solo o el proyecto entero. El de solo salientes no.

Propiedades y falseo. Según Briand, Daly y Wüst, al fusionar dos clases sin relación entre sí el acoplamiento debería sumarse, pero el CBO de la clase fusionada puede ser menor: una clase acoplada con las dos cuenta una sola vez. Fusionar clases que se usan entre sí lo baja más aún. Fusionar, o meter clases como anidadas en otra en una herramienta que no las distinga, mejora el número y empeora el diseño.

Evidencia empírica. Basili, Briand y Melo (1996) estudiaron ocho sistemas en C++ desarrollados por equipos de estudiantes y encontraron que el CBO era un predictor significativo de las clases con fallos, sobre todo en las de interfaz de usuario. El Emam, Benlarbi, Goel y Rai (2001) mostraron después que, en sus datos, las métricas de Chidamber y Kemerer dejaban de asociarse con los fallos al controlar el tamaño de la clase. Leer el CBO junto a una medida de tamaño evita atribuir al acoplamiento lo que es solo volumen.

Relación con otras métricas

En las herramientas

Antes de aplicar un umbral publicado conviene saber qué cuenta cada herramienta: unas cuentan clases en los dos sentidos, otras solo las salientes, y otras tipos de cualquier origen.

Stau Metro (CouplingBetweenObjectsClass, a nivel de clase). Une las clases que cuentan el «número de dependencias» y el «número de dependientes», cada una una vez.

  • Se mide en las clases con nombre: también clases abstractas, enumerados, records y clases anidadas. No se mide en interfaces ni en anotaciones (las interfaces tienen su propia página), ni en clases anónimas o locales.
  • Una clase usa otra cuando la nombra como supertipo, como tipo de un campo, parámetro, variable local o catch, como tipo de retorno o en throws, en un new, una conversión, un instanceof, un patrón de deconstrucción o X.class, como anotación o argumento genérico (también cotas de parámetros de tipo), cuando llama a uno de sus métodos, lee uno de sus campos, la usa en una referencia a método o es la interfaz funcional de una lambda. Los comentarios y los import no cuentan.
  • La herencia cuenta: la superclase y las interfaces implementadas son dependencias, y la clase es dependiente de ellas.
  • Lo que hacen las clases anónimas y locales se atribuye a la clase con nombre que las contiene. Una clase anidada con nombre es una clase distinta: sus usos no suman a la exterior, y la exterior y su anidada pueden estar acopladas entre sí.
  • Solo cuentan clases con código fuente en el proyecto: las del JDK y las de bibliotecas quedan fuera. Una dependencia hacia una clase del proyecto que está fuera del ámbito analizado sí cuenta; los dependientes solo se buscan dentro del ámbito analizado.
  • Si el ámbito incluye código de test, las clases de test que usan una clase cuentan como dependientes suyos.

CK (Aniche). Su CBO cuenta las dependencias de una clase, considerando cualquier tipo usado en toda la clase, e ignora las dependencias a Java (como java.lang.String). Ofrece además CBO Modified, que su documentación presenta como muy parecida a ese CBO pero considerando tanto las referencias que la clase hace como las que recibe: es la lectura en los dos sentidos. Da también FAN-IN y FAN-OUT por separado.

PMD (regla CouplingBetweenObjects). Cuenta los tipos únicos de los atributos, variables locales y tipos de retorno de una clase, y avisa por encima de un umbral de 20. Mide solo un sentido y solo declaraciones.

Checkstyle (ClassFanOutComplexity). No se llama CBO, pero es la medida más próxima: el número de otros tipos de los que depende una clase, con un máximo por defecto de 20. Ignora java.lang y una lista de clases comunes (String, List, Integer…).

Referencias

  • Chidamber, S. R. y Kemerer, C. F. (1991). «Towards a Metrics Suite for Object Oriented Design». OOPSLA '91, 197-211.
  • 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
  • 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.
  • CK, métricas de código Java de Maurício Aniche: https://github.com/mauricioaniche/ck
  • PMD, reglas de diseño para Java: https://docs.pmd-code.org/latest/pmd_rules_java_design.html
  • Checkstyle, comprobación ClassFanOutComplexity: https://checkstyle.sourceforge.io/checks/metrics/classfanoutcomplexity.html