Número de dependencias

Actualizado el 15 de noviembre de 2026

Sigla Dcy
Aspecto «Acoplamiento»
Se mide en clase, interfaz
Tipo de valor valor numérico entero, mínimo 0: tamaño de un conjunto de clases distintas
Dirección más alto es peor
Stau Metro NumDependenciesClass, NumDependenciesInterface

En pocas palabras

Cuenta de cuántas otras clases del proyecto depende directamente una clase: las que extiende, las que guarda en sus campos, las que recibe o devuelve, las que instancia, aquellas a cuyos métodos llama. Cada clase se cuenta una vez, aunque se use cien veces. Cuantas más haya, más cosas tienes que conocer para entender o reutilizar esa clase, y más motivos hay para que un cambio ajeno la rompa.

Qué mide

Mide el acoplamiento de salida de un tipo: el número de elementos distintos del resto del código de los que depende. Una dependencia significa que, si la otra clase cambia o desaparece, esta puede dejar de compilar o de comportarse bien.

Importa por tres razones. Una clase con muchas dependencias es difícil de probar de forma aislada (hay que construir o simular todo lo que usa), difícil de reutilizar en otro sitio (arrastra su entorno) y frágil ante cambios ajenos. Un valor bajo no garantiza un buen diseño: una clase de datos sin comportamiento también depende de muy pocas.

Ojo. El valor cuenta clases distintas, no usos. Una clase que llama cincuenta veces a otra depende de ella una sola vez. Para contar usos, mira el «número de llamadas a métodos».

Cómo se calcula

Para una clase CC dentro del conjunto de código analizado:

Dcy(C)=∣{ D≠C∣C hace referencia a D }∣Dcy(C) = |\{\, D \neq C \mid C \text{ hace referencia a } D \,\}|

Es decir, el tamaño del conjunto de clases distintas de CC a las que CC hace referencia. Qué cuenta como «hacer referencia» cambia entre herramientas. En la métrica clásica CBO (Chidamber y Kemerer, 1994), dos clases están acopladas cuando los métodos de una usan métodos o variables de instancia de la otra. Lo que cuenta Stau Metro está en «En las herramientas».

Ejemplo

package shop;

import java.io.Serializable;
import java.util.List;
import shop.billing.BillingException;                              // los import no cuentan
import shop.billing.Invoice;
import shop.billing.Tax;
import shop.core.BaseEntity;
import shop.crm.Customer;

public class Order extends BaseEntity implements Serializable {   // BaseEntity (Serializable es de la biblioteca)
    private Customer customer;                                     // Customer
    private List<Item> items;                                      // Item, del mismo paquete (List es de la biblioteca)

    public Invoice bill() throws BillingException {                // Invoice, BillingException
        return new Invoice(this, Tax.rate(customer));              // Invoice (ya contada), Tax
    }
}

Las clases distintas a las que Order hace referencia, sin contar las de la biblioteca estándar, son BaseEntity, Customer, Item, Invoice, BillingException y Tax: Dcy(Order) = 6. Invoice aparece dos veces (tipo de retorno e instanciación) y cuenta una. List y Serializable no cuentan porque su código no está en el análisis, pero el argumento de tipo Item de List<Item> sí.

Cómo interpretarla

No hay un umbral publicado y Stau Metro tampoco trae uno de referencia. Úsala de forma comparativa:

  • Ordena las clases de un módulo por Dcy y mira las del extremo alto. Suelen ser clases que coordinan (un controlador, una fachada, un main), y eso es esperable, o clases que hacen demasiado.
  • Léela junto a la «cohesión»: una clase con muchas dependencias y poca cohesión suele mezclar responsabilidades.
  • Compárala con el «número de dependientes»: mucho Dcy y poco Dpt es una clase de la capa alta de la aplicación, de la que casi nadie depende; poco Dcy y mucho Dpt es una base estable.

Para reducir un valor alto: extrae responsabilidades a otras clases e introduce una interfaz que oculte varias clases concretas. Si los campos y parámetros tienen el tipo de la interfaz, la dependencia es solo con ella.

Un valor alto es aceptable en el código que, por oficio, une piezas: la clase de arranque, la configuración de la inyección de dependencias, los mappers.

Para profundizar

  • Dirección. Dcy es el acoplamiento eferente (de salida) de una clase, la idea del fan-out llevada a clases; su contrapartida entrante es «Dpt». A nivel de paquete, las ideas análogas son «Ce» y «Ca».
  • Ambigüedad de la definición clásica. La definición de CBO de Chidamber y Kemerer es simétrica: dos clases están acopladas si una actúa sobre la otra, en cualquier sentido. Las herramientas la leen de forma distinta: la documentación de Project Analyzer cuenta los dos sentidos una sola vez y trata la herencia como un acoplamiento más, porque la definición original no dice nada de ella; ckjm define CBO como acoplamientos eferentes, solo de salida. Dos valores de «acoplamiento entre objetos» de herramientas distintas no se comparan sin mirar qué cuenta cada una.
  • Tipo de dependencia. Contar clases distintas trata igual un campo, una llamada y una cláusula extends, aunque su fuerza como acoplamiento es muy distinta: heredar de una clase ata mucho más que recibirla como parámetro.
  • Ruido de las bibliotecas. Si se contaran las clases de las bibliotecas, casi todas las clases sumarían String, List u Optional, que dicen poco del diseño. Excluirlas tiene un precio: una clase muy atada a un marco (framework) concreto puede tener un Dcy bajo.

Relación con otras métricas

En las herramientas

Stau Metro (NumDependenciesClass en clases, NumDependenciesInterface en interfaces). El valor es el número de clases distintas a las que se refiere el elemento. Cuentan como referencia:

  • la superclase y las interfaces implementadas o extendidas, y los límites de los parámetros de tipo;
  • el tipo de cada campo, parámetro y variable local (también el inferido de una variable var o de un parámetro de lambda sin tipo), el tipo de retorno y las excepciones declaradas con throws; de un array cuenta el tipo de sus elementos;
  • las clases que se instancian con new, los tipos de una conversión (cast), de un instanceof y de un patrón de record, los literales Foo.class y las anotaciones;
  • la clase que declara cada método al que se llama y cada campo al que se accede (la que lo declara, no la del tipo estático del receptor: llamar a un método heredado cuenta la superclase que lo declara);
  • las clases nombradas directamente, como el calificador de una llamada estática;
  • el tipo de destino de cada lambda y de cada referencia a método, y la clase que declara el método referenciado;
  • los argumentos de tipo de todos esos tipos (List<Item> cuenta Item), los límites de los comodines (? extends Item) y cada alternativa de un catch múltiple.

No cuentan: las clases de una cláusula permits, las menciones en Javadoc o en los import, el propio elemento, los parámetros de tipo (T), las clases anónimas y locales, ni las clases compiladas (las de bibliotecas, incluida la estándar). Sí cuenta cualquier clase con código fuente en el proyecto, aunque esté en otro módulo o fuera del ámbito analizado. Las clases anónimas y locales forman parte de la clase que las contiene, y sus dependencias se suman a las de ella. Una clase anidada tiene su propia fila y sus propias dependencias, que no se suman a las de la externa; una referencia de la clase anidada a la externa, o al revés, cuenta como cualquier otra.

Hay fila para las clases (también las abstractas, los enumerados y los records) y, por separado, para las interfaces; las anotaciones no tienen fila, pero sí pueden contar como dependencia de otras clases. Las clases de test del ámbito analizado participan como las demás: tienen su propia fila y sus dependencias cuentan como las de cualquier clase. Solo se recorren ficheros Java.

Referencias