Docsity
Docsity

Prepara tus exámenes
Prepara tus exámenes

Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity


Consigue puntos base para descargar
Consigue puntos base para descargar

Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium


Orientación Universidad
Orientación Universidad


Excepciones en Programación Java: Tipos, Manejo y Creación, Apuntes de Ingeniería Infórmatica

Lo básico sobre las excepciones en java, desde su definición, tipos, manejo y creación. Aprenderás qué son las excepciones, cómo se diferencian de problemas normales, cómo se lanzan y capturan, y cómo crear tus propias excepciones. Además, se abordarán los bloques try y catch, manejadores de excepciones y las clases throwable, error y exception.

Tipo: Apuntes

Antes del 2010

Subido el 22/05/2007

_vivayo_
_vivayo_ 🇪🇸

3.7

(117)

149 documentos

1 / 4

Toggle sidebar

Esta página no es visible en la vista previa

¡No te pierdas las partes importantes!

bg1
Excepciones
El momento ideal para coger los errores es en tiempo de compilación, pero no todos los
errores se pueden detectar hasta tiempo de ejecución.
Ejemplo de C que devuelve códigos de error.
Si podemos tener un error, pero no sabemos como debemos manejarlo en un momento
dado, lanzamos la excepción a un nivel superior, para que en algún sitio con más
información lo manejen.
Las excepciones hacen más limpio el manejo de errores. Ahora no tenemos que
preguntar al llamar al método en el momento de llamarlo, la excepción garantiza que
alguien tiene que tratarla. Y sólo tenemos que manejar el problema en un sitio, el
manejador de excepciones. Esto salva el código y separa el código que describe lo que
queremos del que se ejecuta cuando las cosas se tuercen.
Excepciones básicas
Una condición excepcional es un problema que no permite la continuación del método
o bloque en el que estamos. Es importante distinguir entre excepción y problema
normal, en este último tenemos suficiente información para manejar el problema. Con
la excepción no tenemos información suficiente para manejarlo.
Argumentos de las excepciones.
El las excepciones estándar hay dos constructores: por defecto y con un String como
argumento.
La palabra clave throw hace que pasen varias cosas “mágicas”:
se utiliza new para crear un nuevo objeto que representa la condición de error.
La referencia la pasamos a throw
El objeto es devuelto desde el método, aunque ese método no esté diseñado para
devolver ese tipo de objetos, y termina.
Aunque parezca parecido a return, hay varias diferencias importantes.
el flujo de control pasa a un punto diferente que si volvemos con return.
La información del error está representada dentro de la excepción y va implícito en el
tipo de la excepción, para que alguien en un nivel superior pueda saber que hacer con la
excepción.
Cogiendo una excepción
Si un método lanza una excepción, debe asumir que esa excepción es cogida y tratada
en algún sitio.
Una de las ventajas de java es que te permite concentrarte en el problema que quieres
resolver y tratar los errores en otra parte.
El bloque try
Si dentro de un bloque o método se lanza una excepción, el método termina en el
momento en el que lanza la excepción. Si no queremos que se termine el método,
podemos prepara un bloque especial para capturar la excepción (try). Todos los métodos
que pueden lanzar excepciones van dentro del bloque try y todas las excepciones se
capturan en el mismo sitio. El código es mucho más fácil de escribir y leer.
Manejadores de excepciones.
Van justo detrás del bloque try. Y se denotan por la palabra clave catch.
pf3
pf4

Vista previa parcial del texto

¡Descarga Excepciones en Programación Java: Tipos, Manejo y Creación y más Apuntes en PDF de Ingeniería Infórmatica solo en Docsity!

Excepciones

El momento ideal para coger los errores es en tiempo de compilación, pero no todos los

errores se pueden detectar hasta tiempo de ejecución.

Ejemplo de C que devuelve códigos de error.

Si podemos tener un error, pero no sabemos como debemos manejarlo en un momento

dado, lanzamos la excepción a un nivel superior, para que en algún sitio con más

información lo manejen.

Las excepciones hacen más limpio el manejo de errores. Ahora no tenemos que

preguntar al llamar al método en el momento de llamarlo, la excepción garantiza que

alguien tiene que tratarla. Y sólo tenemos que manejar el problema en un sitio, el

manejador de excepciones. Esto salva el código y separa el código que describe lo que

queremos del que se ejecuta cuando las cosas se tuercen.

Excepciones básicas

Una condición excepcional es un problema que no permite la continuación del método

o bloque en el que estamos. Es importante distinguir entre excepción y problema

normal , en este último tenemos suficiente información para manejar el problema. Con

la excepción no tenemos información suficiente para manejarlo.

Argumentos de las excepciones.

El las excepciones estándar hay dos constructores: por defecto y con un String como

argumento.

La palabra clave throw hace que pasen varias cosas “mágicas”:

• se utiliza new para crear un nuevo objeto que representa la condición de error.

• La referencia la pasamos a throw

• El objeto es devuelto desde el método, aunque ese método no esté diseñado para

devolver ese tipo de objetos, y termina.

Aunque parezca parecido a return , hay varias diferencias importantes.

• el flujo de control pasa a un punto diferente que si volvemos con return.

La información del error está representada dentro de la excepción y va implícito en el

tipo de la excepción, para que alguien en un nivel superior pueda saber que hacer con la

excepción.

Cogiendo una excepción

Si un método lanza una excepción, debe asumir que esa excepción es cogida y tratada

en algún sitio.

Una de las ventajas de java es que te permite concentrarte en el problema que quieres

