Download Las excepciones estándar - Iut

Las excepciones estándar
Los programadores de cualquier lenguaje se esfuerzan por escribir programas libres de errores, sin
embargo, es muy difícil que los programas reales se vean libres de ellos. En Java las situaciones que
pueden provocar un fallo en el programa se denominan excepciones. Java lanza una excepción en
respuesta a una situación poco usual. El programador también puede lanzar sus propias excepciones.
Las excepciones en Java son objetos de clases derivadas de la clase base Exception. Existen también
los errores internos que son objetos de la clase Error que no estudiaremos. Ambas clases Error y
Exception son clases derivadas de la clase base Throwable. Existe toda una jerarquía de clases derivada
de la clase base Exception. Estas clases derivadas se ubican en dos grupos principales:
Las excepciones en tiempo de ejecución ocurren cuando el programador no ha tenido cuidado al
escribir su código. Por ejemplo, cuando se sobrepasa la dimensión de un array se lanza una excepción
ArrayIndexOutOfBounds. Cuando se hace uso de una referencia a un objeto que no ha sido creado se
lanza la excepción NullPointerException. Estas excepciones le indican al programador que tipos de
fallos tiene el programa y que debe arreglarlo antes de proseguir. El segundo grupo de excepciones, es
el más interesante, ya que indican que ha sucedido algo inesperado o fuera de control.
Captura de las excepciones
Empecemos por solucionar el error que se produce en el programa durante la compilación. Tal como
indica el mensaje que genera el compilador, se ha de poner la sentencia System.in.read(); en un bloque
try...catch, del siguiente modo.
try {
System.in.read();
}
catch (IOException ex)
{ }
Para solucionar el error que se produce en el programa durante su ejecución, se debe poner la llamada a
Integer.parseInt en el siguiente bloque try...catch.
String str="12";
int numero;
try{
numero=Integer.parseInt(str);
}
catch(NumberFormatException ex)
{
System.out.println("No es un número…");
}
En el caso de que el string str contenga caracteres no numéricos como es éste el caso, el número 12 está
acompañado de espacios en blanco, se produce una excepción del tipo NumberFormatException que es
capturada y se imprime el mensaje "No es un número". En vez de un mensaje propio se puede imprimir
el objeto ex de la clase NumberFormatException
try{
//...
}
catch(NumberFormatException ex)
{
System.out.println(ex);
}
La clase base Throwable de todas las clases que describen las excepciones, redefine la función toString,
que devuelve el nombre de la clase que describe la excepción acompañado del mensaje asociado, que
en este caso es el propio string str.
java.lang.NumberFormatException:
12
Podemos extraer dicho mensaje mediante la función miembro getMessage, del siguiente modo
try{
//...
}
catch(NumberFormatException ex)
{
System.out.println(ex.getMessage());
}
Si usted desea saber mas de las Exceptions en Java: revise la siguiente pagina:
http://mindprod.com/jgloss/exception.html
Manejando varias excepciones
Vamos a crear un programa que divida dos números. Supongamos que los números se introducen én
dos controles de edición. Se obtiene el texto de cada uno de los controles de edición que se guardan en
dos strings. En esta situación se pueden producir dos excepciones NumberFormatException, si se
introducen caracteres no numéricos y ArithmeticException si se divide entre cero.
public class ExcepcionApp
{
public static void main(String[] args)
{
String str1="12";
String str2="0";
String respuesta;
int numerador, denominador, cociente;
try{
numerador=Integer.parseInt(str1);
denominador=Integer.parseInt(str2);
cociente=numerador/denominador;
respuesta=String.valueOf(cociente);
}
catch(NumberFormatException ex)
{
respuesta="Se han introducido caracteres no numéricos";
}
catch(ArithmeticException ex)
{
respuesta="División entre cero";
}
System.out.println(respuesta);
}
}
Como vemos las sentencias susceptibles de lanzar una excepción se sitúan en un bloque try...catch. Si
el denominador es cero, se produce una excepción de la clase ArithmeticException en la expresión que
halla el cociente, que es inmediatamente capturada en el bloque catch que maneja dicha excepción,
ejecutándose las sentencias que hay en dicho bloque. En este caso se guarda en el string respuesta el
texto "División entre cero". Hay veces en las que se desea estar seguro de que un bloque de código se
ejecute se produzcan o no excepciones. Se puede hacer esto añadiendo un bloque finally después del
último catch. Esto es importante cuando accedemos a archivos, para asegurar que se cerrará siempre un
archivo se produzca o no un error en el proceso de lectura/escritura.
try{
//Este código puede generar una excepción
}
catch(Exception ex)
{
//Este código se ejecuta cuando se produce una excepción
}
Finally
{
//Este código se ejecuta se produzca o no una excepción
}
Lectura por teclado en JAVA
El siguiente ejemplo, es una sección de código que permite (de una manera sencilla) leer el nombre de
una persona por teclado y mostrarlo por consola.
import java.io.*;
class lectura
{
public static void main(String[]args)throws IOException
{
BufferedReader T = new BufferedReader(new InputStreamReader(System.in));
String nombre;
System.out.println("Ingrese su nombre: ");
nombre = T.readLine();
System.out.println("Bienvenido " + nombre);
}
}
En java para poder escribir se emplea el objeto System.out, pero para leer del teclado es necesario
emplear System.in. Este objeto pertenece a la clase InputStream, esto significa que para leer tenemos
que emplear sus métodos, el más básico es read, que permite leer un carácter:
char caracter = (char) System.in.read();
Pero como podemos comprobar es muy incómodo leer de letra en letra, por ello para poder leer una
línea completa emplearemos el siguiente código:
BufferedReader lectura = new BufferedReader(new InputStreamReader(System.in));
En el cuál creamos un InputStreamReader a partir de System.in y pasamos dicho InputStreamReader al
constructor de BufferedReader, el resultado es que las lecturas que hagamos sobre lectura son en
realidad realizadas sobre System.in, pero con la ventaja de que se permite leer una línea completa.
Es necesario realizar un import de java.io para poder emplear esta lectura de líneas.
PROGRAMA LECTURA DE NÚMEROS POR TECLADO EN JAVA:
import java.io.*;
class lectura
{
public static void main(String[]args)throws IOException
{
BufferedReader T = new BufferedReader(new InputStreamReader(System.in));
int num;
System.out.println("Ingrese numero: ");
num = Integer.parseInt(lectura.readLine());
System.out.println("su numero es " + num);
}
}
Integer : Clase estándar que no necesita ser instanciada (está disponible por defecto).
parseInt : Método que convierte un string (cadena de caracteres) en un dato numérico de tipo int.
Este método pertenece a la clase de Java Integer.
y un ultimo ejemplo:
import java.io.*;
public class ejercicio {
public static void main(String[] args)throws IOException {
BufferedReader T = new BufferedReader(new InputStreamReader(System.in));
String nombre, apellido;
int edad;
System.out.println("Ingrese su nombre:");
nombre = T.readLine();
System.out.println("Ingrese su apellido:");
apellido = T.readLine();
System.out.println("Ingrese su edad:");
edad = Integer.parseInt(T.readLine());
System.out.println("Su nombre Completo es: " + nombre + apellido);
System.out.println("Su edad es:"+edad);
if (edad >=18)
{System.out.println("Usted es mayor de edad");}
else
{System.out.println("Usted no es mayor de edad");}
}
}