Saltar navegación

20260311 Exception_5 - 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 17 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues vamos a hacerlo 00:00:00
Y ya nos quitamos esto de en medio 00:00:03
Vale 00:00:07
Venga, a ver si sacamos algo interesante 00:00:07
Bueno, clase alumno 00:00:10
Pues ala, alumno es con lo que vamos a trabajar 00:00:13
Paquete nuestro 00:00:15
Con el modelo 00:00:17
Pues venga 00:00:18
El modelo solamente tiene 00:00:19
Una entidad, alumno, pues alumno 00:00:26
Las propiedades serán 00:00:28
Nombre y 00:00:39
año de nacimiento, ¿verdad? 00:00:40
pues ya está 00:00:45
nacimiento, ala, ya está 00:00:46
¿vale? 00:01:02
ahora lo de siempre, get, set 00:01:07
¿vale? nosotros hacemos de corrido 00:01:09
siempre un montón de cosas, los get y los set 00:01:12
porque realmente los get y los set 00:01:14
son el estándar 00:01:16
es la forma que nosotros 00:01:17
publicamos 00:01:19
dicho en palabras 00:01:21
más técnicas, exponemos 00:01:23
nuestra entidad 00:01:25
vale, exponer en este contexto 00:01:26
nuestro de desarrollo, significa 00:01:29
que es lo que hacemos visible 00:01:31
al exterior, pues estamos 00:01:33
exponiendo nuestras propiedades con 00:01:35
los getter y los setter, vale 00:01:37
lo hacemos de corrido y ya está 00:01:39
lo ponemos ahí y se acabó 00:01:40
luego esto admite 00:01:43
esto lo menciono 00:01:45
simplemente pues para que se nos vaya 00:01:48
quedando como ahí en el, yo que sé, como rondando 00:01:49
vale, porque luego de repente 00:01:52
van apareciendo las cosas 00:01:53
en segundos sí que nos encontraremos ya 00:01:55
al tener proyectos más complejos 00:01:58
pues con la opción de hacer las cosas de otra manera 00:02:00
entonces veis 00:02:02
que generar los get y los setters 00:02:04
desde el entorno 00:02:06
afortunadamente fácil 00:02:07
pero no deja de ser un chorizo de métodos 00:02:10
que están ahí puestos, ¿vale? 00:02:12
pues entonces hay cosas como 00:02:14
long box, records 00:02:16
cosas 00:02:18
que te permiten trabajar con ellos 00:02:19
como si estuvieran ahí aunque no estén 00:02:22
¿Vale? Entonces vosotros 00:02:24
A lo mejor le pedís cosas a CharGPT 00:02:26
Y os saca clases que no tienen 00:02:28
Getter y Setter, pero luego sí que se están llamando 00:02:30
Desde fuera, ¿esto qué pasa? 00:02:32
Bueno, pues que sepáis que existen Lombok, existen 00:02:34
Record, existen cosas que 00:02:36
Hacen que esos Getter y Setter estén 00:02:37
Aunque no los veamos 00:02:40
Bueno, solamente por 00:02:41
Mencionarlo 00:02:44
Vale, pero no estamos en ello 00:02:45
Nosotros, ni es algo 00:02:48
Tampoco especialmente común 00:02:52
lo generamos 00:02:53
y se acabó, este es mi alumno 00:02:56
vale, pues este alumno 00:02:58
en lugar de 00:03:00
esta aplicación 00:03:02
en lugar de 00:03:04
ofrecer, crear los alumnos con 00:03:06
constructor 00:03:08
ofrece un método, crear alumno 00:03:08
no ofrece un constructor para ello 00:03:12
vale, entonces 00:03:14
eso, que parece una tontería 00:03:16
pero tiene mucho sentido 00:03:18
normalmente los frameworks que hacen cosas 00:03:19
ya está como bastante 00:03:22
abandonado instanciar 00:03:24
los objetos con el constructor directamente 00:03:26
¿vale? es relativamente 00:03:28
habitual, tú te haces tu clase 00:03:30
y la forma en la 00:03:32
que ofreces a los demás instanciar 00:03:34
tus objetos no es directamente con 00:03:36
new, con el constructor, sino 00:03:38
ofreces tu método 00:03:40
en este caso, crear alumno 00:03:41
para crearlos, y en ese método pues 00:03:44
a lo mejor lo aprovechas para hacer validaciones 00:03:46
para hacer cosas, pues bueno 00:03:48
Ya que ha surgido con este ejercicio 00:03:50
Vamos a hacerlo así 00:03:51
¿Vale? Vamos a hacer que el usuario que quiera 00:03:52
Crear un alumno lo tenga que hacer obligatoriamente 00:03:56
Con este método 00:03:58
Dígame 00:03:59
Sí 00:04:02
Sí, sí, es un método más 00:04:05
No lo sé, pero lo vamos a quitar 00:04:08
¿Vale? 00:04:22
Ahora miramos el enunciado 00:04:24
Pero a ver si 00:04:26
Incluir el constructor correspondiente 00:04:27
Crear alumno 00:04:30
Venga, pues entonces 00:04:39
¿Qué haría este? 00:04:41
Pues efectivamente 00:04:43
Si el año pasado 00:04:44
Fuera negativo, devuelve objeto nulo 00:04:51
¿Vale? 00:04:53
Si nacimiento 00:04:57
Menor que cero 00:04:59
Return nul 00:05:03
Y en cualquier otro caso 00:05:06
Incluso cero 00:05:08
Pues devuelve al alumno 00:05:10
Pues entonces aquí lo podemos hacer 00:05:12
Aquí, ¿verdad? 00:05:15
New alumno 00:05:16
Y ahora, new alumno 00:05:17
Si yo quiero hacerlo así, tengo que 00:05:22
Efectivamente 00:05:24
Incluir aquí un constructor 00:05:25
Para poder llamarlo, o sea, si yo quiero 00:05:27
Pasarle estos parámetros 00:05:30
Yo por comodidad quiero hacer este crear alumno 00:05:31
Así, ¿verdad? 00:05:34
Nacimiento 00:05:39
vale, entonces si yo quiero aquí 00:05:39
devolver el objeto ya con estos parámetros 00:05:42
pues entonces me voy a hacer aquí mi constructor 00:05:47
vale, bueno, lo voy a generar directamente y ya está 00:05:51
vale, entonces ahora pregunto yo por preguntar 00:05:57
a ver, podría no haberme hecho este constructor 00:06:11
y entonces aquí tendría, me hago con el new alumno por defecto 00:06:15
le pongo las propiedades con el set 00:06:19
y luego ya lo devuelvo 00:06:22
pero 00:06:24
esto si a primera vista es una tontería 00:06:25
me he hecho crear alumno 00:06:27
para, con la idea de que 00:06:30
la gente que me use a mí y crea alumnos 00:06:32
lo haga con este método 00:06:34
pero para hacer este método 00:06:35
me he creado el constructor para poder 00:06:37
llamarlo desde aquí, pasándole los dos parámetros 00:06:40
y que fuera más cómodo, con lo cual 00:06:42
ya estoy aquí ofreciendo el constructor 00:06:44
¿vale? ¿qué puedo hacer? 00:06:45
¿Para ofrecer solo este método? 00:06:49
No, no voy a eso. 00:06:55
¿Qué puedo hacer para ofrecer solo este método 00:06:57
y no el constructor? 00:06:59
Hacerlo privado. 00:07:05
A esto me refería. 00:07:09
No sé si esta vez pensaba algo más retorcido. 00:07:10
Los constructores privados no son nada del otro mundo. 00:07:12
Los constructores privados 00:07:16
solamente los puedo usar yo 00:07:17
desde métodos propios de mi propia clase. 00:07:19
Entonces, de esta manera, 00:07:22
nadie me va a poder instanciar nunca con new. 00:07:23
Nunca jamás nadie me va a poder instanciar nunca con new. 00:07:26
porque el único constructor que hay 00:07:28
es privado 00:07:29
entonces desde fuera de esa clase 00:07:31
nadie me va a poder instanciar con new 00:07:34
que es algo que yo puedo querer 00:07:35
y muchas veces lo querré 00:07:37
que alguien quiere crear alumnos 00:07:38
tendrá que hacerlo con este método 00:07:40
crear alumno 00:07:42
que este sí que es public 00:07:44
y yo aquí ya hago lo que quiera 00:07:46
pues valido los datos 00:07:49
lo podría hacer el constructor 00:07:50
pero una arquitectura 00:07:51
relativamente habitual es esa 00:07:55
los constructores son privados 00:07:57
están de apoyo para métodos 00:07:59
que ya con el nombre créame alumno 00:08:01
son los que ya ofrezco yo 00:08:03
para hacer las cosas 00:08:05
esto en el fondo tiene un nombre 00:08:07
que es el patrón 00:08:11
factoría en realidad 00:08:13
es decir, hay una cosa 00:08:14
que se llaman patrones de diseño 00:08:16
que son formas de diseñar aplicaciones 00:08:18
formas de diseñar 00:08:21
¿cuántas formas de diseñar una aplicación hay? 00:08:22
200.000 millones 00:08:25
vale, pero algunas 00:08:26
siguen ciertas pautas, están estandarizadas 00:08:28
entonces esas formas 00:08:31
relativamente estandarizadas 00:08:33
de diseñar aplicaciones 00:08:35
son los patrones de diseño 00:08:36
hay un montón de patrones de diseño 00:08:38
patrón DAO, patrón Singleton 00:08:42
patrón no sé qué 00:08:43
cada uno se ocupa 00:08:44
de consejos 00:08:46
sobre cómo diseñar 00:08:48
partes concretas 00:08:51
la parte de la pesadilla 00:08:52
bueno, todo esto lo digo un poco 00:08:53
por cultura general 00:08:56
por ahora, ¿vale? 00:08:59
Bueno, pues aquí he diseñado siguiendo 00:09:00
sin saberlo en realidad 00:09:02
siguiendo un patrón de diseño muy común 00:09:04
¿vale? 00:09:06
que es un patrón que se ocupa de cómo 00:09:08
crear objetos, pues un patrón 00:09:10
de diseño te dice, oye 00:09:13
ofrece métodos propios 00:09:14
para crearlo, oculta 00:09:16
los constructores y usa los de apoyo 00:09:18
para dentro de esos métodos, claro 00:09:20
esto en realidad, esta tontería es un 00:09:22
patrón de diseño de los 00:09:24
Bueno, pues entonces 00:09:26
Son clases más antiguas 00:09:28
Bueno, y no siempre 00:09:36
Se siguen ciertos patrones de diseño 00:09:38
Según si conviene o no conviene 00:09:40
Bueno, a ver 00:09:42
El parámetro le llama al alumno en vez de nombre 00:09:54
Pero da igual 00:09:56
¿Qué más da? Mientras sea un estil 00:09:57
Y lo pases correctamente, a ver si te aclaras mejor 00:10:00
Llamándolo nombre, pero vamos que eso es lo de menos 00:10:02
No, es que arriba lo llamaste 00:10:04
No me lo estaba por eso 00:10:06
Claro, pero que da igual como lo llame yo, da lo mismo 00:10:07
Lo puedo llamar como quiera 00:10:10
Vale 00:10:12
Vale, pues entonces ya tenemos nuestro 00:10:15
Entidad alumno que no le queda 00:10:18
Más remedio que crearse así 00:10:20
Vale 00:10:21
Y ahora la clase principal 00:10:24
Pues crea alumnos 00:10:25
Venga 00:10:27
Pues vamos a hacer la clase main 00:10:30
En un paquete main 00:10:35
Aquí tenemos nuestra 00:10:36
Aplicación 00:10:45
De alumnos, vale 00:10:46
¿Qué va a hacer esta aplicación? 00:10:51
Rellenar 00:10:57
Un array, bueno 00:10:58
Más que un array 00:10:59
Vamos a hacer un mapa 00:11:00
Vamos a hacer un map, ¿no? 00:11:02
En lugar de meterlo en un array 00:11:04
Lo vamos a meter en un map y así tiene un poquito más de interés 00:11:05
Entonces 00:11:09
¿Cuántos alumnos? Pues unos cuantos 00:11:11
Vamos a pedirlo primero 00:11:14
Uy, no he puesto 00:11:17
Todo 00:11:19
¿Cómo? 00:11:20
Bueno, ¿cuántos va a haber en el mapa? 00:11:29
El mapa es una caja de alumnos 00:11:31
Tendría que decir cuántos quiero 00:11:32
Igual que si con una lista, una RAI 00:11:34
No entiendo la pregunta 00:11:36
O sea, map es la forma de guardarlos 00:11:38
¿Pero cuántos guarde? 00:11:40
Pues puedo guardar 20, 30 00:11:43
No sé 00:11:44
Claro, pero no tiene un límite, ¿no? 00:11:45
O sea, puede para lo que quiera. 00:11:47
Claro. 00:11:49
Ah, bueno, lo dices por el espacio a reservar. 00:11:50
Ah, no, por el for, por luego en el for, vale. 00:11:52
Para no hacerlo por condición de finalización, 00:11:59
cuando meta fin, que es más pesado. 00:12:01
Sí. 00:12:02
¿Cómo haces a crear alumnos 00:12:03
si no tienes un objeto para crear? 00:12:04
¿Cómo que no tienes un objeto para crear, no? 00:12:07
O sea, porque ahora has hecho stand-in, 00:12:08
necesitas un objeto para crear a ese método, ¿no? 00:12:10
Sí, tienes razón. 00:12:13
A ver, no sería un problema 00:12:14
Puedo yo crear un 00:12:16
Efectivamente, tienes toda la razón 00:12:17
Muy bien, muy bien visto, claro 00:12:20
Si no lo hago estático 00:12:22
Lógicamente es una tontería esto 00:12:23
Si no lo hago estático, solamente puedo llamarlo 00:12:25
Con un objeto alumno 00:12:28
Y es que no voy a poder crearlo 00:12:29
Porque no tengo ningún constructor visible 00:12:31
Entonces efectivamente es que este método 00:12:33
Su objetivo es ser estático 00:12:36
Claro, tienes razón, sí, sí, sí 00:12:37
Se me ha escapado el estático 00:12:40
hoy no estás dormido 00:12:41
mira que raro 00:12:44
pero vamos 00:12:48
venga, nuestros alumnos van a estar aquí 00:12:50
metidos 00:13:14
en este map 00:13:15
venga, vamos a 00:13:18
meterlo en new hash map 00:13:28
A ver, repito 00:13:31
Vamos a cambiar, en lugar de meterlos en un array 00:13:38
Vamos a meterlos en un map 00:13:41
Entonces para meterlos en un map 00:13:43
Cada alumno 00:13:44
Se corresponde con un par 00:13:46
La clave, lo que lo identifica de forma única 00:13:49
Y el valor 00:13:52
El valor está claro cuál va a ser 00:13:52
El propio objeto alumno 00:13:53
La clave cuál va a ser 00:13:55
Lo que lo identifique de forma única 00:13:57
El alumno sólo se caracteriza 00:13:59
según mi aplicación, que es una aplicación muy cutre 00:14:01
solo para ver excepciones 00:14:03
el alumno de él solamente tengo como datos 00:14:04
nombre y nacimiento 00:14:07
uno de los dos tendrá que funcionar de clave primaria 00:14:08
no tiene sentido que sea el nacimiento 00:14:12
lógicamente, pues el nombre 00:14:14
pues entonces la clave primaria de mi map 00:14:15
va a ser un stream 00:14:18
el nombre del alumno 00:14:19
y el valor es el alumno enterito 00:14:22
estos son 00:14:24
es imposible de coger ese stream 00:14:28
el nombre 00:14:31
Sí, pero tengo que tener ese dato 00:14:32
y como mi aplicación 00:14:36
dice el enunciado 00:14:38
alumnos con nombre y entonces 00:14:39
claro, se supone que este enunciado 00:14:42
me lo ha dado alguien que me ha dicho que haga eso 00:14:44
y él me ha dicho que tengo el nombre y el año de nacimiento 00:14:46
entonces yo son los datos que tengo 00:14:48
otra cosa es que yo vaya a hablar con él 00:14:50
y le diga, ¿es posible que esta aplicación 00:14:52
trabaje también con los NIF? 00:14:54
Ah, sí, sí, el alumno te va a meter el NIF, vale, pues yo ya cambio 00:14:55
mi diseño, luego la clave NIF 00:14:58
pero en este caso, pues lo tenemos 00:15:00
pues vamos a respetarlo 00:15:04
Venga, ¿cuántos alumnos tiene usted, señor? 00:15:05
Vale, ya que estamos 00:15:27
Vamos a validar la entrada 00:15:28
Vamos a validarla ya que estamos 00:15:30
Para 00:15:32
Que se nos quede en la cabeza lo del bloque try-catch 00:15:35
Nosotros ya sabemos que si él dijera 00:15:39
¿Cuántos alumnos tiene usted? 00:15:42
Tengo HJ, pues la aplicación se para ahí 00:15:43
Entonces vamos a validarlo 00:15:46
Para que meta un número seguro 00:15:48
Entonces vamos a 00:15:50
Intentar leer 00:16:07
Y vamos a capturar 00:16:09
La excepción 00:16:12
Input 00:16:13
Mismatch 00:16:16
Exception 00:16:18
Vale 00:16:20
Si entramos en la excepción 00:16:22
Vamos a avisar 00:16:24
De alguna manera 00:16:26
Con un boolean por ejemplo 00:16:27
Boolean 00:16:34
Valid 00:16:37
Igual a false 00:16:38
Y aquí válido igual a true 00:16:40
Eh, perdón 00:16:47
Válido while 00:16:51
Lo hago yo aquí 00:16:52
Para decidir cuando se sale del bucle 00:16:55
Válido igual a true 00:17:01
Mientras no válido 00:17:04
Entonces si salta excepción 00:17:08
Entonces le decimos que introduzca otro número 00:17:19
introduzca entero 00:17:28
sí, eso estaba revisando 00:17:35
porque si no nos va a pasar lo de siempre 00:17:44
si va aquí 00:17:45
y volvemos a pedir el next in 00:17:48
pues pasa otra vez lo de siempre 00:17:50
entonces eso 00:17:52
que ya vimos ayer el problema 00:17:53
lo habíamos arreglado así 00:17:56
¿verdad? 00:18:00
vale, a ver 00:18:11
este bucle me está validando 00:18:12
que lo que introduzca el tío 00:18:19
sea un número entero, ¿verdad? 00:18:21
Si lo hemos hecho bien, luego si no lo has probado, 00:18:23
lo comprobaremos. En principio, de ese bucle 00:18:25
no sale hasta que no llegue 00:18:27
aquí. Y solamente 00:18:29
va a llegar aquí si esta sentencia 00:18:31
se termina correctamente. 00:18:33
Luego, en principio, este bucle 00:18:36
solamente termina, este do while, 00:18:37
si se mete un número entero. 00:18:40
¿Vale? Si no se mete 00:18:42
un número entero, esto no se ejecuta. 00:18:43
Luego de aquí 00:18:46
entramos aquí, nos pide 00:18:46
otra vez para arriba 00:18:49
vale 00:18:50
pero vamos, si quisiéramos validar 00:18:51
no solo entero, sino entero positivo 00:18:54
¿cuántos alumnos quiere usted? 00:18:56
y me dice menos 12, el menos 2 tampoco me gusta 00:18:59
quiero que sea 00:19:01
mayor que 1 00:19:02
esto estoy improvisando sobre la marcha 00:19:03
¿cómo podríamos incorporar aquí 00:19:06
que la validación fuera entero 00:19:08
y además positivo? hay que incluir algo más 00:19:10
porque la excepción solo valida que sea 00:19:13
entero 00:19:15
a ver, el tema es que 00:19:16
si me mete un negativo 00:19:25
bueno, o que este 00:19:27
válido solo se ponga true 00:19:39
ya está un if y se acabó 00:19:40
bueno, no hace falta un bucle 00:19:42
sino simplemente 00:19:46
que solamente lo ponga 00:19:47
true si es positivo 00:19:51
porque si no, va a volver arriba 00:19:52
otra vez, no hace falta meter otro bucle ahí 00:19:55
pero de un if 00:19:56
sin más 00:20:02
eso, eso, sí, sí, vale 00:20:03
te he entendido hacer aquí otro bucle dentro 00:20:05
vale, vale 00:20:08
exacto 00:20:09
también, ¿no? 00:20:11
mientras no válido 00:20:20
ya, pero no, pero no, pero es que 00:20:21
si no cambias eso, el válido ya se ha puesto 00:20:23
Bueno, no, claro 00:20:25
Si ponemos no válido 00:20:27
Mientras IN 00:20:29
Diferente de IN menor 00:20:31
Entonces, aunque válido 00:20:33
Lo hayas puesto ya true 00:20:36
Va a volver arriba otra vez, ¿verdad? 00:20:37
También 00:20:43
Podríamos hacer otra y capturar las dos 00:20:44
Esta y número negativo 00:20:48
Número de alumnos negativo 00:20:50
También, sería otra posibilidad 00:20:52
hacer una excepción, número de alumnos negativo 00:20:53
entonces 00:20:56
si hiciéramos 00:20:57
a ver, cualquiera de las 00:21:00
vamos a recopilar las dos primeras 00:21:01
y luego la de la excepción 00:21:03
entonces una, la primera que habéis dicho 00:21:05
sería 00:21:08
que solo ponga el válido a true 00:21:10
n es mayor que 0 00:21:14
¿verdad? 00:21:16
También, efectivamente 00:21:25
Else, pones aquí 00:21:26
Otra vez, introduzca entero 00:21:28
Entonces 00:21:31
Y dentro del 00:21:36
Y luego además 00:21:38
Y luego además habría que hacer el scan next line 00:21:39
También aquí en el else, ¿verdad? 00:21:43
Es decir, como va a volver arriba otra vez 00:21:51
Aquí habría que hacer 00:21:53
También el scan next line 00:21:55
¿Verdad? 00:21:57
Vale, esta creemos que 00:22:01
Funcionaría 00:22:02
creemos que sí 00:22:03
que validaría si el número es 00:22:07
entero positivo 00:22:09
perdón, no te oigo 00:22:11
bueno, por lo mismo que lo hemos metido 00:22:16
aquí, porque al volver a hacer 00:22:19
el next y se nos quedaba encajado 00:22:21
y aquí va a pasar lo mismo 00:22:22
yo entiendo que 00:22:25
si no lo haces 00:22:27
es que yo tampoco me lo esperaba 00:22:27
leer varios números seguidos 00:22:34
la situación conflictiva es cuando 00:22:36
lees una cadena 00:22:39
después del número 00:22:41
esa es la que hemos identificado 00:22:42
y aquí estás leyendo dos nextkin 00:22:45
entonces yo no sé por qué antes se nos 00:22:46
ha quedado, vamos a probar esto 00:22:49
a ver, el tema es que 00:22:51
cuando sale 00:23:01
claro, pero aquí la diferencia es que puede que 00:23:04
aquí no haga falta, la diferencia 00:23:07
es que cuando llegamos 00:23:09
aquí, este no se ha llegado 00:23:12
a completar y no sabemos 00:23:14
en qué estado ha dejado el buffer 00:23:15
y cuando llegamos aquí 00:23:17
por este lado, este sí se ha llegado 00:23:20
a completar, con lo cual sí que tenemos la seguridad 00:23:22
de que el buffer lo habrá dejado limpio 00:23:24
entonces yo creo que no va a hacer 00:23:25
falta este, pero este 00:23:27
sí hace falta porque llegamos 00:23:30
a este punto no habiendo completado 00:23:31
el next in, sino habiendo salido 00:23:33
por la mitad y no sabemos 00:23:36
en qué estado se ha quedado el buffer en ese momento 00:23:37
¿vale? entonces vamos a 00:23:39
probarlo así sin el 00:23:42
next line, que yo creo que vamos a ver 00:23:43
si así validaría esto 00:23:45
sí que funciona, ¿verdad? 00:23:47
¿no hace falta ni probarlo? ¿ya está? 00:23:49
uy, qué rapidez, ¿este mismo idéntico clavado? 00:23:51
vale, pues entonces nuestra intuición 00:23:54
es correcta, aquí realmente no hace falta 00:23:55
hacer varias lecturas de números seguidos 00:23:57
no deja nada en el buffer 00:23:59
pero claro, cuando tú vas 00:24:01
por el catch, no has 00:24:03
completado la lectura del número 00:24:05
te has ido a medias 00:24:06
entonces hemos comprobado 00:24:08
empíricamente que hace falta 00:24:11
¿por qué? es que no tenemos los detalles 00:24:12
de en qué momento ha saltado la excepción realmente 00:24:15
claro 00:24:17
pues es que habría que ver 00:24:20
habría que buscar aquí en el throw 00:24:22
efectivamente cuando hace el throw 00:24:24
en qué estado se ha quedado aquí el buffer 00:24:26
pero bueno, es más fácil funcionar 00:24:27
por prueba y error y ya está 00:24:31
Vale, bueno pues entonces 00:24:33
Este ya efectivamente no hace falta 00:24:35
Como podemos intuir 00:24:38
Esta validación funciona 00:24:39
¿Qué otro método de validación 00:24:41
Habíais planteado? 00:24:44
El de cambiar la condición 00:24:46
Es que sí, que sí 00:24:48
Que estamos, a ver 00:24:58
Espera un momento 00:24:59
Ya, pero es que 00:25:02
Me estreso 00:25:05
paz, por favor 00:25:07
vamos por partes 00:25:12
vale, entonces 00:25:13
siguiente opción 00:25:15
que habíais planteado 00:25:17
vamos ahora a ella 00:25:20
esta era la opción original, verdad 00:25:21
la de que solo valida 00:25:24
que sea un número entero 00:25:26
vale, pues tú sigue aquí en el bucle 00:25:27
mientras no válido 00:25:29
mientras no válido 00:25:32
y o 00:25:34
mientras no sea válido 00:25:34
o sea negativo 00:25:53
el número sea 00:25:56
menor que cero 00:25:58
vale, entonces 00:25:59
esto 00:26:01
lo primero que implica es que 00:26:02
n se quede inicializado a algo, a cualquier 00:26:06
número, vale 00:26:07
entonces 00:26:09
pues a cualquiera 00:26:11
a menos uno, no os da igual 00:26:13
vale, entonces ahora, esto funcionaría 00:26:15
pregunto, vamos a ver 00:26:17
la secretaria que lo prueba todo rápido 00:26:19
eso funcionaría, la secretaria por favor 00:26:21
vale 00:26:23
vamos a verlo 00:26:25
vamos a suponer 00:26:28
que si mete uno 00:26:30
no válido, está claro 00:26:31
que el válido no cambia, con lo cual 00:26:33
esta condición ya directamente 00:26:36
sería true 00:26:38
con lo cual sigue, eso está claro 00:26:40
vale 00:26:42
ahora, ha metido uno válido 00:26:43
con lo cual válido ha cambiado, entonces esta ya sería 00:26:46
falso, miraría la siguiente 00:26:48
como n es negativo 00:26:50
esta se convierte en true 00:26:52
con lo cual vuelve arriba 00:26:54
que es lo único que le haría salir, las dos 00:26:55
falsas, que es 00:26:58
que 00:26:59
el número haya sido entero, es decir 00:27:00
que válido es igual a true, que eso se ha completado 00:27:04
y que además 00:27:06
el número sea mayor o igual que 0 00:27:08
esto es lo único que le haría salir, las dos falsas 00:27:09
¿verdad? con lo cual esto 00:27:12
en principio funcionaría 00:27:13
¿verdad? 00:27:16
¿lo has probado? 00:27:18
vamos a probarlo porque hay veces que las 00:27:19
intuiciones de uno, uno ve los códigos 00:27:21
y dice uy que bien y luego de repente 00:27:23
lo prueba y dice uy no me he dado cuenta de esta 00:27:25
tontería 00:27:27
bueno a ver, salta si lo pongo 00:27:28
aquí, claro 00:27:35
Si n menor que 0 00:27:37
Entonces 00:27:39
Introduzca entero 00:27:40
Si lo pongo aquí, sí 00:27:45
No, ahorrar 00:27:46
No, no, es que el try catch no lo puedes ahorrar 00:27:52
Porque es que 00:27:54
A ver 00:27:55
O sea, el try catch no lo puedes quitar 00:28:00
Porque si el tío te mete jj 00:28:02
Va a parar el programa 00:28:04
El try catch no lo puedes quitar 00:28:05
El tema es añadir alguna validación extra 00:28:07
Entonces, a ver un momentito 00:28:11
Vamos a ver si funciona 00:28:13
Y si está ahí 00:28:14
Me pongo a un fin 00:28:16
Para que me entere yo de bien 00:28:19
De cuando ha salido 00:28:21
Vamos a probar 00:28:22
¿Cuántos alumnos queremos? 00:28:24
Le pongo esto 00:28:34
Introduzca entero 00:28:35
Vale, esta está clara 00:28:36
Le pongo menos cuatro 00:28:37
Introduzca entero 00:28:39
Vale, parece que sí, ¿no? 00:28:41
Y ahora ya le pongo 98 alumnos, fin 00:28:46
Vale 00:28:49
Bueno, pues eso también nos gusta 00:28:50
Y ahora 00:28:52
Vamos a hacer una excepción 00:28:55
¿Vale? 00:29:01
Se quedan las dos comentadas 00:29:03
Nuestro bucle original era este 00:29:05
Que vamos a darle la otra opción 00:29:08
Vale, pues volvemos al bucle original 00:29:12
que era este, que este es el que valida 00:29:41
solo que el número 00:29:43
no sea entero, ¿verdad? 00:29:45
si no es entero te vienes por aquí 00:29:47
y ya hemos visto que hay que poner el netline 00:29:49
porque como te vas a medias pues ha quedado roto 00:29:51
vale, bueno 00:29:53
ahora 00:29:54
vamos a validar también que el número no sea negativo 00:29:58
haciendo que lance 00:30:01
una excepción 00:30:03
pero 00:30:05
a ver 00:30:07
eso no sería tan sencillo porque 00:30:09
es que quedaría muy 00:30:11
tendríamos que meter esto 00:30:15
en un método aparte y que ese método 00:30:22
lance la excepción 00:30:24
si el número es negativo 00:30:27
entonces 00:30:29
vamos a ponerlo aquí 00:30:30
opción lanzando dos excepciones 00:30:32
vale 00:30:44
pues entonces 00:30:46
vamos a hacer un método auxiliar 00:30:48
que lea el número y ahora ese método 00:30:49
que lance las dos posibilidades 00:30:51
No eres número o eres número negativo 00:30:54
¿Vale? No nos queda más remedio 00:30:56
Tenemos que hacerlo así 00:30:58
Pues venga, vamos a hacernos aquí 00:30:59
Un método 00:31:01
Sí, sí, sí, claro 00:31:04
Porque es otro método aparte 00:31:14
Leer número 00:31:15
Vale, entonces este leer número 00:31:17
Me hace esto de aquí 00:31:21
Int n igual a 00:31:23
Esto 00:31:26
Y aquí me pongo yo un escáner local 00:31:27
Para no 00:31:38
guiar las cosas 00:31:40
vale, y ahora ya sí 00:31:42
si n 00:31:53
es menor que 0 00:31:55
entonces lanza 00:31:56
una excepción 00:31:59
vale 00:32:00
si n es menor que 0, lanza una excepción 00:32:02
que esa excepción 00:32:05
pues puede ser new 00:32:09
número 00:32:10
alumnos 00:32:13
negativo 00:32:14
excepción 00:32:19
y si no, return n. 00:32:22
Vale, pues este método 00:32:34
nuestro puede lanzar 00:32:35
dos excepciones. 00:32:37
La de input mismatch, 00:32:39
si el número es cadena. 00:32:42
O la de número 00:32:44
alumnos negativo excepción. Puede lanzar 00:32:45
dos. Entonces, cuando lo llamemos 00:32:47
arriba, haremos los dos catch. 00:32:49
¿Vale? 00:32:52
Pero claro, tenemos que completarlo. 00:32:53
Esta clase hay que 00:32:56
crearla. 00:32:57
entonces para no emborronar 00:32:57
y seguir aprendiendo cosas 00:33:00
nosotros hasta ahora todas las clases 00:33:02
las hemos declarado 00:33:04
cada una un código aparte 00:33:05
un fichero aparte 00:33:08
cada clase va por separado 00:33:09
y está fuera de las otras 00:33:12
no hace falta en realidad que estén en ficheros aparte 00:33:13
eso es lo de menos 00:33:16
yo en un fichero puedo tener clase, una clase entera 00:33:17
debajo de ella clase, otra clase entera 00:33:19
eso siempre lo podemos hacer 00:33:21
pero luego cuando se precompilan 00:33:23
ya son punto clase distinto 00:33:25
pero 00:33:27
por comodidad 00:33:29
se puede hacer una cosa que es 00:33:31
declarar una clase dentro de la otra 00:33:34
¿vale? 00:33:36
por ejemplo, en esta situación 00:33:38
me gusta y me interesa 00:33:40
esa idea, es decir 00:33:42
esta excepción yo me la he inventado 00:33:44
aquí solamente para poder 00:33:46
hacer la validación de forma bonita 00:33:48
con dos try-catch, con dos catch 00:33:50
¿vale? me la he inventado 00:33:52
para poder hacer una validación 00:33:53
Más bonita que estas de arriba 00:33:55
Que me he ofrecido aquí 00:33:57
Para hacer un try con dos cats 00:33:59
¿Vale? Para esto me he inventado esa excepción 00:34:01
Para poder hacer un try con dos cats 00:34:04
En este fichero 00:34:05
Pero esta excepción no va más allá de eso 00:34:06
No la van a usar otras clases por ahí 00:34:09
Ni la va a usar nadie 00:34:11
Entonces, meter otra clase más 00:34:12
En mi aplicación 00:34:15
Pequeñita 00:34:16
Que solamente va a ser usada desde aquí 00:34:18
Y solo desde aquí 00:34:21
Pues hombre, quizás emboronar un poco la aplicación 00:34:22
entonces yo siempre puedo hacer una cosa 00:34:25
que es declarar una clase dentro de la otra 00:34:27
eso es una clase interna 00:34:30
clase anónima es su siguiente paso 00:34:32
es una clase interna 00:34:35
que ni siquiera tiene nombre 00:34:37
es todavía más 00:34:39
más 00:34:39
como se dice cuando vas 00:34:42
se me van las palabras 00:34:44
no, no, no 00:34:47
no tiene que ver con programación 00:34:49
como es la palabra cuando vas quitándole a alguien 00:34:51
destitulado, no es destituida 00:34:53
más todavía destituida que la otra 00:34:56
no me gusta esa palabra 00:34:57
vale, de la clase anónima 00:34:59
por ahora, olvídate, si es 00:35:02
una clase anónima, es una interna 00:35:03
pero además sin nombre, está todavía, es que me sale 00:35:05
descatalogada, no, bueno, da igual 00:35:07
vale, pues a ver 00:35:10
uno puede declarar una clase dentro de la otra 00:35:11
si quiere, entonces 00:35:14
esta es mi clase 00:35:15
bueno, vamos a parar y lo hacemos 00:35:17
luego, vale 00:35:19
que esto no es corto 00:35:20
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:
17 de marzo de 2026 - 12:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 26″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
142.14 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid