Saltar navegación

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

1 visualizaciones

Más información Transcripción

Descargar la transcripción

No, por Dios, faltaría más. Vale, pues esto de las excepciones había venido a cuento de esto de aquí. 00:00:00
Esta sentencia, como muchísimas otras, pues puede ocurrir que cuando se ponga a ejecutar su tarea, se pone a ejecutarla, 00:00:13
pin, pin, pin, de repente 00:00:23
haga una validación, vea que 00:00:25
algo no 00:00:27
funciona como debe, con lo cual 00:00:29
no tiene sentido que siga 00:00:31
entonces eso mediante código 00:00:33
con sus if, con sus no sé qué, se ve que 00:00:35
ahí no tiene sentido seguir 00:00:37
y entonces en lugar de seguir ese método 00:00:39
hasta el final, lo que 00:00:42
hace es, crea un objeto excepción 00:00:43
y pum, lo lanza 00:00:45
al punto del 00:00:47
código en el que se llamó 00:00:49
en el que fue llamado este método 00:00:51
Ahí lanza ese objeto excepción 00:00:53
¿Ese objeto de qué clase pertenece? 00:00:54
Pues a una clase excepción 00:00:57
Que hay tropecientas mil 00:00:59
Input, mismatch, excepción es una 00:01:01
Render, no excepción, no excepción, la que sea 00:01:02
Construye un objeto 00:01:05
Que guarda esa información y pum 00:01:06
Devuelve 00:01:09
El control 00:01:11
A esta línea de código 00:01:12
Y además de devolver el control a esta línea de código 00:01:14
Entrega un objeto 00:01:17
Excepción con la información dentro 00:01:19
Sobre qué ha pasado, etc. 00:01:21
entonces cuando el control vuelve a esta línea de código 00:01:22
hay dos posibilidades 00:01:26
que este try-catch no exista 00:01:28
que era lo que hemos hecho nosotros hasta ahora 00:01:30
entonces si este try-catch no existe 00:01:31
que es lo que hemos hecho nosotros hasta ahora 00:01:33
la máquina virtual cuando se encuentra 00:01:35
ese objeto de excepción dice vale 00:01:38
te voy a mostrar lo que hay dentro 00:01:39
por consola 00:01:42
para que tú tengas un detalle de lo que ha pasado 00:01:43
y luego voy a parar la ejecución 00:01:46
para siempre, ya jamás parado el programa 00:01:48
y esto ya nunca sigue 00:01:50
bueno, vale, ya sabemos obviamente 00:01:51
que pega tiene eso, en tiempo de desarrollo 00:01:54
de código, cuando estamos haciendo, pues que el programa 00:01:56
pete y pare, muy bien 00:01:58
ha pasado esto, es que he hecho 00:02:00
esto mal, pues 00:02:02
lo arreglo, lo cambio, lo que sea 00:02:03
pero, cuando ya 00:02:05
hemos entregado la aplicación, no puede ser 00:02:08
que el programa se pare 00:02:10
no puede ser que el programa se pare cuando 00:02:11
en este caso 00:02:13
el usuario mete en lugar de un número 00:02:16
mete una cadena, no puede ser 00:02:18
que el programa se pare 00:02:20
entonces, ¿cuál es el plan B? 00:02:21
el plan B es 00:02:25
la sentencia que puede 00:02:26
provocar 00:02:28
esa situación, se mete en este 00:02:29
bloque, tricats, ya está, eso es lo que vimos 00:02:32
ayer, se mete en este bloque tricats 00:02:34
y entonces ahora ya, esta sentencia 00:02:35
trata de ejecutarse 00:02:38
si se ejecuta de principio a fin 00:02:39
fenomenal, se va a la siguiente 00:02:41
si se ejecuta de principio 00:02:44
a fin, fenomenal, ya está 00:02:46
hemos sacado este bloque y ya seguimos 00:02:48
por abajo los catch como si no 00:02:50
existieran, seguiríamos por aquí 00:02:52
los catch como si no existieran 00:02:54
vale, pero 00:02:55
¿qué es lo otro que puede ocurrir? 00:02:57
que esta sentencia 00:03:00
no se ejecute de principio a fin 00:03:02
porque en la mitad por código 00:03:04
por código se detecta que algo 00:03:06
no va bien, el programa 00:03:08
decide pararlo 00:03:10
lanzar ese objeto, vale 00:03:12
pues entonces si tenemos un try catch 00:03:16
Ese objeto que ha llegado a este punto 00:03:18
Ese objeto que ha llegado a este punto 00:03:22
Empieza a compararse con los cats 00:03:23
Que hay abajo, en nuestro caso hay dos 00:03:26
Dice, a ver, me acaba de llegar aquí una excepción 00:03:28
Esa excepción de qué clase es 00:03:30
Es de la clase 00:03:32
Pepito exception, vale 00:03:34
Voy a ver si hay algún cat 00:03:35
Que capture pepito exception 00:03:37
Pepito exception, no, paso del cat 00:03:39
Pepito exception, no, paso del cat 00:03:41
Con lo cual 00:03:44
No hay ningún cat que capture 00:03:45
la pepito exception que lanzó este 00:03:47
luego este try-catch no vale para nada 00:03:49
se para la aplicación 00:03:52
igualmente, se para igualmente 00:03:54
vale, pero 00:03:56
si el 00:03:58
objeto excepción que nos ha mandado este 00:04:00
no es pepito exception, sino 00:04:02
input mismatch exception 00:04:04
pues él va a catch por, anda mira 00:04:05
coincide, el objeto 00:04:07
que me ha llegado en este punto 00:04:10
coincide con este, pues entonces 00:04:11
me meto aquí en este bloque y hago 00:04:14
lo que haya en ese bloque 00:04:16
hago lo que hay en ese bloque 00:04:17
que es lo que al programador le dé la gana 00:04:19
avisar, volver a pedir 00:04:21
el dato 00:04:23
en ese caso habría que meter el try-catch en un bucle 00:04:24
claro, para que estuviera todo el rato 00:04:27
intentándolo hasta que el dato fuera 00:04:29
correcto, lo que fuera 00:04:31
y una vez que ha acabado el catch 00:04:33
continuamos 00:04:35
con la línea siguiente 00:04:37
al bloque try-catch, como si nada 00:04:39
hubiera pasado, el programa no se para y todo 00:04:41
sigue ahí estupendamente 00:04:43
como si nada hubiera pasado, ahí seguimos 00:04:44
¿vale? y así es como deberían ser 00:04:47
los programas ya en producción 00:04:49
si algo falla 00:04:51
porque el usuario ha metido mal los datos 00:04:53
por lo que sea 00:04:55
el programa te da una alternativa 00:04:56
sobrevive como puede 00:04:58
en este caso ¿cómo ha sobrevivido? 00:05:00
pues poniendo n igual a 10 00:05:02
y sigue 00:05:04
no se para y ya está 00:05:07
¿vale? 00:05:08
si aquí, si la excepción ha salido aquí 00:05:10
por ejemplo en esta 00:05:13
sentencia 00:05:15
aunque haya 00:05:16
sentencias después 00:05:18
estas ya no se llegan a ejecutar 00:05:20
nunca, vale 00:05:22
me explico 00:05:24
next in ha intentado ejecutarse 00:05:26
y en un momento ha visto que algo no funciona 00:05:28
no le gusta y pum, crea el objeto 00:05:30
excepción y devuelve el control 00:05:32
vale, pues ahí ya 00:05:33
empiezan a comprobarse los catch 00:05:36
estas sentencias como si no existiera 00:05:38
nunca se ejecuta, todo lo que haya 00:05:40
por debajo, dentro del bloque 00:05:42
Todo lo que haya por debajo de la sentencia que provoca la excepción se queda sin ejecutar para siempre jamás. Se ejecutará el catch correspondiente y luego ya se sigue por abajo. Y esto que estaba por debajo se ha quedado sin ejecutar porque se interrumpió el flujo del programa, se interrumpió aquí por la excepción. 00:05:44
Se interrumpió aquí el flujo 00:06:09
Se va el catch y seguimos 00:06:11
¿Vale? 00:06:12
Entonces bueno, nosotros ya usamos 00:06:13
El bloque try catch 00:06:15
Como nos dé la gana 00:06:17
¿Vale? 00:06:19
Entonces para 00:06:23
Antes de seguir 00:06:24
Para que no os aburráis 00:06:27
Por ejemplo, pues ahora ya que conocemos el try catch 00:06:28
Vamos a 00:06:30
Usarlo para hacer la validación 00:06:33
Esto de aquí 00:06:36
porque yo aquí en realidad no he hecho una validación 00:06:37
cuando he planteado este ejemplo 00:06:40
he hecho un try-catch para que el programa no pare 00:06:41
pero si lo mete mal el usuario 00:06:45
me mete JJ en lugar de un número 00:06:48
lo fijo a N igual a 10 00:06:51
es decir, en realidad no estoy validando 00:06:53
porque no estoy volviéndolo a pedir hasta que me meta 00:06:56
un número en lugar de una cadena 00:06:59
¿vale? entonces, repito, esa validación 00:07:01
se podría hacer sin un try-catch 00:07:05
como dijimos ayer 00:07:07
tú me lees con ScanNextLine 00:07:08
ScanNextLine jamás va a lanzar excepción 00:07:10
nunca, entonces ahora ya 00:07:13
una vez que has cogido la cadena 00:07:15
vas a ver si 00:07:16
carácter por carácter son un dígito 00:07:19
de la tabla ASCII, te puedes hacer la validación 00:07:21
por código, ¿vale? pero yo 00:07:23
no quiero esa validación, quiero que 00:07:25
hagáis una validación usando 00:07:27
NextInt 00:07:29
usando el bloque TryCatch 00:07:30
y combinándolo con un bucle de alguna manera 00:07:32
para asegurarse de que eso se va 00:07:35
va a estar ahí todo el rato, mientras el usuario no meta un número. 00:07:37
Entonces, vamos a, por tanto, sacarlo a un método para que lo hagáis en un método. 00:07:43
Por ejemplo, esto lo podríamos refactorizar a un método. 00:07:50
Vamos a suponer que yo ahora lo que quiero es esto. 00:07:53
n igual, con lo cual esta inicialización ya no la quiero, 00:07:57
n igual leerNúmero, ¿vale? 00:08:02
leer número, me voy a hacer ahora el método leer número auxiliar 00:08:09
aquí abajo, vale, entonces lo que quiero es que este código 00:08:12
que iría en 00:08:20
leer número, me falta 00:08:24
aquí el escáner, esto, aquí ya 00:08:43
no nos pinta nada, era el ejemplo que habíamos puesto 00:08:57
varias excepciones, vale, leer número 00:09:02
return n 00:09:05
vale 00:09:07
y aquí quito n igual a 00:09:09
vale, entonces esta versión 00:09:11
de leer número es una versión 00:09:14
que en realidad no valida 00:09:16
intenta leer el número 00:09:17
que puede hacerlo, fenomenal 00:09:19
me devuelve n 00:09:21
que no ha podido hacerlo porque me ha dado excepción 00:09:22
me devuelve n igual a 10 00:09:26
luego no es una versión 00:09:28
en realidad que se meta en un bucle 00:09:30
y esté validando 00:09:31
Y no termine hasta que no me pueda devolver un número 00:09:32
Vale, pues 00:09:36
Hacedme ahora 00:09:37
Combinando el try-catch 00:09:40
La versión con validación 00:09:42
De esto 00:09:48
Joder, ¿qué estoy haciendo? 00:09:49
Vale 00:09:53
Vamos a llamarla valida 00:09:58
Para que sea más bonita 00:10:01
Pues venga 00:10:03
Completadme ese método 00:10:11
Con try-catch 00:10:14
y next in 00:10:16
vale, un bucle que está ahí todo el rato 00:10:25
y hasta que no se 00:10:29
introduzca un número entero, no sale 00:10:31
vale, pues aquí simplemente 00:10:33
tampoco 00:10:40
quedo, no vamos locos 00:10:41
a ver, aquí 00:10:44
hay que hacer un bucle, lógicamente 00:10:46
hay que hacer un bucle porque hay que estar todo el rato 00:10:50
leyendo 00:10:52
mientras no se cumpla la condición 00:10:53
de número válido, ¿no? 00:10:56
entonces a ver si lo hacemos así directamente 00:10:57
mientras 00:11:00
no válido 00:11:01
si vamos tecleando así 00:11:02
luego ya podemos depurar si queremos 00:11:05
¿vale? o sea esto es un bucle 00:11:07
un bucle que va a estar ahí 00:11:15
pum pum pum pum pum pum 00:11:17
mientras se dé esta condición 00:11:18
que es no válido 00:11:21
¿vale? entonces entramos inicialmente 00:11:22
¿y qué es lo que hacemos? pues que lo que hacemos 00:11:25
es leer el numerito 00:11:27
n igual a scan 00:11:28
punto next int 00:11:31
vale, aquí como podemos 00:11:33
validar que sea no válido 00:11:36
pues en el catch es la única opción 00:11:37
porque si no es válido 00:11:39
next in nos avisa lanzándonos una excepción 00:11:41
es como nos avisa next in de que no es 00:11:43
válido 00:11:45
entonces la forma 00:11:46
de que nosotros tenemos de saber 00:11:49
que no ha sido válido es 00:11:51
porque 00:11:53
estamos entrando en la excepción 00:11:55
entonces 00:11:57
no nos queda más remedio 00:11:59
que capturar esto lógicamente entonces tenemos que capturar esto intenta hacer 00:12:01
esto si no consigues hacerlo porque te sale input miss match exception si no te 00:12:10
sale pues avisa número no válido y no válido seguirá siendo true vale 00:12:21
entonces cuando lo cambiamos a false 00:12:37
para que el bucle salga 00:12:39
después de haberlo leído 00:12:40
si hemos conseguido terminarla 00:12:43
si lo hemos leído de principio a fin 00:12:45
y llegamos a este punto 00:12:47
si llegamos a este punto es porque no nos vamos al catch 00:12:48
no válido 00:12:51
igual a false 00:12:54
y ya está 00:12:54
y ahora cuando hayamos salido ya del while 00:12:56
tenemos la seguridad de que n 00:12:58
es un número válido 00:13:01
porque si no nunca habríamos salido de 00:13:03
vale pues ya está 00:13:04
Por ejemplo 00:13:06
Otra cosa es que luego lo hagáis con un do while 00:13:08
O lo hagáis con 00:13:10
La condición de otra manera 00:13:13
Pero vamos, que la idea es eso 00:13:14
Un bucle que está intentando todo el rato 00:13:16
Intentando todo el rato 00:13:19
Espera que lo llame 00:13:20
Desde aquí 00:13:25
Válido 00:13:27
¿Dónde está? 00:13:29
Voy a llamar a ese método 00:13:30
Se llamaba 00:13:33
Ah, valida número 00:13:38
Vamos a ver dónde está 00:13:39
¿Dónde tengo la llamada valida número? 00:13:42
Ah, está aquí 00:13:54
En candidaturas, estará, ¿no? 00:14:03
Vale, está aquí, sí 00:14:04
Valida 00:14:05
Vale, pues lo llamo aquí en candidaturas 00:14:07
Para leerme un número válido 00:14:13
Valida número 00:14:14
Vamos a... 00:14:15
Y aquí tengo un error en algún sitio 00:14:16
Abajo del todo está, ¿no? 00:14:19
Ah, que tengo dos retunen 00:14:25
Vale 00:14:26
vale, vamos a ver si esto funciona 00:14:28
correctamente 00:14:31
¿cuántos se presentan? entonces si yo aquí 00:14:31
metiera esto 00:14:41
vale, que maravilla 00:14:43
vale, pues vamos a 00:14:47
arreglarlo 00:14:49
no, no, no 00:14:57
el número lo hemos 00:15:12
leído correctamente 00:15:14
Ah, vale, vale, el número lo hemos leído 00:15:15
No, no, no, el número lo hemos leído 00:15:18
Y ahora 00:15:20
No válido se pone a falso 00:15:21
Y ahora como no es válido 00:15:24
Lo ha leído correctamente 00:15:26
Sí, pero no entiendo por qué 00:15:33
No, con el 00:15:39
Yo lo que he intentado ha sido ponerte en el 00:15:41
Que volviese a asignar el n a 0 00:15:44
O a 0 00:15:47
Porque si no se te quedaba con el número que le estaba dando 00:15:47
y buscar trabajo 00:15:50
pero como a ver 00:15:52
si lo que se trata de entender 00:15:54
porque hace eso, no lo entiendo 00:15:57
vamos a ver 00:15:59
no entiendo porque lo hace 00:16:00
vale, pues nada, ya he puesto esto 00:16:02
entonces, esta cláusula se puede añadir 00:16:07
opcionalmente, en el contexto 00:16:09
de lo que estamos haciendo nosotros ahora no pinta mucho 00:16:11
pinta sobre todo cuando has abierto recursos 00:16:13
de ficheros, de sockets 00:16:15
de lo que sea, y tienes que asegurarte 00:16:17
de que tanto si vas por el try 00:16:19
como si ibas por el catch 00:16:21
los recursos quedan cerrados 00:16:22
entonces el finally 00:16:23
¿qué es? 00:16:24
abre un bloque 00:16:27
y lo que hay en este bloque 00:16:28
se ejecuta 00:16:29
tanto si finalizas el try 00:16:31
como si finalizas el catch 00:16:33
¿vale? 00:16:34
si el try es exitoso 00:16:36
y completas todo 00:16:37
se va a finally 00:16:39
hace lo que ponga en finally 00:16:40
y sigue 00:16:41
si el try no es exitoso 00:16:42
porque aparece una excepción 00:16:44
va a catch 00:16:45
completa el catch 00:16:46
y luego a finally 00:16:47
ya está 00:16:48
el finally es un bloque 00:16:49
que se ejecuta 00:16:50
tanto si vas por la rama try como si vas por esta 00:16:51
entonces si hay algo 00:16:54
que queremos hacer en ambos casos 00:16:56
que normalmente es cerrar recursos 00:16:57
que hayamos abierto 00:17:00
para intentar hacer algo 00:17:01
pero como no estamos dando recursos de ningún tipo 00:17:03
ni bases de datos, ni fichero, ni nada 00:17:05
pues la finally en este contexto nuestro 00:17:07
pinta poco 00:17:09
porque si hay algo que queremos hacer 00:17:10
tanto por esta rama 00:17:13
como por esta, pues lo vamos a poner después 00:17:15
y ya está 00:17:17
vale, no necesitamos que sea una cosa 00:17:18
ahí acotada 00:17:21
pero bueno, ahí está el final 00:17:21
bueno, es otro bloque que puedes tú 00:17:24
hacer aquí, asociado al try-catch 00:17:31
y es simplemente un código 00:17:32
que se va a ejecutar 00:17:34
sí o sí, si haya hecho el try 00:17:36
o se haya hecho el catch 00:17:39
se va a hacer sí o sí, entonces 00:17:40
pega en un contexto muy concreto 00:17:42
en el contexto de que lo que tú haces en el try 00:17:45
es acceder a un 00:17:47
fichero, acceder a una base de datos 00:17:49
entonces para hacer eso tienes que abrir un 00:17:50
recurso antes, entonces ese recurso 00:17:53
tú lo quieres dejar, lo tienes 00:17:55
que cerrar luego, lo quieres dejar cerrado 00:17:57
entonces ese cierre de 00:17:59
recursos, se lo voy a poner ahí, lo voy a poner 00:18:00
porque quede 00:18:03
normalmente 00:18:03
para cerrar recursos 00:18:05
de cosas que se hayan abierto 00:18:11
aquí, en el 00:18:15
try-catch, te aseguras de que lo dejas 00:18:17
Ahí cerradito 00:18:19
¿Vale? Pero vamos 00:18:20
Que con el try con recursos 00:18:22
Que es otra variante del try 00:18:25
Que eso tiene más interés verlo con bases de datos 00:18:26
Ni siquiera hace falta 00:18:29
Al final, ni siquiera haría falta 00:18:31
Pero bueno, que sepáis para lo que vale 00:18:33
Por si la veis por ahí 00:18:35
¿Vale? Ya está 00:18:36
Bueno, pues entonces, la otra cosa 00:18:38
Que tenéis que saber de excepciones 00:18:42
La otra cosa 00:18:44
¿Vale? Pues que ha sido una excepción 00:18:45
Una excepción ha sido 00:18:48
una forma de avisarnos de algo 00:18:50
eso ha sido una excepción 00:18:52
el next in 00:18:53
este de aquí 00:18:55
nos ha avisado 00:18:57
¿vale? el next in 00:18:59
nos ha avisado de que algo raro 00:19:01
ha pasado, eso es una excepción 00:19:04
un aviso de que algo raro ha pasado 00:19:05
y luego tú ese aviso 00:19:07
decides qué hacer con él 00:19:09
lo ignoras, con lo cual 00:19:11
el programa se va a parar como eso llegue 00:19:14
o lo capturas con el try catch 00:19:16
¿vale? pero es un aviso 00:19:18
Eso es lo que es una excepción, un aviso de que algo raro ha pasado 00:19:19
Vale, pues igual que ya 00:19:22
Hay tropecientos mil 00:19:24
Posibles avisos programados en Java 00:19:26
Si uno se pone a abrir aquí 00:19:28
De la JRE 00:19:30
Que tiene todas las clases 00:19:32
Que nosotros usamos 00:19:34
Pues aquí, vale, si se pone aquí a abrir 00:19:35
Pues es que aquí se va a encontrar 00:19:38
Con un montón de clases excepción por todas partes 00:19:40
Vale 00:19:42
Vamos a preguntarle 00:19:44
A nuestro amigo, a ver si nos dice 00:19:46
¿Cuántas clases excepción hay en la JRE? 00:19:48
Sí, sí, o cuál quieres tú 00:19:51
Si yo le pregunto a quien quieras 00:19:53
¿Pero por qué os cae mejor este? 00:19:54
Si este es el que manipuló a uno 00:19:57
Y le hizo tirarse por la ventana 00:19:59
¿Por qué os cae también este? 00:20:00
Vale 00:20:04
¿Pero cuál es el enlace de Gemini, el verdadero? 00:20:04
Este, ¿no? Vale 00:20:08
Vale 00:20:09
Clases excepción 00:20:11
Hay 00:20:17
aproximadamente 00:20:18
en la 00:20:20
JDK 00:20:23
estándar, es decir 00:20:25
en las clases que usamos nosotros 00:20:26
para programar 00:20:29
Scanner, System.out, todas esas 00:20:30
pues ¿cuántas de ellas son clases 00:20:32
de excepción? Aproximadamente 00:20:35
¿si tarda mucho? 00:20:36
Ah bueno, que pocas 00:20:42
yo creía que había más 00:20:44
entre 400 y 600 00:20:45
En versiones de JDK 21-25 00:20:48
Porque claro, se han ido sacando 00:20:51
Porque ya pesaba demasiado 00:20:52
¿Vale? 00:20:54
Vale, pues no hay tantas 00:21:00
Yo creía que había más 00:21:02
Vale, no, no queremos esto 00:21:03
¿Y clases en total? 00:21:06
¿De cuántas clases disponemos en la JDK para usarlas? 00:21:13
Porque estamos usando cuatro 00:21:16
Bueno, ahora más 00:21:17
Ahora como usamos ArrayList, LinkedList 00:21:20
Todo eso son clases, claro 00:21:22
Es mucho más impresionante 00:21:24
Es que no me pareció alto 00:21:26
¿Ves? Es que intuye mal 00:21:27
He dicho de hecho que me parecía muy bajo 00:21:29
Bueno, no son tantas 00:21:31
De 4.500 a 5.000 00:21:33
A ver, sin incluir implementaciones 00:21:35
Ni clases internas 00:21:39
Que eso ya lo veremos con interfaces gráficas 00:21:40
Si incluimos implementaciones 00:21:42
De interfaces 00:21:44
Y clases internas 00:21:47
20.000 00:21:49
Pues 20.000 cosas tenemos aquí 00:21:50
Para usar 00:21:56
Y eso sin ningún framework 00:21:57
Cualquier aplicación mínima 00:22:00
Necesita un framework 00:22:02
Un framework es a su vez 00:22:04
Un montón de hard con cosas 00:22:05
Para JavaFX 00:22:07
Para Spring, para todo 00:22:09
Un framework son otras cuantas miles 00:22:12
De clases 00:22:14
Más las que haga uno 00:22:15
Conclusión, una aplicación Java 00:22:16
En realidad estará usando 00:22:18
Cientos de clases 00:22:21
Normalmente 00:22:23
pero claro, solo se distribuyen 00:22:24
las que has hecho tú, porque las otras 00:22:27
las lleva la máquina virtual 00:22:28
se distribuyen las que has hecho tú 00:22:30
y los frameworks de los que tires 00:22:32
ni siquiera, porque ahora 00:22:34
con Mabel, que lo haremos 00:22:36
en JavaFX también, para que lo veáis 00:22:38
tu aplicación se sincroniza 00:22:41
con el repositorio, no tienes que 00:22:43
cargar con lo hard todo el rato 00:22:44
porque si no, las aplicaciones 00:22:46
pesarían un montón 00:22:49
cualquier aplicación pesaría mucho 00:22:50
Tus propias clases si las tiene que tener 00:22:52
Pero los hard de los frameworks 00:22:55
Que tú quieres usar 00:22:57
Si los quieres meter ya eso iría engordando 00:22:58
Entonces está en un repositorio 00:23:01
Y tú pones el enlace a ese repositorio 00:23:02
Y cuando la aplicación arranca 00:23:04
Las descarga 00:23:07
Y las tiene local, eso sí que sí 00:23:08
Las tiene que tener en almacenamiento local 00:23:10
Cuando se, pero bueno 00:23:13
Eso ya lo veremos, vale 00:23:14
Bueno, muy bonito, ¿no? 00:23:15
Entonces, esto venía a cuento de que 00:23:18
Las excepciones son 00:23:20
avisos, ¿vale? 00:23:21
Avisos ya establecidos. 00:23:26
Hay los que nos ha dicho este, 00:23:27
entre 300 y 500 o algo así nos ha dicho. 00:23:30
Pero aún así puede ser que nosotros 00:23:32
queramos avisar de cosas 00:23:34
que ahí no están contempladas. 00:23:36
Por ejemplo, para no engorronar esta, 00:23:39
¿o la engorronamos? 00:23:42
Venga, vamos a engorronarla 00:23:47
y así ya la dejamos completa. 00:23:49
Esta aplicación de los votos. 00:23:51
Nosotros aquí hemos validado 00:23:52
Venga, vamos a 00:23:55
En lugar de engorronarla vamos a hacer 00:23:57
Votaciones B 00:23:58
Me hago aquí un copia y pega 00:24:00
Votaciones 00:24:02
Versión 2 00:24:07
Votaciones 2 00:24:07
Venga 00:24:23
Para no poner 00:24:23
Ala, pues estas votaciones 2 00:24:25
Venga, vamos a situarnos 00:24:30
A ver, por ejemplo, este programa 00:24:39
Nuestro que hacía 00:24:41
Pues establecía las candidaturas con este método 00:24:42
Para eso, para establecer las candidaturas 00:24:48
Pedía primero cuántos se iban a presentar 00:24:52
Haciendo un método que lo validaba 00:24:54
Y luego ya me hacía los candidatos 00:24:57
Todo eso lo hacía el método candidaturas 00:24:59
Vale, y luego ahora ya empezaba nuestro recuento 00:25:02
Que se iba guardando en un map 00:25:06
Y ahora, ¿qué hacía esto? 00:25:08
Pues 00:25:11
Empezaban los votos 00:25:13
Con este for 00:25:17
En este caso eran 10 votos 00:25:18
Empezaban los votos 00:25:20
Lo primero que hacía 00:25:21
Pedir un voto 00:25:22
Para eso 00:25:25
Hacía esta variable y era un do while 00:25:27
Mientras el voto no esté 00:25:29
En los candidatos 00:25:31
Venga vamos a sacar esto a un método 00:25:33
Vamos a refactorizar esto 00:25:36
Vamos a sacarlo a un método 00:25:37
Y que ese método sea pedir voto 00:25:38
Y devolverlo como valor de retorno 00:25:41
¿Vale? 00:25:43
Validando 00:25:45
Que esté en este array 00:25:46
Con lo cual va a haber que pasárselo a ese método 00:25:49
¿Vale? 00:25:51
Entonces vamos a refactorizar el código 00:25:53
¿Sabéis lo que es refactorizar 00:25:55
Dentro de nuestro desarrollo? 00:25:57
Sí, ¿no? 00:25:59
La aplicación, yo no voy a cambiar su funcionamiento 00:26:01
En ningún momento, va a funcionar igual 00:26:04
Voy a cambiar solo el diseño del código 00:26:05
Ya está 00:26:08
Pues vamos a cambiarlo 00:26:08
Sacando esto 00:26:10
¿Lo habéis refactorizado con los diferentes entornos? 00:26:11
Bueno, pues 00:26:13
Todos los entornos 00:26:16
Tienen la posibilidad de hacer un refactor automático 00:26:19
Pero es casi más lioso usar eso 00:26:21
Que copiarlo tú y llevarlo a otro método 00:26:23
Es casi, pero aquí podríamos hacer un refactor 00:26:24
Y hay un extract método 00:26:27
Que te dice, sácalo a un método 00:26:29
Vamos a probarlo, a ver 00:26:30
Entonces vamos a sacar esto 00:26:32
Esto de aquí 00:26:34
Vamos a refactorizarlo y sacarlo 00:26:36
A un método, StratMethod 00:26:38
Vale 00:26:39
¿Cómo vamos a llamar al método? 00:26:41
GetBoto 00:26:43
Vamos a intentar 00:26:44
A ver si nos lo hace bien 00:26:47
GetBoto, el escáner no se lo quiero pasar 00:26:48
Este no, este fuera 00:26:51
¿Esto lo puedo borrar? No quiero pasarle este 00:26:53
Eh... 00:26:56
Sí, a ver, no 00:26:58
Editar, declarar, no, lo quiero borrar 00:26:59
No quiero pasarle este 00:27:02
Porque lo va a usar él 00:27:04
Entonces, ¿no puedo yo aquí 00:27:05
Este quitarlo? No puedo, ¿verdad? 00:27:07
¿Eh? 00:27:11
Pero no lo tenía, es que no lo he cogido 00:27:15
No, claro, a ver 00:27:17
Él lo que te dice es lo que necesita 00:27:19
Pero yo el escáner no quiero 00:27:21
Quiero crearlo dentro otra vez 00:27:23
Entonces él te dice, vaya a eso, pero bueno 00:27:24
Voy a hacerlo y luego lo borro y se acabó 00:27:26
Entonces, refactor, rename 00:27:29
Pero tiene que haber, no, rename no 00:27:31
Extraer método, tiene que haber alguna manera 00:27:33
De poder quitarle parámetros, es decir, no, este no lo quiero 00:27:35
Pero bueno, no lo sé 00:27:37
Vale, y ahora le paso candidato 00:27:39
Si me va a devolver un este 00:27:42
Venga, que le ca... 00:27:43
Ah, sí, el método va a ser 00:27:45
GetVoto 00:27:47
Vale, pues venga 00:27:49
Nos gusta este, pues no nos llama 00:27:51
Remedio porque no me deja quitar el escáner 00:27:54
Claro, no me deja quitar el escá... 00:27:55
A ver, ah, bueno, pero puedo hacer 00:27:59
Una cosa, le pongo aquí el... Ah, no, es que 00:28:01
Ponérselo para que no tire de aquí 00:28:02
NewScanner 00:28:05
bueno, ya se lo quito a mano y se acabó 00:28:06
refactor 00:28:09
extraeme eso a un método 00:28:11
venga 00:28:14
getBoto 00:28:15
ese es el nombre del método 00:28:17
entonces, efectivamente 00:28:21
me llama a getBoto, pasándole mi scan 00:28:25
no, yo de este scan paso me hago uno local 00:28:27
para él, porque si no tenemos un poco de problemilla 00:28:29
con los cierres, los buffers 00:28:31
etcétera 00:28:35
Y getBoto mío está aquí debajo. 00:28:36
Le quito el escáner y se lo pongo aquí, local. 00:28:39
Que eso da menos problemas. 00:28:47
A ver, y se lo pago como parámetro. 00:29:04
Este va a tirar del otro. 00:29:06
Entonces comparten buffer, comparten todo. 00:29:09
Y yo he visto, a ver, con consola la verdad es que no trabajo mucho. 00:29:11
Pero es más complicado gestionar el tema de los buffers. 00:29:14
Limpiar el buffer de uno que te ha dejado es mucho mejor. 00:29:19
Que todos trabajen con uno suyo local. 00:29:22
y ya está, entonces en lugar de trabajar 00:29:24
con el que me pasa el otro, que tiene toda su mierda 00:29:26
de arriba, pues me hago uno local 00:29:29
que luego va a desaparecer en cuanto este método termine 00:29:31
vale 00:29:33
vale, pues ya está 00:29:34
getVoto 00:29:37
no he cambiado el código, simplemente 00:29:38
me devuelve el voto 00:29:43
validándolo así y me lo devuelve 00:29:44
y aquí llamo a getVoto y se acabó 00:29:46
no he cambiado el código, lo refactorizo 00:29:49
vale, pero vamos a parar aquí un momentito 00:29:50
y luego se 00:29:53
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:00
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 54″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
128.88 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid