Número de veces invocado

Actualizado el 15 de noviembre de 2026

Sigla CALLED
Aspecto «Acoplamiento»
Se mide en método
Tipo de valor entero, mínimo 0: número de puntos de llamada
Dirección informativa: ni alto ni bajo es mejor
Stau Metro NumTimesCalled

En pocas palabras

Cuenta en cuántos sitios del código del proyecto se llama a un método. Un método llamado desde cuarenta sitios es delicado de cambiar: cualquier cambio de comportamiento llega a esos cuarenta. Un método al que no llama nadie puede ser código muerto.

Qué mide

El acoplamiento entrante de un método: cuánto código depende de él. Es la versión, a nivel de método, de lo que en clases mide el «número de dependientes» y en general el fan-in.

Sirve para dos preguntas prácticas:

  • ¿Qué rompo si lo cambio? Un valor alto indica un método muy usado, cuyo contrato conviene mantener estable.
  • ¿Se usa? Un valor de 0 es la primera pista de código muerto.

Cuenta puntos de llamada, es decir, sitios del código fuente, no ejecuciones: una llamada dentro de un bucle que se ejecuta mil veces cuenta una vez.

Cómo se calcula

Se suma 1 por cada sitio del código que llama al método. Con herencia, una llamada hecha a través de un supertipo (shape.area() sobre una variable de tipo Shape) puede acabar ejecutando la versión de cualquier subclase, así que se atribuye también a los métodos que sobrescriben el del supertipo.

Ejemplo

import java.util.List;

interface Shape {
    double area();                          // CALLED = 1: la llamada de total
}

class Circle implements Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    public double area() {                  // CALLED = 2: la de total (vía Shape) y la de one
        return Math.PI * r * r;
    }
    public String toString() {              // CALLED = 0
        return "circle";
    }
}

class Report {
    double total(List<Shape> shapes) {
        double sum = 0;
        for (Shape s : shapes) {
            sum += s.area();                // llama a Shape.area
        }
        System.out.println(shapes.get(0));  // ejecuta toString, pero a través de println
        return sum;
    }
    double one(Circle c) {
        return c.area();                    // llama a Circle.area
    }
}

Circle.area recibe su llamada directa (1) más la de Shape.area (1): 2. Shape.area solo recibe la suya: 1, porque la llamada a c.area() va dirigida a Circle. Circle.toString vale 0: la única llamada que lo ejecuta pasa por código del JDK, que no se ve.

Cómo interpretarla

No tiene umbrales; los dos extremos tienen lectura propia:

  • 0: candidato a código muerto. Antes de borrarlo, comprueba que no se llame por un camino que la métrica no ve: a través de un método del JDK o de una biblioteca que sobrescribe (toString(), run(), compareTo()), por reflexión, desde un framework (métodos anotados, callbacks), o como parte de una API pública usada fuera del proyecto.
  • Alto: el método es un punto de apoyo del código. Cambiar su comportamiento tiene un efecto amplio; si además es complejo, merece buenos tests.

Para saber si un método solo lo usan los tests, compáralo con el «número de veces invocado en código de producción» y el «de test».

Relación con otras métricas

En las herramientas

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

  • Busca las referencias al método en todo el proyecto, sea cual sea el ámbito analizado, en código de producción y de test. Cuentan también las llamadas desde código Kotlin.
  • Cada sitio cuenta una vez. Una referencia a método (Circle::area) cuenta como un sitio más.
  • No cuentan las menciones en comentarios Javadoc o KDoc ({@link}, @see), en los import (también los import static) ni en ficheros que no son código, como un descriptor XML.
  • Suma, de forma recursiva, los sitios que llaman a los métodos que este sobrescribe, siempre que estén declarados en el proyecto. Una misma llamada que llega por varios caminos (por ejemplo, a través de dos interfaces) cuenta una sola vez. Las llamadas a métodos del JDK o de bibliotecas que sobrescribe, como Object.toString(), no cuentan.
  • Se mide en todos los métodos, constructores incluidos, también en los abstractos y en los de interfaz; no en los métodos de clases anónimas o locales declaradas dentro de otro método.