EXCEPCIÓNES JAVA
Una excepción (o acontecimiento excepcional) es un problema que se presenta durante la ejecución
de un programa. Cuando una excepción se produce el flujo normal del programa se interrumpe y el
programa / aplicación termina de forma anormal, que no se recomienda, por lo tanto, estas excepciones
son para ser manipulados.
Una excepción puede ocurrir por muchas razones diferentes. A continuación se presentan algunos
escenarios en los que se produce una excepción.
Un usuario ha introducido un conjunto de datos no válidos.
Un archivo que necesita ser abierto no se puede encontrar.
Una conexión de red se ha perdido en el medio de comunicación o la JVM se ha quedado sin
memoria.
Algunas de estas excepciones son causadas por un error del usuario, otros por error del programador,
y otras por los recursos físicos que han fallado de alguna manera.
Sobre la base de estos, tenemos tres categorías de excepciones. Es necesario comprender que sepan
cómo funciona el manejo de excepciones en Java.
1ª.- Checked exceptions - A excepción chequeada es una excepción que se produce en el momento de
la compilación, éstos también se llaman como excepciones tiempo de compilación. Estas excepciones no
pueden ser simplemente ignorados en el momento de la compilación, el programador debe tener en
cuenta estas excepciones.
Por ejemplo, si se utiliza la clase FileReader en su programa para leer datos de un archivo, si el archivo
especificado en su constructor no existe, entonces se produce una FileNotFoundException, y el
compilador le pide al programador para controlar la excepción.
Ejemplo
import [Link];
import [Link];
public class FilenotFound_Demo {
public static void main(String args[]) {
File file = new File("E://[Link]");
FileReader fr = new FileReader(file);
}
}
Si intenta compilar el programa anterior, obtendrá las siguientes excepciones.
Salida
C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or
declared to be thrown
FileReader fr = new FileReader(file);
^
1 error
2ª.- Unchecked exceptions- Una excepción sin control es una excepción que se produce en el
momento de la ejecución. Éstas también se llaman “excepciones de tiempo de ejecución” . Incluyen
errores de programación, tales como errores de lógica o el uso indebido de una API. Excepciones de
tiempo de ejecución se tienen en cuenta en el momento de la compilación.
Por ejemplo, si se ha declarado una matriz de tamaño 5 en su programa, y tratando de llamar al 6º
elemento de la matriz, a continuación se produce, un ArrayIndexOutOfBoundsExceptionexception.
Ejemplo
public class Unchecked_Demo {
public static void main(String args[]) {
int num[] = {1, 2, 3, 4};
[Link](num[5]);
}
}
Si se compila y ejecuta el programa anterior, recibirá la siguiente excepción.
Salida
Exception in thread "main" [Link]: 5
at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)
3.- Errors - No son excepciones en absoluto, pero son los problemas que surgen más allá del control
del usuario o el programador. Los errores son normalmente ignorados en su código, ya que rara vez se
puede hacer nada acerca de un error. Por ejemplo, si se produce un desbordamiento de pila, surgirá un
error. También se tienen en cuenta en el momento de la compilación.
Jerarquía de excepciones
Todas las clases de excepciones son subtipos de la clase [Link]. La clase de excepción es
una subclase de la clase Throwable. Aparte de la clase de excepción existe otra subclase llamada de error
que se deriva de la clase Throwable.
Los errores son condiciones anormales que se producen en caso de fallos graves, éstas no son
manejados por los programas Java. Los errores se generan para indicar errores generados por el entorno
de ejecución. Ejemplo: JVM(Maquina Virtual Java) no esta en ejecucion. Normalmente, los programas no
pueden recuperarse de los errores.
La clase de excepción tiene dos subclases principales: la clase IOException y clase RuntimeException.
excepciones1
A continuación se presenta una lista de los más comunes marcado y sin marcar excepciones internas
de Java .
Nº Exception Descripción
1 ArithmeticException. error aritmético, tales como división por cero.
ArrayIndexOutOfBoundsException. El índice de matriz está fuera de los
2
límites.
ArrayStoreException. La asignación a un elemento de matriz de un tipo
3
incompatible.
4 ClassCastException. Cast no válido
IllegalArgumentException. Argumento ilegal utilizado para invocar un
5
método.
6 IndexOutOfBoundsException. Algún tipo de índice está fuera de los límites.
7 NegativeArraySizeException Matriz creada con un tamaño negativo.
8 NullPointerException Uso no válido de una referencia null
NumberFormatException. Conversión de string a numérico no es valida.
9
10 StringIndexOutOfBounds Indice fuera de los límites de una cadena(string).
Métodos
A continuación se presenta la lista de los métodos importantes disponibles en la clase Throwable.
1 public String getMessage()Devuelve un mensaje detallado sobre la excepción de que se ha
producido. Este mensaje se ha inicializado en el constructor de la clase Throwable.
2 public Throwable getCause() Devuelve la causa de la excepción representada por un objeto
Throwable.
3 public String toString() Devuelve el nombre de la clase concatenado con el resultado de
getMessage ().
4 public void printStackTrace() Imprime el resultado de toString () junto con el seguimiento de la
pila para [Link], la lista de salida de errores.
La captura de excepciones
Un método detecta una excepción usando una combinación de los try y catch palabras clave. Un
bloque try / catch se coloca alrededor del código que podría generar una excepción. Código dentro de un
bloque try / catch se conoce como código protegido, y la sintaxis para usar try / catch tiene el siguiente -
try {
// código protegido
}catch(ExceptionName e1) {
// Catch
}
El código que es propenso a las excepciones se coloca en el bloque try. Cuando se produce una
excepción, es manejado por bloque catch asociada a ella.
Si se produce una excepción en el código protegido, se comprueba el bloque catch (o bloques) que
sigue el intento. Si el tipo de excepción que se produjo aparece en un bloque catch, la excepción se pasa
al bloque catch tanto como un argumento se pasa a un parámetro de método.
Ejemplo
La siguiente es una matriz declarada con 2 elementos. A continuación, el código intenta acceder a la 3
rd elemento de la matriz, que produce una excepción.
// File Name : [Link]
import [Link].*;
public class ExcepTest {
public static void main(String args[]) {
try {
int a[] = new int[2];
[Link]("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e) {
[Link]("Exception thrown :" + e);
}
[Link]("Out of the block");
}
}
Esto producirá el siguiente resultado -
Salida
Exception thrown :[Link]: 3
Out of the block
Bloques de capturas múltiples
Un bloque try puede ser seguido por varios bloques catch. La sintaxis de varios bloques catch tiene el
siguiente -
Sintaxis
try {
// Protected code
}catch(ExceptionType1 e1) {
// Catch block
}catch(ExceptionType2 e2) {
// Catch block
}catch(ExceptionType3 e3) {
// Catch block
}
Las declaraciones anteriores demuestran tres bloques catch, pero puede tener cualquier número de
ellos después de un solo intento. Si se produce una excepción en el código protegido, la excepción es
lanzada al primer bloque de captura de la lista. Si el tipo de datos de la excepción lanzada coincide
ExceptionType1, queda atrapado allí. Si no es así, la excepción pasa a la segunda sentencia catch. Esto
continúa hasta que la excepción sea capturado o se cae a través de todas las capturas, en cuyo caso el
método actual detiene la ejecución y la excepción es lanzada hacia abajo con el método anterior en la pila
de llamadas.
Ejemplo
Aquí está segmento de código que muestra cómo utilizar varias instrucciones try / catch.
try {
file = new FileInputStream(fileName);
x = (byte) [Link]();
}catch(IOException i) {
[Link]();
return -1;
}catch(FileNotFoundException f) // Not valid! {
[Link]();
return -1;
}
Múltiple Excepciones
Desde Java 7, se puede manejar más de una excepción el uso de un único bloque catch, esta
característica simplifica el código. Esta es la manera que lo haría -
catch (IOException|FileNotFoundException ex) {
[Link](ex);
throw ex;
Las Palabras clave Throws/Throw
Si un método no maneja una excepción checked, el método debe declarar el uso de Throw. La palabra
clave Throw aparece al final del nombre del método.
Trate de entender la diferencia entre throws y throw. Throws se utiliza para posponer el manejo de
una excepción comprobada(checked) y throw se utiliza para invocar una excepción explícita.
El siguiente método declara que throws una RemoteException -
Ejemplo
public class className {
public void deposito(double saldo) throws RemoteException {
// Implementacion de metodo
throw new RemoteException();
}
// Resto de la definición de clase
}
Un método puede declarar que lanza más de una excepción, en cuyo caso las excepciones se declaran
en una lista separada por comas. Por ejemplo, el siguiente método declara que lanza una
RemoteException y un InsufficientFundsException -
Ejemplo
import [Link].*;
public class className {
public void AnchoDibujo(double lado) throws RemoteException, InsufficientFundsException {
// Implementacion de metodo
}
// Resto de la definición de clase
}
El bloque fynaly
El bloque finally se sigue un bloque try o un bloque catch. A fin bloque de código se ejecuta siempre,
independientemente de que se produzca una excepción.
El uso de un bloque finally le permite ejecutar cualquier declaración de tipo de limpieza que desee
ejecutar, no importa lo que sucede en el código protegido.
Un bloque finally aparece al final de los bloques catch y tiene la siguiente sintaxis -
Sintaxis
try {
// Protected code
}catch(ExceptionType1 e1) {
// Catch block
}catch(ExceptionType2 e2) {
// Catch block
}catch(ExceptionType3 e3) {
// Catch block
}finally {
// The finally block always executes.
}
Ejemplo
public class ExcepTest {
public static void main(String args[]) {
int a[] = new int[2];
try {
[Link]("Access element three :" + a[3]);
}catch(ArrayIndexOutOfBoundsException e) {
[Link]("Exception thrown :" + e);
}finally {
a[0] = 6;
[Link]("First element value: " + a[0]);
[Link]("The finally statement is executed");
}
}
}
Esto producirá el siguiente resultado -
Salida
Exception thrown :[Link]: 3
First element value: 6
The finally statement is executed
Tenga en cuenta lo siguiente -
Una cláusula catch no puede existir sin una sentencia try.
No es obligatorio tener finalmente cláusulas siempre que un bloque try / catch está presente.
El bloque try no puede estar presente sin que ninguna cláusula catch o finally cláusula.
Cualquier código no puede estar presente en entre el try, catch, finally bloques.
El try-con-recursos
En general, cuando se utiliza cualquier recurso como arroyos, conexiones, etc. tenemos que cerrar
explícitamente el uso de este bloque. En el siguiente programa, que estamos leyendo datos de un archivo
usando FileReader y estamos cerrando usando este bloque.
Ejemplo
import [Link];
import [Link];
import [Link];
public class ReadData_Demo {
public static void main(String args[]) {
FileReader fr = null;
try {
File file = new File("[Link]");
fr = new FileReader(file); char [] a = new char[50];
[Link](a); // reads the content to the array
for(char c : a)
[Link](c); // prints the characters one by one
}catch(IOException e) {
[Link]();
}finally {
try {
[Link]();
}catch(IOException ex) {
[Link]();
}
}
}
}
try-con-recursos , también conocidos como la gestión automática de recursos , es un nuevo
mecanismo de manejo de excepciones que se introdujo en Java 7, que se cierra automáticamente los
recursos utilizados en el bloque catch try.
Para utilizar esta declaración, sólo hay que declarar los recursos necesarios dentro del paréntesis, y el
recurso creado se cerrará automáticamente al final del bloque. A continuación se muestra la sintaxis de la
instrucción try-con-recursos.
Sintaxis
try(FileReader fr = new FileReader("file path")) {
// use the resource
}catch() {
// body of catch
}
}
Lo que sigue es el programa que lee los datos en un archivo utilizando la sentencia try-con-recursos.
Ejemplo
import [Link];
import [Link];
public class Try_withDemo {
public static void main(String args[]) {
try(FileReader fr = new FileReader("E://[Link]")) {
char [] a = new char[50];
[Link](a); // reads the contentto the array
for(char c : a)
[Link](c); // prints the characters one by one
}catch(IOException e) {
[Link]();
}
}
}
Siguientes puntos deben tenerse en cuenta al trabajar con sentencia try-con-recursos.
Para utilizar una clase con sentencia try-con-recursos debe aplicar AutoCloseable interfaz y el cierre ()
método para que se invoca automáticamente en tiempo de ejecución.
Se puede declarar más de una clase de instrucción try-con-recursos.
Si bien se declara múltiples clases en el bloque try de instrucción try-con-recursos estas clases se
cierran en el orden inverso.
Salvo la declaración de los recursos dentro del paréntesis todo lo que es lo mismo que el bloque try /
catch normal de un bloque try.
El recurso se declaró en intentarlo instancia justo antes del inicio de la prueba-bloque.
El recurso declarado en el bloque try se declara implícitamente como definitiva.
Las excepciones definidas por el usuario
Puede crear sus propias excepciones en Java. Mantenga los siguientes puntos en mente al escribir sus
propias clases de excepciones -
Todas las excepciones deben ser hijo de Throwable.
Si desea escribir una excepción comprobada que se aplica automáticamente por el mango o declarar el
estado de, es necesario ampliar la clase de excepción.
Si desea escribir una excepción de tiempo de ejecución, es necesario extender la clase
RuntimeException.
Podemos definir nuestra propia clase de excepción de la siguiente manera -
class MyException extends Exception {
}
Sólo tiene que extender el predefinida Excepción clase para crear su propio Excepción. Estos son
considerados como excepciones comprobadas. La siguiente InsufficientFundsException clase es una
excepción definida por el usuario que extiende la clase de excepción, por lo que es una excepción
comprobada. Una clase de excepción es como cualquier otra clase, que contiene los campos y métodos
útiles.
Ejemplo
// File Name [Link]
import [Link].*;
public class InsufficientFundsException extends Exception {
private double amount;
public InsufficientFundsException(double amount) {
[Link] = amount;
}
public double getAmount() {
return amount;
}
}
Para demostrar el uso de nuestra excepción definida por el usuario, la siguiente clase CuentaCorriente
contiene un método de retirar () que emite una InsufficientFundsException.
// File Name [Link]
import [Link].*;
public class CheckingAccount {
private double balance;
private int number;
public CheckingAccount(int number) {
[Link] = number;
}
public void deposit(double amount) {
balance += amount;
}
public void withdraw(double amount) throws InsufficientFundsException {
if(amount <= balance) {
balance -= amount;
}else {
double needs = amount - balance;
throw new InsufficientFundsException(needs);
}
}
public double getBalance() {
return balance;
}
public int getNumber() {
return number;
}
}
El siguiente programa demuestra BankDemo invocando el depósito () y retirar () de CuentaCorriente.
// File Name [Link]
public class BankDemo {
public static void main(String [] args) {
CheckingAccount c = new CheckingAccount(101);
[Link]("Depositing $500...");
[Link](500.00);
try {
[Link]("\nWithdrawing $100...");
[Link](100.00);
[Link]("\nWithdrawing $600...");
[Link](600.00);
}catch(InsufficientFundsException e) {
[Link]("Sorry, but you are short $" + [Link]());
[Link]();
}
}
}
Recopilar todos los tres archivos anteriores y ejecutar BankDemo. Esto producirá el siguiente resultado
-
Salida
Depositing $500...
Withdrawing $100...
Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
at [Link]([Link])
at [Link]([Link])
Las excepciones comunes
En Java, es posible definir dos catergories de excepciones y errores.
Excepciones JVM - Estas son excepciones / errores generados exclusivamente o lógicamente por la
JVM. Ejemplos: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.
Excepciones programáticos - Estas se producen excepciones explícitamente por la aplicación o los
programadores de la API. Ejemplos: IllegalArgumentException, IllegalStateException.
[Link]