Número de puntos de retorno
| Sigla | RETURN |
| Aspecto | «Complejidad» |
| Se mide en | método |
| Tipo de valor | puntuación (entero, mínimo 0): un número que sirve para comparar métodos, no para sumar |
| Dirección | informativa: ni alto ni bajo es mejor |
| Stau Metro | NumReturnPoints |
En pocas palabras
Cuenta por cuántos sitios puede salir un método. Un método con un solo return al final tiene un único punto de
salida; uno con varios return repartidos por el cuerpo tiene tantos como return.
Qué mide
Cuántas salidas tiene el método. La programación estructurada clásica prefiere una sola salida, porque así basta
mirar el final del método para saber qué devuelve y qué se ha ejecutado antes. La práctica moderna lo matiza:
las salidas tempranas («cláusulas de guarda») al principio del método reducen el anidamiento y se leen mejor que
una cadena de if anidados. Por eso la métrica es informativa: un valor alto no es un defecto, pero varias salidas
combinadas con anidamiento profundo sí complican seguir el flujo.
Stau Metro la trata como puntuación, no como recuento corriente: no muestra su total en los resultados, solo la media, el mínimo y el máximo.
Cómo se calcula
Número de sentencias return del método, más 1 si el método es void o un constructor y el final del cuerpo es
alcanzable, es decir, si puede terminar sin pasar por un return explícito. Un throw no es un punto de retorno:
saca del método por una excepción, no por una salida normal.
Ejemplo
int sign(int x) {
if (x < 0) return -1; // 1
if (x > 0) return 1; // 2
return 0; // 3
} // total: 3
void log(String message) {
if (message == null) return; // 1
System.out.println(message); // el cuerpo acaba aquí sin return: +1
} // total: 2
sign vale 3 y log vale 2. Un método void que acaba con return; o con throw no suma la salida
por el final.
Cómo interpretarla
No tiene umbrales de Stau Metro. Referencias externas:
- la regla
OnlyOneReturnde PMD, que dice: «un método debe tener un único punto de salida, y debe ser la última sentencia del método»; - la comprobación
ReturnCountde Checkstyle, que por defecto permite como máximo 2returnen un método que devuelve un valor y 1 en un métodovoido un constructor. Como no cuenta el final implícito, su 1 equivale aquí a 2 en un métodovoidque puede llegar al final del cuerpo.
Interprétala junto con el anidamiento. Valores de 2 o 3 con salidas tempranas al principio son habituales y
legibles. Preocupa un método con muchos return dentro de bucles y condiciones anidadas, donde hay que seguir cada
rama hasta el final para saber qué devuelve.
Relación con otras métricas
- «Complejidad ciclomática» (
v(G)): losreturnno suman env(G); un método con varias salidas tempranas puede tener la mismav(G)que uno con una sola. - «Complejidad ciclomática esencial» (
ev(G)): la medida de cuánto se aparta el método de la estructura de una entrada y una salida. - «Profundidad de anidamiento» (
NBD): se lee junto a esta, como se explica arriba. - «Número de sentencias de ramificación» (
BRANCH): otros saltos que alteran el flujo.
En las herramientas
Stau Metro (NumReturnPoints, a nivel de método). Cuenta los return del cuerpo del método, sin los de las
lambdas ni los de los métodos de clases anónimas o locales declaradas dentro de él, porque esos terminan la lambda o
el otro método. Si el método es void o un constructor, añade 1 cuando la última sentencia del cuerpo puede
completarse con normalidad (o el cuerpo está vacío). El análisis sigue el flujo de control: un bucle while (true)
sin break no se completa, un switch con default cuyas ramas terminan todas con return o throw tampoco, y un
switch sin default (y no exhaustivo) sí. Por ejemplo, en un método void cuyo cuerpo es solo switch (x) { }
vale 1 (el final); si el switch tiene las reglas case 1 -> { return; } y default -> throw …, vale 1 (el
return); sin el default, vale 2 (el return y el final). Un switch sobre un tipo sellado con patrones que lo
cubren todo se trata como si tuviera default. No se calcula para los métodos abstractos.
Checkstyle (ReturnCount). Cuenta solo los return escritos, no el final implícito de un método void o de
un constructor. Comprueba también las lambdas, cada una con su propio límite. Ignora por defecto los métodos
equals.
PMD (OnlyOneReturn). Exige un único punto de salida, al final del método. Ignora por defecto equals y
compareTo, y con la opción allowGuardIfs admite cláusulas de guarda al principio del método.
Referencias
- Checkstyle, comprobación
ReturnCount: https://checkstyle.sourceforge.io/checks/coding/returncount.html - PMD, reglas de estilo de código para Java: https://docs.pmd-code.org/latest/pmd_rules_java_codestyle.html