resolver y tratar los errores en otra parte.

El bloque try

Si dentro de un bloque o método se lanza una excepción, el método termina en el

momento en el que lanza la excepción. Si no queremos que se termine el método,

podemos prepara un bloque especial para capturar la excepción (try). Todos los métodos

que pueden lanzar excepciones van dentro del bloque try y todas las excepciones se

capturan en el mismo sitio. El código es mucho más fácil de escribir y leer.

Manejadores de excepciones.

Van justo detrás del bloque try. Y se denotan por la palabra clave catch.

Cada cláusula catch es como un pequeño método que tiene un solo argumento de un

tipo particular. El identificador puede ser usado dentro del manejador. A veces el

identificador no se utiliza porque el tipo de la excepción nos da suficiente información,

pero debe estar de todas formas.

Cuando una excepción es capturada por un catch se considera tratada y deja de buscar

manejadores, no como en el switch.

Creando tus propias excepciones.

Para crear un nuevo tipo de excepción tienes que heredar de un tipo de excepción

existente, preferiblemente el más cercano al significado de tu nueva excepción.

  • Solo crearlo. No conseguimos el constructor con String de parámetro.
  • Crearlo para que tenga el constructor con parámetro String.
  • Crearlo con más cosas (atributos y métodos). Una excepción es un objeto, así

que podemos añadirle atributos y métodos cómo queramos, de todas formas hay

que tener en cuenta que habitualmente sólo se tiene en cuenta el tipo de la

excepción, por lo que cualquier cliente no tendrá en cuenta el resto.

La especificación de las excepciones.

En java hay que informar al cliente, que va a utilizar tus métodos, de qué excepciones se

lanzan desde ellos. Lógico ya que tienen que saber qué código deben escribir para

capturarlas.

No se puede mentir en este aspecto. No puede lanzar una excepción sin manejar y sin

especificar que se está lanzando. Error de compilación.

Hay un sitio donde sí se puede mentir. Puedes decir que lanzas una excepción que en

realidad no estás lanzando. Esto nos sirve para tener es sitio para lanzar la excepción

más tarde sin tener que cambiar el código. Importante también para clases abstractas e

interfaces.

Cogiendo cualquier excepción.

Capturando la clase base excepción.

Relanzar una excepción.

A veces interesará relanzar una excepción, sobre todo si es del tipo Exception.

Consigue que la excepción vaya a los manejadores de excepción de un nivel superior. El

resto de los catch son ignorados, y todo en el objeto excepción es preservado.

También se puede relanzar una excepción diferente de la que se ha capturado.

Las excepciones estándar en Java.

La clase Throwable describe todo lo que se puede lanzar como una excepción. Hay dos

tipos que heredan de Throwable. Error representa los errores en tiempo de compilación

y del sistema que no nos tenemos que preocupar en capturar. Exception es el tipo

básico que puede ser lanzado desde cualquier método y accidentes en tiempo de

ejecución. Es el tipo básico que le interesa el programador de java.

RuntimeException, un caso especial.

Ej NullPointerException.

Este tipo de excepciones son lanzadas automáticamente por Java y no es necesario que

las especifiquemos como excepciones en nuestros métodos. Todas estas excepciones

están agrupadas bajo una clase llamada RuntimeException (ejemplo perfecto de

herencia). Se asume que todos los métodos pueden lanzar Runtime… por eso no lo

tenemos que especificar. Si no capturamos estas excepciones llegaran al main.

//: c10:StormyInning.java // From 'Thinking in Java, 2nd ed.' by Bruce Eckel // www.BruceEckel.com. See copyright notice in CopyRight.txt. // Overridden methods may throw only the exceptions specified in their // base-class versions, or exceptions derived from the base-class exceptions. class BaseballException extends Exception {} class Foul extends BaseballException {} class Strike extends BaseballException {} abstract class Inning { Inning() throws BaseballException {} void event () throws BaseballException { // Doesn't actually have to throw anything } abstract void atBat() throws Strike, Foul; void walk() {} // Throws nothing } class StormException extends Exception {} class RainedOut extends StormException {} class PopFoul extends Foul {}

interface Storm { void event() throws RainedOut; void rainHard() throws RainedOut; } public class StormyInning extends Inning implements Storm { // OK to add new exceptions for // constructors, but you must deal // with the base constructor exceptions: StormyInning() throws RainedOut, BaseballException {} StormyInning(String s) throws Foul, BaseballException {} // Regular methods must conform to base class: //! void walk() throws PopFoul {} //Compile error // Interface CANNOT add exceptions to existing // methods from the base class: //! public void event() throws RainedOut {} // If the method doesn't already exist in the // base class, the exception is OK: public void rainHard() throws RainedOut {} // You can choose to not throw any exceptions, // even if base version does: public void event() {} // Overridden methods can throw inherited exceptions: void atBat() throws PopFoul {} public static void main(String[] args) { try { StormyInning si = new StormyInning(); si.atBat(); } catch(PopFoul e) { System.err.println("Pop foul"); } catch(RainedOut e) { System.err.println("Rained out"); } catch(BaseballException e) { System.err.println("Generic error"); } // Strike not thrown in derived version. try { // What happens if you upcast? Inning i = new StormyInning(); i.atBat(); // You must catch the exceptions from the base-class version of the method: } catch(Strike e) { System.err.println("Strike"); } catch(Foul e) { System.err.println("Foul"); } catch(RainedOut e) { System.err.println("Rained out"); } catch(BaseballException e) { System.err.println( "Generic baseball exception"); } } } ///:~