Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 05-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 7 de abril de 2024 por Raquel G.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues vamos a seguir con lo siguiente que vamos a ver 00:00:00
Venga, relax 00:00:05
Bueno, pues a ver, ¿qué es esto de las excepciones? 00:00:08
Vale, bueno, hasta ahora ya no suenan 00:00:25
No suenan porque a veces no las hemos encontrado 00:00:29
Entonces, para nosotros, ahora mismo, hasta ahora, ¿qué es una excepción? 00:00:32
Una excepción es algo que ha aparecido de repente, no sabemos ni de dónde ha salido, 00:00:39
se supone que resulta de una sentencia que no ha funcionado correctamente y ha parado el programa. 00:00:46
Esa es nuestra experiencia hasta ahora con las excepciones. 00:00:53
Por ejemplo, pues nos la hemos encontrado en una situación como esta. 00:00:56
Por ejemplo, imaginaos que tenemos esto, un programa que tiene esto escrito 00:01:00
y ahora por ejemplo 00:01:08
imaginaos que tenemos esto aquí 00:01:11
bueno, pues imaginaos que tenemos 00:01:12
un código 00:01:20
con dos líneas de código que 00:01:21
tienen esto 00:01:24
entonces nosotros ya sabemos que pasa 00:01:25
cuando la máquina virtual se ponga a ejecutar 00:01:27
esto, cuando ya estamos en tiempo de ejecución 00:01:30
hace esta línea 00:01:32
y cuando va a hacer esta ya hemos visto 00:01:34
lo que pasa, ya hemos visto lo que pasa 00:01:36
que de repente 00:01:38
han salido una línea roja 00:01:39
ahí, en la consola 00:01:42
han salido una línea roja 00:01:44
donde ha aparecido 00:01:45
escrito algo como esto 00:01:48
¿vale? 00:01:50
ha aparecido escrito algo como eso 00:01:56
y además 00:01:58
el programa se ha detenido 00:01:59
todas las sentencias 00:02:02
que hubiera a partir de aquí 00:02:04
ya no se han ejecutado 00:02:06
porque el programa se ha parado 00:02:08
¿vale? 00:02:10
esta es nuestra experiencia hasta ahora 00:02:11
en tiempo de ejecución 00:02:14
con las excepciones 00:02:17
nos ha pasado también, pues a lo mejor 00:02:17
imaginaos que tenemos un código así 00:02:20
y de repente 00:02:22
tenemos a lo mejor esta línea 00:02:28
tenemos un código con estas líneas 00:02:30
bueno, pues la máquina virtual 00:02:34
ha hecho esta sentencia, muy bien 00:02:36
ahora se ha puesto a hacer esta, que implica 00:02:38
una división, ¿y qué nos ha pasado? 00:02:40
pues que de nuevo 00:02:43
han aparecido, una letra roja por ahí 00:02:44
donde ponía 00:02:46
algo como esto 00:02:48
y el programa además se ha parado 00:02:49
y todo lo que hubiera a continuación 00:02:59
ha dejado de ocurrir, esto es más o menos 00:03:00
lo que nos hemos encontrado 00:03:03
nosotros hasta ahora relacionado 00:03:04
con el término excepción 00:03:06
relacionado con el término excepción 00:03:08
bueno, pues la idea es que ahora entendamos 00:03:09
qué es una excepción y cómo usarlas 00:03:12
cómo utilizarlas 00:03:15
dentro de nuestros desarrollos 00:03:16
porque son una herramienta más 00:03:18
para hacer nuestros desarrollos, son una herramienta más 00:03:20
no son sólo algo que aparece 00:03:23
cuando hemos hecho algo mal 00:03:24
y que tenemos entonces que irnos 00:03:26
al código a cambiarlo para que no aparezca 00:03:29
no son sólo eso 00:03:30
hasta ahora sí han sido sólo eso para nosotros 00:03:32
algo que cuando ya estábamos 00:03:35
en tiempo de ejecución 00:03:37
aparecía y decíamos 00:03:38
uy, he hecho algo mal en el código 00:03:40
pues voy a entrar a cambiarlo 00:03:42
porque he hecho algo mal 00:03:45
hasta ahora es lo único que ha sido para todas las excepciones 00:03:46
pero repito, son más que eso, son una herramienta 00:03:49
más grande que podemos usar 00:03:51
dentro de nuestros desarrollos 00:03:53
para comunicar 00:03:55
cosas 00:03:57
que eso es justo lo que nos está pasando aquí 00:03:58
lo que nos está haciendo 00:04:01
Java aquí 00:04:03
es comunicarnos cosas 00:04:05
nos está comunicando, cállate 00:04:06
nos está comunicando, ojo 00:04:09
que estás dividiendo por cero 00:04:11
ojo que estás accediendo 00:04:12
a un objeto que es null 00:04:15
nos está comunicando cosas, nos está dando información. 00:04:17
Pues nosotros también podemos usar las excepciones 00:04:20
y hacer nuestras propias excepciones para comunicar cosas. 00:04:22
Cuando hacemos nosotros métodos, 00:04:27
podemos usar excepciones nuestras que creamos 00:04:29
y que nos inventamos para comunicar cosas. 00:04:33
Y para eso sirve. 00:04:35
Las excepciones son un mecanismo que tiene el software 00:04:37
para comunicar cosas que están pasando. 00:04:39
Eso es lo que es una excepción. 00:04:42
En realidad es eso. 00:04:45
es un mecanismo 00:04:46
un mecanismo, una herramienta más 00:04:51
de código, un mecanismo 00:04:53
para comunicar 00:04:55
cosas que están pasando 00:05:01
durante la ejecución de un código 00:05:03
eso es en general las excepciones 00:05:05
un mecanismo que tenemos que aprender a utilizar 00:05:27
para comunicar cosas 00:05:29
que pasan durante la ejecución de un código 00:05:30
vale, lo que pasa 00:05:33
es que las excepciones en particular 00:05:35
las cosas que comunican 00:05:36
son cosas que están pasando 00:05:38
mal, son cosas malas 00:05:41
para eso sirven, son una herramienta 00:05:43
para comunicar cosas malas que están 00:05:45
pasando, cosas que no deberían 00:05:47
¿vale? entonces estas 00:05:48
cosas que comunican las excepciones 00:05:51
pues están especializadas 00:05:53
sirven para comunicar 00:05:55
cosas que no deberían pasar 00:05:57
nos informan 00:05:59
oye, está pasando esto y no debería 00:06:01
¿vale? porque tenemos 00:06:03
otras herramientas para comunicar 00:06:10
cosas que no pasa nada 00:06:12
¿por qué pasa? 00:06:13
de hecho 00:06:15
es exactamente 00:06:16
lo mismo que he planteado antes 00:06:19
cuando explicaba el método replace 00:06:21
he dicho el replace 00:06:23
te devuelve un valor de retorno 00:06:24
ese valor de retorno 00:06:26
te sirve para verificar 00:06:28
si encontró el código o si no lo encontró 00:06:31
entonces mediante ese valor de retorno 00:06:33
también nos están informando 00:06:36
de cosas 00:06:37
pero eso que nos informan no tiene nada que ver con que 00:06:38
haya ocurrido algo que no tenga que ocurrir 00:06:41
No, el replace dice que existe, sustituyo, que no existe, no sustituyo, pero es un funcionamiento completamente normal, eso no significa que haya ocurrido algo fuera de control, entonces yo no lo comunico con una excepción, lo comunico con un valor de retorno, ¿vale? 00:06:43
bueno, pues las excepciones son una forma 00:07:02
de comunicar cosas 00:07:04
que no deberían ocurrir 00:07:06
nos alertan de cosas 00:07:09
que no deberían ocurrir 00:07:10
por eso, las excepciones 00:07:11
cuando aparecen, y ahora veremos 00:07:14
cómo aparecen, no es que aparezcan de la nada 00:07:16
no es que el ordenador se las saque de la manga 00:07:18
ahora veremos cómo aparecen 00:07:20
pues las excepciones cuando aparecen 00:07:22
además 00:07:25
además 00:07:27
paran la ejecución del código 00:07:28
detienen la máquina virtual 00:07:30
Entonces, esa es otra de sus particularidades. Cuando la excepción aparece, la máquina virtual detiene la ejecución del código, porque asume que eso que ha ocurrido no debería. Entonces, es importante, cuando la excepción aparece, además se detiene la ejecución del código, ¿vale? 00:07:32
entonces además 00:07:51
después de aparecer la excepción 00:07:55
la máquina virtual 00:07:57
que es 00:07:59
la que está interpretando las sentencias 00:08:01
la que está ejecutando las sentencias 00:08:03
ya sabéis que es la máquina virtual que va sentencia 00:08:05
por sentencia ejecutando 00:08:07
pues como resultado de ejecutar 00:08:09
una, si como resultado de ejecutar 00:08:11
una aparece esto 00:08:13
pues la máquina 00:08:15
virtual para 00:08:17
la máquina virtual para el código, 00:08:18
para la ejecución. 00:08:22
Y repito, precisamente por eso, 00:08:25
porque lo que nos comunican las excepciones 00:08:27
se supone que es algo que no debería ocurrir. 00:08:29
Por eso la máquina virtual para la ejecución. 00:08:31
Aún así, ya sabemos que tenemos una manera 00:08:35
de evitar que la máquina virtual 00:08:39
pare la ejecución, 00:08:42
aunque haya salido una de estas. 00:08:44
Porque eso también lo hemos usado. 00:08:46
¿vale? es la otra cosa 00:08:48
con la que también hemos 00:08:50
trabajado relacionada con excepciones 00:08:52
¿vale? es decir 00:08:54
relacionada con excepciones 00:08:56
ya estamos familiarizados con que aparezcan 00:08:57
cuando hacemos algo raro 00:09:01
como esto 00:09:02
como esto, ya estamos familiarizados 00:09:04
con que aparezcan y también ya 00:09:06
hemos visto alguna vez 00:09:08
que podemos evitar que el código se pare 00:09:09
aunque aparezca 00:09:12
entonces si nosotros no hacemos nada 00:09:14
y ponemos las sentencias tal cual 00:09:16
ya hemos verificado 00:09:18
porque nos ha pasado muchas veces 00:09:20
que el código se va a detener 00:09:21
eso es como funciona por defecto 00:09:22
pero si queremos evitar que la máquina virtual 00:09:25
pare la ejecución 00:09:28
ya sabemos que tenemos un truco 00:09:29
una herramienta de código para evitarlo 00:09:33
¿qué truco hemos usado 00:09:36
a veces para eso? 00:09:38
¿qué os suena? 00:09:39
para evitar que la máquina virtual pare la ejecución 00:09:41
cuando hay una excepción 00:09:43
¿os suena? 00:09:44
try cut 00:09:47
es decir 00:09:48
es decir, este código 00:09:50
este código tal cual está 00:09:57
con estas dos sentencias 00:10:01
aquí no hay tutía 00:10:03
cuando la máquina virtual se ponga a ejecutar 00:10:05
este código, va a salir 00:10:07
el null pointer exception 00:10:09
va a salir 00:10:11
y no solo va a salir el null pointer exception 00:10:14
sino que la ejecución 00:10:17
se va a parar 00:10:19
y se acabó 00:10:20
lo que viniera después no se va a ejecutar 00:10:22
porque se ha parado, está claro 00:10:25
con ese código así no hay alternativa 00:10:26
esto es lo que va a pasar 00:10:29
null pointer exception y la ejecución detenida 00:10:30
vale 00:10:33
que queremos impedir que la ejecución 00:10:34
se detenga 00:10:37
aunque haya salido la excepción 00:10:38
porque va a salir, eso sí que no puedo evitarlo con este código 00:10:40
si aquí tengo null y aquí a un objeto null 00:10:43
accedo a sus propiedades 00:10:45
no va a salir null pointer exception 00:10:47
bueno, pues si quiero evitar que se detenga la ejecución 00:10:48
aunque la excepción me salga, si quiere evitarlo 00:10:51
¿qué podemos hacer? 00:10:54
pues la sentencia 00:10:56
que creemos que va a provocar 00:10:57
ese problema, la que creemos 00:11:00
que puede provocarlo, la peligrosa 00:11:02
la metemos en un bloque 00:11:04
así, la metemos 00:11:06
entre llaves, en un bloque con un tray delante 00:11:08
y entonces le decimos 00:11:10
oye, inténtala 00:11:12
inténtala 00:11:14
que te sale 00:11:15
magnífico, la haces 00:11:17
y sigues con el código que venga debajo. 00:11:20
Que no te sale, porque te sale una excepción. 00:11:23
Pues entonces te metes aquí. 00:11:27
Es como si fuera un if-else, pero adaptado a excepciones. 00:11:29
Entonces, el try-catch tiene este formato. 00:11:34
Try, entre llaves, la o las sentencias, 00:11:37
aquí puede haber muchas, no tiene por qué haber una. 00:11:40
Entre llaves, el código que nos preocupa. 00:11:42
El código que creemos que puede que dé excepción 00:11:45
y por tanto pararse el programa. 00:11:48
hay el código que nos preocupa 00:11:50
y ahora catch 00:11:52
y aquí tenemos que escribir 00:11:53
la excepción que creemos que va a salir 00:11:54
¿vale? 00:11:57
esto con pequeños matices 00:12:00
que ya incorporaremos cuando tengamos más 00:12:01
entonces yo aquí creo que 00:12:04
puede que salga null pointer exception 00:12:05
por ejemplo 00:12:07
bueno, pues entonces tenemos que poner el catch 00:12:11
y entre paréntesis 00:12:18
como si pusiéramos la declaración 00:12:20
de un objeto 00:12:22
de un objeto 00:12:23
que pertenece a una clase 00:12:25
excepción con ese nombre 00:12:28
ahora nos meteremos más 00:12:29
nos meteremos más en 00:12:35
estos nombres 00:12:36
estos nombres de clase, nos meteremos más 00:12:38
ahora mismo lo que estoy simplemente poniendo es 00:12:41
cómo se hace un try-catch 00:12:43
bueno, pues un try-catch 00:12:44
básico se hace así 00:12:54
ya lo hemos usado en algún momento 00:12:56
cuando hacíamos la clase teclado 00:12:58
para evitar 00:12:59
tener que poner el throws, etc. 00:13:00
Lo usamos porque lo habíamos necesitado, pero todavía no teníamos muy claro por qué lo usábamos. 00:13:03
Bueno, pues ¿para qué lo usamos? 00:13:10
Para evitar que un código, en caso de generar excepción de algún tipo, pare la ejecución. 00:13:12
Si plantamos un try-catch, estas sentencias se ejecutan. 00:13:20
Y en caso de que salga la excepción que está en el catch, si sale la que está en el catch, 00:13:24
entonces la máquina virtual lo que hace es 00:13:29
se va aquí 00:13:32
y ejecuta lo que yo ponga ahí 00:13:33
lo que me dé la gana, como si pongo ahí mis líneas 00:13:35
hombre, no es la idea, porque si 00:13:38
yo he venido aquí al catch 00:13:39
es porque algo ha ido mal, si algo ha ido mal 00:13:41
lo más que querré hacer será 00:13:44
avisar y ya está 00:13:46
¿vale? pero ahí uno puede poner lo que quiera 00:13:47
es un bloque más de código 00:13:49
bueno, pues solamente incorporando el try catch 00:13:50
ya, la excepción sale igualmente 00:13:54
eso no lo hemos cambiado 00:13:56
porque si yo hago n.nombre 00:13:57
es que va a salir la excepción, pero 00:13:59
la máquina virtual ya no para el programa 00:14:01
y esto continúa por aquí tan tranquilo 00:14:02
¿vale? continúa por ahí y ya está 00:14:05
y además 00:14:07
se ejecuta lo que haya aquí dentro 00:14:09
que normalmente pues será 00:14:11
un aviso 00:14:13
una escritura 00:14:14
de archivo de logs para indicar 00:14:17
ha habido error de no sé qué, lo que sea 00:14:19
bueno, pues en resumen 00:14:21
una excepción es algo que se 00:14:25
genera, ahora veremos 00:14:28
como consecuencia de 00:14:30
la ejecución de una sentencia 00:14:32
de código que ha salido mal. 00:14:34
Que ha salido mal. 00:14:36
Entonces, como una sentencia de código 00:14:37
ha salido mal, pues la excepción 00:14:39
aparece. 00:14:42
Que está capturada 00:14:43
o lo que es lo mismo, que está dentro de un 00:14:45
try-catch, porque 00:14:47
estar dentro de un try-catch significa estar 00:14:49
capturada. Que está 00:14:51
capturada, que está dentro de un bloque try-catch, 00:14:53
no pasa nada. 00:14:56
La máquina virtual salta 00:14:58
automáticamente al catch 00:14:59
hace lo que tenga que hacer y continúa 00:15:01
el programa y no se para 00:15:03
entonces, eso hace que 00:15:05
sí, uy, gracias 00:15:07
eso hace 00:15:09
que el programa sea más robusto 00:15:13
porque no se para por cualquier tontería 00:15:16
pero claro, cuidado 00:15:17
porque ha habido un problema, entonces el resto 00:15:19
del programa tiene que estar 00:15:21
hecho de tal manera 00:15:23
que no arrastre estas complicaciones 00:15:24
claro, pero eso ya es tema del programador 00:15:27
de lo que esté haciendo 00:15:30
bueno, pues entonces 00:15:30
eso es una excepción, una forma de avisar 00:15:33
de que algo ha ido mal 00:15:36
y ahora ya la pregunta siguiente 00:15:37
sería, pero ¿de dónde sale? 00:15:40
¿cómo es que aparece? 00:15:42
yo sé que si tecleo esta línea 00:15:43
y la ejecuto, me salen palabras rojas 00:15:46
pero no sabemos más 00:15:48
no sabemos qué es lo que ha pasado ahí debajo 00:15:50
si ha salido un enano escribiendo 00:15:52
en el redal roja, qué es lo que ha salido ahí 00:15:54
no tenemos ni idea de cuál es el origen de eso, 00:15:55
que se ha desencadenado. 00:15:57
Bueno, eso es lo que tenemos que entender ahora. 00:15:59
Bueno, pues entonces, silencio. 00:16:05
Bueno, algunas excepciones ya nos suenan, 00:16:11
porque nos las hemos encontrado a veces. 00:16:16
Null pointer exception ya nos suena. 00:16:19
Sabemos que nos aparece cuando un objeto que es null, 00:16:21
un objeto que es null, 00:16:24
tratamos de acceder 00:16:26
o a propiedades o a métodos con el punto 00:16:28
como tratemos de acceder 00:16:30
al contenido o al comportamiento 00:16:32
con métodos de un objeto que es null 00:16:35
ya sabemos que esta nos sale 00:16:36
nos han salido más 00:16:38
nos han salido la divide by 0 00:16:40
esa excepción que he escrito antes 00:16:42
que nos ha salido cuando hemos tratado 00:16:45
de hacer una división por 0 00:16:46
pero nos han salido más 00:16:48
nos ha salido 00:16:50
esta también nos ha salido 00:16:51
esta excepción nos salía 00:17:04
cuando recorríamos un array 00:17:06
cuando tratábamos de acceder a una posición 00:17:08
que el array no tenía 00:17:11
el array tenía tres posiciones 00:17:13
y debíamos acceder a las siete 00:17:15
pues nos salía array index bound exception 00:17:16
también nos ha salido la string 00:17:18
index out of bound exception 00:17:21
cuando tratábamos de acceder a posiciones 00:17:22
de un string en las que no había tampoco 00:17:25
caracteres 00:17:27
bueno pues 00:17:28
nombrecitos de estos ya nos suenan 00:17:29
ya no suenan nombres de esos 00:17:32
bueno, pues esos nombres de dónde salen 00:17:34
estos nombres en realidad 00:17:36
son nombres de clases de Java 00:17:38
que ya están hechas 00:17:41
es decir 00:17:42
cada posible cosa rara 00:17:50
que puede ocurrir, cada posible cosa rara 00:17:52
dividir por cero 00:17:54
salirte de un array 00:17:55
acceder a un objeto nulo 00:17:57
acceder de forma concurrente a un recurso 00:17:59
que también nos ha salido el concurrent modification exception 00:18:02
nos salió con el for each y las colecciones 00:18:04
pues cada cosa rara 00:18:06
que puede ocurrir 00:18:08
tiene una clase declarada 00:18:10
asociada, tiene una clase 00:18:12
declarada 00:18:14
conclusión, tenemos 00:18:15
en la máquina virtual de Java, en la librería que tiene dentro 00:18:18
tropecientan mil clases de estas 00:18:21
tropecientan mil 00:18:23
una por cada cosa rara 00:18:24
que puede ocurrir, tropecientan mil 00:18:26
si las 00:18:29
miramos por aquí 00:18:31
a ver 00:18:39
bueno, a ver 00:18:40
vale, pues 00:19:38
la máquina virtual de Java 00:19:42
ya sabéis que incorpora 00:19:45
un montón de paquetes 00:19:47
tropecientos mil 00:19:49
tropecientos, estos son sólo los de 00:19:50
el JAR Java base 00:19:55
de ahí, pero aparte del JAR Java base 00:19:57
pues está este JAR 00:19:59
está este, o sea, hay tropecientos 00:20:00
donde 00:20:03
cada jar tiene un montón 00:20:04
de paquetes 00:20:06
y cada paquete, si uno se pone 00:20:07
a cotillear, se va a encontrar en cada 00:20:10
uno de ellos distribuido 00:20:12
clases que acaban con la palabra 00:20:14
excepción. Bueno, pues 00:20:16
las clases que representan cosas 00:20:18
raras que pueden ocurrir 00:20:20
por convenio, para 00:20:21
enterarnos todos y entendernos todos, tienen 00:20:24
el nombrecito que tengan 00:20:26
y acaban en excepción. 00:20:27
Entonces, esto en particular será 00:20:30
excepción de tipo NTLM 00:20:32
que vete a saber a qué se refieren las siglas estas 00:20:34
algo de seguridad de NTLM, yo que sé 00:20:36
aquí que lo entendemos mejor 00:20:38
pues por ejemplo 00:20:42
en este paquete están las clases relacionadas 00:20:43
con entrada y salida archivos 00:20:46
pues aquí nos encontramos muchas 00:20:48
que acaban en excepción 00:20:50
pues por ejemplo 00:20:51
esta 00:20:54
esto es 00:20:55
excepción de que has llegado 00:20:57
a fin de archivo, una cosa rara que te ha ocurrido 00:21:00
has llegado a fin de archivo, estás tratando de leer. 00:21:02
No puedo, has llegado al final. 00:21:04
Esta es una clase excepción programada 00:21:06
para esa situación. 00:21:08
Aquí abajo, pues tenemos otra. 00:21:10
Esta es una excepción programada 00:21:13
para la situación, el fichero no existe. 00:21:14
Al que tratas de acceder no existe. 00:21:17
Quiero decir, 00:21:20
hay tropecientas 00:21:22
clases excepción ya hechas, 00:21:23
tropecientas hechas, que están 00:21:25
asociadas a cosas raras que pueden ocurrir. 00:21:27
¿Vale? Ya nos hemos encontrado, 00:21:29
repito, el array inDesbound, 00:21:31
el pointer exception, etc. 00:21:33
Bueno, pues esas clases 00:21:35
de esas clases se instancian objetos 00:21:37
de esas clases 00:21:41
y esos objetos son los que aparecen 00:21:43
cuando ha ocurrido 00:21:45
alguna de esas cosas raras. 00:21:47
Así es como funciona esto. 00:21:49
Por ejemplo, a ver 00:21:52
ahí he cerrado esto, mierda. 00:21:53
Vale, pues a ver 00:22:31
vamos por ejemplo 00:22:32
a abrir la clase string 00:22:35
que la clase string 00:22:37
alguno de los métodos que tiene 00:22:39
alguno de los métodos tendrá contemplado 00:22:40
que si hace algo raro avise con alguna excepción 00:22:43
pues vamos a mirar 00:22:45
cómo está avisando 00:22:47
cómo es eso de que se cree 00:22:48
el objeto, este que digo, que se crea 00:22:51
cuando pasa eso raro 00:22:53
aquí seguro que tengo una clase 00:22:54
string por algún lado 00:22:57
sí, no sé, lo que quiero es entrar en una clase de la máquina 00:22:58
Y entrar desde aquí, porque si entro desde el otro lado 00:23:04
Tarda mucho en abrirlo 00:23:06
Aquí, quiero entrar 00:23:07
Implementación de la clase string 00:23:10
Vale 00:23:12
Entonces 00:23:13
A ver si encuentro rápido 00:23:15
Un throw 00:23:21
Por ahí 00:23:26
Espera, vamos a buscar aquí 00:23:27
Control F 00:23:36
Vale, este método 00:23:37
Lanza 00:23:52
vale, pues por ejemplo 00:23:54
a ver, la clase string 00:24:06
tiene aquí un método 00:24:10
bueno, es que perdí antes el constructor 00:24:12
vamos a coger otro método cualquiera 00:24:14
que se entenderá mejor 00:24:17
throws este, por ejemplo 00:24:18
vale, pues por ejemplo 00:24:35
la clase string, que la clase string ya está hecha 00:24:50
la clase string ya está hecha 00:24:52
pues la clase string tiene métodos para hacer cosas 00:24:54
entonces 00:24:56
cuando nosotros llamamos a 00:24:58
por ejemplo a este método 00:25:00
checkIndex de la clase string 00:25:02
que habría que ver para qué es 00:25:04
pero bueno, es para 00:25:07
verificar algo del índice, dentro de la longitud 00:25:08
es lo de menos, cuando llamamos a este método 00:25:10
este método a su vez 00:25:13
se basa llamando 00:25:14
a este otro de esta clase 00:25:16
llama a este método 00:25:18
y fijaos que hace este método 00:25:20
pues este método cuando ocurre una cosa 00:25:22
que el index 00:25:25
es menor que 0 00:25:27
o mayor que la longitud 00:25:29
del string 00:25:31
silencio, ¿qué hace? 00:25:32
hace esto, que esto hasta ahora no nos lo habíamos 00:25:35
encontrado, no nos lo habíamos 00:25:36
encontrado, vale, pues 00:25:38
esta sentencia throw ¿qué hace? 00:25:40
esta sentencia throw 00:25:43
es la que hace que 00:25:44
aparezca una instancia 00:25:46
de un objeto de la excepción que yo he puesto 00:25:48
aquí, que aparezca 00:25:50
y en ese momento es cuando aparece la excepción. 00:25:52
Entonces la máquina virtual 00:25:55
cuando va ejecutando, 00:25:57
va ejecutando, va ejecutando y se encuentra 00:25:58
un throw. Se encuentra un throw 00:26:00
pues cuando se encuentra el throw 00:26:03
la máquina virtual dice, ojo, 00:26:04
apareció una excepción. 00:26:06
Apareció una excepción. Y en ese 00:26:08
momento es cuando 00:26:10
para la máquina virtual. 00:26:12
Para la ejecución. 00:26:14
Cuando la máquina virtual se encuentra un throw. 00:26:16
Entonces la sentencia 00:26:19
throw es la sentencia que hace 00:26:20
que aparezca un objeto de la 00:26:22
excepción correspondiente, que aparezca 00:26:24
y la máquina 00:26:27
virtual cuando llega a ella y dice 00:26:28
toca lanzar excepción 00:26:30
toca lanzarla 00:26:32
pues lanzar excepción ¿qué significa? 00:26:33
que la máquina virtual para el 00:26:37
programa a menos que tengamos un try catch 00:26:38
en esa sentencia 00:26:40
¿vale? bueno pues las 00:26:41
excepciones no es que aparezcan de la 00:26:44
nada, las excepciones 00:26:46
aparecen también porque alguien ha programado 00:26:48
que aparezcan. 00:26:50
Aparecen porque alguien ha programado que aparezcan 00:26:52
cuando ha visto que algo no le gusta. 00:26:54
Entonces, Java, 00:26:57
cuando hace lo de dividir, 00:26:59
cuando Java ve la esta de dividir, 00:27:00
a su vez salta un código 00:27:03
para hacer cosas. 00:27:04
Ese código tendrá un 00:27:06
si divisor igual a cero, 00:27:08
throw. 00:27:10
Luego las excepciones aparecen 00:27:12
porque están programadas, porque alguien las ha programado 00:27:13
cuando pasa algo que no gusta 00:27:16
aparece 00:27:18
cuando la máquina virtual 00:27:19
a respeto de la ejecución llega al throne 00:27:21
en ese momento es en el momento en el que 00:27:24
la excepción nace 00:27:26
y aparece 00:27:28
y a partir de ahí que pasa, lo que ya hemos visto 00:27:29
que no está capturada 00:27:32
con el try-catch, se detiene 00:27:34
que está capturada con el try-catch 00:27:36
se hace lo que hay en el catch 00:27:38
y se sigue, ¿vale? 00:27:40
luego ese es el momento en el que aparece 00:27:42
y ahí hay dos caminos 00:27:43
Bueno, pues nosotros también podemos jugar con este throw 00:27:45
Y hacer aparecer excepciones 00:27:49
Y pasan cosas que no nos gustan 00:27:51
¿Vale? 00:27:53
Por ejemplo 00:27:56
Vamos a 00:27:57
A ver 00:27:59
Muy rápidamente 00:28:02
Para irnos con la idea un poco entendida 00:28:05
Esto lo acabo de decir 00:28:07
Porque lo del throw se habrá hecho un poco raro 00:28:08
Muy así un poquito por encima 00:28:10
Para acabar de entenderlo y ya nos vamos 00:28:12
A ver 00:28:14
vamos a hacer un proyecto, ejemplo excepciones 00:28:16
vale, pues 00:28:18
bueno, voy a hacer un paquete 00:28:36
que siempre queda más bonito en un paquete, pero da igual 00:28:46
vale, pues vamos a 00:28:48
lanzar nosotros 00:28:50
una excepción como programadores 00:28:52
para avisar de que algo ha pasado 00:28:54
y así entendemos un poquito 00:28:56
cómo aparecen las excepciones 00:28:58
vamos a lanzar nosotros una 00:29:00
para ver cómo aparecen, hasta ahora nosotros nos hemos 00:29:01
encontrado que las lanzaba 00:29:04
código al que hemos llamado 00:29:06
cuando hemos llamado a código 00:29:08
nos hemos encontrado que la lanzaban 00:29:10
y ya he explicado yo 00:29:12
que es lo que ha ocurrido en realidad 00:29:14
que cuando hemos llamado a ese código, la máquina virtual ha entrado 00:29:15
se ha encontrado un throw 00:29:18
y entonces ha aparecido la excepción 00:29:19
pues vamos a hacer eso mismo nosotros 00:29:22
que nos hemos encontrado que alguien ya ha hecho 00:29:24
vamos a programarlo nosotros para entender un poco 00:29:25
como aparece 00:29:27
pues venga, vamos a hacer una clase 00:29:28
pues venga, yo que sé, main 00:29:30
y vamos a hacer un método 00:29:35
para que alguien nos llame 00:29:42
desde el main 00:29:44
pues venga, vamos a hacer aquí un 00:29:46
static void 00:29:49
método 00:29:52
al que le pasamos un numerito entero 00:29:54
y ya está 00:29:56
entonces este método 00:29:57
adiós 00:29:59
imagínate que tiene que hacer algo 00:30:02
sin acritud 00:30:04
que luego os enfadáis 00:30:05
que este método tiene que hacer algo con n 00:30:07
Cualquier cosa 00:30:12
Pero si n es negativo 00:30:13
A este método no le mola 00:30:15
Que n sea negativo 00:30:18
Porque lo que hace necesita que n sea positivo 00:30:19
No le mola 00:30:22
¿Vale? 00:30:23
Entonces, aquí el que desarrolla 00:30:26
Tiene muchas posibilidades 00:30:28
Pues decir, a ver 00:30:29
Voy a verificar si n es negativo 00:30:32
Y si lo es 00:30:34
Muestra un mensajito 00:30:36
Bueno, es una forma, pero claro 00:30:37
Tiene que estar alguien sentado en la consola 00:30:40
Ahí para verlo 00:30:42
¿Vale? Por ejemplo 00:30:44
Si n es negativo, pues uno 00:30:48
Podríamos avisar de lo que no nos gusta 00:30:50
De esta manera 00:30:52
A la es negativo 00:30:53
Y luego aquí haríamos un retun 00:30:58
Para terminar 00:31:06
¿Vale? 00:31:07
Y si es positivo, pues ya lo que fuera 00:31:12
Que queremos hacer con ese número n 00:31:14
¿Qué podemos querer hacer con un número n 00:31:16
Que solo nos gusta hacer con los positivos? 00:31:19
pues la raíz normalmente puede ser o algo así 00:31:21
pues 00:31:23
yo que sé, pues esto 00:31:24
por ejemplo, esto mismo 00:31:27
imaginaos que tenemos aquí un método 00:31:33
que solo quiere operar, solo quiere 00:31:37
trabajar si n es positivo 00:31:41
o cero, si es negativo no quiere 00:31:43
entonces claro 00:31:45
aquí no hay forma de restringirlo 00:31:47
mediante el parámetro 00:31:49
porque el tipo de dato número positivo no existe 00:31:50
existe el tipo de dato entero 00:31:53
pero el tipo de dato de un número natural no existe 00:31:56
a ver, podría ocurrir, podría haber un lenguaje 00:31:58
de programación que tuviera un tipo de dato 00:32:00
que fuera int positivo 00:32:03
pero no es el caso, no existe 00:32:04
entonces restringirlo por tipo de 00:32:06
dato no podemos 00:32:08
bueno, pues entonces tenemos que 00:32:09
aquí programar 00:32:13
de tal manera que avisemos, que 00:32:14
concibamos, que consideremos que hacer si n es negativo 00:32:16
bueno, pues esta sería una opción 00:32:19
es decir, si n es negativo 00:32:21
te aviso y no hago nada 00:32:22
bueno, vale 00:32:24
a ver, es una opción fea 00:32:26
porque entonces necesitamos que haya alguien aquí 00:32:27
necesitamos que haya 00:32:30
alguien aquí sentado 00:32:38
para enterarse de esto 00:32:39
entonces si no hay alguien aquí sentado para enterarse de esto 00:32:44
pues no 00:32:49
y claro, no siempre hay un humano 00:32:51
ahí sentado, ¿por qué? 00:32:53
porque las salidas de los métodos 00:32:55
lo que hace un método, muchas veces 00:32:57
va a otro método o va a otro 00:32:59
programa, va a otro programa 00:33:01
y ese otro método 00:33:03
al que va el resultado de esto 00:33:05
no es un señor ahí sentado mirando 00:33:07
entonces, la solución 00:33:08
de avisar por consola en situaciones 00:33:11
será útil y en otras no tendrá ningún sentido 00:33:13
no tendrá ningún sentido 00:33:15
bueno, pues cuál es la siguiente 00:33:16
cosa que se puede hacer 00:33:19
la hemos mencionado antes con el replay 00:33:20
aviso con el valor 00:33:23
de retorno 00:33:25
aquí en este caso 00:33:25
vale, este método se supone 00:33:28
que si hace la raíz, hombre, debería devolverla 00:33:31
porque si no es un poco tonto esto 00:33:33
vale, entonces 00:33:35
return 00:33:37
y aquí 00:33:38
return 00:33:40
vale, pues esta sería 00:33:43
otra opción, decir 00:33:53
me las ingenio 00:33:54
si es que puedo, para utilizar 00:33:56
el valor de retorno como aviso 00:33:58
y digo, y lo comento, porque si no 00:34:00
lo comento, pues estoy siendo 00:34:03
un programador horrible, lo comento 00:34:04
y digo, a ver, que devuelve 00:34:07
menos 1 si n es negativo 00:34:09
¿qué devuelve? 00:34:13
pues devuelve la raíz 00:34:17
si n es mayor o igual que 0 00:34:19
vale, pues aquí estoy avisando con el valor de retorno 00:34:23
entonces el que me usa 00:34:29
ya sabe que si ha devuelto menos 1 00:34:30
el número es negativo 00:34:33
esto de todas maneras estaría un poco mal hecho 00:34:34
porque existen números para los cuales la raíz es menos 1 00:34:38
entonces había confusión 00:34:41
Si devuelves menos 1, oye, ¿estás haciendo la raíz de 1, que también es menos 1? 00:34:43
¿O es que el número es negativo? 00:34:48
Pero bueno, os lo digo como ejemplo de que cuando uno tiene que avisar de cosas relacionadas con lo que está pasando, 00:34:50
pues tiene primero, opción, avisar por consola. 00:34:56
Buena, si es que ese método lo va a usar alguien que está ahí sentado. 00:35:00
Mala, si eso no va a ser así. 00:35:04
Opción B, avisar con el valor de retorno si podemos. 00:35:08
si eso no volvía a nada 00:35:11
porque hay un voy, lo tengo clarísimo 00:35:13
pues como el replace, te devuelve null 00:35:15
si no está, por ejemplo 00:35:17
pues así, menos uno si es 00:35:19
negativo, la propia raíz 00:35:21
si no lo fuera, puede avisar por valor de retorno 00:35:23
y tres 00:35:25
otra forma de avisar 00:35:27
si ocurre lo que yo no quiero que ocurra 00:35:29
que es que sea negativo 00:35:32
lanzar una excepción 00:35:33
esa sería la tercera forma de avisar 00:35:35
y la mejor 00:35:37
porque no tengo que usar el valor de retorno. 00:35:38
No tengo que usarlo. 00:35:41
Y en este caso sería el ideal 00:35:43
porque el valor de retorno tiene una función 00:35:44
que es el propio resultado del método. 00:35:46
El propio resultado. 00:35:49
Entonces, dejemos el valor de retorno 00:35:51
para guardar el resultado del método 00:35:53
y aviso de que ha pasado algo raro 00:35:55
lanzando una excepción. 00:35:57
Esa sería la tercera manera y la buena 00:35:59
de avisar de que algo raro ha pasado 00:36:02
lanzando una excepción. 00:36:04
¿Y cómo se lanza una excepción? 00:36:06
bueno, tendríamos que lanzarla en este punto 00:36:07
aquí, que es donde 00:36:09
ha pasado lo raro 00:36:11
donde ha pasado lo raro es aquí 00:36:12
cuando él es negativo, ¿cómo se lanza 00:36:15
una excepción? pues 00:36:17
escribiendo la sentencia 00:36:19
throw 00:36:21
la sentencia throw, lanzo la excepción 00:36:21
¿y ahora qué tengo que lanzar ahí? 00:36:25
tengo que lanzar un objeto 00:36:27
de la clase exception 00:36:29
asociada a esta cosa rara 00:36:31
un objeto de la clase exception 00:36:33
asociada a esta cosa rara 00:36:37
hemos dicho ya que objetos 00:36:38
excepción, perdón, que clases excepción 00:36:40
hay ya un montón creadas 00:36:43
cada una asociada a una cosa 00:36:45
rara concreta, objeto nulo 00:36:47
lo que pasa es que esta en particular 00:36:49
que el número sea negativo 00:36:51
eso por defecto no es nada 00:36:52
malo, no es malo 00:36:55
entonces 00:36:56
así que tengo que hacer 00:36:58
crearme yo mi propia excepción 00:37:00
que eso ya lo dejaremos para el otro día 00:37:02
pero que queremos reutilizar 00:37:05
a ver si me deja, que no lo tengo claro 00:37:07
como no tenemos tiempo a crear nuestra propia excepción 00:37:08
que es lo que tendríamos que hacer, vamos a decir 00:37:10
bueno, si pasa esta cosa rara voy a lanzar una excepción 00:37:12
pero de las que ya están creadas, null pointer exception 00:37:14
aunque no pega ahí, porque el problema aquí 00:37:16
no es null pointer exception, el problema aquí 00:37:18
es número negativo 00:37:21
pero vamos a intentar, aunque yo creo 00:37:22
que el constructor 00:37:24
va a ser privado, sí que no me va a dejar 00:37:26
lanzar esta 00:37:29
pero bueno, voy a probar por si 00:37:30
ah mira, sí que me deja 00:37:32
no es privado el constructor de null pointer exception 00:37:35
pues fijaos lo que estoy haciendo aquí 00:37:37
lo que estoy haciendo aquí es 00:37:39
si n es negativo 00:37:41
estoy haciendo yo por código 00:37:43
que se lance la excepción 00:37:45
de tipo null pointer exception 00:37:47
no es un aviso muy claro 00:37:50
porque de lo que yo estoy avisando 00:37:53
yo estoy avisando 00:37:55
de que ha habido un problema 00:37:57
de objeto nulo y no es verdad 00:37:59
el problema no ha sido de objeto nulo 00:38:01
pero bueno he cogido esa porque no hemos hecho 00:38:02
una que se adapte a lo nuestro 00:38:04
bueno, pues mi método ya está estupendo 00:38:06
mi método ya recibe el valor 00:38:08
que le gusta 00:38:10
devuelve el valor de retorno 00:38:12
que no le gusta, avisa lanzando 00:38:14
una excepción, ¿vale? 00:38:16
y magnífico 00:38:18
esto está mucho mejor programado 00:38:19
ahora nosotros ejecutamos esto 00:38:22
ejecutamos nuestro main 00:38:24
que llama a este método 00:38:26
y efectivamente nos ha salido 00:38:27
null pointer excepción 00:38:32
el método nos ha avisado 00:38:34
de que ha habido una excepción o un puente de excepción 00:38:36
a ver, muy mal avisado 00:38:38
claro, ha avisado 00:38:40
de lo que yo le he dicho que avise 00:38:42
ha avisado de lo que yo le he dicho que avise 00:38:43
vale 00:38:46
pero entendéis, lo que quiero que entendáis es 00:38:47
que las excepciones cuando os han 00:38:50
aparecido, cuando nos han aparecido 00:38:52
ejecutando cosas, no es que ya se hayan 00:38:54
generado de la nada, que la red roja 00:38:56
la se haya escrito ahí uno que estaba ahí dentro 00:38:58
no, cuando aparece una excepción 00:38:59
es porque la máquina virtual 00:39:02
se ha puesto a ejecutar lo que le hemos pedido 00:39:05
y como consecuencia de entrar 00:39:07
en los métodos, los métodos ir ejecutando 00:39:08
se ha encontrado un throw 00:39:10
entonces se ha encontrado un throw 00:39:12
pues 00:39:14
el throw es una sentencia más 00:39:16
y el throw que hace, hace aparecer 00:39:18
un objeto de este tipo 00:39:21
te pone las letritas rojas 00:39:23
correspondientes, ¿qué te pone letras rojas? 00:39:26
lo que está configurado en esta clase 00:39:28
que eso no lo hemos hecho nosotros 00:39:30
porque la clase ya está hecha, te hace aparecer esos mensajitos 00:39:32
correspondientes y para 00:39:35
la ejecución, y la para 00:39:37
eso es lo que hace la máquina virtual cuando se encuentra 00:39:38
al centro, entonces es una sentencia más 00:39:40
cuando nos han aparecido por tanto 00:39:42
estas cosas aquí 00:39:44
estas cosas 00:39:45
era simplemente porque la máquina 00:39:48
virtual, pipipipi, ha visto un throw 00:39:50
y ya está, ha visto un throw 00:39:52
nos ha puesto el mensaje y ha parado 00:39:54
¿vale? 00:39:56
entonces, nosotros ya 00:39:59
como programadores que somos los que decidimos 00:40:00
lo que hace el programa, como pasan 00:40:03
las cosas, ¿cuándo 00:40:05
pondremos un throw? Pues pondremos 00:40:06
un throw cuando queramos avisar 00:40:08
de que ha pasado una cosa muy rara que no 00:40:11
debería pasar y queremos 00:40:12
avisar lanzando 00:40:14
un objeto excepción, porque para eso los 00:40:16
usamos, para avisar de que han pasado cosas 00:40:18
raras, no usamos los objetos 00:40:20
de excepción para avisar de algo que no tiene importancia 00:40:22
no, los usamos 00:40:25
para avisar de que han pasado cosas raras 00:40:26
porque sabemos que la implicación que tiene es que el programa 00:40:28
para, entonces con el programa parar 00:40:31
lo usamos si es que ha ocurrido 00:40:33
algo raro, el throw 00:40:35
y repito, aún así 00:40:37
yo puedo salvarme de que el programa 00:40:40
pare capturando 00:40:43
imaginaos que aquí tengo otra sentencia 00:40:44
esta 00:40:46
si yo ejecuto mi programa 00:40:47
ahora, ya sabemos 00:40:51
que cuando yo ejecuto esto 00:40:53
como la excepción ha saltado 00:40:54
aquí, ni adiós ni nada 00:40:56
porque aquí se paró 00:40:58
aquí el programa se ha parado 00:41:00
porque sabemos que esa es la consecuencia 00:41:02
del throw que hay aquí dentro 00:41:04
pero que yo 00:41:06
no quiero que el programa pare porque es fundamental 00:41:08
lo que viene después, que muestre la dios, lo que sea 00:41:10
no quiero que pare, pues no pasa nada 00:41:12
voy a capturar la excepción 00:41:15
la capturo 00:41:17
como hemos dicho antes 00:41:21
la capturo 00:41:26
y ahora que va a ocurrir 00:41:35
el throw se va a ejecutar igualmente 00:41:37
cuando haya método raíz menos 12 00:41:39
el throw se va a ejecutar, pero la máquina 00:41:41
virtual ya ni saca 00:41:43
letras rojas, ni para el programa 00:41:45
ni hace nada, lo que hace 00:41:47
es lo que hay en el catch 00:41:50
es lo que hace, luego si no está 00:41:51
el try catch, saca 00:41:53
letras rojas y para 00:41:56
el programa 00:41:57
si hay un try catch 00:41:58
el throw se ejecuta igualmente 00:42:01
porque el throw está, porque el número es negativo 00:42:03
pero la máquina virtual 00:42:05
no hace nada más, ni para el 00:42:07
programa, ni saca de tarroja, ni nada 00:42:09
hace lo que hay en el catch 00:42:11
que en el catch hay algo, lo hace, que en el catch no hay nada 00:42:13
no lo hace, no hace nada 00:42:15
entonces cuando yo ejecute esto ahora 00:42:17
llamaremos a método raíz 00:42:18
método raíz entraremos 00:42:21
a método raíz, hará esto 00:42:23
bla bla bla, llegará el throw 00:42:25
una vez que llega el throw, ya está 00:42:27
el método este ya sí que termina 00:42:29
porque es un throw, esto es como si fuera un return 00:42:31
llega el throw, termina, subimos arriba 00:42:33
otra vez 00:42:35
como está capturada 00:42:36
como está capturada 00:42:38
ya ni se para 00:42:40
ni hay letras rojas 00:42:41
si no estuviera capturada 00:42:43
ya la segunda parte sería 00:42:44
parar la ejecución 00:42:46
y sacar las letras rojas 00:42:48
como está capturada 00:42:49
ni lo para 00:42:50
ni saca letras rojas 00:42:51
y se va al catch 00:42:52
se va ahí 00:42:53
hace eso 00:42:54
y luego continúa tan feliz 00:42:55
¿vale? 00:42:57
continúa tan feliz 00:43:00
aunque haya salido el throw 00:43:01
entonces ejecutamos esto 00:43:02
pues vale 00:43:03
Ha pasado esto y ya está 00:43:04
Ha salido la excepción 00:43:07
Pero a resulta de la excepción 00:43:09
No ha pasado nada 00:43:12
Porque en el catch no hay nada 00:43:13
Y luego ha seguido 00:43:14
¿Vale? 00:43:15
Venga, pues ahora sí que paramos aquí 00:43:19
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
15
Fecha:
7 de abril de 2024 - 13:48
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
43′ 23″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
555.96 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid