Número de llamadas a métodos

Actualizado el 15 de noviembre de 2026

Sigla CALL
Aspecto «Acoplamiento»
Se mide en método
Tipo de valor recuento (entero, mínimo 0)
Dirección informativa: ni alto ni bajo es mejor
Stau Metro NumMethodCalls

En pocas palabras

Cuenta las llamadas a otros métodos y los new que aparecen escritos dentro de un método. Dice cuánto delega el método en otro código en lugar de hacer el trabajo él mismo. Cada aparición cuenta: llamar tres veces al mismo método suma 3.

Qué mide

El grado de delegación de un método. Un método con muchas llamadas coordina trabajo que hacen otros; uno con pocas hace el trabajo con sus propias expresiones. Ninguno de los dos estilos es malo: un buen método de alto nivel suele ser casi todo llamadas a métodos con nombres claros, y un buen método de bajo nivel, casi ninguna.

No es una métrica de la literatura con autor conocido, sino un recuento sencillo.

Cómo se calcula

Se suma 1 por cada expresión de llamada a método y por cada expresión de creación de un objeto con new. No se distinguen los destinos: dos llamadas a log() son 2.

Ejemplo

String describe(Order order) {
    StringBuilder text = new StringBuilder();            // 1 (new)
    text.append(order.id());                             // 2 (append, id)
    for (Item item : order.items()) {                    // 1 (items)
        text.append(", ").append(item.name());           // 3 (append, append, name)
    }
    int[] counts = new int[3];                           // 0: creación de array
    return text.toString();                              // 1 (toString)
}

Total: 1 + 2 + 1 + 3 + 0 + 1 = 8.

Cómo interpretarla

No tiene umbrales. Se lee junto a otras métricas del método:

  • CALL alto y «complejidad ciclomática» baja: un método orquestador, que encadena pasos. Suele estar bien si los pasos tienen buenos nombres.
  • CALL alto y complejidad alta: el método coordina mucho y además decide mucho. Es candidato a dividirse.
  • CALL alto con llamadas en cadena (a.b().c().d()): el método conoce la estructura interna de otros objetos; conviene revisar si esa navegación pertenece a otra clase.

Relación con otras métricas

En las herramientas

Stau Metro (NumMethodCalls, a nivel de método).

  • Cuentan las llamadas a métodos, incluidas super(…) y this(…), y los new de objetos, también los que crean una clase anónima.
  • No cuentan las creaciones de arrays (new int[3], new int[] {1, 2}) ni las referencias a método (Foo::bar).
  • Las llamadas y los new de las lambdas y de las clases anónimas o locales declaradas dentro del método se suman al método que las contiene; los métodos de esas clases no tienen valor propio.
  • Se mide en métodos y constructores, salvo en los abstractos: los marcados abstract y los de interfaz que no son default, static ni private.
  • Las llamadas de los inicializadores de campos y de los bloques de inicialización no pertenecen a ningún método y no se cuentan. La excepción son los métodos de una clase anónima creada en un inicializador: no están dentro de otro método, así que reciben su propio valor.