Número de puntos de retorno

Actualizado el 15 de noviembre de 2026

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 OnlyOneReturn de 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 ReturnCount de Checkstyle, que por defecto permite como máximo 2 return en un método que devuelve un valor y 1 en un método void o un constructor. Como no cuenta el final implícito, su 1 equivale aquí a 2 en un método void que 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

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