Número de sentencias ejecutables

Actualizado el 15 de noviembre de 2026

Sigla EXEC
Aspecto «Tamaño»
Se mide en método
Tipo de valor recuento (entero, mínimo 0)
Dirección más alto es peor
Stau Metro NumExecutableStatements

En pocas palabras

Cuenta las sentencias de un método que hacen algo por sí mismas: asignar, llamar a otro método, declarar una variable, devolver un valor o lanzar una excepción. No cuenta los if, los bucles, los switch ni los try, que solo organizan el orden en que se ejecuta lo demás.

Qué mide

Mide el trabajo directo de un método, quitando el esqueleto de control. Es una vista más fina del tamaño que el «número de sentencias»: un método lleno de if anidados puede tener muchas sentencias y pocas ejecutables, y uno que solo asigna campos uno tras otro tendrá las dos cifras casi iguales.

Cómo se calcula

Se suman las sentencias de estos tipos y solo estas:

  • declaración de variables locales (int x = 0;);
  • sentencia de expresión (x = 1;, x++;, f(););
  • assert;
  • return;
  • throw.

No cuentan los if, los bucles (for, while, do), switch y sus etiquetas case, try, synchronized, las sentencias con etiqueta, break, continue ni yield; tampoco las llaves de bloque ni la sentencia vacía.

Ejemplo

static int sumPositives(int[] values) {
    int total = 0;                            // declaración: 1
    for (int i = 0; i < values.length; i++) { // for: no cuenta; declaración int i = 0: 1; i++: 1
        if (values[i] > 0) {                  // if: no cuenta
            total += values[i];               // expresión: 1
        }
    }
    return total;                             // return: 1
}

Total: 1 + 2 + 1 + 1 = 5. El mismo método tiene 7 sentencias en total («STAT»): la diferencia, 2, son el for y el if.

Cómo interpretarla

Más alto es peor, con la misma lectura que STAT: un método con muchas sentencias ejecutables hace mucho trabajo directo y suele convenir dividirlo. Stau Metro no trae umbral de referencia para esta métrica.

Compárala con STAT. Si EXEC es muy inferior, el método es sobre todo estructura de control: mira entonces su «complejidad ciclomática». Si son casi iguales, el método es una secuencia de pasos y tiene poca lógica de decisión.

Relación con otras métricas

En las herramientas

Stau Metro (NumExecutableStatements, método). Cuenta las declaraciones, las sentencias de expresión, los assert, los return y los throw. Por tanto, break, continue, yield, las sentencias con etiqueta y synchronized no suman, y tampoco lo hacen los if, los bucles, switch, sus etiquetas case y try. La inicialización y la actualización de un for clásico sí suman, porque son una declaración y una sentencia de expresión (una actualización con comas, i++, j--, suma 1). El cuerpo de una regla case 1 -> f(); cuenta como sentencia de expresión. Una clase local declarada dentro del método cuenta como una declaración, y una llamada this(…) o super(…) al principio de un constructor, como sentencia de expresión. Las sentencias de lambdas y de clases anónimas o locales se suman al método que las contiene. No se calcula para métodos abstractos ni de interfaz sin cuerpo; los constructores cuentan como métodos. No existe versión de clase.

Checkstyle (ExecutableStatementCount) tiene un nombre parecido, pero cuenta otra cosa: suma las sentencias que hay directamente en cada bloque entre llaves del miembro, incluidas las de control (if, for, try…), por separado en constructores, métodos, bloques de inicialización y lambdas. Su recuento se parece más al de «STAT». Informa cuando supera 30, su máximo por defecto.

Referencias