Existen dos tipos de excepciones en Java:
- No verificadas.
- Verificadas.
Las excepciones no verificadas son aquellas que dejan al programador tomar la decisión de la conveniencia de atraparla o no.
Todas las excepciones vistas hasta ahora son 'no verificadas': InputMismatchException, ArithmeticException, NumberFormatException y IndexOutOfBoundsException. Existen en el API de Java muchas otras excepciones de este tipo.
Si queremos una lista completa de excepciones no verificadas en Java podemos visitar la documentación oficial aquí. Todas estas clases heredan de la clase java.lang.RuntimeException
Excepciones verificadas.
Este nuevo tipo de excepciones tienen la característica que deben ser capturadas en forma obligatoria por nuestro programa, si no la capturamos no se compila nuestra aplicación.
Las excepciones que se definen como verificadas generalmente son errores que no son directamente de nuestro programa sino a errores que surgen por ejemplo al intentar conectarnos a una base de datos, abrir un archivo inexistente, problemas de conexión de red etc.
La captura y tratamiento de la excepción verificada es idéntica a las excepciones no verificadas, con la salvedad que no podemos omitirla.
Problema:
Crear un archivo de texto con dos líneas. Luego proceder a leer el contenido del archivo de texto y mostrarlo por pantalla.
Programa:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CreacionLecturaArchivoTXT {
public static void main(String[] ar) {
try {
FileWriter fw = new FileWriter(new File("datos.txt"));
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Línea 1");
bw.newLine();
bw.write("Línea 2");
bw.close();
fw.close();
} catch (IOException ex) {
System.out.println("Problemas en la creación del archivo");
System.out.println(ex.getMessage());
}
try {
FileReader fr = new FileReader(new File("datos.txt"));
BufferedReader br = new BufferedReader(fr);
String linea = br.readLine();
while (linea != null) {
System.out.println(linea);
linea = br.readLine();
}
br.close();
fr.close();
} catch (IOException ex) {
System.out.println("Problemas con la lectura del archivo");
System.out.println(ex.getMessage());
}
}
}
Para crear un archivo de texto utilizamos la clase FileWriter. Al constructor hay que pasar un objeto de la clase File indicando el nombre del archivo de texto a crear:
FileWriter fw = new FileWriter(new File("datos.txt"));
El constructor de la clase FileWriter si tiene un problema en la creación del archivo procede a elevar una excepción de tipo 'IOException' que pertenece al grupo de excepciones 'verificadas'.
Podemos probar de no disponer el bloque try/catch y veremos que el compilador detecta que la clase FileWriter genera excepciones verificadas:
Como podemos comprobar el entorno de Eclipse nos informa que no hemos capturado la excepción.
Utilizamos la clase BufferedWriter para hacer más eficiente la creación del archivo de texto:
try {
FileWriter fw = new FileWriter(new File("datos.txt"));
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Línea 1");
bw.newLine();
bw.write("Línea 2");
bw.close();
fw.close();
} catch (IOException ex) {
System.out.println("Problemas en la creación del archivo");
System.out.println(ex.getMessage());
}
La lectura del archivo de texto requiere la clase FileReader que también genera excepciones verificadas:
try {
FileReader fr = new FileReader(new File("datos.txt"));
BufferedReader br = new BufferedReader(fr);
String linea = br.readLine();
while (linea != null) {
System.out.println(linea);
linea = br.readLine();
}
br.close();
fr.close();
} catch (IOException ex) {
System.out.println("Problemas con la lectura del archivo");
System.out.println(ex.getMessage());
}
Para ver que nos retorna el método getMessage de la clase IOException dispongamos la lectura de un archivo distinto al que creamos:
Todas estas clases heredan de la clase java.lang.Exception pertenecen a excepciones verificadas y debemos capturarlas.
Otras excepciones verificadas que podemos nombrar son: SQLException, InterruptedException etc.
Si queremos una lista completa de excepciones verificadas en Java podemos visitar la documentación oficial aquí. Todas estas clases heredan de la clase java.lang.Exception
Comando throws
Podemos dejar que la máquina virtual de Java se encargue de las excepciones no verificas agregando la palabra clave throws y el nombre de la excepción en el método main en este caso, luego si ocurre un error se detiene el programa y nos informa la excepción lanzada:
Programa:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CreacionLecturaArchivoTXT {
public static void main(String[] ar) throws IOException {
FileWriter fw = new FileWriter(new File("datos.txt"));
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Línea 1");
bw.newLine();
bw.write("Línea 2");
bw.close();
fw.close();
FileReader fr = new FileReader(new File("datos2.txt"));
BufferedReader br = new BufferedReader(fr);
String linea = br.readLine();
while (linea != null) {
System.out.println(linea);
linea = br.readLine();
}
br.close();
fr.close();
}
}
Tengamos en cuenta que hemos ingresado un error cuando tratamos de leer el archivo de texto 'datos2.txt', dicho archivo no existe.
Si utilizamos el comando throws en otro método distinto a la main luego quien llame a dicho método deberá implementar la excepción verificada o también propagar la excepción con un nuevo comando throws:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CreacionLecturaArchivoTXT {
public static void crear() throws IOException {
FileWriter fw = new FileWriter(new File("datos.txt"));
BufferedWriter bw = new BufferedWriter(fw);
bw.write("Línea 1");
bw.newLine();
bw.write("Línea 2");
bw.close();
fw.close();
}
public static void leer() throws IOException {
FileReader fr = new FileReader(new File("datos.txt"));
BufferedReader br = new BufferedReader(fr);
String linea = br.readLine();
while (linea != null) {
System.out.println(linea);
linea = br.readLine();
}
br.close();
fr.close();
}
public static void main(String[] ar) throws IOException {
crear();
leer();
}
}
Los tres métodos propagan las excepciones mediante el comando throws.
La captura de excepciones verificadas y su tratamiento evitando el throws hace nuestros programas más robustos.