Return Statement Vs Try Catch

Return Statement

Return Statement Vs Try Catch

1. Definición.
2. return vs try/catch.

1. Definición


La sentencia "return" es una sentencia de bifurcación o ramificación (también considerada como sentencia de control), que provoca la salida del método actual, devolviendo el flujo de control hacia el lugar desde el cual se invocó dicho método. La sentencia de control se presenta de dos formas distintas: una que devuelve un valor, y otra que no devuelve ninguno. Para devolver un valor, simplemente pondremos el valor (o una expresión que calcule el valor) tras la palabra reservada "return".

   return ++count;

El tipo de datos del valor devuelto debe coincidir con el tipo del valor de retorno establecido en la declaración del método. Todo método declarado como "void" no devolverá ningún valor, por lo tanto, su sentencia de retorno "return" será de la forma:

   return;

2. return vs try/catch


Dado el siguiente método que acepta un parámetro de tipo "String" y devuelve un objeto de tipo "Problema", donde el método "obtenerProblema" puede generar una excepción que queremos capturar en nuestro código, vamos a analizar los posibles lugares donde insertar la sentencia de retorno de dicho método:

public Problema metodo(String parametro) {

   log.debug("-> metodo(String parametro");

   // Variables
   Problema problema = null;
  
   try {

      problema = obtenerProblema(parametro);
     
      // (a) return problema

   } catch (Exception e) {

      log.error("Error:"+e.getMessage(),e);

      // (b) return problema

   } finally {

      log.debug("<- metodo(String parametro");

      // (c) return problema
   }

   // (d) return problema
}

Existen cuatro posibilidades,

(a) Dentro del try: se produce el siguiente error, "This method must return a result of type Problema.

(b) Dentro del catch: se produce el mismo error que en la opción (a).

(c) Dentro del finally: se produce el warning siguiente, "finally block does not complete normally".

(d) Al final del método: no se produce ningún error ni warning.

Puesto que la sentencia "return" devuelve el flujo de control al invocador, si situamos el "return" dentro de los bloques "try" o "catch" contradecimos la propia lógica de la sentencia "try-catch-finally", que establece y garantiza que el bloque "finally" siempre debe ejecutarse en última instancia. Por otra parte, si lo colocamos en el "finally" el compilador nos indica la posibilidad de que exista o pueda existir una sentencia de código dentro del "finally" que aún no se haya ejecutado, debido a que el bloque "finally" todavía no ha concluído.

Por tanto, podemos concluir que toda sentencia "return" debe situarse inmediatamente antes de finalizar el método y fuera del bloque try-catch-finally.