Saltar navegación

Clase 08-04-24 - 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 8 de abril de 2024 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

luego tenemos la interfaz 00:00:00
rogable que es la más genérica 00:00:04
y luego de aquí heredan 00:00:05
la superclase 00:00:08
exceptio y la superclase error 00:00:09
ahora mencionamos esta 00:00:11
¿vale? y luego ya de esta 00:00:13
pues heredan 00:00:16
empiezan a heredar otras, hereda esta 00:00:17
de aquí 00:00:19
que esta, ahora cuando 00:00:20
hagamos nuestras proyecciones 00:00:23
lo veremos, es otra 00:00:24
superclase en realidad 00:00:27
para la mayoría de las excepciones. 00:00:29
Esta sigue siendo súper clasa. 00:00:32
Y luego ya a partir de aquí ya hay excepciones concretas. 00:00:34
Pues esta, por ejemplo, que la conocemos, 00:00:38
esta que a su vez está construida heredando de esta. 00:00:40
A ver, lo único que nos importa es que las excepciones 00:00:43
forman parte de una jerarquía, ¿vale? 00:00:45
Que en última instancia todas se heredan de excepción, 00:00:48
como vemos aquí, 00:00:51
y por tanto, si uno hacía el catch este, 00:00:52
que hemos puesto antes, 00:00:57
pues cualquier excepción que se genere 00:00:58
caería dentro de ese catch 00:01:00
porque cualquier excepción que se genere 00:01:02
hereda de esta 00:01:04
entonces si se trae catch con excepción 00:01:05
capturaría a todas 00:01:08
pues captura a todas pero a cambio no podemos 00:01:09
saber cuál es la que se ha generado 00:01:12
bueno 00:01:14
esta es la jerarquía 00:01:15
¿qué es esto de error? 00:01:17
a ver, lo de error 00:01:21
es, hay otras cosas 00:01:22
que pueden ocurrir 00:01:24
que no están relacionadas 00:01:25
con el programa 00:01:28
en general. Estas, las que 00:01:30
están aquí, que eran de exceptions, silencio, 00:01:32
son cosas que están 00:01:35
relacionadas con nuestro 00:01:36
código. Pues 00:01:38
que nos hemos salido 00:01:40
de la RAI, 00:01:41
que nos hemos salido 00:01:44
aquí de la RAI a la hora de recorrerlo. 00:01:46
Pues 00:01:49
que hemos accedido 00:01:50
a un puntero, a un objeto, perdón, 00:01:52
que hemos accedido a un objeto que era nulo. 00:01:54
las excepciones en general son cosas que han ocurrido 00:01:56
en nuestro código 00:01:59
y que se pueden resolver 00:02:01
también vía código 00:02:03
han ocurrido a consecuencia 00:02:04
de sentencias que hemos hecho 00:02:07
y que están pensadas 00:02:08
como para que se puedan resolver vía código 00:02:11
pues que este objeto lo anulo 00:02:13
pues hombre, pues lo cambio para que no sea nulo 00:02:15
que me he salido del array 00:02:17
pues lo modifico para no salirme del array 00:02:18
son situaciones generadas 00:02:21
por el mal funcionamiento 00:02:23
de nuestro código y que podemos arreglar 00:02:25
bueno, pero hay otro concepto 00:02:27
que se incluye también en esta jerarquía 00:02:30
que es cosas 00:02:31
que están fuera de nuestro control 00:02:32
que pueden haber ocurrido porque de repente 00:02:35
el sistema operativo se ha quedado sin memoria 00:02:37
entonces cada vez que 00:02:39
va llamando a métodos, pues 00:02:41
sabemos, intuimos, porque a principio del curso 00:02:42
un poco lo mencionamos, pues que según 00:02:45
lo va llamando a métodos 00:02:47
en una pila 00:02:48
de la RAM se tienen que ir guardando 00:02:51
las direcciones de 00:02:53
programa, los contadores de programa 00:02:55
que se llaman para que luego 00:02:57
el estado operativo pueda ir devolviendo a los procesos 00:02:58
de arriba, bueno, no me interesa 00:03:00
meterme en esto, pero lo que quiero decir 00:03:03
es que pueden ocurrir cosas también 00:03:04
que no sean por nuestro código 00:03:07
sino porque de repente el proceso 00:03:08
se ha encontrado sin memoria 00:03:11
¿vale? o ha desbordado 00:03:13
la pila de los contadores de programa 00:03:15
cosas que no están realmente relacionadas 00:03:17
con lo que nosotros estamos 00:03:19
programando, sino que están 00:03:21
fuera un poquito de nuestro control 00:03:23
entonces, esas cosas 00:03:25
se las llama errores 00:03:27
se las llama errores 00:03:29
y también son lanzables 00:03:30
como las excepciones, también son lanzables 00:03:33
y son clases como 00:03:36
estas, pues por ejemplo esta 00:03:38
out of memory error, esta go to flow error 00:03:39
entonces en realidad 00:03:42
funcionan igual que las excepciones 00:03:43
se las puede lanzar 00:03:46
igual que las excepciones 00:03:48
con throw 00:03:49
y se las puede capturar 00:03:50
igual que las excepciones 00:03:53
lo que pasa es que 00:03:54
estas no están pensadas para capturarlas 00:03:57
no están pensadas para capturarlas 00:03:59
porque no son 00:04:01
cosas que se pueden arreglar por código 00:04:03
no las puedo arreglar yo por código 00:04:04
entonces esas no se capturan 00:04:06
pero se podría capturar 00:04:09
entonces simplemente que sepáis 00:04:10
que se pueden generar no solo excepciones 00:04:12
sino también errores 00:04:15
y ahora hacemos un ejemplo 00:04:16
de cómo podemos crear un error. 00:04:19
Podemos crear también errores. 00:04:21
Entonces, que sepáis que existan, 00:04:23
que existen también clases 00:04:24
dentro de esta jerarquía 00:04:26
que están programadas 00:04:28
para representar 00:04:31
cosas que 00:04:32
se decide que no 00:04:35
nos interesa arreglarlas por código. 00:04:37
No nos interesa arreglarlas porque 00:04:39
si ocurren que el programa se pare 00:04:40
y ya está. Entonces, se distinguen 00:04:43
conceptualmente, se distinguen 00:04:45
las excepciones y los errores. 00:04:46
Pero esto es una decisión anárquica, el que programa, el que ha hecho la máquina virtual, las librerías de la máquina virtual y ha hecho las clases, ha tomado decisiones suyas anárquicas. 00:04:48
Se supone otra anárquica que las ha pensado, pero estas son decisiones tomadas y se ha decidido, pues venga, estas clases son excepciones, estas son errores, son decisiones, se podrían cambiar en cualquier momento, claro, rehaciendo esas librerías. 00:04:59
Bueno, pues esas decisiones dicen unas cuantas clases son las que le dan deception y recogen la mayoría de las situaciones que hemos identificado que pueden ocurrir y cuando yo haga mi código, si identifico que han pasado, las lanzo a control, lo que hemos visto. 00:05:10
Vale, asumo que hay otra serie de posibilidades que pueden también ocurrir, pero en ese caso yo interpreto que no me apetece que el programa continúe si han ocurrido, no me apetece, pues las programo dentro de la jerarquía como clases que heredan de estas, de ROT, y son lanzables igual que estas y capturables igual que esas, pero conceptualmente representan otra cosa. 00:05:30
y cuando son lanzadas 00:05:56
no se espera que se capturen 00:05:59
no se espera, lo que se espera es que el programa 00:06:01
se pare, porque lo que ha ocurrido pues es grave 00:06:03
¿vale? lo que ha ocurrido es grave 00:06:05
y no esperamos seguir si nos hemos quedado 00:06:06
sin memoria o si la pila se ha desbordado 00:06:09
en ese caso no esperamos que el programa 00:06:10
siga, no esperamos, se para y ya está 00:06:13
¿vale? bueno, pues eso 00:06:15
por un lado, pero vamos, que funcionan igual 00:06:17
bueno, vale 00:06:18
pues entonces 00:06:21
ahora ya vamos a 00:06:21
ver algún ejemplo 00:06:24
Bueno, pues este es el programita que vimos el otro día 00:06:27
Vimos como efectivamente 00:06:32
Nosotros ya podemos 00:06:33
Silencio 00:06:36
Cuando queramos y nos da la gana lanzar excepciones 00:06:37
Porque es nuestra forma 00:06:40
Silencio 00:06:42
Porque es nuestra forma 00:06:44
Desde los métodos de avisar que algo malo ha pasado 00:06:49
¿Vale? 00:06:52
Y por eso hicimos este ejemplo 00:06:53
Por ejemplo, yo me hago un método 00:06:55
Para hacer la raíz cuadrada de un numerito 00:06:57
Vale, entonces 00:07:00
este método solo me interesa 00:07:02
que haga cosas, solo me interesa 00:07:05
que tenga un resultado 00:07:06
consentido, solo me interesa que tenga un resultado 00:07:08
válido, si este número 00:07:11
es mayor o igual que cero 00:07:13
silencio 00:07:15
si no, no me interesa 00:07:17
vale, pues entonces 00:07:20
una posibilidad es efectivamente 00:07:23
en mi caso raro 00:07:24
que es que el número sea negativo 00:07:26
en mi caso raro, decido 00:07:28
que lanzo una excepción 00:07:31
y lanzar una excepción 00:07:32
a ver, os queréis callar 00:07:35
todos los que estéis hablando 00:07:37
whatsappearos 00:07:38
escribidos por aquí, pero no hagáis ruido 00:07:40
¿vale? 00:07:43
bueno, pues en este caso 00:07:47
mi caso raro es que el número sea negativo 00:07:48
pues lo que dijimos el otro día 00:07:51
yo puedo optar por avisar 00:07:53
con el valor de retorno 00:07:54
pero en este caso, ¿qué hago? devuelvo un cero 00:07:56
y digo, si devuelvo un cero 00:07:58
es que 00:08:00
y pongo aquí, es que el número 00:08:01
era negativo 00:08:04
pues mal, y que pasa si le doy 00:08:05
un 0 aquí, en ese caso 00:08:08
devolveré un 0 porque la raíz de 0 es 0 00:08:10
pero no estoy diciendo que haya 00:08:12
ido algo mal, no, estoy devolviendo la raíz de 0 00:08:14
entonces 00:08:16
usar el valor de retorno 00:08:17
para indicar que ha pasado un error 00:08:19
como código de control 00:08:22
pues muchas veces no procede 00:08:23
porque esta variable 00:08:26
ya tiene un uso, que es guardar el resultado 00:08:28
ya lo tiene 00:08:30
vale, pues aviso de mi caso raro con esto 00:08:31
y ya sabemos cómo avisar, throw 00:08:33
instancio del objeto excepción 00:08:35
que yo quiera 00:08:37
aquí vimos como ejemplo, pues mira, lanzo este 00:08:38
pero esto es una tontería 00:08:41
porque entonces, aquí 00:08:43
cuando yo ejecute esto 00:08:45
pues lo que ocurre 00:08:46
es que, ah bueno, que lo había 00:08:49
capturado, cuando yo lance 00:08:53
esto 00:09:04
lo que ocurre es que 00:09:04
me dice, ha habido excepción de null pointer exception 00:09:08
pues muy mal explicado, no ha habido excepción 00:09:10
de null pointer exception, ha habido excepción 00:09:12
de que el número era negativo 00:09:14
y no hay raíz para número negativo 00:09:16
luego 00:09:18
en esta situación 00:09:20
no hay una excepción 00:09:21
ya creada que se adapte 00:09:25
a lo mío, yo querría 00:09:26
que hubiera una excepción que fuera 00:09:28
número negativo exception, pero esa excepción 00:09:30
no existe porque un número negativo 00:09:33
en sí no es un error 00:09:35
un número negativo es un número negativo 00:09:37
para mí lo es en este caso 00:09:38
para mí lo es, pero en general no lo es 00:09:41
entonces no hay una excepción ya creada que sea 00:09:42
número negativo excepción 00:09:45
¿por qué va a haber una excepción ya creada que sea 00:09:46
número negativo excepción? si eso en sí no es un problema 00:09:49
bueno, pues entonces 00:09:51
¿qué hacemos aquí? 00:09:53
pues nos creamos nuestras propias excepciones 00:09:54
¿vale? 00:09:57
que es lo habitual, uno cuando hace un desarrollo 00:09:58
grande, una aplicación grande 00:10:01
y la tiene ya diseñada, contemplada y dice 00:10:02
vamos a ver, de mis clases 00:10:04
si mis métodos, qué cosas 00:10:06
pueden ocurrir 00:10:09
que me induzcan 00:10:10
a que mis métodos avisen de que ha ocurrido algo mal 00:10:12
pues que el número sea negativo 00:10:15
que la edad sea menor de 18 00:10:16
que el color de pelo sea pelirrojo 00:10:18
en esos casos 00:10:21
yo quiero avisar de que ha ocurrido algo raro 00:10:22
que se lance una excepción 00:10:24
pues tendré que hacer excepciones para eso 00:10:25
porque esas excepciones obviamente no están hechas 00:10:28
no está hecha la excepción pelo pelirrojo 00:10:30
excepción o edad menor que 18 excepción 00:10:32
no existen, las tendré que hacer yo 00:10:34
Y esa es la manera de hacerlo 00:10:35
Bueno, pues en este caso, obviamente 00:10:38
Por tanto, no optaríamos por lanzar esta excepción 00:10:40
Sino por hacer una nuestra 00:10:43
¿Vale? Pues ¿cómo programamos una excepción? 00:10:45
Una excepción es una clase, ya lo hemos dicho 00:10:49
Pues venga, vámonos a nuestro proyecto 00:10:51
Que estaba por aquí, ejemplo excepciones 00:10:53
Y ahora, claro, estoy haciendo todo el mismo paquete 00:10:55
Lo normal es que hubiera un paquete 00:11:00
Que fuera el paquete para las clases excepción 00:11:01
Y habría excepción 00:11:03
menor de edad 00:11:04
exception 00:11:08
pelo pelirrojo exception 00:11:09
las que fueran 00:11:11
yo lo estoy metiendo todo en el mismo paquete prueba 00:11:12
pues venga, primero identificamos 00:11:15
¿qué error 00:11:17
es el que yo quiero identificar aquí? 00:11:19
que el número sea negativo 00:11:21
pues bueno, elijo un nombre 00:11:23
para esa excepción, lo normal por convenio 00:11:24
para que todos nos entendamos 00:11:27
es que 00:11:28
acabe en exception, porque así el código 00:11:30
queda más claro. Y así se ve 00:11:33
rápidamente que esa clase es una clase 00:11:35
de tipo excepción. 00:11:36
Pues venga. Y uno le pone el nombre 00:11:38
que le dé la gana. Da igual que sea muy largo. 00:11:48
Da lo mismo. Que fijaos qué nombres 00:11:50
tienen ya. Arraindes, out of bound, 00:11:52
exception. Ya son muy largos. 00:11:54
¿Por qué? Cuanto más explicativo, mejor. 00:11:56
¿Qué más me da que el nombre sea largo? 00:11:58
Pues tú pon lo que quieras. 00:12:01
Yo he puesto, cuidado, número negativo, 00:12:02
exception. 00:12:04
Esto. ¿Vale? 00:12:06
¿Vale? Esta es mi excepción. 00:12:12
Vale, entonces, para que sea una clase excepción tengo que meterla dentro de la jerarquía, tengo que meterla dentro de la jerarquía para convertirla en excepción, hacerla throwable, lanzable. 00:12:14
Si no la hago heredera de throwable, el throw no la va a admitir. 00:12:28
Recordar que este objeto está para luego lanzarlo con un throw. 00:12:33
Throw new, cuidado patatín. 00:12:37
pues para poder ser lanzada con un throw 00:12:39
tiene que implementar la interfaz 00:12:42
throwable, que es la que la hace lanzable 00:12:44
entonces si quiero que esto sea una clase 00:12:46
excepción, tiene que entrar 00:12:48
en la jerarquía de excepciones para heredar 00:12:50
todo lo que la convierte 00:12:53
en excepción, desde el momento 00:12:54
que una clase entra en una jerarquía 00:12:56
hereda todo lo que haya en las superclases 00:12:58
de arriba, lo hereda todo 00:13:00
y ya puede empezar a comportarse 00:13:02
como todo eso que hereda 00:13:05
bueno pues entonces vamos a 00:13:06
meterla dentro de esa jerarquía 00:13:08
haciendo la heredera 00:13:11
de esta 00:13:13
que hemos visto en la jerarquía que existe 00:13:17
¿vale? 00:13:21
entonces, las vamos a hacer herederas 00:13:23
normalmente, de runtime 00:13:25
exception o de exception, que es más general 00:13:27
luego ya vemos la diferencia 00:13:29
entre las dos 00:13:31
ahora mismo elijo esta porque me va a ser 00:13:32
me va a facilitar una cosa, pero luego ya 00:13:35
diremos que cambia si la hago 00:13:37
heredera de exception, sin más 00:13:39
¿Vale? O sea, en la jerarquía que he mostrado antes 00:13:40
En la jerarquía que he mostrado antes 00:13:43
Teníamos estas dos 00:13:47
Y estas de aquí 00:13:49
Que ya eran excepciones concretas asociadas a cosas concretas 00:13:50
Error de entrada y salida 00:13:53
Error de fichero no encontrado 00:13:54
Error de socket 00:13:57
Error de que me he salido de los índices 00:13:58
¿Vale? Estas ya son concretas 00:14:00
Estas son superclases 00:14:02
Superclases de las que yo haré 00:14:04
Que mis propias excepciones se hereden 00:14:06
o bien de esta o bien de esta 00:14:09
luego vemos la diferencia 00:14:11
entre las dos 00:14:14
ahora mismo voy a meter esta clase nueva 00:14:14
que he hecho en mi jerarquía heredando de esta 00:14:17
porque me va a facilitar 00:14:19
las cosas, ahora veremos por qué 00:14:22
pues con eso ya la meto en mi jerarquía 00:14:23
bueno, pues la hago 00:14:25
que herede 00:14:27
de roomtime exception 00:14:29
pues ala, ahí está 00:14:31
heredando de esa 00:14:34
entonces como sabéis 00:14:35
cuando uno le da de otro 00:14:38
se le da todo menos los constructores 00:14:40
se le da todo menos los constructores 00:14:42
bueno, pues entonces aquí tendría sentido 00:14:44
hacer un constructor 00:14:46
recordad que los constructores 00:14:48
se tienen que llamar 00:14:54
igual que la clase 00:14:56
que instancia 00:14:58
este sería 00:15:00
mi constructor 00:15:02
¿vale? entonces 00:15:03
constructores 00:15:06
uno puede hacer 00:15:08
los que quiera 00:15:10
vale, recordad que los constructores de las subclases 00:15:11
suelen hacerse apoyándose en llamadas 00:15:15
de los constructores de las superclases 00:15:18
mediante el término super, ¿verdad? 00:15:19
bueno, pues la superclase runtime exception 00:15:22
esta clase de aquí, esta 00:15:25
tiene un constructor 00:15:27
tiene el constructor sin parámetros 00:15:29
¿vale? 00:15:36
y luego tiene un constructor 00:15:38
con un parámetro 00:15:39
este de aquí 00:15:42
este parámetro 00:15:43
a su vez runtime exception como hereda de exception 00:15:46
construye el constructor 00:15:49
pasando este parámetro 00:15:51
al constructor de exception 00:15:53
porque runtime exception hereda 00:15:55
de exception que hemos visto en la jerarquía 00:15:56
hereda de exception 00:15:59
y esta variable mensaje de aquí 00:16:00
que es heredada de exception 00:16:03
también 00:16:05
vale 00:16:06
si entramos en exception que a su vez 00:16:08
hereda de este de aquí 00:16:17
bueno pues para no perdernos más 00:16:18
Y esta propiedad mensaje que viene heredada desde arriba, esta propiedad mensaje, ¿qué valor tiene? 00:16:22
Pues tiene casualmente el valor que se nos muestra en las letras rojas cuando se nos muestra una explicación. 00:16:35
Se han salido ustedes los índices, se han salido no sé qué. 00:16:42
Pues lo que muestra el print extract trace, aparte de mostrar en qué línea de código se produjo la excepción, 00:16:46
muestra un mensaje que nos lo explica. 00:16:52
pues ese mensaje 00:16:54
lo saca de esta variable 00:16:56
lo saca de esa variable 00:16:59
entonces 00:17:00
aquí lo natural sería 00:17:02
instanciar en realidad 00:17:04
o sea, sobrescribir el constructor 00:17:06
que inicializa esta variable 00:17:08
¿vale? y ahora yo 00:17:10
cuando yo instancie esta excepción 00:17:27
cuando yo instancie 00:17:29
le paso al constructor 00:17:30
como parámetro el mensaje explicativo 00:17:32
que quiero que tenga esa excepción 00:17:35
el mensaje explicativo que quiero que tenga 00:17:37
y ese mensaje explicativo 00:17:38
irá a través de la llamada 00:17:41
del constructor de arriba a la variable 00:17:43
mensaje de la que luego tira el print extract 00:17:44
trace, la que luego tira 00:17:47
entonces de esta manera 00:17:48
inicializo con este parámetro 00:17:50
con el string que yo quiera darle 00:17:53
con este parámetro inicializo esa propiedad 00:17:54
de ese objeto 00:17:57
una propiedad que se le dada, por eso no la 00:17:58
tengo aquí, que se le dada 00:18:01
y esa propiedad 00:18:02
explica, su uso es explicar 00:18:04
qué significa esa excepción, 00:18:06
qué significa. 00:18:09
Y el print extra trace, 00:18:10
si luego lo llamo, 00:18:11
usa ese mensajito, 00:18:13
usa ese mensaje. 00:18:15
Bueno, pues yo para construir 00:18:16
mi propia excepción, 00:18:17
ya la tengo, 00:18:18
yo no tengo que hacer más, 00:18:19
porque lo que importa 00:18:20
de esa excepción 00:18:21
es esa variable, 00:18:22
esa propiedad mensaje 00:18:24
que tiene la explicación, 00:18:25
esa propiedad es heredada, 00:18:26
no tengo que volverla a escribir, 00:18:27
es heredada, 00:18:28
porque esto recordad 00:18:29
que va heredando de runtime, 00:18:30
runtime a su vez 00:18:31
es heredada de exception, 00:18:32
y exception de throwable, 00:18:33
esa propiedad es heredada, 00:18:35
y además yo la voy a inicializar 00:18:36
le voy a dar un valor a través del constructor 00:18:38
no tengo que hacer más con la excepción 00:18:40
ya está, ya está creada 00:18:42
esta es mi propia excepción 00:18:43
luego aquí, lo único importante es 00:18:45
que yo elija un nombre 00:18:48
que explique 00:18:50
bien lo que hace 00:18:51
para que luego mi código sea más claro 00:18:53
cuando se vea el throw, pues se vea que lo que yo estoy lanzando 00:18:56
efectivamente está asociado con lo que ha ocurrido 00:18:58
lo más importante para hacer uno la excepción 00:19:00
es que elija bien el nombre 00:19:03
nada más, que lo elija 00:19:04
vale, pues mi excepción ya está 00:19:06
pues entonces yo ahora en mi método 00:19:09
en este método de aquí 00:19:12
cuando pasa eso 00:19:13
que yo he asociado al error 00:19:16
de número negativo 00:19:18
pues ahora lanzaré esa excepción 00:19:19
y en el constructor 00:19:22
de número negativo exception 00:19:38
lo he hecho, ¿verdad? 00:19:39
el constructor de esta excepción 00:19:42
lo he hecho para pasarle aquí 00:19:45
el mensajito de que quiera que se explique 00:19:46
no puedo hacer la raíz 00:19:48
lo voy a poner mayúscula para que se vea bien luego cuando 00:19:50
aparezca 00:19:52
no puedo hacer la raíz 00:19:53
de un 00:19:57
número 00:19:58
negativo 00:20:00
vale, ese es el mensajito que quiero que aparezca 00:20:02
y ya está 00:20:07
y ahora este método 00:20:10
ya está mucho mejor hecho, ya es un código 00:20:11
mucho mejor 00:20:13
es un método que le paso un número 00:20:14
hace la raíz 00:20:17
de ese número 00:20:19
pero yo como programador me he dado cuenta 00:20:20
de que si le paso un negativo 00:20:22
tengo una complicación 00:20:24
y es que en ese caso no puedo hacer la raíz 00:20:26
tendré que indicar 00:20:29
de alguna manera que no he podido cumplir 00:20:30
con mi cometido, tendré que indicarlo de alguna manera 00:20:32
pues indico 00:20:35
que no he podido cumplir con mi cometido 00:20:36
lanzando la excepción 00:20:38
y lanzando además 00:20:40
un objeto excepción que está creado 00:20:42
específicamente para esa causa 00:20:44
que está creado para esa causa 00:20:46
No me aprovecho de otro 00:20:48
Porque entonces lo hago muy 00:20:49
Confuso 00:20:51
Lo hago muy confuso todo 00:20:53
Vale, pues entonces 00:20:55
Ahora ya tenemos nuestro método bien hecho 00:20:58
Ahora, que yo lo llamo 00:21:00
Con el 12 00:21:02
Ningún problema 00:21:02
Me muestra 00:21:04
Bueno, como no le he metido 00:21:07
En un sistema, pues no me muestra nada 00:21:10
Vale 00:21:11
Pues nada, yo llamo ahora ya 00:21:16
A mi método 00:21:23
raíz con 12, vale, en este caso 00:21:24
12 es positivo, lo llamo 00:21:28
y muy bien, me saca 00:21:29
la raíz de 12 00:21:31
vale, porque no ha habido ningún problema 00:21:33
hemos llamado a método raíz 00:21:35
como el número no era negativo 00:21:37
ha ido por aquí y me ha devuelto 00:21:40
la raíz de 12 como valor de retorno 00:21:41
lo ha mostrado y se acabó, vale 00:21:44
ahora llegamos al método con un 00:21:45
número negativo, menos 12 00:21:47
llegamos con 00:21:50
un número negativo 00:21:54
y efectivamente me ha dicho 00:21:55
excepción, la máquina virtual 00:21:58
ha visto un throw 00:22:00
y ya sabemos lo que pasa cuando ve un throw 00:22:01
que muestra las letras 00:22:04
rojas 00:22:06
que avisan de lo que ha pasado 00:22:07
y en esas letras rojas 00:22:09
se incluye 00:22:12
esa variable mensaje 00:22:13
que está en la excepción 00:22:15
se incluye esa variable mensaje 00:22:17
entonces cuando más explicativo sea mejor 00:22:19
porque es lo que se va a encontrar 00:22:21
el que está haciendo el, ¿vale? 00:22:23
Pues esto es lo que me sale. 00:22:27
Entonces, mucho mejor así 00:22:30
que no que me salga un null pointer exception 00:22:31
como antes, porque el null pointer exception 00:22:34
no me estaba explicando qué ocurría. 00:22:36
No me estaba explicando. 00:22:38
Este sí me está diciendo, cuidado, número negativo 00:22:40
y luego encima, por si no me ha quedado claro, 00:22:42
con el nombre de la clase todavía no me ha quedado claro, 00:22:44
pues tengo el mensajito. 00:22:46
Es que no puedes acelerar el número negativo. 00:22:48
Y ya está. 00:22:50
¿Vale? Entonces así es como programaríamos. 00:22:51
vale, aquí 00:22:55
como ya vimos el otro día, el programa se ha parado 00:22:56
claro, porque como no está capturada 00:22:59
la excepción, no hay try-catch, se ha parado 00:23:01
y al adiós no hemos llegado, claro 00:23:03
¿que queremos capturar 00:23:05
la excepción para que el programa no se pare 00:23:07
y siga? pues lo de 00:23:09
pues lo que teníamos hecho antes 00:23:11
ah bueno, que tenía cambiado 00:23:13
ponemos un try-catch 00:23:14
y ya está 00:23:17
y aquí 00:23:22
si soy muy 00:23:26
vaga, pues puedo hacer esto 00:23:28
vale 00:23:30
entonces cualquier excepción que se genere 00:23:38
cualquiera 00:23:41
incluido esta, porque esta le da de excepción 00:23:42
incluido esa, va a ir a este catch 00:23:45
va a ir a este catch cualquiera 00:23:47
y si soy más 00:23:49
precisa y quiero distinguir cada excepción 00:23:52
pues pondría 00:23:54
toda, vamos a ejecutar primero esta 00:23:56
para ver que efectivamente se captura 00:23:58
entonces que se va a hacer 00:24:00
lo que haya en el catch, vamos a imaginar 00:24:02
que yo pongo pues 00:24:04
error, pues esto es lo que 00:24:06
voy a ver en este caso, voy a ver error 00:24:12
y además el programa va a seguir 00:24:14
que es lo importante, además va a seguir, no se va a parar 00:24:16
vale, yo ejecuto 00:24:18
esto y me sale 00:24:20
error porque es lo del catch, el programa 00:24:21
no se para y seguimos con 00:24:24
el adiós, el programa no se para 00:24:26
vale 00:24:28
que estoy en tiempo de desarrollo y quiero 00:24:28
tener un poquito de más detalles de por qué 00:24:32
ha ocurrido la excepción, hombre 00:24:34
pues me aprovecho de los métodos de este objeto 00:24:36
lo que hemos explicado antes 00:24:38
este objeto 00:24:40
es el pasado como parámetro 00:24:42
que se ha instanciado aquí 00:24:44
este objeto que se ha instanciado ahí 00:24:45
después del throw 00:24:47
este objeto que se instanció ahí 00:24:49
es el que se ha pasado como parámetro 00:24:51
y llega por aquí 00:24:54
es este que llega por aquí 00:24:54
puedo aprovecharme de métodos para hacer cosas 00:24:56
entre ellos 00:24:59
este, que es el que siempre nos encontramos 00:25:00
de hecho me lo pone automáticamente el eclipse 00:25:03
cuando hacemos un surround with trycatch 00:25:05
me lo pone automáticamente 00:25:07
¿y el print extract trace qué hace? 00:25:09
pues es un system out de una información 00:25:12
que coincide 00:25:14
coincide 00:25:15
con la que te saca la máquina virtual cuando no capturas 00:25:16
y para el programa, coincide 00:25:20
de hecho si ejecutamos esto 00:25:21
pues vemos efectivamente que nos sale 00:25:24
nos sale 00:25:28
lo mismo que nos sale 00:25:29
cuando no capturamos la excepción 00:25:32
lo mismo 00:25:34
porque el print 00:25:34
stack trace 00:25:37
saca eso, pero la diferencia 00:25:39
es que aquí no se nos ha parado el programa 00:25:41
no se nos ha parado, ha seguido con 00:25:42
adiós, vale, aquí lo tenemos 00:25:44
luego no se nos ha parado 00:25:46
porque hay un try catch, no se nos ha parado 00:25:48
pero el print stack trace 00:25:50
me ha sacado esta información 00:25:52
que en tiempo de desarrollo es útil, porque cuando yo estoy 00:25:54
ejecutando esto, anda, que ha pasado 00:25:56
pues tengo aquí la información 00:25:58
cuando ya entrego este software 00:25:59
al usuario que lo va a usar 00:26:03
esto fuera, esto lo quito 00:26:04
porque él no quiere ver esto 00:26:06
él como mucho lo que quiere ver es 00:26:09
esto, por ejemplo 00:26:11
esto 00:26:20
lo cambiaríamos a esto 00:26:21
lo cambiaríamos 00:26:30
a esto y ahora ya cuando ejecutamos esto 00:26:33
pues ya el cliente verá, ah vale 00:26:34
que he debido ponerlo negativo 00:26:36
vale, hay que introducirlo positivo, vale 00:26:38
pero esto 00:26:41
lo pondremos cuando ya esto se lo 00:26:44
entreguemos al usuario 00:26:46
cuando estamos nosotros desarrollando 00:26:47
lo que nos interesa 00:26:50
es esto 00:26:51
que es lo que nos informa 00:26:53
de donde ha estado el fallo de nuestro código 00:26:56
en que línea de código ha estado, donde tengo que meter para 00:26:57
cambiarla 00:26:59
yo hago esto 00:27:00
y me saca esta información 00:27:02
que es la que le vale al desarrollador 00:27:05
porque el desarrollador ahora 00:27:07
se viene aquí y pincha 00:27:09
la línea de código que le ha dado el error 00:27:12
oye, ¿dónde me ha dado? ah, aquí 00:27:13
Ah, vale, me la ha dado aquí. 00:27:15
¿Vale? 00:27:18
¿Y esto de dónde me venía? 00:27:19
Ah, me viene de la llamada método raíz. 00:27:21
Entonces, uno va utilizando esta fila, esta traza, 00:27:24
para irse yendo al código para cambiarlo, 00:27:29
pero el usuario de la aplicación esta traza no le sirve para nada. 00:27:31
Vale, ¿entendéis la diferencia, no? 00:27:37
Bueno, entonces, está claro que uno puede hacer sus propias excepciones 00:27:44
para que sus métodos vayan comunicando 00:27:51
qué cosas han ocurrido 00:27:54
que suponen un mal funcionamiento 00:27:55
por causas controladas 00:27:59
que se pueden cambiar por código. 00:28:01
Se pueden cambiar porque introduzca un positivo 00:28:04
y ya está, y no hay problema. 00:28:06
No son errores en sí. 00:28:08
Bueno, una cosa que no sé si ha quedado clara 00:28:11
con el throw, quizá no. 00:28:13
Cuando la máquina virtual encuentra un throw, 00:28:16
encuentra un throw, 00:28:18
lanza la excepción 00:28:20
y si hay más cosas, silencio 00:28:21
y si hay más cosas 00:28:24
después del método, esas ya no se hacen 00:28:26
esto es como si fuera un retun 00:28:27
cuando en un método uno se encuentra un retun 00:28:29
el método sale 00:28:32
y da igual lo que hubiera después 00:28:34
pues un throw instancia el objeto 00:28:35
para que el método 00:28:38
que lo llamo lo tenga ahí, para en el caso de haber 00:28:40
catch, capturarlo 00:28:42
y lanzarlo, si no hay catch nada, no sirve 00:28:44
para nada ese objeto 00:28:46
y además es como si hubiera un retun automáticamente 00:28:46
Aquí es como si hubiera un return 00:28:50
¿Vale? 00:28:52
¿Veis? Aquí es como si hubiera un return 00:29:03
Pero el propio compilador me dice 00:29:05
Cuidado, a este código no llegas nunca 00:29:06
Qué tontería que lo pongas porque nunca vas a llegar 00:29:09
¿No? Ese es el mensaje 00:29:12
Código inalcanzable 00:29:13
Que nos dice a veces cuando hemos hecho un código 00:29:14
Raro 00:29:17
Código inalcanzable 00:29:18
Después de un throw 00:29:21
Se ignora todo lo que hay después 00:29:22
Se acabó, se ignora 00:29:25
un throw es como si llevaba un retun dentro 00:29:26
es como si llevaba un retun 00:29:29
cuando la máquina virtual ejecuta un throw 00:29:30
lanza la excepción al de arriba 00:29:32
al que lo llamó 00:29:35
y el método se acabó, que hay cosas después 00:29:35
pues esas cosas 00:29:38
no se ejecutan 00:29:41
imaginaos que aquí hay 00:29:42
después de leerse, pues si hubiera una sentencia 00:29:44
que fuera cualquier cosita 00:29:46
claro, me dice código inalcanzable 00:29:49
porque es o throw o retun 00:29:58
con lo cual aquí no llega nunca 00:30:00
entonces voy a cambiar el 00:30:01
return un segundito 00:30:04
para que me lo meta 00:30:06
en una variable 00:30:08
ahora el resultado este 00:30:09
lo meto aquí 00:30:20
vale, ahora ya os muestro el mensajito 00:30:21
de despedida, lo que sea 00:30:28
y ahora ya devuelvo el resultado 00:30:29
vale 00:30:32
he cambiado el código guardando el resultado 00:30:33
una variable intermedia 00:30:36
que lanzo al final 00:30:37
entonces esta sentencia 00:30:38
si yo voy por el else 00:30:40
obviamente se ejecuta 00:30:42
pero si voy por el if 00:30:44
lanza la excepción 00:30:46
y se acabó, ya no va a hacer 00:30:48
nada más, se acabó 00:30:50
¿verdad? 00:30:52
o sea, si yo ahora en mi main 00:30:54
llamo a método raíz 00:30:55
pasándole un positivo 00:30:58
pues efectivamente 00:31:00
me muestra el mensajito 00:31:07
me muestra la raíz y adiós 00:31:09
pero si llamo 00:31:11
a este método con un negativo 00:31:13
esto ya no me lo muestra 00:31:15
porque a eso no llega 00:31:17
¿Vale? 00:31:18
¿Veis? 00:31:24
Ha lanzado 00:31:24
este es el print extract trace 00:31:25
y no ha hecho más 00:31:26
no ha hecho más 00:31:28
dentro del método 00:31:28
no lo ha hecho 00:31:29
luego el throw 00:31:29
asociadlo a que también 00:31:33
lleva un return incorporado 00:31:34
o sea el método termina 00:31:36
se crea el objeto 00:31:37
se lanza para arriba 00:31:38
y se acabó 00:31:39
¿Vale? 00:31:40
Pues ya está 00:31:41
así 00:31:42
programaríamos 00:31:42
haciendo nuestras 00:31:43
propias excepciones 00:31:44
crear una clase excepción 00:31:45
es tan sencillo como esto 00:31:46
hacer la heredera 00:31:47
de run time 00:31:48
exception 00:31:49
o de exception sin más 00:31:50
ahora es cuando vamos 00:31:51
incorporar la diferencia entre hacer la ladera de una 00:31:52
o de otra. Ponerle un 00:31:54
constructor, es lo habitual. 00:31:57
Aquí, si queremos, a veces lo que 00:31:59
hacemos para facilitarnos el trabajo, 00:32:01
si no queremos cada vez que la instanciemos 00:32:04
tener que 00:32:06
escribir esto, 00:32:07
pues podemos hacer un constructor 00:32:10
con parámetros donde pongo yo un mensajito 00:32:11
para que sea siempre el mismo. 00:32:13
Podríamos hacer esto. 00:32:16
Hacernos un constructor 00:32:28
sin parámetros 00:32:30
para permitir la instanciación 00:32:31
más fácil, sin parámetros 00:32:34
y llamar al constructor de super 00:32:35
pasándole ya, en lugar 00:32:38
de un parámetro que yo le pase 00:32:40
le paso ya el mensajito que yo quiera 00:32:41
entonces así, desde la propia 00:32:43
clase excepción ya dejo fijado el mensaje 00:32:55
ya lo dejo fijado, asumo 00:32:57
que siempre que yo instancie esto 00:32:58
siempre quiero poner este mensaje 00:33:01
bueno, pues eso me lo puedo 00:33:03
hacer más cómodo, porque ahora cuando 00:33:05
instancio la excepción desde aquí 00:33:06
pues la puedo instanciar así 00:33:09
por ejemplo, la instancio 00:33:10
con el constructor sin parámetros 00:33:12
bueno y así es más fácil 00:33:14
y más rápido de escribir 00:33:25
uso el constructor sin parámetros 00:33:26
para instanciarla, uso este 00:33:29
y este constructor 00:33:31
sin parámetros 00:33:33
llame 00:33:34
a ver que no tengo el punto y coma 00:33:36
ahí 00:33:39
y este constructor sin parámetros 00:33:40
ya está fijando el mensajito que sea 00:33:43
ya lo está fijando 00:33:45
entonces de hecho ahora si ejecutamos 00:33:46
el main 00:33:49
bueno, pues me ha sacado el mensajito que yo he puesto en la clase 00:33:50
este, me ha sacado este 00:33:59
vale, pues así haríamos 00:34:01
nuestras clases de excepción 00:34:07
y no tienen más, elegimos 00:34:09
silencio 00:34:12
elegimos una clase de excepción 00:34:13
por cada posible causa de error 00:34:16
que contemplemos nosotros que puede salir 00:34:17
y luego las lanzamos de esta manera 00:34:19
y ya vemos como funciona 00:34:21
vale, pues que nos falta 00:34:23
diferencia 00:34:25
entre hacerla 00:34:27
heredera de esta 00:34:29
o hacerla 00:34:32
heredera de exception sin más 00:34:34
¿vale? esto ya es 00:34:36
muy cortito, vale, vamos a aprovechar 00:34:38
y paramos aquí unos minutitos y luego ya 00:34:40
completamos con esto y ponemos a unos ejercicios 00:34:42
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
8 de abril de 2024 - 19:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 45″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
160.84 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid