Saltar al contenido

Excepciones en java y control de errores

Las excepciones en java son estructuras que se utilizan para el control de errores. A través de la estructura try – catch, podemos capturar errores en tiempo de ejecución.

En java, las excepciones son objetos que derivan de la clase Exception y que a su vez, la clase Exception deriva de la clase Throwable.

Dentro del bloque try, incluiremos el código que queremos que se ejecute. Este código, podrá generar o no una excepción que lanzará una excepción si ocurre algún error.

Por otro lado podemos incluir tanto bloques catch como deseemos indicando el tipo de excepción que pueda llegar a ocurrir.

Además dentro de este bloque, podemos incluir un bloque adicional que no es obligatorio y que se llama bloque finally, que se ejecutará tanto si ocurre la excepción como si no.

Otra cosa a tener en cuenta, es que cuando cuando un método o función tiene que lanzar una excepción, bien porque nosotros queramos que así sea, o bien, porque el método o función en si, así lo requiera, podemos utilizar a continuación del método la palabra reservada throws junto al nombre de la excepción que queremos que lance el método o función.

Ejemplo de uso excepciones en java. Estructura try – catch – finally.

package ejerciciosDeExcepciones;
import java.util.*;
public class ClasePrincipal {
	public static void main(String[] args) {
		
		/* Declaramos dos variables
		 * para almacenar dos números
		 * y una tercera para almacenar
		 * el resultado de una división*/
		double primerNumero, segundoNumero, resultado;
		
		// Declaro un objeto Scanner para leer los datos
		Scanner lectura=new Scanner(System.in);
		
		try { // Intentamos			
			// Pedir los números al usuario
			System.out.println("Introduce el primer número");
			primerNumero=lectura.nextDouble();
			
			System.out.println("Introduce el segundo número");
			segundoNumero=lectura.nextDouble();
			
			// y dividir los dos números
			resultado=primerNumero/segundoNumero;
			
			// Mostramos el resultado por pantalla.
			System.out.println("El resultado es " + resultado);			
		}
	
		/* En caso de que surja algún error
		 * de tipo aritmético,Por ejemplo,
		 * que no se puede dividir entre cero*/
		catch (ArithmeticException e){
			
			// Mostramos este mensaje 
			System.out.println("No se puede dividir entre cero");	
		}
		/* En caso que se la excepcion no sea
		 * de tipo aritmético, se ejecutará este bloque*/
		catch (Exception ex){
			
			/* Mostramos este mensaje en caso de que no
			 * sea una excepción de tipo aritmético*/
			System.out.println("Se ha producido un error");	
		}
		
		/* Tanto si se produce la excepción,
		 * como si no se produce, se ejecutará
		 * el bloque finally*/
		finally {
			lectura.close();
		}
	}	    
}

Excepciones en java más frecuentes.

Por otro lado, en muchos casos, las excepciones son obligatorias, por ejemplo, al manejar archivos, acceso a bases de datos, etc.

En la siguiente imagen, vemos las excepciones más frecuentes que podemos encontrarnos. Todas estas excepciones, derivan de la clase principal Exception.

excepciones en java
excepciones más frecuentes en java

Métodos más comunes de la clase Throwable.

Algunos métodos que podemos utilizar cuando se implementa un bloque try-catch son los siguientes.

excepciones en java y metodos de la clase throwable
métodos que implementa la clase throwable.

Como usar la palabra reservada throws.

En este ejemplo vamos a ver como el código anterior, podría acortarse utilizando la palabra reservada throws. En este caso, introduciremos la cláusula throws en el método main para que se lance una excepcion de tipo ArithmeticException si se divide entre cero. Además incluiremos un bloque try – catch para lanzar un mensaje de una excepción genérica si en lugar de escribir números, se escriben letras.

package excepciones;
import java.util.*;
public class Principal {
	
	public static void main(String[] args) throws ArithmeticException{
		// Declaro un objeto Scanner para leer los datos
		Scanner lectura=new Scanner(System.in);
		/* Declaramos dos variables para almacenar dos números
		 * y una tercera para almacenar el 
		 * resultadode una división*/
		double primerNumero, segundoNumero, resultado;
		
		try { // Intentamos pedir y leer los dos números
			
			System.out.println("Introduce el primer número");
			primerNumero=lectura.nextDouble();
				
			System.out.println("Introduce el segundo número");
			segundoNumero=lectura.nextDouble();
			
			// Si no hay errores dividimos los dos números
			resultado=primerNumero/segundoNumero;
			
			// Mostramos el resultado por pantalla.
			System.out.println("El resultado es " + resultado);
			// Si se divide entre cero
			// saltará la excepción ArithmeticException
			
		}
		
		// Si ocurre algun error. Por ejemplo que se escriban
		// letras en lugar de números saltará el mensaje del catch
		catch(Exception e) {
			// Mostramos el mensaje de la excepcion
			System.out.println(e.getMessage());
			lectura.close(); // Se cierra el objeto lectura
		}
		
		// Si no hay errores cerramos el objeto de lectura
		lectura.close();
	}
}

