Acoplamiento por abstracción de datos

Actualizado el 15 de noviembre de 2026

Sigla DAC (variante DAC')
Aspecto «Acoplamiento»
Se mide en clase
Tipo de valor recuento (entero, mínimo 0)
Dirección más alto es peor
Umbrales de referencia ninguno en la fuente original; 7 es el máximo por defecto de la comprobación de Checkstyle con ese nombre, que mide otra cosa (ver «En las herramientas»)
Origen Wei Li y Sallie Henry, 1993
Familia «Métricas de Li y Henry»
Stau Metro no la calcula

En pocas palabras

Cuenta cuántos de los campos de una clase son objetos de otras clases del propio programa. Una clase Invoice con un campo Customer y otro Address está atada a esas dos clases: para entenderla, construirla o probarla hay que saber cómo son. Cuantos más campos así tenga, más depende su estado de decisiones tomadas en otras partes.

Qué mide

El acoplamiento que nace de la composición: una clase que guarda como atributo un objeto de otra clase. Li y Henry partían de la idea de que una clase es la implementación de un tipo abstracto de datos (TAD, en inglés ADT). Cuando una clase X declara una variable cuyo tipo es otra clase, X puede acceder a las propiedades de ese TAD, y queda acoplada a él. Si el lenguaje deja acceder a las partes privadas del TAD, ese acoplamiento puede romper además la encapsulación.

Li y Henry propusieron DAC junto con «MPC» para separar dos formas de acoplamiento que la CBO de Chidamber y Kemerer junta en un solo número:

  • por paso de mensajes (MPC): la clase llama a métodos de otras;
  • por abstracción de datos (DAC): la clase contiene objetos de otras.

Una clase puede tener mucho de uno y nada del otro. Un servicio sin estado que delega en diez colaboradores recibidos por parámetro tiene MPC alto y DAC 0; una entidad con muchos campos de tipos propios y poca lógica, al revés.

Cómo se calcula

La definición original es breve: DAC es el número de TAD definidos en una clase. El texto aclara que se refiere al número de variables que tienen como tipo un TAD, es decir, otra clase.

Briand, Daly y Wüst (1999) la formalizaron y distinguieron dos lecturas, que hoy se citan con nombres propios. Con AI(c)A_I(c) los atributos declarados en la clase cc, T(a)T(a) el tipo del atributo aa y CC el conjunto de clases del sistema:

DAC(c)=∣{ a∈AI(c):T(a)∈C }∣DAC′(c)=∣{ T(a):a∈AI(c), T(a)∈C }∣\mathit{DAC}(c) = \big|\{\, a \in A_I(c) : T(a) \in C \,\}\big| \qquad \mathit{DAC'}(c) = \big|\{\, T(a) : a \in A_I(c),\ T(a) \in C \,\}\big|
  • DAC cuenta atributos: diez campos del tipo Money suman 10.
  • DAC' cuenta clases distintas: esos diez campos suman 1.

No cuentan los tipos primitivos ni, en la formalización de Briand y sus coautores, los tipos que no son clases del sistema analizado (la biblioteca estándar, las librerías). Solo cuentan los atributos declarados en la clase, no los heredados.

Ejemplo

record Address(String street, String city) {}
record Money(long cents) {}
final class Customer {}

final class Invoice {
    private Customer customer;          // DAC +1, DAC' +1 (Customer)
    private Address billingAddress;     // DAC +1, DAC' +1 (Address)
    private Address shippingAddress;    // DAC +1 (Address ya contada en DAC')
    private Money total;                // DAC +1, DAC' +1 (Money)
    private int lines;                  // primitivo: no cuenta
    private String notes;               // String no es una clase del sistema: no cuenta

    Invoice(Customer customer, Address address) {
        this.customer = customer;
        this.billingAddress = address;
        this.shippingAddress = address;
        this.total = new Money(0);
    }
}

DAC(Invoice)=1+1+1+1=4\mathit{DAC}(\texttt{Invoice}) = 1 + 1 + 1 + 1 = 4 y DAC′(Invoice)=3\mathit{DAC'}(\texttt{Invoice}) = 3 (Customer, Address, Money). Los parámetros del constructor no cuentan: no son atributos.

Cómo interpretarla

Un DAC alto dice que el estado de la clase está hecho de objetos de otras clases. Eso tiene un coste concreto: para crear una instancia en un test hay que crear o simular cada una de ellas, y un cambio en cualquiera de esas clases puede obligar a tocar esta.

No hay umbrales publicados para la definición de Li y Henry. Su estudio no buscaba un valor límite, sino comprobar si la métrica ayudaba a predecir el esfuerzo de mantenimiento (ver «Para profundizar»). Compara el valor con el del resto del proyecto.

Qué hacer con un valor alto:

  • Agrupa los campos que van juntos en un objeto de valor. Tres campos que siempre se leen y escriben a la vez (street, city, zip) piden ser una sola Address; DAC baja y la clase gana claridad.
  • Separa responsabilidades. Una clase cuyos campos se dividen en grupos que no se tocan entre sí suele ser dos clases; la «falta de cohesión» lo confirma.
  • Depende de abstracciones. Un campo cuyo tipo es una interfaz sigue contando, pero es más fácil de sustituir en un test que uno de una clase concreta.

Cuándo es aceptable. Las entidades de dominio, los records que agregan datos y los objetos de configuración existen para contener otros objetos; un DAC alto en ellos es su naturaleza, no un defecto. Tampoco es lo mismo contener objetos de valor inmutables (Money, Address) que servicios con estado.

Ojo. No confundas la DAC de Li y Henry con la comprobación ClassDataAbstractionCoupling de Checkstyle, que cuenta las clases que se instancian con new dentro de la clase, no los tipos de sus atributos.

Para profundizar

La validación original. Li y Henry midieron dos sistemas comerciales escritos en Classic-Ada, UIMS (39 clases) y QUES (71 clases), y tomaron como esfuerzo de mantenimiento el número de líneas cambiadas por clase a lo largo de tres años. En el informe técnico de 1993, un modelo de regresión con diez métricas (las de Chidamber y Kemerer salvo CBO, más MPC, DAC, NOM y dos de tamaño) explicaba el 91 % de la varianza en UIMS y el 87 % en QUES (R2R^2 de 0,9096 y 0,8737), frente al 66 % y el 63 % de un modelo solo con las dos métricas de tamaño. Una prueba F parcial rechazó que las métricas de diseño no añadieran nada al tamaño. DAC quedó en el modelo reducido final.

Son dos sistemas, de un mismo entorno y con pocas clases, y la contribución se mide para el conjunto de métricas, no para DAC sola. Briand, Daly y Wüst señalan además que algunos coeficientes del modelo cambian de signo entre un sistema y otro sin explicación de los autores.

Propiedades formales. Briand, Daly y Wüst comprobaron cinco propiedades que debería cumplir una medida de acoplamiento:

  • Ni DAC ni DAC' tienen un valor nulo coherente: una clase con un atributo de su propio tipo (un nodo de una lista enlazada, por ejemplo) tiene valor mayor que 0 aunque no esté acoplada con ninguna otra clase.
  • DAC es aditiva al fusionar dos clases sin relación: la suma se conserva. DAC' no lo es, porque una clase que aparece en las dos solo se cuenta una vez tras la fusión.

Atributos o clases. Contar atributos o contar clases distintas responde a preguntas diferentes, y Briand y sus coautores concluyen que no hay una sola forma correcta de contar la frecuencia de las conexiones: hay que elegir según el objetivo de la medición. DAC refleja cuánto del estado depende de otras clases; DAC' refleja de cuántas clases depende ese estado.

Más allá de los atributos. Briand, Daly y Wüst relacionan DAC con las medidas de interacción clase-atributo de Briand, Devanbu y Melo (1997), que también cuentan los atributos cuyo tipo es otra clase, pero por separado según la relación de herencia entre las dos clases (antecesoras, descendientes u otras). La misma familia tiene medidas de interacción clase-método, que cuentan los parámetros de los métodos cuyo tipo es otra clase. DAC se queda en los atributos.

Cómo se falsea. Declarar el campo con un tipo de biblioteca (Object, Map<String, Object>) o con un tipo genérico hace desaparecer el acoplamiento del recuento sin quitarlo del código.

Relación con otras métricas

En las herramientas

Stau Metro no calcula DAC. La métrica más cercana es el «número de dependencias» (Dcy, NumDependenciesClass), que cuenta las clases distintas a las que se refiere una clase; los tipos de sus campos son solo una de las referencias que suma, junto con la herencia, los parámetros, las variables locales, las clases instanciadas, las llamadas y otras. Es, por tanto, más amplia que DAC' y, como cuenta clases distintas, no equivale a DAC. Solo cuenta clases con código fuente, no las de bibliotecas compiladas, algo parecido a limitarse a las clases del sistema como en la formalización de Briand y sus coautores. El «acoplamiento entre objetos» (CBO) añade el sentido contrario.

Checkstyle (ClassDataAbstractionCoupling). Pese al nombre, cuenta el número de clases distintas que se instancian dentro de la clase o el record, no los tipos de sus atributos. El máximo por defecto es 7. Ignora por defecto una lista de clases corrientes (envoltorios, colecciones, String, excepciones habituales, Optional…) y todo el paquete java.lang; las listas se cambian con excludedClasses, excludedPackages y excludeClassesRegexps. En el ejemplo de arriba, Invoice solo instancia Money, así que su valor sería como mucho 1, frente a una DAC de 4: Customer y Address llegan por el constructor y no se crean dentro.

Referencias

  • 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
  • Li, W. y Henry, S. (1993). Object-Oriented Metrics Which Predict Maintainability. Informe técnico TR-93-05, Department of Computer Science, Virginia Polytechnic Institute and State University. http://hdl.handle.net/10919/19811
  • Briand, L. C., Daly, J. W. y Wüst, J. (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 (versión previa: informe técnico ISERN-96-14, Fraunhofer IESE).
  • Briand, L. C., Devanbu, P. y Melo, W. L. (1997). «An Investigation into Coupling Measures for C++». Proceedings of the 19th International Conference on Software Engineering (ICSE 1997), 412-421.
  • 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
  • Checkstyle, comprobación ClassDataAbstractionCoupling: https://checkstyle.org/checks/metrics/classdataabstractioncoupling.html