Número de sentencias

Actualizado el 15 de noviembre de 2026

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

En pocas palabras

Cuenta las órdenes que contiene un método, o una clase entera. Una sentencia es una unidad de código que termina en ; o que abre un bloque de control, como if o for. Es una forma de medir el tamaño que no se deja engañar por una línea muy larga ni por tres sentencias escritas en una sola línea.

Qué mide

Mide el tamaño en pasos de ejecución, no en texto. Dos métodos con las mismas líneas pueden tener un número de sentencias muy distinto si uno escribe a = 1; b = 2; c = 3; en una línea y el otro reparte una expresión enorme en diez. Por eso se prefiere a las «líneas de código» cuando se quiere comparar volumen de trabajo y no formato.

Como toda medida de tamaño, avisa de que un método o una clase hace demasiado, pero no dice si hace algo difícil. La dificultad la miden la «complejidad ciclomática» y las que se derivan de ella.

Cómo se calcula

STAT=nuˊmero de sentencias del meˊtodo (o suma sobre los meˊtodos de la clase)\text{STAT} = \text{número de sentencias del método (o suma sobre los métodos de la clase)}

Una sentencia es, en Java, cada instrucción de la gramática del lenguaje: declaraciones de variables locales, expresiones usadas como sentencia (x++;, f();), if, for, while, do, switch, try, return, throw, break, continue, assert, synchronized, etc. Las sentencias anidadas se cuentan además de las que las contienen: un if con dos sentencias dentro vale 3.

La definición no es única entre herramientas: la cuenta de las llamadas NCSS (non-commenting source statements) y la de «sentencias ejecutables» difieren en qué construcciones entran. Los detalles de Stau Metro están en «En las herramientas».

Ejemplo

El mismo método sirve de ejemplo en «Número de sentencias ejecutables»:

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

Total: 1 + 3 + 1 + 1 + 1 = 7. Las llaves de bloque no suman. Fíjate en que el for aporta tres: él mismo, la declaración int i = 0 de la cabecera y la expresión i++.

Cómo interpretarla

Más alto es peor: un método con muchas sentencias hace muchas cosas y cuesta entenderlo, probarlo y cambiarlo. Stau Metro no trae umbral de referencia para esta métrica. Como orientación externa, la regla NcssCount de PMD informa por defecto de métodos con 60 o más sentencias NCSS y de clases con 1500 o más (valores por defecto de PMD; su recuento no es idéntico al de Stau Metro, ver más abajo), y la comprobación ExecutableStatementCount de Checkstyle avisa por defecto por encima de 30 sentencias por método.

En una clase, el valor solo se interpreta junto al «número de métodos»: una clase con 400 sentencias repartidas en 40 métodos de 10 no es lo mismo que una con 4 métodos de 100. Esa relación la dan el «tamaño promedio» y el «máximo» de las operaciones.

Qué hacer con un valor alto: extrae métodos coherentes, separa responsabilidades en clases distintas y elimina duplicación. Un valor alto es aceptable en código plano y repetitivo (rellenar un objeto campo a campo, tablas de datos escritas como código) donde cada sentencia es trivial.

Relación con otras métricas

En las herramientas

Stau Metro (NumStatements por método, NumStatementsClass por clase). Cuenta todas las sentencias del árbol sintáctico, menos las sentencias vacías (;) y las llaves de bloque que forman una sentencia por sí solas. Cuentan, entre otras, las declaraciones de variables locales (también la de una clase o una interfaz local), las sentencias de expresión, y cada if, bucle, switch, try, synchronized, return, throw, break, continue, yield y assert. La inicialización y la actualización de la cabecera de un for cuentan como sentencias propias, y por tanto un for clásico suma 3 más las del cuerpo. Un else if suma como un if más. Una sentencia con etiqueta (bucle: for (…)) suma 1 además de la sentencia etiquetada. En un switch, cada etiqueta case o default es una sentencia, y cada regla case … -> también, además de la sentencia de su cuerpo cuando no es un bloque: case 1 -> f(); suma 2.

Las sentencias de las lambdas y de las clases anónimas o locales declaradas dentro de un método se suman a ese método. Los métodos de una clase anónima que no está dentro de un método (la de un inicializador de campo, o el cuerpo de una constante de un enumerado) tienen fila propia. Los métodos abstractos y los de interfaz sin cuerpo no tienen valor; un constructor sí, como un método más. Los bloques de inicialización no pertenecen a ningún método y no cuentan a nivel de método.

A nivel de clase (NumStatementsClass) es la suma de las sentencias que hay dentro de la clase, sin las de sus clases anidadas con nombre, que tienen su propia fila. Incluye los métodos, los constructores, los bloques de inicialización y las lambdas de los inicializadores de campos; incluye también las clases anónimas y locales que contiene. No se calcula para interfaces ni anotaciones (sus métodos por defecto no suman a ninguna fila de clase), sí para enumerados y records; las sentencias de los cuerpos de las constantes de un enumerado se suman a él.

El texto de ayuda del plugin dice «suma de las sentencias de todos los métodos declarados directamente en la clase»; el cálculo real es el descrito arriba.

El código de test se mide igual que el de producción.

PMD (regla NcssCount). Mide el tamaño con la métrica NCSS, que ignora comentarios y líneas en blanco y cuenta sentencias; informa cuando el recuento llega a 60 en un método o a 1500 en una clase (valores por defecto).

Checkstyle (ExecutableStatementCount). Pese al nombre, su recuento se parece más a este que a «EXEC»: suma las sentencias que hay directamente en cada bloque entre llaves del miembro, incluidas las de control, y lo hace por separado en constructores, métodos, bloques de inicialización y lambdas (las sentencias de una lambda no suman al método que la contiene). Informa cuando el recuento supera 30, su máximo por defecto.

SonarQube. Ofrece la métrica statements, definida como «el número de sentencias».

Referencias