Como crear nuestras propias excepciones en java.

Llegado este punto, por un lado ya sabemos como capturar excepciones a través de los bloque try – catch. Por otro, hemos visto como utilizar la clausula throws detrás de un método para lanzar una excepción. Y además de todo ello, ya sabemos crear nuestros propios objetos o clases personalizadas.

Por ello, en este apartado vamos a ver como crear nuestras propias excepciones para hacer que se lancen cuando lo consideremos oportuno. Para ello, seguiremos los siguientes pasos.

  • Crearemos una nueva clase en nuestro proyecto que herede de la clase Exception.
  • En esta clase, crearemos una variable (a nivel de clase) de tipo String para almacenar el mensaje de error que nosotros queramos.
  • Crearemos dos constructores.
    • Uno que no recibirá parámetros, pero que si mostrará un mensaje genérico en caso de producirse la excepción.
    • Otro constructor que recibirá por parámetro una cadena de texto. Esta cadena de texto, estará definida por el usuario para que de esta forma pueda enviar un mensaje de error personalizado.
  • Para devolver el mensaje de error, sobreescribiremos el metodo getMessage de la clase Exception. El mensaje que mostrará la excepción, dependerá del tipo de constructor que utilicemos a la hora de construir nuestra excepción.

Vamos a ver con código java un ejemplo para crear una excepción personalizada.

package excepciones;
/**
 * 
 * ESTA CLASE HEREDA DE LA CLASE EXCEPTION
 */
public class MiPropiaExcepcion extends Exception{
	// Creamos una variable a nivel de clase
	private String mensajeDeError;
	
	// Creamos un constructor sin parametros pero
	// En el constructor le asignamos un mensaje
	// a la variable mensajeDeError. En este caso,
	// En este primer constructor vamos a asignarle
	// a la variable mensajeDeError el mensaje: Error1
	
	public MiPropiaExcepcion() {
		this.mensajeDeError="Error 1";
	}
	
	// Creamos un constructor que recibirá un parámetro
	// de tipo String y le asignaremos a la variable
	// mensajeDeError el valor del parametro. Este parametro
	// es un mensaje que el usuario introducirá por teclado
	// desde el método main
	
	public MiPropiaExcepcion(String introduceMensaje) {
		// Asignamos el valor del paramentro a la variable mensajeError
		this.mensajeDeError=introduceMensaje;	
	}
	
	// Sobreescribimos el metodo getMessage de la clase Exception
	public String getMessage() {
		return mensajeDeError;
	}
}

Como lanzar nuestra excepción desde el método main.

Ahora vamos a ver como podríamos lanzar nuestra excepción desde el método main.

Primeramente, con el código que mostraremos a continuación, mostraremos un mensaje personalizado, es decir, usaremos el segundo constructor.

package excepciones;
import java.util.*;
public class Principal {
	
	public static void main(String[] args){
		// Declaro un objeto Scanner para leer los datos
		Scanner lectura=new Scanner(System.in);	
		// Declaramos una variables de tipo String
		//para almacenar un número
		String num1;
		
		try { // Intentamos
			// Pedir el número
			System.out.println("Introduce el primer número");
			// Leer el número 1
			num1=lectura.nextLine();
			
			// Si la variable esta vacía
			if(num1.isEmpty()) {
				
				// Lanzamos la excepción con un mensaje personalizado
				throw new MiPropiaExcepcion("Debes introducir un número");
			}
		}
		
		// En caso de error mostramos ese mensaje personalizado
		catch(MiPropiaExcepcion e) {
			System.out.println(e.getMessage());
		}
		finally { // Finalmente, tanto si se produce error
			// como si no, cerramos el objeto lectura
			lectura.close();
		}
	}
}

A la hora de lanzar esta excepción, también podemos usar el constructor sin parámetros, esto lo haremos de la siguiente forma.

package excepciones;
import java.util.*;
public class Principal {
	
	public static void main(String[] args){
		// Declaro un objeto Scanner para leer los datos
		Scanner lectura=new Scanner(System.in);	
		// Declaramos una variables de tipo String
		//para almacenar un número
		String num1;
		
		try { // Intentamos
			// Pedir el número
			System.out.println("Introduce el primer número");
			// Leer el número 1
			num1=lectura.nextLine();
			
			// Si la variable esta vacía
			if(num1.isEmpty()) {
				
				// Lanzamos la excepción con el primer constructor
				throw new MiPropiaExcepcion();
			}
		}
		
		// En caso de error mostramos el mensaje del primer constructor
		catch(MiPropiaExcepcion e) {
			System.out.println(e.getMessage());
		}
		finally { // Finalmente, tanto si se produce error
			// como si no, cerramos el objeto lectura
			lectura.close();
		}
	}
}