Número de sentencias
| 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
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
- «Número de sentencias ejecutables» (
EXEC): lo mismo sin las sentencias de control; la diferencia entre las dos es el esqueleto de control del método. - «Líneas de código» (
LOC) y «líneas sin comentarios» (NCLOC): el tamaño medido en líneas físicas, sensible al formato. - «Número de expresiones» (
EXP): cuánto cálculo hay dentro de las sentencias. - «Complejidad ciclomática» (
v(G)): suele crecer con el número de sentencias, pero mide decisiones, no volumen. - «Número de métodos» (
METH): el divisor natural para leer el valor de una clase. - «Tamaño promedio» (
OSavg) y «máximo» (OSmax) de las operaciones: la distribución del tamaño de los métodos de una clase.
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
- PMD, reglas de diseño para Java,
NcssCount: https://docs.pmd-code.org/latest/pmd_rules_java_design.html - Checkstyle, comprobación
ExecutableStatementCount: https://checkstyle.org/checks/sizes/executablestatementcount.html y su código fuente: https://github.com/checkstyle/checkstyle/blob/master/src/main/java/com/puppycrawl/tools/checkstyle/checks/sizes/ExecutableStatementCountCheck.java - PMD, código fuente de
NcssCountRule: https://github.com/pmd/pmd/blob/main/pmd-java/src/main/java/net/sourceforge/pmd/lang/java/rule/design/NcssCountRule.java - SonarQube, definición de métricas: https://docs.sonarsource.com/sonarqube-server/latest/user-guide/code-metrics/metrics-definition/