Saltar navegación

Manejo Exception parte 2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 21 de febrero de 2023 por Stefano C.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, todo lo que digáis puede ser grabado en este vídeo. 00:00:00
Entonces, estamos hablando de excepciones. 00:00:07
Y las excepciones, hemos visto que son estos errores que ocurren a tiempo de ejecución, 00:00:14
de que menos mal no podía saber que existían antes, podía imaginar que sí podían explotar algo, 00:00:26
pero que no puedo estar seguro de que va a pasar o no. 00:00:34
Y que entonces hemos visto que hay este sistema del try-catch, que me permite decir, tú inténtalo, 00:00:37
trae, y si algo pasa, catch. 00:00:44
Hemos visto que tenemos el objeto exception, que es la llave que la maquina intenta crear, 00:00:48
y lo más preciso posible con respecto a la... 00:00:59
Entonces, ¿cómo se lanzan las excepciones? 00:01:22
Es decir, ¿cómo puedo hacer yo que en un determinado momento la ejecución de mi programa, 00:01:27
en un cierto momento se dé cuenta que algo aquí está yendo mal, 00:01:34
y diga, oye mira, en este momento sí pasa esta cosa o bajo determinadas condiciones, 00:01:40
lo único que puedes hacer es explotar y lanzar una excepción. 00:01:46
Esta excepción luego podrá ser capturada con el try-catch que hemos visto antes. 00:01:51
Entonces yo tendré este método que lanza las excepciones, 00:01:58
no lo pronunciaré nunca más, nunca viene. 00:02:02
Las exceptions las tendré dentro de un try-catch, 00:02:05
y si llega a lanzar la excepción, pues lo recogerá el catch apropiado. 00:02:09
Entonces, para lanzar esta excepción se usa el comando throw. 00:02:15
Entonces, en un determinado momento de mi programa, 00:02:24
de un método o de algo que estoy programando, 00:02:28
le puedo decir que if no sé qué no sé cuánto, 00:02:31
si pasa esto, si la cosa no va bien, 00:02:34
o tengo que indicar que aquí mi programa tiene que fallar 00:02:37
porque no puede seguir adelante porque ha tenido un problema, 00:02:41
puedo lanzar una excepción. 00:02:44
Claramente crearé este objeto exception, 00:02:47
o crearé un objeto de una clase mía que es la xException, 00:02:50
que es hereda de exception, 00:02:56
y una vez que he creado ese objeto, lo lanzo. 00:02:59
Lo que se le pasa, o sea, el objeto este de aquí, 00:03:05
tiene que ser o exception o una subclase de exception. 00:03:08
Lo que decíamos antes. 00:03:13
Por lo tanto, incluirá todos los métodos que hemos visto antes, 00:03:15
más si yo estoy haciendo un manejo de excepciones, 00:03:19
míos, personales, 00:03:23
entonces a lo mejor yo puedo necesitar algunas cosas más, 00:03:25
algunos datos más o algunos métodos más, 00:03:28
y como me estoy creando mi propia clase que está en excepciones, 00:03:31
puedo añadir lo que me da la gana, 00:03:35
además de lo que hace exception normalmente. 00:03:37
Digamos que exception me da la infraestructura, 00:03:41
el esqueleto general de que todas las excepciones tienen que tener, 00:03:45
y a eso yo le añado lo que yo necesito. 00:03:49
Cuando se usa el throw, 00:03:57
se sale inmediatamente del bloco de código actual. 00:03:59
Es decir, que cuando llego a ejecutar un throw, 00:04:02
quiero decir que allí es que tengo que bloquear la ejecución. 00:04:04
No es que lanzo el throw y luego sigo con los datos que están detrás. 00:04:08
Porque si llego a ejecutar uno de estos, 00:04:12
quiere decir que ya ha llegado el momento de hacer saber 00:04:14
a quién ha lanzado o quién está trabajando con este método, 00:04:21
que aquí ha habido un error. 00:04:25
Si hay un error, no puedo seguir adelante. 00:04:27
Si yo estoy haciendo una división por cero, 00:04:29
no puedo decir que hago una división por cero 00:04:31
y sigo adelante utilizando el resultado de esta operación. 00:04:33
Si yo intento acceder a una celda que no existe 00:04:37
y luego desde esta celda tengo que sacar los datos 00:04:40
y hacer algo con esos datos, 00:04:43
si no he podido sacar, pues no puedo seguir adelante. 00:04:44
Si el bloqueo está asociado a la cláusula catch adecuada, 00:04:48
para el tipo de excepción generada, 00:04:51
se ejecuta ese cuerpo de catch. 00:04:53
O sea que si yo cuando lanzo throw, 00:04:55
esto está en un try catch y hay un catch para esa excepción, 00:04:57
pues se ejecuta ese catch. 00:05:01
Si no, se sale directamente del bloqueo 00:05:03
o del método donde estoy 00:05:07
y se lanzará esta excepción 00:05:09
a quien me ha llamado y de allí a quien me ha llamado 00:05:14
y de allí a quien me ha llamado 00:05:17
hasta que encontre una cláusula catch 00:05:18
que me permite depillarme. 00:05:22
Es decir, imaginaos que yo tengo el método A 00:05:25
que llama al método B, que llama al método C 00:05:28
y es en el método C donde se lanza la excepción, 00:05:31
donde se hace la throw. 00:05:34
Lo que se intentará hacer es 00:05:36
volver atrás en las llamadas 00:05:39
hasta buscar si uno de estos métodos 00:05:42
tiene un try catch con un catch 00:05:45
que pille este tipo de excepción. 00:05:47
Entonces, si el try catch 00:05:50
yo lo he metido directamente en el método C, 00:05:51
pues usaré el catch de ese método. 00:05:54
En cierto sentido, al explotar la excepción, 00:05:56
el método mismo intenta recuperarse. 00:05:59
Si en vez de no lo he hecho así, 00:06:02
el método C no tiene ningún try catch, 00:06:04
podría ser que el método B, 00:06:06
el que llamaba al método C, 00:06:08
tenga un try catch 00:06:10
y que el método B al método C 00:06:12
haya sido llamado dentro del try. 00:06:14
Entonces, en este caso voy a mirar 00:06:17
si algún catch de ese bloque 00:06:19
me permite pillar esta excepción. 00:06:21
Y si no, voy al método A. 00:06:24
Y si no llego al método A, 00:06:26
llegaré a un cierto momento 00:06:27
que llegaré al main, digamos, 00:06:28
al que ha lanzado, 00:06:32
y a ese punto no he manejado la excepción. 00:06:33
Si no he manejado la excepción, ¿qué pasa? 00:06:37
Pasa lo que ha pasado hasta ahora 00:06:41
cuando salía una excepción. 00:06:43
¿Qué os ha pasado ahora? 00:06:44
Hasta hoy no hemos gestionado ninguna excepción 00:06:45
y si yo llego arriba, arriba, arriba, arriba 00:06:51
y nadie ha hecho un try catch, 00:06:53
nadie ha hecho algo para manejarla, 00:06:55
pues simplemente bloqueo la ejecución del programa 00:06:57
y te escribo un pantallazo de 00:07:00
hoy mira, ha pasado esto. 00:07:02
Y se acabó. 00:07:04
No has gestionado el error. 00:07:05
¿Sí? 00:07:09
El proceso continúa hasta llegar 00:07:12
al método main de la aplicación. 00:07:13
Si ahí tampoco existe una causa catch adecuada, 00:07:14
la máquina Java virtual finaliza su ejecución 00:07:17
y da un mensaje error. 00:07:20
¿Dudas? 00:07:22
También está otra cosa que es el throws, ¿vale? 00:07:27
Con la S. 00:07:31
Este de aquí es algo que se pone 00:07:33
no dentro del cuerpo de un método 00:07:35
sino en el prototipo del método, 00:07:38
en la declaración del método, 00:07:40
como es aquí, ¿vale? 00:07:42
Por ejemplo, public void método F 00:07:43
que no pilla parámetros, 00:07:46
throws, una excepción. 00:07:47
Esto quiere decir que estás declarando 00:07:50
que el método F, 00:07:52
dentro de su ejecución, 00:07:55
puede en un determinado momento 00:07:57
lanzar una excepción de tipo E. 00:08:00
Tú estás diciendo sustancialmente 00:08:05
a quién te va a utilizar, 00:08:07
a quién va a utilizar F, 00:08:09
cuidado que cuando usas F 00:08:11
el resultado podría ser que explote 00:08:14
porque F hace determinadas operaciones 00:08:17
como por ejemplo hacerse un array 00:08:19
y haga un determinado momento 00:08:21
que si hace de malo el array 00:08:23
pues te lanzaría un índice autobando derecho. 00:08:24
De esta forma, yo desde fuera 00:08:30
que voy a utilizar F, 00:08:33
quiero meterlo dentro del try-catch 00:08:35
que pille ese tipo de excepción. 00:08:40
En vez de E puede ser índice autobando derecho. 00:08:43
E sería una excepción genérica de la clase E. 00:08:46
Si en el código método F 00:08:50
se lanza una excepción de la clase E, 00:08:52
sea cual sea porque la has creado tú, 00:08:54
es una clase tuya o una de que ya existe, 00:08:56
pues entonces en el prototipo 00:08:58
deberías poner throws E. 00:09:00
Es un modo para decir 00:09:03
mira, aquí hay un problema 00:09:06
pero no lo voy a gestionar yo, 00:09:08
lo voy a pasar por arriba. 00:09:10
Quien me llama tiene que estar consciente 00:09:12
que aquí puede haber un error 00:09:14
y entonces lo tiene que manejar él. 00:09:16
Y yo no te voy a manejar directamente 00:09:19
porque yo no siempre, 00:09:22
desde mi perspectiva optimista quizás, 00:09:24
yo voy a hacer las cosas con E 00:09:26
pero si explotara, explotará con esta excepción 00:09:28
y entonces se va a avanzar. 00:09:31
Esto pasa por ejemplo en cosas como 00:09:33
el acceso a ficheros. 00:09:35
Si tú accesas a ficheros, 00:09:37
podría ser que el fichero no exista 00:09:38
y que tú intentes leer un fichero que no existe. 00:09:40
Entonces algunos métodos 00:09:43
para creación de ficheros, 00:09:45
para buscar ficheros y cosas por el estilo 00:09:46
lanzan errores de tipo IOException, 00:09:48
Input Output Exception. 00:09:52
Y tú dices, 00:09:54
tiene quien va a crear el fichero, 00:09:55
manejar el fichero, 00:09:58
que tener en cuenta 00:10:00
que podría en algún momento 00:10:01
haber una IOException 00:10:02
y que entonces tendrá que manejar 00:10:04
y ver qué pasa cuando va a saltar 00:10:06
una de estas excepciones. 00:10:08
Esto sirve para que potenciales usuarios de EFE 00:10:11
sepan a qué atenerse. 00:10:14
Yo sé que si voy a utilizar EFE 00:10:16
me puede pasar esto, 00:10:18
por lo tanto, lo voy a manejar. 00:10:19
Si un método lanza más de un tipo de excepciones 00:10:21
se indican detrás de throws 00:10:23
separadas por comas. 00:10:24
Por ejemplo, público EFE, 00:10:26
throws E1, E2, E3. 00:10:27
Esto E1, E2, E3 no son objetos, 00:10:30
son clases. 00:10:32
Son excepciones. 00:10:34
Siempre lanza las excepciones. 00:10:41
¿Cuándo en un código utilizamos 00:10:44
métodos que lanzan potencialmente excepciones? 00:10:46
Siempre todavía tengo throws. 00:10:49
Estamos obligados a hacer 00:10:51
una de estas dos cosas. 00:10:52
Vamos a ver si yo tengo un código 00:10:54
y en este código estoy utilizando 00:10:56
un método que tiene declarado un throws. 00:10:58
Puede hacer dos cosas. 00:11:01
O proteger esta llamada del método 00:11:03
con un try catch. 00:11:05
Proteger esta llamada del método 00:11:07
con un try catch, fenomenal. 00:11:09
O decir que yo también lanzo esa excepción. 00:11:11
¿Arriba? 00:11:15
Yo soy un método que lanza la excepción. 00:11:17
Tengo otro método que usa ese método 00:11:21
que lanza la excepción. 00:11:23
Tiene dos opciones. 00:11:25
O manejo la excepción, 00:11:27
o la lanzo para ti. 00:11:29
Y será quien me ha llamado a mí 00:11:31
a hacer algo. 00:11:34
Depende un poco de cómo queréis 00:11:36
estructurar vuestro programa. 00:11:38
Esto delega la responsabilidad 00:11:43
de manejo a otras clases invocantes. 00:11:45
Y de ahí viene el sentido 00:11:47
del print stack trace. 00:11:49
El print stack trace que me permite saber 00:11:51
todas las llamadas de 00:11:53
quién me ha llamado a mí, etc. 00:11:55
Para saber más o menos 00:11:59
dónde es que ha explotado 00:12:01
y quién estaba llamando 00:12:03
para saber quién se debería haber 00:12:05
encargado de eso. 00:12:07
Y ver un poco. 00:12:09
Si la excepción lanzada es hija 00:12:11
de runtime exception, 00:12:13
no es necesario manejarla. 00:12:15
Esto es interesante. 00:12:17
Tenerlo por ahora allí. 00:12:21
Hago esta transparencia aquí 00:12:23
y luego os lo digo. 00:12:25
Pero hay excepciones especiales 00:12:27
si lo que se está lanzando 00:12:29
es una runtime excepción 00:12:31
o hijos de la runtime excepción, 00:12:33
no estoy obligado 00:12:35
a ni hacer la trace 00:12:37
ni hacer el breakage. 00:12:39
Vosotros habéis 00:12:45
utilizado 00:12:49
arrays. 00:12:51
¿Os ha salido alguna vez 00:12:55
una excepción? 00:12:57
¿No habéis puesto nunca un breakage? 00:12:59
Acceder por allí 00:13:03
puede causar una excepción 00:13:05
pero nadie os ha obligado 00:13:07
a usar un breakage para pillar. 00:13:09
¿Os habéis hecho divisiones? 00:13:11
X dividido A 00:13:15
siendo una variable. 00:13:17
¿Y si esa A era cero, no debería haber explotado? 00:13:19
¿No habéis protegido 00:13:21
ese código con breakage? 00:13:23
Nos ha dado un error de 00:13:25
oye mira, aquí habría debido 00:13:27
proteger este código. 00:13:29
Porque estas excepciones 00:13:31
tanto divide by zero 00:13:33
como reindex out of bound 00:13:35
son hijas 00:13:37
de runtime excepción. 00:13:39
Entonces nos obliga 00:13:41
a manejarlas. 00:13:43
Hay otras como por ejemplo 00:13:45
la IOException 00:13:47
que si vuestro programa, si vuestro método 00:13:49
lanza una IOException 00:13:51
os da un error a tiempo de compilación 00:13:53
si no la habéis puesto 00:13:55
en un breakage. 00:13:57
Dependiendo del tipo de excepciones que hay 00:14:19
hay excepciones que las tienes que manejar 00:14:21
si o si. 00:14:23
Todas las excepciones 00:14:37
como son hijas de, 00:14:39
hijas de, etc. 00:14:41
crean una jerarquía. 00:14:43
Entonces la clase por arriba 00:14:45
de todas las excepciones 00:14:47
es la clase throwable. 00:14:49
Se llama throwable y parece una 00:14:51
interfaz, pero no es una 00:14:53
interfaz, es una clase. 00:14:55
Sustancialmente cualquier 00:14:57
error que pueda surgir 00:14:59
y que se pueda lanzar ese error 00:15:01
es de la clase throwable. 00:15:03
Y luego hay dos posibles 00:15:05
tipologías de errores 00:15:07
en general. 00:15:09
Lo que son error, 00:15:11
la clase error y todos los que derivan 00:15:13
de error, que son errores 00:15:15
graves. 00:15:17
Errores que si explotan 00:15:19
es un problema realmente 00:15:21
serio para mi programa porque 00:15:23
tampoco tengo mucho 00:15:25
control sobre eso. 00:15:29
Son errores que 00:15:31
no derivan 00:15:33
casi siempre de mi código. 00:15:35
Son errores 00:15:37
que van más allá del código 00:15:39
que estoy escribiendo yo, como por ejemplo 00:15:41
virtual machine error. 00:15:43
Si la máquina virtual machine 00:15:45
hace un error, yo no he 00:15:47
implementado la virtual machine. 00:15:49
Yo la he bajado e instalado. 00:15:51
Y como es software eso también, 00:15:53
podrá tener errores. 00:15:55
Si explota la virtual machine, 00:15:57
¿qué hago? 00:15:59
O hacerse un error que no me acuerdo que es. 00:16:01
Pero son errores 00:16:03
serios, errores a nivel 00:16:05
de infraestructura que estoy 00:16:07
utilizando yo. 00:16:09
Si tengo mi infraestructura que me permite 00:16:11
trabajar con Java, mi programa está por encima de esta infraestructura. 00:16:13
Si hay un problema a nivel 00:16:15
de infraestructura que me permite 00:16:17
trabajar con Java, pues ese es un error. 00:16:19
Y luego están las excepciones, que son siempre hijas 00:16:25
de throwable, pero sí que son 00:16:27
las mías que puedo manejar. 00:16:29
Estas de aquí, los errores, 00:16:33
no deben ser manejados 00:16:35
y normalmente no pasan, y espero que no pasen. 00:16:37
Si pasan, pues tendré 00:16:39
que ir a mirar 00:16:41
la instalación del JBK 00:16:43
y cosas por estilo de por qué ha pasado eso. 00:16:45
Sin embargo, las excepciones son 00:16:47
cosas que yo sí puedo gestionar dentro 00:16:49
de mis 00:16:51
programas y que tengo 00:16:53
muchas veces que manejar. 00:16:55
Dentro de las excepciones, que son manejables 00:16:57
o me puedo recuperar de ellos 00:16:59
sin problema, 00:17:01
pero haciendo algo, 00:17:03
es parte de mi programación, es parte de mi algoritmo 00:17:05
recuperarme de estos errores, de este tipo de errores, 00:17:07
pues hay la Runtime Exception 00:17:09
y las otras. 00:17:11
La Runtime Exception 00:17:13
son las que hemos visto ahora, que son 00:17:15
errores que son tan habituales 00:17:17
que pueden pasar 00:17:19
tan a menudo, es normal 00:17:21
que puedan pasar, 00:17:23
que no tiene sentido 00:17:25
manejarlas y vigilarlas constantemente, 00:17:27
porque sobrecargarían 00:17:29
muchísimo el código. 00:17:31
Imaginaos que cada división que hacéis 00:17:33
tenéis que ponerle hoy, pero cuidado que 00:17:35
no se pueda explotar, 00:17:37
pues 00:17:39
haría todo mucho más 00:17:41
engordoso, ¿vale? 00:17:43
Y por lo tanto, no se requiere que se haga, 00:17:45
se puede hacer, 00:17:47
pero no se requiere. 00:17:49
Y ejemplos de eso son como Arithmetic Exception, 00:17:51
Index Outbound Exception, 00:17:53
Null Pointer Exception, también cuando vosotros 00:17:55
habéis utilizado objetos 00:17:57
y lo habéis puesto a NULL y lo habéis 00:17:59
utilizado, allí no habéis hecho otra excepción, 00:18:01
esta otra excepción no la hemos usado nunca. 00:18:03
Y aún así, la excepción puede saltar. 00:18:05
Pero como Null Pointer Exception 00:18:07
es hija de Runtime Exception, 00:18:09
pues no se requiere. 00:18:11
¿Vale? 00:18:13
Sin embargo, todas las demás, 00:18:15
las que no son hijas de Runtime Exception, 00:18:17
sí, ¿vale? 00:18:19
En el sentido que cuando yo hago 00:18:21
un método que puede lanzar 00:18:23
una excepción 00:18:25
que no sea Runtime Exception, 00:18:27
pues sí que tengo que utilizar 00:18:29
un Trag-Etch o Throws. 00:18:31
¿Vale? 00:18:35
Como por ejemplo, 00:18:37
Certificate Exception, 00:18:39
Clone No Support Exception, 00:18:41
y esto es un dibujito 00:18:43
de la jerarquía, ¿vale? 00:18:45
Tenemos los Throwable, que claramente 00:18:47
son una clase, por lo tanto, de Object. 00:18:49
Dentro de Throwable 00:18:51
hay Error o Exception, 00:18:53
los Error son Virtual Machine Error, 00:18:55
No Class Default Error, 00:18:57
Assertion Error, 00:18:59
Stack Overflow Error, 00:19:01
Stack Overflow Send Back. 00:19:03
¿Vale? 00:19:05
Stack Overflow, por ejemplo, 00:19:07
es cuando yo llamo un método 00:19:09
que llamo otro método, 00:19:11
que llamo otro método, 00:19:13
imaginaos que hacéis un while 00:19:15
donde yo llamo 00:19:17
al mismo método que hace este while. 00:19:19
Entonces lo llamo otra vez, 00:19:21
lo llamo otra vez, 00:19:23
y llega un momento que ha hecho 00:19:25
infinitas llamadas. 00:19:27
Cada llamada se mete en una stack, 00:19:29
este llama a este, que llama a este, 00:19:31
y llega un momento que mi memoria 00:19:33
no me permite llamar más. 00:19:35
O sea, allí, Stack Overflow. 00:19:37
¿Vale? 00:19:39
Y estas son cosas 00:19:41
de errores. 00:19:43
Hace poco nada. ¿Vale? 00:19:45
Sin embargo, están las excepciones, 00:19:47
y aquí hay un montón de Class Not Found 00:19:49
Exception, Illegal Access, 00:19:51
Interrupted. 00:19:53
¿Vale? Interrupted, por ejemplo, 00:19:55
es cuando 00:19:57
tú puedes desde 00:19:59
un hilo de ejecución 00:20:01
interrumpir otro hilo de ejecución 00:20:03
y que él diga, mira, yo estaba 00:20:05
haciendo cosas y ahora sé que alguien 00:20:07
me ha mandado una señal. 00:20:09
¿Vale? Cuando se manda esta señal, 00:20:11
se lanza una Interrupted Exception que se puede 00:20:13
recoger y por lo tanto hacer algo. 00:20:15
¿Vale? 00:20:17
Aquí están las IO Exception, 00:20:21
por ejemplo, que tienen otras 00:20:23
cosas por aquí también, y todas 00:20:25
estas 00:20:27
sí que tengo que manejarlas. 00:20:29
¿Vale? Sin embargo, 00:20:31
hay otra rama que es la 00:20:33
Runtime Exception, y estas de aquí 00:20:35
no requieren un manejo 00:20:37
explícito. Las puedo recoger, 00:20:39
pero no es requerido. 00:20:41
¿Vale? Y aquí están todas las cosas 00:20:43
muy, muy comunes, como esto de 00:20:45
Index Outbound, 00:20:47
como... 00:20:49
otras que podamos haber visto, 00:20:51
Null Pointer Exception, 00:20:53
Negative Array Size 00:20:57
Exception. 00:20:59
Ese es el Number Format Exception 00:21:05
que está aquí. 00:21:07
Sí, 00:21:15
entonces esto lo echáis un vistazo. 00:21:17
Aún así, Eclipse los ha hecho a la mano. 00:21:19
Si vosotros usáis un método 00:21:21
que 00:21:23
nos muestra una excepción que requiere 00:21:25
ser manejada, os la marca. 00:21:27
Os dice, oye, mira, aquí tiene que poner 00:21:29
un Try Catch. Es más, botón derecho, añade 00:21:31
el Try Catch, y te lo añade él. 00:21:33
¿Sí? Por ahora yo creo que 00:21:35
no hemos visto cosas así, porque no hemos visto 00:21:37
las excepciones. Ahora algunos métodos 00:21:39
que veremos, pues, sí que lo 00:21:41
necesitarán. ¿Vale? 00:21:43
En todo esto, ¿vale?, hay 00:21:47
una marea, como hemos visto ahora, 00:21:49
excepciones que ya 00:21:53
se pueden, que existen, 00:21:55
y que la Java Extra Machine, el API, me 00:21:57
proporciona para que yo la pueda utilizar, 00:21:59
y eso no quita que yo me pueda crear 00:22:01
mis propias excepciones. 00:22:03
¿Vale? Que se basarán sobre 00:22:05
mi sistema concreto. 00:22:07
Errores que 00:22:09
no usan 00:22:11
mecanismos generales 00:22:13
de Java, como por ejemplo 00:22:15
los Arrays, sino que es un error 00:22:17
propio del programa que estoy creando yo. 00:22:19
¿Vale? Claramente los programitas 00:22:21
que hacemos nosotros, esto tiene muy poco 00:22:23
sentido. ¿Vale? Esto 00:22:25
empieza a crear un error propio 00:22:27
de un sistema, es cuando el sistema 00:22:29
empieza a ser ya suficientemente complejo. 00:22:31
Un programita de 00:22:33
calcúlame los primeros 20 00:22:35
números de Fibonacci, 00:22:37
pues, no es que tienes 00:22:39
Fibonacci exception. 00:22:41
Lo puedes inventar 00:22:43
a la hora de practicar con eso, 00:22:45
como haremos nosotros, pero claramente esto ya 00:22:47
sería un sistema un poco más avanzado. 00:22:49
Creas tus propias excepciones, 00:22:51
pues, esto. ¿Vale? 00:22:53
¿Y cómo la creo? 00:22:55
Pues, puedo 00:22:57
crear haciendo, heredando 00:22:59
de Trovavol o alguna 00:23:01
de sus hijos 00:23:03
o hijas de Trovavol. 00:23:05
¿Vale? En particular, 00:23:07
desde Exception. ¿Sí? 00:23:09
Entonces cuando yo creo mi excepción, 00:23:11
creo una public class a mi excepción 00:23:13
que está en Exception, y allí ya tengo 00:23:15
todo lo que tiene Exception 00:23:17
más lo que yo quiero. 00:23:19
Pero lo que se suele hacer es 00:23:21
crear un constructor de este estilo 00:23:23
¿Vale? Para que utilice 00:23:25
el mensaje 00:23:27
que tienen todas las Exception. 00:23:29
¿Sí? Entonces luego puedo 00:23:31
utilizar el toString, el 00:23:33
getMessage 00:23:35
que hemos visto antes de Exception, porque 00:23:37
como la extendo, y si no 00:23:39
creo un constructor como este, 00:23:41
pues, el message 00:23:43
de error se queda vacío 00:23:45
y por lo tanto cuando luego explota 00:23:47
pues no me da un mensaje. 00:23:49
¿Sí? 00:23:51
Y de esta forma puedo crear objetos de esta clase 00:23:53
con un mensaje personalizado. 00:23:55
¿Sí? Que sea asociado al 00:23:57
getMessage. 00:23:59
La idea es que luego yo me cree 00:24:01
new miException 00:24:03
y entre paréntesis le pondré 00:24:05
comillas 00:24:07
el error que ha pasado desde aquí. 00:24:09
Dos puntos. No me gustan el número 3. 00:24:11
Haciendo referencia 00:24:13
a la StefanoException 00:24:15
de antes. ¿Vale? 00:24:17
¡Ejemplo! 00:24:19
Por lo tanto, yo me creo 00:24:21
public divideByZeroException 00:24:23
¿Vale? 00:24:25
Que extende ArithmeticException 00:24:27
Me creo una nueva excepción 00:24:29
que extende 00:24:31
una excepción aritmética 00:24:33
que es dividir por cero. 00:24:35
¿Vale? Entonces, 00:24:37
aquí tengo un public 00:24:39
divideByZeroException stringMessage 00:24:41
superMessage. 00:24:43
Y ya está. Te hago una nueva 00:24:45
excepción que 00:24:47
tiene solo un constructor que me permite 00:24:49
construir un constructor con un mensaje. 00:24:51
¿Cómo la uso? 00:24:53
¿Cómo lo hago? 00:24:55
¿Cómo lo hago? 00:24:57
¿Cómo lo hago? 00:24:59
No sé si se ve mejor. 00:25:01
¡Ahhh! 00:25:03
¡Ahhh! 00:25:05
Así. 00:25:07
Vale. Deja así. 00:25:09
Entonces, aquí tengo 00:25:11
public doubleDivide. Este es un 00:25:13
método, ¿vale? No sé, en otra clase 00:25:15
voy a utilizar este método 00:25:17
de aquí, que dice, dame 00:25:19
un número, un numerador y un 00:25:21
denominador. Vale, fenomenal. 00:25:23
Y este método de aquí lanza 00:25:25
divideByZeroException. 00:25:27
¿Vale? Entonces, ¿quién va a utilizar 00:25:29
este señor de aquí? 00:25:31
Sabrá, tendrá escrito 00:25:33
por algún lado que este método podría 00:25:35
lanzar esta excepción. 00:25:37
¿Vale? Como esta excepción 00:25:39
deriva, si no me equivoco, de 00:25:41
RuntimeException, pues posiblemente 00:25:43
puedo no manejarla. 00:25:45
¿Sí? Pero sí puedo 00:25:47
manejarla. Este es como un 00:25:49
un aviso. 00:25:51
Oye, esto puede pasar. 00:25:53
Luego tú sabrás que tienes que hacer. 00:25:55
Si es 00:25:57
hija de RuntimeException, 00:25:59
pues entonces puedes o no 00:26:01
manejarla si no fuera 00:26:03
hija de RuntimeException, tienes. 00:26:05
Y te lo dice. ¿Vale? 00:26:07
¿Y cómo funciona? Que si el denominador 00:26:09
que me has dado es cero, 00:26:11
lanza un nuevo 00:26:13
divideByZeroException con escrito error. 00:26:15
Este error podría ser un poquito 00:26:17
más interesante, como decir 00:26:19
has intentado dividir por cero. 00:26:21
¿Sí? 00:26:23
Y si no, 00:26:25
si esto no lo hace, 00:26:27
returna doubleNum 00:26:29
dividido por doubleNum. 00:26:31
¿Sí? 00:26:33
Si no es cero, lo puedes hacer. 00:26:35
Fijaos que aquí es un if, no tiene 00:26:37
las paréntesis, porque si no tiene paréntesis 00:26:39
solo esto entra en el if. 00:26:41
¿Hace falta 00:26:43
hacer el cast de double 00:26:45
en ambos? 00:26:47
¿El número pariado? ¿Solo por curiosidad? 00:26:49
¿O se podría hacer double y entre 00:26:51
paréntesis? 00:26:53
Yo creo que con uno solo es suficiente. 00:26:55
Es que no es más extraño. 00:26:57
Yo creo que esto es más bien por 00:26:59
¿cómo se dice? 00:27:01
Por 00:27:03
complejo y 00:27:05
por formalidad. 00:27:07
Quiero que esta operación sea entre double 00:27:09
para que sea, pero no. 00:27:11
Con que uno sea double ya la operación es entre double. 00:27:13
¿Dudas? 00:27:17
Y estas son las excepciones. 00:27:19
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
10
Fecha:
21 de febrero de 2023 - 12:08
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′ 26″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
229.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid