Saltar navegación

20250304 Error_EjemploRecursion - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 8 de marzo de 2025 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

A ver, de throwable no solo le da 00:00:00
exception, le da también error. 00:00:02
Porque también se pueden lanzar 00:00:04
errores. Hay cosas 00:00:05
que son errores. Los errores no están pensados 00:00:07
para capturarlos y seguir trabajando. 00:00:09
Los errores se están pensando para 00:00:12
asumir el error y abandonar. 00:00:13
¿Cuál es el 00:00:17
típico que se nos ocurre? 00:00:18
Él, cuando te ha desbordado la pila, la RAM, 00:00:19
por ejemplo. Vamos a provocar uno. 00:00:22
Eso. Esos no 00:00:24
están pensados para capturarlos. 00:00:25
Porque te ha petado. Por ejemplo, 00:00:28
Que explote 00:00:30
Venga, vamos a hacer un ejemplo de error 00:00:35
Claro, pues vamos a provocar un error de memoria 00:00:38
Para ver que error nos sale 00:00:46
Venga 00:00:47
Vamos a hacernos un paquete main 00:00:50
Vale 00:00:54
Pues como podemos provocar 00:00:55
Que la memoria RAM falle. 00:00:59
Hostia, pues ya tenemos que tener moral. 00:01:02
Porque para que la RAM falle hay que meter mucho. 00:01:03
Vale, entonces lo más... 00:01:08
No, con un bucle infinito no falla. 00:01:09
Un bucle infinito, el problema es que tú estés... 00:01:11
Sí, pero podríamos estar aquí media hora. 00:01:14
O más. 00:01:21
No tenemos tanto tiempo. 00:01:23
Entonces... 00:01:25
¿Pones pasta térmica en el slot de la RAM? 00:01:26
Vale, vamos a intentar un error remediable. 00:01:30
No. 00:01:33
Lo más fácil de provocarlo. 00:01:35
Cuando estamos llamando recursivamente a una función, 00:01:36
vamos a ver, ¿cuándo se está haciendo un uso de RAM 00:01:41
que la RAM está haciendo así, si no estamos enterados? 00:01:43
Claro, cuando estamos llamando recursivamente, 00:01:48
que es una, de recursividad hemos visto poco, 00:01:50
porque no tenemos tiempo, 00:01:53
pero como al final pre-siento que no os vais a ir a la FFE 00:01:54
vamos a tener tiempo para un montón de cositas más 00:01:57
pre-siento y deseo por vuestro bien 00:01:59
que no vayáis a perder 15 días a vuestra casa 00:02:05
sino que quedéis aquí 00:02:07
no, no, no, son dos semanas 00:02:09
las prácticas de primer año 00:02:12
bueno, a ver, ¿qué es una función recursiva? 00:02:14
es una función que se llama a sí misma 00:02:21
¿Vale? Es una función que se llama a sí misma 00:02:23
Entonces, eso es una 00:02:26
¿Ya tienes dudas? 00:02:28
Primeros de junio 00:02:37
Aproximadamente primera quincena de junio 00:02:39
Gracias por darme permiso 00:02:42
Si no me llegas a permiso 00:02:47
Voy a ir a esta calle a todo lado 00:02:49
Bueno, puedo continuar 00:02:51
no, gracias, hombre 00:02:53
los exámenes finales 00:02:54
a ver 00:02:57
la tercera evaluación 00:02:58
finales de mayo 00:03:00
mediados finales 00:03:01
la tercera evaluación 00:03:04
¿quién dijo principios? 00:03:05
bueno, a ver 00:03:12
quien dice principios, dice mediados 00:03:13
bueno, a ver, para mí del 10 al 15 mediados 00:03:14
Bueno, depende de los optimistas que seáis 00:03:21
A ver, mediados de mayo 00:03:25
Exámenes de tercera evaluación 00:03:27
¿Vale? 00:03:29
Después de eso se supone que 00:03:31
Dos semanas de FFE 00:03:33
O aquí 00:03:35
Los que no vayan a FFE, aquí los demás 00:03:37
Currando 00:03:39
¿Vale? Y luego ya 00:03:40
Se vuelve aquí a clase la segunda quincena 00:03:42
De junio y ahí es donde se hacen los exámenes 00:03:45
Finales para quien 00:03:47
Tenga que recuperar 00:03:49
ya como colofón de las excepciones 00:03:50
venga Andrea, Ana 00:03:59
como te llames, me da igual 00:04:01
cállate, que te interesa además 00:04:03
porque están mirándola a ella 00:04:07
y hablando con una codorra 00:04:11
bueno, a ver 00:04:12
como colofón de las excepciones 00:04:17
Las excepciones son objetos que se pueden lanzar con throw, ¿vale? Pero no son solo los únicos objetos que se pueden lanzar con throw y provocar que el programa pare o forzarnos a capturarlo, a elegir. 00:04:19
También está, para que no digáis, es que nos oculta información cuando estudiéis por ahí. Pues no, nos oculta información. También están los errores, que son la clase error, exception error. 00:04:34
entonces los errores son objetos también 00:04:44
que se instancian cuando pasa alguna 00:04:47
de las cosas consideradas como error 00:04:49
y se lanzan 00:04:51
y provocan que el programa pare, cuando la máquina virtual 00:04:53
recibe un objeto error 00:04:55
porque el código ha detectado que ha pasado algo raro 00:04:57
pues recibe ese objeto error 00:04:59
y a menos que hayamos puesto un try catch 00:05:01
que se puede capturar un error 00:05:03
a menos que hayamos puesto un try catch 00:05:04
pues la máquina virtual lo para 00:05:06
lo que pasa es que los errores 00:05:08
conceptualmente 00:05:11
conceptualmente están para reflejar situaciones 00:05:12
que no interesa capturar. 00:05:14
Entonces, por ejemplo, 00:05:17
la que hemos dicho de que la memoria se satura. 00:05:20
Situación típica en la que memoria se satura, 00:05:23
habitual, si hemos programado mal. 00:05:26
Cuando hacemos una recursión de la que no salimos. 00:05:28
Vale, la recursividad vamos a dedicar solo 10-15 minutos. 00:05:33
A eso ahora lo es interesante. 00:05:35
La recursividad es un recurso para programar 00:05:37
que es muy interesante 00:05:40
porque es muy fácil 00:05:42
cuando tú te das cuenta de que un programa 00:05:44
es recursivo, lo programas 00:05:46
directamente con la misma 00:05:49
es facilísimo, sin embargo 00:05:51
pasar la versión iterativa 00:05:53
con bucles es más complicado 00:05:54
pero ¿cuál es el problema? 00:05:56
una vez que has programado esa solución recursiva 00:05:58
de la situación 00:06:01
que si no la has programado bien 00:06:02
y no sales de la recursión 00:06:05
te cargas la memoria 00:06:07
la petas, ¿vale? 00:06:08
Entonces, es muy bueno 00:06:10
como recurso de desarrollo, para programar 00:06:12
es muy fácil, pero 00:06:14
a efectos computacionales, 00:06:16
a efectos de rendimiento, por un lado 00:06:18
es peor porque carga más la memoria, 00:06:20
ahora veremos por qué, y si encima 00:06:22
no lo has programado bien, pues ya puedes petarla 00:06:24
del todo. Vale, pues 00:06:26
entonces, ¿cuándo un programa 00:06:28
es recursivo? A ti te van a 00:06:30
plantear una situación. 00:06:32
Tienes que hacerme un programa que haga no sé qué. 00:06:34
Pues venga, me pongo a pensar 00:06:36
Me cruzo ahí de brazos y me pongo a pensar 00:06:38
¿Qué es lo que tenemos que hacer? 00:06:40
En ese cruzarse de brazos 00:06:41
Uno se cruza de brazos con un lápiz y un papel 00:06:44
¿Vale? 00:06:46
Que es como programa uno 00:06:48
Pues usando la cabeza con un lápiz y un papel 00:06:49
¿Vale? Cuando lleva ya mucho rato 00:06:52
Usando la cabeza y con un lápiz y un papel 00:06:54
Pues ya bueno 00:06:56
Empieza a garabatear en el papel 00:06:57
Y ya cuando ya lo tiene muy garabateado 00:06:59
Y ya pasa mucho tiempo, pues ya se acerca a algún ordenador 00:07:02
Si hay por ahí, ¿vale? 00:07:04
pero antes está ahí con su papelillo 00:07:05
bueno, pues entonces 00:07:06
en esa fase de pensar 00:07:07
cuando se da cuenta uno 00:07:09
de que puede ser que un problema 00:07:11
admita una solución recursiva 00:07:12
pues cuando el problema 00:07:15
para unos datos concretos 00:07:17
podría ser resuelto 00:07:19
si yo lo tuviera resuelto 00:07:20
para un conjunto de datos más pequeñito 00:07:22
por ejemplo 00:07:25
el típico problema 00:07:25
que se usa siempre 00:07:29
por ejemplo 00:07:33
vale, lo que pasa es que 00:07:42
se me ha roto la cámara 00:07:47
no sé sacar aquí la cámara 00:07:50
entonces los que sepan de informática 00:07:52
yo le pongo cámara 00:07:54
y aquí 00:08:04
no me sale nada 00:08:05
Espera, un momentito 00:08:07
Venga, vamos 00:08:13
Vale 00:08:18
Vale 00:08:32
Pues cuando 00:08:33
Cuando se da cuenta 00:08:33
Silencio ya 00:08:37
venga, llegamos a un día muy tonto 00:08:38
muy tonto 00:08:40
bueno, es que hoy lo has contagiado al resto del mundo 00:08:40
bueno, cuando se da cuenta uno 00:08:45
mira, y el otro durmiéndose 00:08:48
esto es un desastre, de verdad 00:08:49
no hay forma de movilizarlo aquí 00:08:52
no sé, me da igual 00:08:55
venga, no, no, no 00:08:58
no me imagino nada 00:09:00
problemas recursivos 00:09:01
¿cuándo problemas recursivos? 00:09:03
hay que plantear un problema 00:09:05
Entonces yo, a ver, ¿cómo elaboro yo el algoritmo para solucionar esto? 00:09:06
Pues a uno rápidamente, o no tan rápidamente, se le puede, 00:09:11
ah, pues mira, me hago un bucle, que no sé qué, patatín, 00:09:13
y desarrollo el algoritmo, anax, cállate, 00:09:16
y desarrollo el algoritmo y ya está, vale. 00:09:19
Pero a veces me doy cuenta de, a ver, yo no sé cómo se tiene el problema, 00:09:21
pero sé que si yo tuviera el problema resuelto 00:09:26
para un conjunto de datos más pequeño, 00:09:29
el problema para un conjunto de datos mayor 00:09:33
lo puedo resolver apoyándome en la solución 00:09:35
de un conjunto de datos más pequeño. 00:09:38
Entonces, identifico esa relación medio extraña 00:09:40
y me doy cuenta de que es recursiva. 00:09:43
Entonces, empiezo a explorar por ahí. 00:09:45
Por ejemplo, nos han planteado, 00:09:47
pues mira, hazme un algoritmo 00:09:49
que me haga la potencia, 00:09:52
un método que me devuelva la potencia 00:09:56
de una base A elevada a un exponente B. 00:09:58
Entonces, ahí nosotros hemos pensado diciendo, 00:10:02
a ver qué es a elevado a b, pues a elevado a b es a por a un montón de veces, entonces 00:10:05
ya nos hemos dado cuenta que es hacer varias veces una multiplicación, pues entonces hemos 00:10:13
llegado a la conclusión de que hacíamos un bucle, porque hemos visto que es hacer 00:10:17
varias veces algo y bueno, lo hicimos con un bucle y ya está, ¿vale? Pues este algoritmo 00:10:22
tenía una solución iterativa, que es mediante un bucle, porque nos hemos dado cuenta que 00:10:26
se puede hacer haciendo varias veces algo 00:10:32
pero hay problemas en los cuales no es tan fácil 00:10:33
encontrar la solución iterativa 00:10:36
y de repente sí que vemos lo siguiente 00:10:37
y es, a ver 00:10:40
yo no sé 00:10:41
cómo resolver la potencia 00:10:43
de a elevado a b 00:10:46
pero sé que si 00:10:47
tuviera 00:10:49
la potencia de a 00:10:52
elevado a b menos 1 00:10:54
si la tuviera por casualidad 00:10:55
pues esta sería igual 00:10:57
a a por esta otra 00:11:00
entonces uno se da cuenta 00:11:01
de que hay una relación 00:11:05
entre la solución del problema 00:11:06
para un conjunto concreto de los datos 00:11:08
y la solución del problema 00:11:10
para otro conjunto de los datos 00:11:12
más reducido 00:11:14
pues aquí nos hemos dado cuenta 00:11:15
de que esa relación la hay 00:11:19
es decir 00:11:20
la solución del problema para a y b-1 00:11:22
me permitiría obtener 00:11:25
la solución del problema para a y b 00:11:27
me lo permitiría 00:11:29
luego esta es la primera cosa que nos damos cuenta 00:11:30
parece ser que admite una solución recursiva 00:11:33
¿por qué se la llama recursiva? 00:11:35
porque para resolver 00:11:38
el problema en general 00:11:39
para datos genéricos 00:11:41
te apoyas en ti mismo 00:11:42
te estás apoyando en ti mismo para otros datos 00:11:45
entonces como 00:11:47
se está apoyando en sí mismo 00:11:49
aunque con otros datos, por eso es recursivo 00:11:51
porque se apoya en 00:11:53
en sí mismo 00:11:54
nos hemos dado cuenta de la primera cosa importante 00:11:56
que están dentro de una solución recursiva. 00:11:59
Qué bien, ¿vale? 00:12:01
Pero ¿con esto a dónde llego? 00:12:02
Claro, esto parte de la base de si yo tuviera esto. 00:12:04
Pero es que yo no tengo esto. 00:12:08
Es precisamente lo que quiero resolver. 00:12:09
Quiero resolver un algoritmo para la función potencia. 00:12:11
No lo tenemos. 00:12:14
Pero entonces nos damos cuenta de la segunda cosa. 00:12:15
De que hay un conjunto concreto de los datos, 00:12:18
un conjunto concreto para el cual la solución es inmediata. 00:12:21
Que no tengo que hacer nada. 00:12:25
Que ese sería el caso base. 00:12:27
¿Vale? Es decir, me doy cuenta de que existe un caso base. 00:12:29
¿Y cuál es el caso base? 00:12:35
Cuando b es 0, cuando el segundo parámetro es 0, no tengo que hacer nada. 00:12:38
Sé que el resultado de la potencia es 1. 00:12:43
Lo sé. 00:12:47
Luego existe un caso base, que es, cuando b es igual a 0, sé que la potencia, me da igual lo que sea a, sé que la potencia es 1. 00:12:48
Lo sé. 00:12:58
Tengo el resultado. 00:12:59
no tengo que hacer nada. 00:13:00
Luego ya he encontrado 00:13:04
las dos condiciones 00:13:05
que me llevan ya 00:13:07
a la solución recursiva 00:13:09
de un problema. 00:13:12
Ahora ya pasar esto a código 00:13:13
es inmediato. 00:13:15
No tengo que pensar nada más. 00:13:18
¿Vale? 00:13:21
Entonces, hay que identificar 00:13:21
dos cosas. 00:13:23
Primero, que la solución genérica 00:13:25
se puede obtener 00:13:27
en función de la solución para otro conjunto 00:13:29
de datos. 00:13:31
Y esa es la relación recursiva. 00:13:33
Y luego que existe un caso 00:13:35
para el cual la solución es inmediata. 00:13:37
Pues entonces ahora ya 00:13:40
programar esto es, vale, 00:13:41
potencia de elevado a B. 00:13:44
Tengo dos opciones. 00:13:46
Que B sea 0. 00:13:48
Pues si B es 0, 00:13:50
retuno 1. Punto pelota. 00:13:51
Si B no es 0, 00:13:53
retuno A por, 00:13:55
me llamo a mí mismo, 00:13:56
A por B menos 1. 00:13:58
Y ya está 00:13:59
Y se acabó el programa 00:14:00
Si a este no lo que sea 00:14:02
Entonces ahora programar esto 00:14:05
Es única y exclusivamente 00:14:07
Escribir esto de aquí 00:14:09
¿El qué? 00:14:10
Bueno, no es la idea 00:14:15
Bueno, pero según en esa forma 00:14:16
Puede ser 00:14:18
Te voy a meter una leche 00:14:19
Pero gorda, ¿eh? 00:14:27
Segundo 00:14:30
que sí, que según esta fórmula sí 00:14:30
pero a ver, que uno usa este algoritmo 00:14:33
pues lo habrás usado en un código en el cual 00:14:34
lo estés llamando cuando B sea 00:14:36
positivo, etcétera, ¿vale? no está pensado 00:14:38
para eso 00:14:40
que todas las 00:14:41
la validación de datos es algo 00:14:45
que nosotros ahora mismo estamos ignorando 00:14:47
tú pondrás tu validación de datos en el momento en que lo necesites 00:14:48
¿vale? antes de llamar a la función 00:14:51
validarás los datos o lo que sea 00:14:53
vale, pues entonces 00:14:54
vamos a programar esta función 00:14:57
por ejemplo 00:15:01
pues ven 00:15:07
vamos a hacerlo nuestro método 00:15:08
a la primera 00:15:28
Vale, pues entonces 00:15:29
hemos llegado a esas dos conclusiones de ahí 00:16:00
las que estaban en la pizarra y debajo 00:16:03
y ahora ya nos podemos poner a programar 00:16:05
si, me voy a hacer ahora ya 00:16:08
esta función, este método que me han pedido hacer 00:16:11
me lo voy a hacer ya en una clase para poder usarla 00:16:14
pues venga 00:16:16
ahora ya nos vamos a hacer esta función 00:16:18
y ahora yo ya programo 00:16:19
lo que he escrito 00:16:22
ahí 00:16:24
ahora 00:16:24
que b es igual a 0 00:16:26
no tiene nada que ver 00:16:34
esto es otra cosa 00:16:36
no tiene nada que ver, yo para qué te voy a explicar esto 00:16:38
vale, ahora estoy programando 00:16:40
ahora ya lo que he dicho antes 00:16:46
vamos a ver, método potencia de A elevado a B 00:16:47
B es igual a 0 00:16:50
devuélveme 1, no hay ningún problema 00:16:51
no es igual a 0 00:16:53
pues entonces devuélveme 00:16:55
A por la 00:16:57
propia función potencia 00:17:00
pero para b-1 00:17:01
y ya está, y más limpio 00:17:03
más claro, incluso que con bucles 00:17:08
con for 00:17:10
bueno, a ver, muy grande tiene que ser 00:17:11
claro 00:17:19
sí, ahora vamos a eso, vamos a 00:17:22
petarlo ahora 00:17:26
bueno, pues esto es 00:17:27
una 00:17:44
esto es un método recursivo 00:17:45
es un método que se llama 00:17:48
a sí mismo 00:17:50
para obtener su solución 00:17:50
y métodos recursivos 00:17:53
lógicamente podemos hacer 00:17:56
los métodos recursivos que nos interesen 00:17:58
cuando nos interesen, si los necesitamos y nos vienen bien 00:18:00
cualquier método 00:18:02
que se llame a sí mismo es recursivo 00:18:04
y ya está 00:18:05
vale 00:18:06
bueno 00:18:10
es que aquí 00:18:14
si o si 00:18:15
vale, pues entonces 00:18:16
está claro que esto funcionaría 00:18:23
¿no? porque esto, ¿qué es lo que va a hacer? 00:18:25
por ejemplo, le ponemos 2 elevado a 3 00:18:27
pues la primera vez que entra 00:18:29
como no es 0 00:18:31
hace a por 00:18:33
y ahora hace la segunda llamada 00:18:35
con b una menor 00:18:37
entonces el a por se queda aquí 00:18:40
como a la espera 00:18:41
a la espera de que se resuelva el potencia 00:18:42
con b menos 1 00:18:45
potencia vuelve a entrar pero con b menos 1 00:18:47
como sigue sin ser 0 00:18:50
hace otro a por que se acumula 00:18:51
la anterior y se vuelve a llamar 00:18:54
pero con un exponente menor 00:18:56
entonces a lo mejor 00:18:58
si b es igual a 3 00:19:00
pues habrá necesitado ser llamado 3 veces 00:19:01
y cada vez que ha sido 00:19:04
llamado pues se ha acumulado 00:19:06
hay un a por 00:19:08
¿vale? 00:19:09
entonces 00:19:12
a ver, no es un 00:19:17
bucle de programación, pero es un bucle 00:19:20
en el sentido de que es algo que se hace varias veces 00:19:22
¿qué se hace varias veces? 00:19:24
llamar a este método 00:19:26
varias veces se llama a este método 00:19:27
y cada vez que llamas al método 00:19:29
hay otro 00:19:32
arriba que está esperando que tú acabes 00:19:34
la primera llamada a potencia 00:19:36
que te llama con 2 elevado a 3, por ejemplo 00:19:38
vamos a hacer el main para 00:19:40
vamos a hacer el 00:19:43
main 00:19:47
vamos a ponerle 00:19:48
aquí un siso para verlo 00:19:57
al menos 00:19:59
efectivamente 00:19:59
y el punto y coma no 00:20:36
por ejemplo, vamos a ejecutarlo 00:20:39
bueno, le he puesto 00:20:42
antes de que se vuelva a llamar a sí mismo 00:20:44
le he dicho, voy a llamar a potencia otra vez 00:20:46
para lo que vale en ese momento A y B 00:20:48
muy grande tiene que ser 00:20:50
de hecho 00:20:54
va a desbordar antes el tamaño del log 00:20:56
que la rama 00:20:58
Con lo cual eso no da error 00:20:59
Sino que simplemente se pierde el significado del número 00:21:01
Vale, entonces si llamamos ahora 00:21:04
A matemáticas 00:21:06
Punto potencia 00:21:08
Para 2 elevado a 3 00:21:10
Y bueno, lo mostramos 00:21:13
Porque si no lo mostramos 00:21:15
Así para que 00:21:16
Es así 00:21:17
Madre mía, ya 00:21:21
Vamos teniendo años todos 00:21:24
Venga 00:21:26
¿Veis? Primero, la primera llamada 00:21:28
que se hace, pues para 2 elevado a 3 00:21:34
y este ya hace un a por 00:21:36
y se queda esperando la llamada 00:21:38
para 2 elevado a 2 00:21:40
y luego se queda esperando la llamada 00:21:41
para 2 elevado a 1 00:21:44
hasta que al final ya me devuelve el valor final 00:21:45
8, luego esta es la idea 00:21:48
no es mi objetivo ahora que entendáis la recursividad 00:21:54
del dedillo porque tampoco es tan sencillo 00:21:56
porque lo que está ocurriendo aquí 00:21:58
cada vez que llamas al método 00:21:59
es que un método se queda a medias 00:22:01
el primero empieza 00:22:03
su código, B3 00:22:05
entro por aquí, hago el system out 00:22:07
hago a por potencia 00:22:10
y me quedo cruzado de brazos 00:22:12
sin terminar, porque ahora tiene que 00:22:13
terminar el potencia para 00:22:15
B2, potencia 00:22:17
para B2, que ya tiene al de B3 00:22:19
esperando arriba, al de B2 00:22:21
él lo llama 00:22:24
voy por el else 00:22:25
tengo que poner una por 00:22:27
hay, tengo que llamar a potencia para b igual a 1 00:22:29
pues otro segundo que se ha quedado a medias 00:22:32
lo que tenemos esperando al primer potencia 00:22:34
que era para b igual a 3 00:22:36
que estáis medias esperando que le den el valor para multiplicarlo por a 00:22:37
luego tenemos esperando 00:22:40
al segundo potencia para b igual a 2 00:22:42
que estáis esperando 00:22:44
al otro potencia 00:22:45
para multiplicarlo por su propio a 00:22:47
así hasta el último potencia 00:22:49
para 0 00:22:52
que se ya hace el retun 00:22:53
veis, por eso aquí 00:22:54
no me aparece llamando a potencia 00:22:56
para 2, 1 00:22:59
porque llamando a potencia para 2, 1 00:23:00
para 2, 0, perdón 00:23:03
claro, no me aparece 00:23:04
para 2, 0, porque cuando ya llamamos 00:23:07
a potencia para 2, 0, con el 0 ya ha entrado 00:23:09
aquí, ya está, me devuelve el 1 y ya se va 00:23:11
haciendo la multiplicación, luego aquí 00:23:13
que está ocurriendo en la rama, aunque no lo veamos 00:23:15
que cada vez 00:23:17
que 00:23:19
la máquina virtual 00:23:19
llama un potencia 00:23:22
el otro se queda esperando 00:23:24
Y como se queda esperando, ¿dónde estaba el famoso, recordáis de sistemas operativos o de por ahí, el registro contador de programa? 00:23:26
Os suena. 00:23:37
El contador de programa es un registro interno de la CPU que te dice la dirección de la sentencia que estás ejecutando. 00:23:38
Entonces, aquí estamos ejecutando este método, pero saltamos a este. 00:23:46
Pero no podemos perder la dirección del otro 00:23:50
Porque cuando este haya terminado 00:23:53
Hay que volver al otro para multiplicar por el A 00:23:54
Ahora, cuando este llamemos 00:23:56
Este entrará 00:23:58
Y volverá a llamar al otro 00:23:59
Pero no podemos perder la dirección de este 00:24:01
Porque cuando el termine hay que multiplicar por el A del de arriba 00:24:03
Luego se van metiendo en una pila 00:24:06
De la RAM 00:24:08
Un montón de contadores de programa 00:24:09
Un montón de contadores 00:24:12
Para que cada vez que acaba una versión potencia 00:24:13
Poderme ir a la de arriba que estaba ahí esperando 00:24:15
Que yo acabara 00:24:17
si saturas la caché no pasa nada 00:24:18
entonces 00:24:19
sí, eso creo 00:24:22
vale, entonces aquí 00:24:24
sí, pero es que me da lo mismo 00:24:26
que me da igual 00:24:30
en fin, conclusión 00:24:32
vale, pues 00:24:34
bueno, pues entonces 00:24:37
bueno, retomemos 00:24:40
para qué hemos contado todo este rollo 00:24:45
de métodos recursivos 00:24:47
que tened ahí presente que existe esta forma de programar 00:24:49
cuando el problema lo admite. 00:24:53
Pues para provocar un error. 00:24:55
Son fáciles de programar, como veis, 00:24:57
una vez que he identificado la relación recursiva. 00:24:59
Es facilísimo de programar, 00:25:01
pero si yo cometo un error, lo pago pues muy caro. 00:25:03
Por ejemplo, vamos a, aprovechando el caso de Ana, 00:25:08
vamos a pasarle un B negativo. 00:25:16
o sea se han hecho una validación 00:25:17
de datos mal hecha 00:25:19
entonces nosotros hemos llegado a este 00:25:21
punto del programa 00:25:23
hemos llegado a este main 00:25:24
aquí, a llamar a potencia 00:25:27
y no hemos validado que 00:25:29
esto sea positivo 00:25:31
porque esto no me debería valer para números 00:25:33
negativos, pero para números negativos 00:25:35
no eso es lo que funciona, es uno entre 00:25:37
y luego hago eso 00:25:39
luego este método solo me funciona 00:25:41
si es positivo, si es negativo 00:25:43
No tiene sentido. 00:25:45
Bueno, yo no he hecho bien la validación de datos aquí. 00:25:45
¿Vale? 00:25:49
Y le voy a dar un número negativo. 00:25:50
¿Vale? 00:25:54
2 elevado a menos 3. 00:25:54
Entonces, vamos a ejecutar esto. 00:25:56
Entonces, primero ha estado un montón de rato. 00:26:05
Pero un huevo. 00:26:10
Ahí, popopopopopopopopopopopo. 00:26:11
Todo esto son llamadas recursivas. 00:26:13
En las que ha ido bajando el valor del b. 00:26:15
Los ha ido bajando. 00:26:18
Pa, pa, pa, pa, pa, pa, pa, pa. 00:26:18
Menos 3, 3, 5. 00:26:19
Menos 3, 3, 6. 00:26:20
Menos 3, 3, 7. 00:26:21
¿Qué pasa? Que jamás va a llegar a cero, lógicamente. 00:26:22
Entonces, como jamás va a llegar a cero, 00:26:25
nunca jamás va a salir la recursión. 00:26:27
Nunca jamás va a salir por aquí. 00:26:30
Nunca. 00:26:32
Porque como nunca va a llegar a cero, 00:26:33
luego esto es una recursión que no termina. 00:26:35
Puede ser un fallo de que yo me he equivocado haciendo esto 00:26:38
y aquí en lugar de b igual a cero me he equivocado 00:26:41
y he puesto un b distinto y me he equivocado por una errata, 00:26:43
con lo cual nunca va a llegar a salir de la recursión. 00:26:46
o puede ser porque no he hecho bien la validación 00:26:50
de datos, por lo que sea 00:26:52
el problema es 00:26:54
que si una función recursiva no termina 00:26:56
no termina, se está ahí primero un buen rato 00:26:58
llamando, llamando, llamando 00:27:00
y llega un momento en que ya, pam 00:27:02
la pila de contadores de programa 00:27:04
salta 00:27:06
y te dice, error de 00:27:07
te has cargado la pila 00:27:10
bueno, pues esto no es una excepción 00:27:12
esto es un error 00:27:14
y también, sí, bueno, porque 00:27:15
en la traza, que dificilito sois 00:27:18
vale, porque en la traza 00:27:21
aparece excepción, pero el objeto 00:27:22
que se ha lanzado es un objeto de tipo 00:27:24
error, que hereda de error 00:27:26
que a su vez hereda de throwable 00:27:28
luego de throwable hay excepciones 00:27:30
errores, ambas pueden ser lanzadas 00:27:32
y los errores nos pueden 00:27:34
aparecer a veces, pero se asocian 00:27:36
conceptualmente a situaciones más raras 00:27:38
entonces hombre, yo no debería 00:27:41
capturar esto 00:27:42
porque si mi programa 00:27:43
le pasa esto, es que lo he hecho fatal 00:27:45
Entonces que pete 00:27:48
Y entonces yo ya lo cambio 00:27:50
No, la idea no es darle una salida 00:27:51
Pero aún así 00:27:54
Entiendo 00:27:56
Que 00:27:58
Si yo 00:27:59
Capturar 00:28:10
Trogable a las secas 00:28:12
No sé 00:28:15
Eh, vamos a 00:28:17
No, yo, tienes que capturar una excepción 00:28:18
Entonces voy, vamos a capturar 00:28:21
Error 00:28:23
Vale 00:28:25
Para que capture cualquier error que salga ahí 00:28:26
Y el programa seguiría 00:28:30
Tranquilamente, pero seguiría 00:28:36
En ese momento con la pila desbordada 00:28:38
Lo que pasa es que luego en cuanto has 00:28:39
Acabado la recursión la has limpiado 00:28:40
Claro 00:28:43
Vale, entonces 00:28:43
Pues bueno, ha estado ahí un montonazo 00:28:53
Muchos intentos, muchos intentos 00:28:57
Cuando ha desbordado 00:28:59
lo ha capturado 00:29:00
y el programa ha seguido 00:29:02
pero los errores normalmente no los 00:29:03
capturamos 00:29:06
en tiempo de desarrollo la idea es que te salgan 00:29:07
y dices, uy es que he programado mal esto 00:29:10
y lo cambias para que no 00:29:12
pero se podrían capturar 00:29:13
y ahora ya sí que sí 00:29:15
podría 00:29:19
haber capturado este específicamente 00:29:27
no lo he puesto por vaguería 00:29:29
eso 00:29:31
vale 00:29:34
pues ahora ya sí que de excepciones errores 00:29:38
todo lo que necesitamos, queremos, interesa saber, pues estaría. 00:29:40
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:
5
Fecha:
8 de marzo de 2025 - 19:09
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 47″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
374.27 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid