Al ejecutar código Java, pueden ocurrir diferentes errores: errores de codificación por parte del programador, errores debido a una entrada incorrecta u otros imprevistos. Cuando ocurre un error, Java normalmente se detendrá y generará un mensaje de error. El término técnico para esto es: Java lanzará una excepción (arrojará un error).

Vídeo de explicación

Cómo usar try catch

En Java, try-catch es una estructura de control de flujo que permite a un programa probar un bloque de código para ver si produce algún error o excepción. Si se produce un error o excepción, el código en el bloque catch se ejecuta para manejar el error o la excepción. Esto permite a un programa recuperarse de errores y continuar ejecutándose en lugar de terminar abruptamente.

La sintaxis para usar try-catch es la siguiente:

try {
   // código que puede generar un error o excepción
} catch (tipoDeError oExcepcion) {
   // código para manejar el error o excepción
}

Aquí te mostramos un pequeño ejemplo de cómo capturar un excepción:

try {
   int x = 5 / 0; // esta línea genera una excepción de división por cero
} catch (ArithmeticException e) {
   System.out.println("Error: no se puede dividir por cero!");
}

En este ejemplo, si se produce una excepción de división por cero al intentar dividir 5 por 0, se ejecutará el código en el bloque catch para manejar la excepción y se imprimirá un mensaje de error. Si no se produce ninguna excepción, el código en el bloque catch no se ejecutará.

Palabra clave try

En Java, la palabra clave try se utiliza en la estructura de control de flujo try-catch para indicar el inicio de un bloque de código que se debe probar para ver si produce algún error o excepción. Si se produce un error o excepción durante la ejecución de este bloque de código, el control del programa salta a un bloque catch asociado que se encarga de manejar el error o la excepción.

Palabra clave catch

En Java, la palabra clave catch se utiliza en la estructura de control de flujo try-catch para indicar el inicio de un bloque de código que se ejecuta cuando se produce un error o excepción durante la ejecución de un bloque de código anteriormente probado.

Manejo de múltiples excepciones

En Java, es posible controlar múltiples excepciones en una sola estructura try-catch y existe 3 maneras para hacerlo.

Múltiples bloques catch

Cada bloque catch se asocia con un tipo de excepción específico y se ejecuta solo si se produce ese tipo de excepción durante la ejecución del código en el bloque try. Ejemplo:

try {
// código que puede generar varias excepciones
} catch (ArithmeticException e) {
// código para manejar excepciones de aritmética
} catch (NullPointerException e) {
// código para manejar excepciones de puntero nulo
} catch (Exception e) {
// código para manejar excepciones
}

Es importante tener en cuenta que los bloques catch deben colocarse en orden de especificidad, de modo que el bloque catch más específico para un tipo de excepción determinado se coloque antes que un bloque catch más genérico para ese tipo de excepción. Por ejemplo, en el ejemplo anterior, el bloque catch para ArithmeticException debe colocarse antes que el bloque catch para Exception, ya que ArithmeticException es una subclase de Exception y se debe manejar primero.

Múltiples excepciones en un bloque catch

A partir de Java 7, es posible manejar múltiples excepciones de diferentes tipos en una sola cláusula catch. Para hacerlo, se deben separar los tipos de excepción por una barra vertical (|) y usar el nombre de la excepción como una variable local para acceder a los detalles de la excepción. Ejemplo:

try {
   // código que puede generar varias excepciones
} catch (ArithmeticException | NullPointerException | IOException e) {
   // código para manejar excepciones de aritmética, puntero nulo y entrada/salida
}

Clase padre en un bloque catch

Es posible manejar excepciones de diferentes tipos en una sola cláusula catch utilizando la clase padre Exception como el tipo de excepción. Al hacerlo, se manejarán todas las excepciones que sean subclases de Exception. Ejemplo:

try {
   // código que puede generar varias excepciones
} catch (Exception e) {
   // código para manejar todas las excepciones que son subclases de Exception
}

Es importante tener en cuenta que, al usar la clase padre Exception en una cláusula catch, se manejarán todas las excepciones que son subclases de Exception, incluyendo las excepciones que ya se hayan manejado en cláusulas catch anteriores. Por lo tanto, es importante colocar la cláusula catch para Exception al final de la estructura try-catch para asegurarse de que se manejen solo las excepciones que no se hayan manejado anteriormente.