Saltar navegación

20260309 Exception_3 - 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 10 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues, venga. 00:00:00
Venga, pues, ya habíamos refactorizado nuestro método 00:00:04
este getVoto estupendo, ¿vale? 00:00:07
Entonces, ahora ya, ahora hemos decidido diseñar nuestro 00:00:11
código, ahora sí. 00:00:18
Ahora, nuestro código llama a un método getVoto y ese método 00:00:20
getVoto está encerrando demasiada complejidad. 00:00:25
Ahí, la idea es que los métodos sean lo más atómicos posibles, ¿vale? Entonces, este método está ahí metiendo validación, a ver, que yo esto también lo estoy diciendo, pues porque me facilita el hilo de la explicación, pero en general tiene sentido. 00:00:28
bueno, pues este método está haciendo 00:00:45
una validación, validación 00:00:47
y cuando yo llame a ese método 00:00:48
cuando llame a ese método 00:00:50
llamo y confío 00:00:51
en que el usuario 00:00:55
que va a votar vote un candidato válido 00:00:57
porque como no vote un candidato 00:00:59
válido, me voy a estar esperando 00:01:01
años y años, porque aquí voy a tener 00:01:03
un bucle infinito 00:01:05
bueno, es una posibilidad de diseño 00:01:06
mi código llama a este voto 00:01:08
y ahí se queda horas y horas 00:01:10
y horas, esperando que 00:01:13
el votante emita un voto válido. 00:01:14
Pero podríamos hacer otra filosofía, 00:01:18
que es, no, no. Yo te doy la opción 00:01:20
de votar y no me estoy ahí esperando 00:01:22
delante de la urna años 00:01:24
si hace falta hasta que tú decidas escribir 00:01:26
en la papeleta lo que toca. 00:01:28
Eso no lo voy a hacer. 00:01:30
Yo te voy a 00:01:32
pedir que votes 00:01:33
y si votas bien, 00:01:35
magnífico, pero y si votas mal, 00:01:38
yo aviso, este ha votado mal y se acabó. 00:01:40
Nada de estarme aquí esperando años 00:01:43
y años y años a que tú votes bien 00:01:44
no, tú vota 00:01:46
que tu voto no es válido, el voto de este tío 00:01:48
no es válido, tú verás qué haces con él 00:01:50
si lo llevas a la cárcel o le das otra oportunidad 00:01:51
lo que tú quieras 00:01:54
esa es una mejor filosofía de diseño 00:01:55
¿vale? 00:01:58
los métodos, las cosas más atómicas posibles 00:02:00
y que las decisiones 00:02:02
estratégicas 00:02:04
como te dejo votar otra vez o te llevo a la cárcel 00:02:05
las decisiones estratégicas 00:02:08
se deleguen para arriba 00:02:09
sería en principio 00:02:11
mejor diseño 00:02:14
vale, pues entonces 00:02:15
eso que implicaría aquí, en esta versión B 00:02:17
de votaciones, este bucle 00:02:20
lo quito 00:02:22
y leo el voto sin más 00:02:22
si el voto 00:02:26
es válido, genial, lo devuelvo 00:02:28
y si no es válido 00:02:30
aviso de que no ha sido válido 00:02:32
vale, eso sería 00:02:34
lo ideal, y ya el de arriba 00:02:36
que decida que hace con ese voto no válido 00:02:38
si le da otra oportunidad o no le da ninguna 00:02:40
bueno, pues ese 00:02:43
aviso de que el voto no ha sido 00:02:44
válido, tiene que ser 00:02:47
mediante una excepción, porque esa es la forma 00:02:49
en la que los métodos avisan 00:02:50
al de arriba de que algo raro 00:02:53
ha pasado, ¿vale? 00:02:55
hasta ahora esos avisos 00:02:57
si hemos querido hacerlos, los hemos hecho 00:02:58
usando el valor de retorno 00:03:01
es decir, yo puedo 00:03:02
hacer un método que me devuelva boolean 00:03:05
si el boolean es falso 00:03:06
ese método no funcionó 00:03:08
no es válido, algo raro pasó 00:03:11
y si el valor de retorno 00:03:13
es true, ese método funcionó correctamente 00:03:15
pero en este caso no podemos usar 00:03:17
el valor de retorno, porque ya está 00:03:19
usado para el voto, ya está usado 00:03:20
para el nombre del candidato 00:03:23
luego no puedo usar un boolean de retorno 00:03:24
para avisar si las cosas han ido bien o mal 00:03:26
no puedo 00:03:28
aún así, tendríamos 00:03:29
otra forma de avisar al de arriba que algo 00:03:32
ha ido mal o no 00:03:35
sin necesidad de 00:03:35
mandarle una excepción 00:03:37
en esta misma firma de aquí 00:03:39
con un string 00:03:42
la tendríamos 00:03:42
devolviendo null 00:03:49
espera, espera, espera 00:03:51
espera, espera, sí 00:03:57
sí, sí 00:03:58
la respuesta sí, pero por partes 00:04:00
vale, entonces tendríamos otra 00:04:03
forma de avisar al de arriba 00:04:05
de que este método ha ido mal 00:04:06
es decir, vamos a quitarle la validad 00:04:08
el bucle, repito 00:04:10
vamos a quitarle el bucle 00:04:11
y esto se nos queda así 00:04:12
entonces, si 00:04:14
el voto emitido 00:04:26
está contenido en los candidatos 00:04:28
pues entonces, magnífico 00:04:32
retúmboto 00:04:34
y si no, si no está contenido 00:04:35
en los candidatos 00:04:38
yo aún así tengo una manera de avisar 00:04:39
de que algo ha ido mal 00:04:42
podría devolver null 00:04:45
y ahora aquí, por supuesto 00:04:47
Primero 00:04:49
Asegurarme de comentarlo bien 00:04:50
Porque si no lo comento bien 00:04:53
Pues ese null 00:04:57
No significa nada 00:04:59
¿Qué significa null? 00:05:01
Entonces tendría sentido 00:05:03
El nombre del 00:05:05
Candidato 00:05:09
Candidato votado 00:05:11
Y ahora pondría aquí 00:05:13
Devuelve null 00:05:15
si el voto no es 00:05:18
válido 00:05:21
vale, esta podría ser una opción 00:05:22
yo con esto 00:05:25
emito el voto 00:05:27
si el voto es válido 00:05:29
lo devuelvo, si no aviso 00:05:31
con null, con lo cual ya he delegado arriba 00:05:33
pero claro, el de arriba 00:05:35
no ve el código de este método, tiene que saber 00:05:37
qué significa el null 00:05:39
eso para empezar, con lo cual buena idea comentarlo 00:05:40
entonces el que usa 00:05:43
el método 00:05:45
menos mal que yo lo he comentado 00:05:45
con javadoc, porque el que usa 00:05:48
el método, dice 00:05:50
ah, espérate, si me da null 00:05:52
es porque no es válido 00:05:54
cuidado, me puede dar null, no es válido 00:05:56
entonces yo ahora ya decido 00:05:58
si me meto en un bucle, mientras esto sea diferente 00:05:59
de null, o si le digo 00:06:02
voto no válido 00:06:04
yo ya puedo decidir, pero hombre 00:06:06
que me lo documente bien, porque un null en sí 00:06:08
no significa nada, que me lo documente 00:06:10
bien, ¿vale? y aquí me aparece 00:06:12
lo que yo he puesto en el javadoc 00:06:14
entonces vale, estupendo 00:06:15
en este entorno y en cualquier otro 00:06:17
porque están 00:06:20
ligados al javadoc 00:06:20
¿vale? recordad que 00:06:23
javadoc son los comentarios 00:06:26
que empiezan así 00:06:27
con dos asteriscos 00:06:29
y todo lo que 00:06:32
pongamos aquí, todo 00:06:34
se integra 00:06:35
en la ayuda 00:06:38
de los métodos 00:06:39
y esa ayuda 00:06:42
donde aparece, aparece luego 00:06:43
cuando lo escribimos 00:06:45
aparece en la herramienta de ayuda 00:06:47
del entorno de desarrollo que sea 00:06:49
así muy en resumen 00:06:51
bueno, pues esta podría ser una opción 00:06:53
pero bueno, a ver 00:06:55
los null tienen muy mala 00:06:58
prensa, y es normal que tengan 00:07:00
mala prensa, ¿no? los null tienen mala prensa 00:07:01
¿por qué? porque nos generan 00:07:04
los null pointer exception 00:07:05
¿vale? tienen muy mala prensa 00:07:07
entonces, si yo uso 00:07:10
eso 00:07:11
aquí 00:07:12
voto puede ser null 00:07:19
tranquilamente puede ser null 00:07:24
y mi programa sigue 00:07:27
y no pasa nada, voto puede ser null 00:07:28
y mi programa va a seguir 00:07:30
y en algún momento ese null puede petar 00:07:32
aquí en particular 00:07:34
voto no llama nada, con lo cual un null pointer exception 00:07:36
no va a salir 00:07:39
pero hay un contents key 00:07:39
de voto, entonces el contents key 00:07:42
cuando es null no sé qué hará 00:07:45
pero vamos 00:07:47
igual te da una 00:07:48
excepción de que no le puedes pasar un null 00:07:52
al contents key 00:07:54
en resumen, es muy mala idea 00:07:55
trabajar lógicamente 00:07:58
con variables objeto que tengan un null dentro 00:08:00
porque en cuanto yo 00:08:02
llame algo dentro de ellas con el punto 00:08:04
me va a salir null pointer exception 00:08:06
se para el programa porque uno no se está capturando 00:08:07
los null pointers de todo el rato 00:08:10
¿vale? entonces esta forma 00:08:11
de avisar, pues bueno, tiene 00:08:14
ese peligro, que estamos devolviendo un null 00:08:16
y si el que la usa 00:08:18
aquí no lo tiene en cuenta 00:08:20
para si es, para meterlo 00:08:22
en un bucle mientras sea diferente de null 00:08:24
o si es null, pon voto 00:08:26
a lo que sea, sin él no lo 00:08:28
tiene en cuenta, tiene su peligro 00:08:30
¿vale? 00:08:32
Bueno, pues opción B, otra 00:08:34
forma de avisar, otra forma de 00:08:36
avisar mucho más segura y menos peligrosa 00:08:38
vamos a hacernos el 00:08:41
getVoto versión 2 00:08:42
el bueno y el bonito 00:08:44
getVoto 00:08:47
versión 2, vale 00:08:52
aquí 00:08:53
cuando 00:08:55
resulta que el voto no es válido 00:08:57
en el else del candidatos 00:09:00
containsVoto, en el else 00:09:02
yo aquí nada de devolver null 00:09:03
nada de devolver null, lo que hago 00:09:06
es, pum 00:09:08
construir un objeto de excepción 00:09:09
y mandarlo para arriba, y se acabó 00:09:11
y se detiene la ejecución del método 00:09:14
aunque hubiera cosas aquí debajo 00:09:16
Eso ya ni se hace 00:09:18
¿Vale? Entonces, ¿qué es lo que queremos hacer aquí? 00:09:19
Aquí queremos 00:09:22
Lanzar una excepción 00:09:23
¿Y cómo se lanza una excepción? 00:09:25
Pues una excepción 00:09:30
Se lanza poniendo throw 00:09:31
Como la de esperar 00:09:33
Y aquí el objeto 00:09:34
Instanciamos el objeto excepción 00:09:37
Que queremos lanzar 00:09:39
¿Cómo se instancia un objeto? Con new 00:09:40
¿Qué tipo de excepción lanzamos? 00:09:42
Pues 00:09:46
Si nos ponemos a buscar entre las 300-500 00:09:46
clases excepción, no hay ninguna 00:09:49
que sea boton o válido. 00:09:51
Exception. 00:09:53
Con lo cual, ¿qué podemos hacer? 00:09:55
Crearnos nuestra propia excepción. 00:09:58
¿Vale? Crearnos 00:10:00
nuestra propia excepción. 00:10:01
A ver, podríamos lanzar otra, la que nos 00:10:03
diera la gana. 00:10:05
Yo podría lanzar esta, pero... 00:10:07
¿Vale? Podría lanzar esta excepción. 00:10:14
Pero qué tontería lanzar 00:10:17
una excepción io, que no me explica 00:10:18
nada, cuando lo que yo quiero es 00:10:20
avisar, porque la excepción es avisar 00:10:22
de que el votante ha emitido 00:10:24
un voto no válido, entonces voy a 00:10:26
crearme yo mi propia excepción 00:10:28
voy a crearme mi propia excepción 00:10:30
para ponerla aquí 00:10:32
venga, pues vamos a 00:10:34
crearnos una clase excepción 00:10:38
vale, pues 00:10:39
aquí estamos en el ejercicio 8 00:10:41
pues venga 00:10:43
nuestra clase se va a llamar 00:10:45
voto no 00:10:48
válido 00:10:50
El nombre de la excepción 00:10:50
Da igual lo largo que sea 00:10:54
Cuanto más explicativo mejor 00:10:56
Voto no válido y por convenio 00:10:58
No es que sea obligatorio 00:11:00
Por convenio suelen acabar en exception 00:11:01
Todas para que se vea que es una clase de excepción 00:11:03
Exception 00:11:06
Vale, no es que sea obligatorio 00:11:09
Pero hombre 00:11:12
Aclara mucho el código 00:11:13
Todas las clases cuyo nombre acabe en exception 00:11:15
Son clases de excepción 00:11:17
vale, pues para que esta clase 00:11:18
sea una excepción 00:11:25
de verdad 00:11:27
y tenga todo lo que tienen que tener las excepciones 00:11:28
de poder ser lanzadas 00:11:31
de que el otro la pueda 00:11:33
recoger, etcétera 00:11:35
tiene que heredar 00:11:37
¿de qué? 00:11:39
de una superclase magnífica que se llama 00:11:41
exception, que tiene todo lo básico de las excepciones 00:11:43
entonces 00:11:45
exception es una superclase 00:11:49
que a su vez hereda de una 00:11:51
interfaz throwable que es todo lo lanzable 00:11:55
todo lo lanzable 00:11:57
y esto ya lo convierte 00:11:58
en excepción y en realidad yo no hace 00:12:01
falta que haga nada más, la puedo dejar así con su 00:12:03
constructor por defecto y ya está 00:12:05
la podría dejar así 00:12:07
pero 00:12:08
la clase exception entre todas 00:12:10
las cosas que tiene dentro tiene una variable 00:12:13
que es su mensajito 00:12:15
y ese mensajito es el mensajito que te 00:12:16
aparece en las líneas rojas cuando 00:12:19
sale, entonces hombre vamos 00:12:21
a aprovechar esa variable y vamos a poner el mensajito 00:12:23
personalizado para esta excepción 00:12:25
que en este caso sería 00:12:27
el votante no ha votado 00:12:29
bien, vale 00:12:31
vale, pues como lo podemos hacer 00:12:33
pues vamos a hacer su 00:12:35
constructor y le vamos a pasar 00:12:37
a partir del constructor esa variable 00:12:39
vale, pues la clase 00:12:41
exception, la clase exception 00:12:50
tiene un constructor 00:12:52
del que yo me voy a aprovechar 00:12:55
un constructor al que si yo le paso 00:12:58
un mensajito 00:13:03
esa variable 00:13:04
mensaje interno se inicializa 00:13:06
con este mensajito 00:13:09
pues cuando este objeto 00:13:10
excepción se instancie 00:13:23
se va a instanciar 00:13:25
metiendo en su variable 00:13:28
interna mensaje esta 00:13:30
y esa variable interna es la que nos saca la máquina virtual 00:13:31
luego, vale, ya está nuestra 00:13:34
excepción hecha 00:13:42
este aviso simplemente de que como implementa 00:13:42
Serializable, todas las exceptions 00:13:45
Nos dice, no tienes un valor de serialización 00:13:47
Pero eso no nos hace falta, si no vamos a serializar 00:13:50
Nah, ese amarillo lo olvidáis 00:13:52
Vale, pues ahora ya 00:13:53
Sí que lanzamos throw new 00:13:55
Voto 00:13:58
Válido 00:14:02
Exception 00:14:03
Ala, y esta es 00:14:06
La forma buena, en realidad 00:14:09
La forma buena de que un método avise al de arriba 00:14:11
De que ha pasado algo raro 00:14:13
no devolviendo un null 00:14:14
porque ese null vete a saber el de arriba como lo interpreta 00:14:16
y nada de eso, esta es la forma buena 00:14:19
lanzando con throw 00:14:20
un objeto de excepción 00:14:23
relacionado que explique lo que ha pasado 00:14:24
que normalmente implica 00:14:26
hacernos uno nuestro para nosotros 00:14:28
¿y por qué se nos ha quedado rojito? 00:14:30
se nos ha quedado rojito 00:14:35
porque si un método puede 00:14:37
que lance una excepción, puede que lance 00:14:38
en la firma que es 00:14:41
lo que hay arriba, hay que avisar 00:14:43
es obligatorio 00:14:45
y esta firma tal y como está hecha 00:14:46
no está avisando de nada de eso 00:14:48
pues tiene que avisar 00:14:50
¿y cómo avisa? pues poniendo 00:14:52
después de la firma 00:14:54
throws 00:14:56
la clase de excepción que puede ser 00:14:57
que lance ¿vale? 00:15:00
entonces 00:15:08
esto 00:15:08
significa, lanza la excepción 00:15:10
se va a lanzar en el 00:15:12
else, es decir, cuando 00:15:14
el voto no sea válido 00:15:15
Se puede lanzar lo que haya el momento cuando yo decida que toca parar y avisar, ¿vale? Y repito, si hubiera líneas de código aquí después, estas líneas de código, por ejemplo, esta, imaginaos que hay esto, ha votado, ¿vale? 00:15:17
Bueno, claro, es que esto como tenemos aquí un retun 00:15:34
Vale, vamos a poner aquí 00:15:38
Si candidatos 00:15:40
Contains voto 00:15:44
A ver, voy a quitar el retun de aquí porque quiero poner una línea después del list 00:15:48
Voy a poner aquí directamente 00:15:52
Si candidatos no contiene el voto 00:15:54
Entonces ahora ya lanzo la excepción 00:15:58
Y así vemos mejor 00:16:00
Y ahora ha votado y retun voto 00:16:01
así me gusta más 00:16:08
vale, esta versión me gusta más 00:16:10
entonces, leemos el voto 00:16:20
si no está 00:16:22
contenido en los válidos 00:16:24
excepción lanzada 00:16:25
y el método da igual, ya se ha parado 00:16:27
ya se ha parado, esto que hay después ya no se va a ejecutar 00:16:29
nunca, se ha lanzado 00:16:32
excepción y para arriba, se acabó 00:16:34
si el 00:16:35
voto si es válido 00:16:38
entonces ya no entra en el if 00:16:41
con lo cual continúa y pondrá votado 00:16:43
y retumboto, vale 00:16:45
y podemos poner aquí 00:16:47
a lo mejor para verlo 00:16:49
ha votado a este 00:16:51
ha votado a este 00:16:52
por ejemplo, vale 00:16:58
vale, pues este método es más bonito 00:16:59
porque este método ya sí que está avisando 00:17:01
está avisando 00:17:04
de una manera 00:17:06
explícita 00:17:07
y además se para 00:17:11
se para, o sea, si el voto no es válido 00:17:13
es que ni siquiera sigue. Esto ya no lo va a hacer. 00:17:15
Se para. Avisa de manera explícita. 00:17:17
Este ya está mejor. 00:17:20
Pero, recuerdo, 00:17:23
no se nos puede olvidar que si 00:17:25
puede que lance 00:17:27
una excepción, es decir, si hay un throw porque 00:17:29
puede que en algún momento la lance, 00:17:31
la firma del método tiene que incorporar el 00:17:33
throw para avisarlo. 00:17:35
La firma del método tiene 00:17:37
que incorporar el throw. 00:17:38
Vale. 00:17:40
Vamos a llamar 00:17:43
ahora a este método. 00:17:44
Ahora, ¿dónde llamaba yo a GetBoto? 00:17:45
Aquí 00:17:48
Vale, pues esto lo vamos a dejar comentado 00:17:48
Vamos a usar ahora el otro 00:17:51
Vamos a usar ahora el otro 00:17:52
GetBotoV2 00:17:57
GetBotoV2 00:17:59
Vamos a llamar a este 00:18:06
Vale, pues ahora mucho mejor 00:18:07
Porque el propio compilador ya nos ha puesto 00:18:11
Una barrera de seguridad 00:18:14
Yo cuando llamaba a GetBoto 00:18:16
Tan tranquilo, que luego me sale un null 00:18:19
¿Ya es problema tuyo? ¿Qué haces con ese null? 00:18:22
Ahora, llamo a getVoto2 00:18:24
que me avisa con excepción. 00:18:26
Automáticamente ya el 00:18:29
compilador ya me pone ahí 00:18:30
un freno. ¿Y qué me está 00:18:31
diciendo el compilador? 00:18:34
Pues vamos a leerlo. El compilador 00:18:35
me está diciendo, uy, 00:18:37
cuidadito, cuidadito 00:18:40
que este método te puede dar 00:18:42
voto no válido excepción. Cuidado. 00:18:43
¿Vale? Cuidado. 00:18:47
Entonces, tú ya sabes 00:18:48
que ese método te puede dar 00:18:49
una excepción y 00:18:51
no te va a compilar mientras tú 00:18:53
no la captures. 00:18:55
Esto es una semi mentira, 00:18:58
pero luego ya la... 00:18:59
¿Vale? Porque puedes no capturarla 00:19:01
y propagarla, pero bueno, 00:19:05
eso lo hacemos ahora después. 00:19:07
¿Veis cómo esta forma de avisar es mucho mejor? 00:19:11
Es mucho mejor porque ya el compilador 00:19:14
te está diciendo, oye, cuidado, ten en cuenta 00:19:15
que eso te puede dar una excepción, ten en cuenta. 00:19:17
Entonces tú dices, ¡ah! 00:19:20
Vale, vale. Entonces yo ya 00:19:22
decido aquí que hago, o me hago un bucle 00:19:23
con el boolean que hemos 00:19:25
hecho antes, o 00:19:27
vale, yo ya la capturo 00:19:31
y digo, vale, intenta votar 00:19:34
si no puedes votar 00:19:36
porque te sale 00:19:39
voto no válido, yo aquí la 00:19:42
capturo, la excepción que lanza este 00:19:44
si me sale la excepción 00:19:46
voto no válido, pues entonces 00:19:48
ya aquí hacemos lo que nos dé la gana 00:19:50
pues por ejemplo 00:19:52
todos los que hagan voto no válido van a votar al primero 00:19:54
Ala, ya está, porque yo he decidido eso, pero vamos, lo normal sería meterlo en un bucle, etc. 00:19:56
Candidatos.get de 0, lo podemos poner aquí, voto no válido, se asigna, se asignará al primer candidato, 00:20:08
O lo que uno quiera 00:20:37
Eso ya es lo de menos 00:20:39
Voto no válido 00:20:40
Se asignará al primer candidato 00:20:42
O lo que uno le dé la gana 00:20:44
Y ya está 00:20:45
¿Vale? 00:20:46
¿Qué es el método ese que te salía? 00:20:50
Ese es el método 00:20:56
Lo vimos ayer 00:20:58
Es el método 00:20:58
Que te muestra las letras rojas 00:20:59
Es decir, te muestra el contenido dentro de la excepción 00:21:03
Entonces, por eso la máquina virtual 00:21:05
Cuando tú no capturas una excepción 00:21:07
Y para el programa 00:21:09
vale, pues lo primero 00:21:09
que hace es llamar, aunque tú no lo ves 00:21:12
a ese print extract trace y por eso nos aparecen 00:21:14
esas cosas rojas, vale 00:21:16
entonces yo lo voy a, primero lo voy a probar 00:21:18
sin llamarlo, luego llamándolo, vale 00:21:20
bueno, pues entonces 00:21:22
ahora ya esta aplicación está mejor 00:21:24
hecha, porque el compilador 00:21:26
nos ha avisado de que esto puede que salga 00:21:28
mal y te ha obligado a ti 00:21:30
a hacer algo, te ha obligado a ti a hacer algo 00:21:32
pues tú lo capturas y lo que has decidido 00:21:34
hacer es dárselo al primero 00:21:36
Y ya está 00:21:37
Podrías haber decidido otra cosa 00:21:39
O haber metido este try catch en un bucle 00:21:40
O lo que quisiéramos 00:21:43
Venga, vamos a ejecutar ahora esto 00:21:45
Con los cambios que hemos hecho 00:21:47
A ver si nos 00:21:49
Funciona todo 00:21:52
¿Cuántos se presentan? 00:21:53
Tres, dime nombre 00:21:57
El A, el B y el C 00:21:59
Y ahora ya empezamos con los votos 00:22:01
Porque no dice ni que voto ni nada 00:22:06
Será eso 00:22:07
A, ha votado A 00:22:08
C, ahora pongo el 00:22:10
G, voto no válido 00:22:13
se asigna el primero, vale, muy bien 00:22:15
pero seguimos 00:22:17
el B, el D, no válido, se asigna el primero 00:22:18
vale, y aquí seguimos 00:22:21
hasta acabar, vale, ya está 00:22:23
8, ya está 00:22:28
¿entendido? 00:22:30
entonces, E es el objeto 00:22:38
excepción 00:22:41
E tiene información que podemos sacar de él si queremos 00:22:42
por ejemplo, a través 00:22:45
de este método, esto te muestra 00:22:47
por consola la traza 00:22:49
de llamadas que llegaron a esa excepción 00:22:51
el mensajito interno 00:22:53
¿vale? o sea, si quisiéramos 00:22:55
que era lo que comentábamos ayer 00:22:57
si estamos en tiempo de desarrollo de código, queremos 00:22:58
toda la información posible 00:23:01
entonces en ese caso, llamaríamos 00:23:02
a este porque además me sale 00:23:05
toda la información de la excepción 00:23:07
¿no? si yo vuelvo a ejecutar este programa así 00:23:08
venga, dos candidatos 00:23:11
A y B 00:23:15
Y ahora voy a votar a uno que no hay 00:23:17
¿Ves? Me sale esto 00:23:19
Este es el print extract trace 00:23:22
Que es la información interna 00:23:24
Entre ella el mensajito 00:23:27
El mensajito que yo he puesto 00:23:28
El votante ni votar ha sabido 00:23:30
Me sale ahí el mensajito 00:23:33
Lo que yo he puesto en la excepción 00:23:35
Pero el programa no ha parado 00:23:37
El programa no para 00:23:38
Porque esto de aquí es simplemente el resultado de 00:23:40
Esta sentencia 00:23:44
Esta 00:23:47
el resultado de esa 00:23:47
y luego después me ha hecho esto 00:23:50
y lo ha asignado al cero 00:23:52
es decir, esto es 00:23:54
esto, que nos da 00:23:57
información, pero claro, cuando ya 00:24:00
le damos el programa a alguien para que lo use 00:24:02
eso lo quitamos, porque no queremos que vea 00:24:04
eso, eso para 00:24:06
nosotros, cuando estamos haciendo pruebas, si nos interesa 00:24:08
para saber dónde ha fallado, tú pinchas 00:24:10
aquí y dices, ah, vale, me falló aquí 00:24:12
pero 00:24:14
cuando ya se acaba o no 00:24:15
No haces eso, ¿vale? 00:24:18
Vale, pues entonces 00:24:36
Más o menos entendido hasta aquí 00:24:38
Pues nos falta un pelinín 00:24:41
Y ya damos lo de las excepciones 00:24:42
Por ventilado 00:24:44
Venga, vamos a aprovechar y paramos aquí un momento 00:24:46
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
10 de marzo de 2026 - 14:01
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 50″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
102.26 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid