Instituto Universitario Politcnico Santiago Mario

Extensin Puerto Ordaz

Escuela de Ingeniera de Sistemas
Escuela: 47
Seccin: I

Manejo de
Excepciones

Alumnos:

Jos Andrs Mndez

CI: 24179421
Indice
Introduccin......................................................................................................... 3
Excepciones........................................................................................................ 4
Manejo de Excepciones:....................................................................................... 4
Tipos de Excepciones........................................................................................... 4
Sintaxis................................................................................................................ 5
Bloques try y catch............................................................................................... 5
Mtodo finally...................................................................................................... 6
Como se manipula una excepcin:........................................................................7
Como Crear Excepciones Propias.........................................................................8
Un error de software:............................................................................................ 9
Tipos de Errores................................................................................................. 11
o

Errores de Sintaxis:...................................................................................... 11

Errores de Ejecucin:................................................................................... 12

Errores de Lgica:........................................................................................ 12

Conclusin......................................................................................................... 13

Introduccin
Como se sabe, los programas algunas veces generan errores. Los errores de
tiempo de compilacin tienen que ver con una sintaxis incorrecta, como olvidar
escribir entre parntesis una condicin de definicin if. Los errores de tiempo de
ejecucin tienen que ver con cdigos que se comportan de manera incorrecta,
como intentar dividir entre cero. Como ya sabemos, los errores de tiempo de
compilacin se reparan generalmente, al corregir la sintaxis errnea, y los errores
de tiempo de ejecucin se reparan al robustecer el cdigo. A continuacin se
abordaran usando una tcnica diferente: el manejo de excepciones. Las
excepciones son errores, o simplemente algo que va mal en un programa. El
manejo de excepciones es una forma elegante de tratar con tales problemas.

Excepciones
Una excepcin es una situacin anmala a la que llega la ejecucin de un
programa. Estas situaciones anmalas pueden ser desde el intento de abrir un
fichero que no existe, a la divisin por cero.
Java proporciona un mecanismo para detectar y solucionar las excepciones que
se puede llegar a producir durante la ejecucin de un programa. En Java estamos
obligados a tratar las excepciones cuando se producen, bien gestionndolas
directamente o bien desentendindonos de ellas, pero hasta esto ltimo debemos
hacerlo explcitamente.

Manejo de Excepciones: El manejo de excepciones es una tcnica de

programacin que permite al programador controlar los errores ocasionados
durante la ejecucin de un programa informtico. Cuando ocurre cierto tipo de
error, el sistema reacciona ejecutando un fragmento de cdigo que resuelve la
situacin, por ejemplo retornando un mensaje de error o devolviendo un valor por
defecto.
Tipos de Excepciones
En Java existen dos grandes tipos de excepciones: los Errores y las Excepciones
propiamente dichas.
Los Errores son situaciones irrecuperables, por ejemplo fallos de la mquina vitual.
Ante ellos no hay ms alternativa que cerrar la aplicacin, y no estamos obligados
a gestionarlas.
Las excepciones son situaciones anmalas ante las cuales bien debemos
reaccionar o bien nos desentendemos explcitamente. Cuando una excepcin se
produce se acompaa de toda la informacin relevante para que podamos
gestionarla.

Un caso particular son las excepciones que derivan de RuntimeException, como

por ejemplo
NullPointerException. No estamos obligados a tratar este tipo de excepciones, ya
que sera muy incmodo tener que comprobar cada vez que, por ejemplo, una
referencia es vlida antes de utilizarla.
Aunque, si deseamos tratar este tipo de excepciones podemos hacerlo.
Sintaxis

Esta es la sintaxis para los bloques try y catch:

Try
{
<statement(s)>
}

Normalmente, una o ms de estas

declaraciones es una llamada
peligrosa a un mtodo API o a un
constructor.

catch (<exception-class> <parameter>)

