laboratorio

1. EXCEPCIONES PROPIAS
El lenguaje Java proporciona las clases que manejan casi cualquier tipo de excepción. Sin embargo, en
algunos casos se pueden presentar situaciones en la que producen excepciones que no están dentro del
lenguaje Java. En este tipo de caso se deben de programar excepciones propias.
En casos como: ingresar edades, estaturas o tamaños negativos, una aplicación puede fallar, por lo cual se
debería manejar las excepciones que le indiquen al programador que debe validar este error. Para crear una
excepción propia se debe programar una nueva clase que herede de Exception. En el siguiente código es un
ejemplo de cómo manejar la edad negativa con una excepción propia.
Lo primero que se debe hacer es programar la nueva excepción:
/**
* Excepción para manejar la edad negativa de una persona
* @author mac
* @version 1.0
*/
public class EdadNegativaException extends Exception {
/**
* Permite usar el constructor de la superclase con mensaje
* @param mensaje mensaje que se desea mostrar
*/
public EdadNegativaException(String mensaje) {
super(mensaje);
}
/**
* Permite manejar el constructor de la superclase que no usa parametros
*/
public EdadNegativaException() {
super();
}
}
Ahora se hace uso de la excepción:
/**
* Clase que muestra un ejemplo de cómo usar una excepción propia
* @author mac
* @version 1.0
*/
public class ManejoDeExcepcionesPropias {
public static void main(String[] args) {
int edad = 34;
Lenguaje de
programación
Técnica profesional en desarrollo de software
Profesor: Andrés Herrera R. Mail: jherrera@eam.edu.co
Laboratorio
Excepciones propias
Nombre:_________________________________________________________________________

2. 2
String nombre= "Ana";
try {
System.out.println(crearPersona(edad, nombre).getEdad());
} catch (EdadNegativaException e) {
e.printStackTrace();
}
}
/**
* Se encarga de crear una nueva persona
* @param edad edad de la persona
* @param nombre nombre de la persona
* @return la nueva persona
* @throws EdadNegativaException error por agregar una edad negativa
*/
private static Persona crearPersona(int edad, String nombre) throws
EdadNegativaException {
if( edad < 0 ){
throw new EdadNegativaException("Error por agregar una edad negativa");
}
return new Persona(nombre, edad);
}
}
Como se puede ver en el código anterior, cuando se ingresa una edad negativa automáticamente se lanzar
una excepción (verificada) indicando que ha ocurrido un error, esto le advertirá a los programadores que
deben manejar el error ocurrido. Si desea lanzar una excepción no verificada se debería usar como
superclase a RuntimeException.
Asociar cada uno de los tipos de fallas graves en tiempo de ejecución con una clase Exception con
nombre apropiado ayuda a mejorar la claridad del programa.
Por convención, todos los nombres de las clases de excepciones deben terminar con la palabra
Exception.
De ser posible, se deben indicar las excepciones en los métodos mediante el uso de las clases de
excepciones existentes, en vez de crear nuevas. La API de Java contiene muchas clases de excepciones que
podrían ser adecuadas para el tipo de problema que el método necesite indicar.
Multi-catch
Es muy común que después de un bloque try haya varios bloques catch para manejar diversos tipos de
excepciones. Si los cuerpos de varios bloques catch son idénticos, el programador puede usar la nueva
característica multi-catch de Java SE7 para atrapar esos tipos de excepciones en un solo manejador catch y
realizar la misma tarea.

3. 3
La sintaxis para el multi-catch es:
catch ( Ttpo1 | Ttpo2 | Ttpo3 e )
Cada tipo de excepción se separa de la siguiente con una barra vertical (|). La línea anterior de código indica
que es posible atrapar uno de los tipos especificados (o cualquier subclase de esos tipos) en el manejador de
excepciones. En una clausula multi-catch, se puede especificar cualquier cantidad de tipos Throwable.
Try con recursos
Por lo general, el código para liberar recursos debe colocarse en un bloque finally, para asegurar que se libere
un recurso sin importar que se hayan lanzado excepciones cuando se utilizó́ ese recurso en el bloque try
correspondiente. Hay una notación alternativa, la instrucción try con recursos (nueva en Java SE 7), que
simplifica la escritura de código en donde se obtienen uno o más recursos, se utilizan en un bloque try y se
liberan en el correspondiente bloque finally. Cada recurso debe ser un objeto de una clase que implemente a
la interfaz AutoCloseable; dicha clase tiene un método llamado close. La forma general de una instrucción try
con recursos es:
try ( NombreClase elObjeto = new NombreClaseO ) {
// aquí se usa elObjeto catch
}
catch ( Exception e ){
// atrapa las excepciones que ocurren al usar el recurso
}
Para asignar varios recursos en el paréntesis del bloque try, se debe agregar consecutivos separados por
punto y como (;).
PRACTICA
1- Cree un proyecto java y nómbrelo <<Manejo de Excepciones Propias>>.
2- Cree un paquete de nombre <<com.EAM.lenguaje.excepciones>>
3- Cree una clase de nombre <<ManejoDeExcepciones>> con el método main.
4- Cree una excepción de nombre <<RangoException>>. Programe un método que reciba como parámetro un numero entero.
Lance la excepción <<RangoException>> si el numero que entra como parámetros no esta entre el rango de 0 a 100.
Llame el método desde el main, use Scanner para obtener el dato de entrada.
5- Cree una excepción de nombre <<NombrePersonaException>>. Programe un método que reciba como parámetro una
cadena de texto, y lance la excepción <<NombrePersonaException>> si la cadena contiene un símbolo diferente a una
letra. Llame el método desde el main, use Scanner para obtener el dato de entrada.
6- Cree una excepción de nombre <<CorreoElectronicoException>>. Programe un método que reciba una cadena de texto
como parámetro, lance la excepción use esta excepción <<CorreoElectronicoException>> si la cadena no tiene el formato
de una correo electrónico. Llame el método desde el main, use Scanner para obtener el dato de entrada.

4. 4
7- Programe en el método main una instrucción try que maneje las tres excepciones creadas en los puntos anteriores (debe
usar multi-catch).
8- Investigue y programe un ejemplo donde use un bloque try con recursos.
ENTREGABLE
Mostrar la Practica realizada en su totalidad.
BIBLIOGRAFÍA
Deitel, P. J. & Deitel, H. M. (2012). Como Programar en java. Novena edición. México: Prentice Hall.