{
<error-handling-code>

La clase exception debe coincidir con el

tipo de excepcin que pudiera lanzar el
bloque try.

Bloques try y catch

En el caso de las excepciones que no pertenecen a las RuntimeException y que
por lo tanto Java obliga a tenerlas en cuenta habr que utilizar los bloques try,
catch y finally. El cdigo dentro del bloque try est vigilado: Si se produce una
situacin anormal y se lanza por lo tanto una excepcin el control salta o sale del
bloque try y pasa al bloque catch, que se hace cargo de la situacin y decide lo
que hay que hacer. Se pueden incluir tantos bloques catch como sean necesarios,
cada uno de los cuales tratar un tipo de excepcin.

Las excepciones se pueden capturar individualmente o en grupo, por medio de

una superclase de la que deriven todas ellas.
El bloque finally es opcional. Si se incluye sus sentencias se ejecutan siempre, sea
cual sea la excepcin que se produzca o si no se produce ninguna. El bloque
finally se ejecuta aunque en el bloque try haya un return.
En el siguiente ejemplo se presenta un mtodo que debe "controlar" una
IOException relacionada con la lectura ficheros y una MyException propia:

void metodo1(){
...
try {
// Cdigo que puede lanzar las excepciones IOException y MyException
} catch (IOException e1) {// Se ocupa de IOException simplemente dando aviso
System.out.println(e1.getMessage());
} catch (MyException e2) {
// Se ocupa de MyException dando un aviso y finalizando la funcin
System.out.println(e2.getMessage()); return;
} finally { // Sentencias que se ejecutarn en cualquier caso
...
}
...
} // Fin del metodo1

Mtodo finally
El bloque finally debe ir detrs de todos los bloques catch considerados. Si se
incluye (ya que es opcional) sus sentencias se ejecutan siempre, sea cual sea el
tipo de excepcin que se produzca, o incluso si no se produce ninguna. El bloque
finally se ejecuta incluso si dentro de los bloques try/catch hay una sentencia
continue, break o return. La forma general de una seccin donde se controlan las
excepciones es por lo tanto:

try {
// Cdigo vigilado que puede lanzar una excepcin de tipo A, B o C
} catch (A a1) {
// Se ocupa de la excepcin A
} catch (B b1) {
// Se ocupa de la excepcin B
} catch (C c1) {
// Se ocupa de la excepcin C
} finally {
// Sentencias que se ejecutarn en cualquier caso
}

Como se manipula una excepcin:

Toda sentencia susceptible de lanzar una excepcin debe ir en un bloque try{...}.
Si se lanza la excepcin, la ejecucin se abandonar en la sentencia que la lanz
y se ejecutar el bloque catch(Exception e) {...} que atrape la excepcin generada.
Ejemplo:
try {
readFromFile("Este fichero no existe");
}
catch(FileNotFoundException e) {
//Aqu tratamos esta excepcin
}
catch(IOException e) {
//Aqu tratamos esta otra
}
finally {
//Aqu realizamos las tareas comunes.
}

Si el fichero del que se pretende leer no existe, se lanza una excepcin del tipo
FileNotFoundException que atrapamos en el bloque catch correspondiente. En la
jerarqua de las clases excepcin, FileNotFoundException hereda de IOException
que a su vez hereda de Exception que es la raz de esta jerarqua; por lo tanto los
bloques catch deben aparecer de mayor a menor profundidad en la jerarqua, ya
que de lo contrario como un FileNotFoundException es un IOException, la
excepcin quedara atrapada en este bloque.
Como hemos comentado antes, no es necesario que tratemos las excepciones,
pero si no lo vamos a hacer, debemos indicarlo explcitamente. El modo de hacerlo
es indicando que el mtodo dentro del cual se puede lanzar una excepcin a su
vez la relanza, aqu tienes un ejemplo: void metodoLanzador(int a) throws
IOException, ClassNotFoundException {...}
Una situacin comn es que en un mtodo en el que se pueden producir varias
excepciones, sea necesario liberar recursos si alguna de ellas se produce. Piensa
por ejemplo en un mtodo que est accediendo a una base de datos, si se
produce alguna excepcin probablemente deseemos cerrar la conexin con la
base de datos. Para evitar escribir el mismo cdigo sea cual sea la excepcin que
se produce el par try{...} catch{...} se puede ampliar con un bloque finally{...}, de
modo que, sea cual sea la excepcin que se produzca, al salir del bloque catch{...}
que la trate siempre se ejecuta el bloque finally. En el Ejemplo 7-1 se muestra un
caso de uso.
Como Crear Excepciones Propias
Para crear una excepcin propia basta extender la clase Exception o la
excepcin ms adecuada, y en el constructor de la clase llamar a la clase padre
con el mensaje que se desee mostrar cuando se produzca la excepcin.
Para arrojar una excepcin explcitamente, utilizamos la palabra reservada trhow e
indicamos en la declaracin del mtodo que puede lanzar la excepcin deseada.
En el siguiente cdigo tienes un ejemplo.

Observa que para arrojar una excepcin debes crear un objeto del tipo de la
excepcin que deseas lanzar.
Cuando la JVM instancia un objeto excepcin, se dice que la JVM lanza un
excepcin. Aqu se preferia decir lanza un objeto excepcin en lucar de lanza
una excepcin puesto que la cosa que se lanza es un objeto excepcin.
Ejemplo:
public class MiExcepcion extends Excepcion {
public MiExcepcion() {
super("Texto de la excepcion");
}
}
public class LanzaExcepcion {
public void metodo() throws MiExcepcion {
//...
if(a < b) trhow new MiExcepcion();
//...
}
}
public class OtraClase {
public void metodo() {
LanzaExcepcion le = new LanzaExcepcion();
try {
le.metodo();
}
catch (MiExcepcion e) {
System.err.println(e.getMessage());
}
}

Programa Ejemplo
package javaapplication4;
import java.util.Scanner;
import java.util.InputMismatchException;

public class JavaApplication4 {

public static void main(String[] args) {

Scanner stdIn = new Scanner(System.in);
int num; //lucky num
try
{
System.out.printf("Introduzca su numero de la Suerte(un entero): ");
num = stdIn.nextInt();
}
catch(InputMismatchException e)
{
System.out.println(
"Entrada invalida. Usted debe proporcionar un numero de la suerte.");
num = (int) (Math.random() * 10) + 1; // entre 1 - 10
}
System.out.println("su numero de la suerte es " + num + ".");

Un error de software: comnmente conocido como bug, es un error o fallo en un

programa de computador o sistema de software que desencadena un resultado
indeseado. Los programas que ayudan a la deteccin y eliminacin de errores de
programacin de software son denominados depuradores.

Tipos de Errores
o Errores de Sintaxis:
Cuando en alguna instruccin del cdigo fuente de un programa existe un error de
sintaxis, dicho error impedir, tanto al compilador como al intrprete, traducir dicha
instruccin, ya que, ninguno de los dos entender qu le est diciendo el
programador. Por ejemplo, en lenguaje C.

Si en vez de la instruccin:
printf( "\n Introduzca el primer nmero (entero): " );
Un programador escribe:
prrintf( "\n Introduzca el primer nmero (entero): " );

Cuando el compilador o el intrprete lean esta lnea de cdigo, ninguno de los dos
entender qu es "prrintf" y, por tanto, no sabrn traducir esta instruccin a cdigo

mquina, por lo que, ambos pararn la traduccin y avisarn al programador con

un mensaje de error.
En resumen, los errores de sintaxis se detectan en el proceso de traduccin del
cdigo fuente a cdigo binario. Al contrario que ocurre con los errores de ejecucin
y de lgica, que slo se pueden detectar cuando el programa se est ejecutando.

o Errores de Ejecucin:
Un error de ejecucin se produce cuando el ordenador no puede ejecutar alguna
instruccin de forma correcta. Por ejemplo, en lenguaje C, la instruccin:
c = 5 / 0;
Es correcta sintcticamente y ser traducida a cdigo binario. Sin embargo,
cuando la computadora intente realizar la divisin:
5/0
Se producir un error de ejecucin, ya que, matemticamente, no se puede dividir
entre cero.
o Errores de Lgica:
En cuanto a los errores de lgica son los ms difciles de detectar. Cuando un
programa no tiene errores de sintaxis ni de ejecucin, pero, aun as, no funciona
bien, esto es debido a la existencia de algn error lgico. De manera que, un error
de lgica se produce cuando los resultados obtenidos no son los esperados. Por
ejemplo, en lenguaje C, si en vez de la instruccin:
c = a + b;
Un programador hubiera escrito:
c = a * b;

Hasta que no se mostrase por pantalla el resultado de la operacin, el

programador no podra darse cuenta del error, siempre que ya supiese de
antemano el resultado de la suma. En este caso, el programador podra
percatarse del error fcilmente, pero, cuando las operaciones son ms complejas,
los errores de lgica pueden ser muy difciles de detectar.

Conclusin
Para realizar nuevas excepciones basta con declarar a una clase como hija de la
clase Exception. Se puede crear excepciones diferentes a las existentes ya preestablecidas en el lenguaje de programacin java. Se pudo realizar las
excepciones con las cuales se cumpli los objetivos planteamos. Logramos validar
cdula por medio de excepciones.