1
00:00:00,000 --> 00:00:02,080
A ver, de throwable no solo le da

2
00:00:02,080 --> 00:00:04,040
exception, le da también error.

3
00:00:04,500 --> 00:00:05,960
Porque también se pueden lanzar

4
00:00:05,960 --> 00:00:07,900
errores. Hay cosas

5
00:00:07,900 --> 00:00:09,939
que son errores. Los errores no están pensados

6
00:00:09,939 --> 00:00:11,480
para capturarlos y seguir trabajando.

7
00:00:12,300 --> 00:00:13,820
Los errores se están pensando para

8
00:00:13,820 --> 00:00:15,720
asumir el error y abandonar.

9
00:00:17,320 --> 00:00:18,019
¿Cuál es el

10
00:00:18,019 --> 00:00:18,859
típico que se nos ocurre?

11
00:00:19,559 --> 00:00:21,899
Él, cuando te ha desbordado la pila, la RAM,

12
00:00:22,039 --> 00:00:23,600
por ejemplo. Vamos a provocar uno.

13
00:00:24,800 --> 00:00:25,960
Eso. Esos no

14
00:00:25,960 --> 00:00:27,219
están pensados para capturarlos.

15
00:00:28,219 --> 00:00:29,839
Porque te ha petado. Por ejemplo,

16
00:00:30,000 --> 00:00:35,060
Que explote

17
00:00:35,060 --> 00:00:38,560
Venga, vamos a hacer un ejemplo de error

18
00:00:38,560 --> 00:00:46,219
Claro, pues vamos a provocar un error de memoria

19
00:00:46,219 --> 00:00:47,939
Para ver que error nos sale

20
00:00:47,939 --> 00:00:50,520
Venga

21
00:00:50,520 --> 00:00:54,859
Vamos a hacernos un paquete main

22
00:00:54,859 --> 00:00:55,600
Vale

23
00:00:55,600 --> 00:00:59,600
Pues como podemos provocar

24
00:00:59,600 --> 00:01:01,740
Que la memoria RAM falle.

25
00:01:02,259 --> 00:01:03,700
Hostia, pues ya tenemos que tener moral.

26
00:01:03,920 --> 00:01:06,000
Porque para que la RAM falle hay que meter mucho.

27
00:01:08,540 --> 00:01:09,819
Vale, entonces lo más...

28
00:01:09,819 --> 00:01:11,400
No, con un bucle infinito no falla.

29
00:01:11,680 --> 00:01:14,719
Un bucle infinito, el problema es que tú estés...

30
00:01:14,719 --> 00:01:21,359
Sí, pero podríamos estar aquí media hora.

31
00:01:21,760 --> 00:01:22,519
O más.

32
00:01:23,000 --> 00:01:23,939
No tenemos tanto tiempo.

33
00:01:25,739 --> 00:01:26,140
Entonces...

34
00:01:26,140 --> 00:01:28,120
¿Pones pasta térmica en el slot de la RAM?

35
00:01:30,540 --> 00:01:32,780
Vale, vamos a intentar un error remediable.

36
00:01:33,719 --> 00:01:34,120
No.

37
00:01:35,019 --> 00:01:36,140
Lo más fácil de provocarlo.

38
00:01:36,760 --> 00:01:39,920
Cuando estamos llamando recursivamente a una función,

39
00:01:41,060 --> 00:01:43,239
vamos a ver, ¿cuándo se está haciendo un uso de RAM

40
00:01:43,239 --> 00:01:45,599
que la RAM está haciendo así, si no estamos enterados?

41
00:01:48,099 --> 00:01:50,780
Claro, cuando estamos llamando recursivamente,

42
00:01:50,780 --> 00:01:53,859
que es una, de recursividad hemos visto poco,

43
00:01:53,959 --> 00:01:54,700
porque no tenemos tiempo,

44
00:01:54,700 --> 00:01:57,599
pero como al final pre-siento que no os vais a ir a la FFE

45
00:01:57,599 --> 00:01:59,659
vamos a tener tiempo para un montón de cositas más

46
00:01:59,659 --> 00:02:05,180
pre-siento y deseo por vuestro bien

47
00:02:05,180 --> 00:02:07,359
que no vayáis a perder 15 días a vuestra casa

48
00:02:07,359 --> 00:02:09,580
sino que quedéis aquí

49
00:02:09,580 --> 00:02:12,639
no, no, no, son dos semanas

50
00:02:12,639 --> 00:02:14,840
las prácticas de primer año

51
00:02:14,840 --> 00:02:20,180
bueno, a ver, ¿qué es una función recursiva?

52
00:02:21,719 --> 00:02:23,979
es una función que se llama a sí misma

53
00:02:23,979 --> 00:02:26,479
¿Vale? Es una función que se llama a sí misma

54
00:02:26,479 --> 00:02:28,639
Entonces, eso es una

55
00:02:28,639 --> 00:02:30,060
¿Ya tienes dudas?

56
00:02:37,840 --> 00:02:39,139
Primeros de junio

57
00:02:39,139 --> 00:02:42,560
Aproximadamente primera quincena de junio

58
00:02:42,560 --> 00:02:47,120
Gracias por darme permiso

59
00:02:47,120 --> 00:02:49,939
Si no me llegas a permiso

60
00:02:49,939 --> 00:02:51,020
Voy a ir a esta calle a todo lado

61
00:02:51,020 --> 00:02:53,259
Bueno, puedo continuar

62
00:02:53,259 --> 00:02:54,180
no, gracias, hombre

63
00:02:54,180 --> 00:02:57,520
los exámenes finales

64
00:02:57,520 --> 00:02:58,860
a ver

65
00:02:58,860 --> 00:03:00,419
la tercera evaluación

66
00:03:00,419 --> 00:03:01,680
finales de mayo

67
00:03:01,680 --> 00:03:04,819
mediados finales

68
00:03:04,819 --> 00:03:05,699
la tercera evaluación

69
00:03:05,699 --> 00:03:11,280
¿quién dijo principios?

70
00:03:12,340 --> 00:03:13,180
bueno, a ver

71
00:03:13,180 --> 00:03:14,780
quien dice principios, dice mediados

72
00:03:14,780 --> 00:03:21,259
bueno, a ver, para mí del 10 al 15 mediados

73
00:03:21,259 --> 00:03:25,860
Bueno, depende de los optimistas que seáis

74
00:03:25,860 --> 00:03:27,800
A ver, mediados de mayo

75
00:03:27,800 --> 00:03:29,379
Exámenes de tercera evaluación

76
00:03:29,379 --> 00:03:30,219
¿Vale?

77
00:03:31,699 --> 00:03:33,780
Después de eso se supone que

78
00:03:33,780 --> 00:03:35,639
Dos semanas de FFE

79
00:03:35,639 --> 00:03:37,060
O aquí

80
00:03:37,060 --> 00:03:39,680
Los que no vayan a FFE, aquí los demás

81
00:03:39,680 --> 00:03:40,159
Currando

82
00:03:40,159 --> 00:03:42,699
¿Vale? Y luego ya

83
00:03:42,699 --> 00:03:45,659
Se vuelve aquí a clase la segunda quincena

84
00:03:45,659 --> 00:03:47,639
De junio y ahí es donde se hacen los exámenes

85
00:03:47,639 --> 00:03:49,680
Finales para quien

86
00:03:49,680 --> 00:03:50,539
Tenga que recuperar

87
00:03:50,539 --> 00:03:59,300
ya como colofón de las excepciones

88
00:03:59,300 --> 00:04:01,800
venga Andrea, Ana

89
00:04:01,800 --> 00:04:03,879
como te llames, me da igual

90
00:04:03,879 --> 00:04:07,120
cállate, que te interesa además

91
00:04:07,120 --> 00:04:11,219
porque están mirándola a ella

92
00:04:11,219 --> 00:04:12,780
y hablando con una codorra

93
00:04:12,780 --> 00:04:17,279
bueno, a ver

94
00:04:17,279 --> 00:04:19,860
como colofón de las excepciones

95
00:04:19,860 --> 00:04:34,600
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.

96
00:04:34,759 --> 00:04:44,800
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.

97
00:04:44,800 --> 00:04:47,540
entonces los errores son objetos también

98
00:04:47,540 --> 00:04:49,759
que se instancian cuando pasa alguna

99
00:04:49,759 --> 00:04:51,740
de las cosas consideradas como error

100
00:04:51,740 --> 00:04:53,079
y se lanzan

101
00:04:53,079 --> 00:04:55,720
y provocan que el programa pare, cuando la máquina virtual

102
00:04:55,720 --> 00:04:57,060
recibe un objeto error

103
00:04:57,060 --> 00:04:59,379
porque el código ha detectado que ha pasado algo raro

104
00:04:59,379 --> 00:05:01,279
pues recibe ese objeto error

105
00:05:01,279 --> 00:05:03,319
y a menos que hayamos puesto un try catch

106
00:05:03,319 --> 00:05:04,980
que se puede capturar un error

107
00:05:04,980 --> 00:05:06,319
a menos que hayamos puesto un try catch

108
00:05:06,319 --> 00:05:08,540
pues la máquina virtual lo para

109
00:05:08,540 --> 00:05:11,060
lo que pasa es que los errores

110
00:05:11,060 --> 00:05:12,360
conceptualmente

111
00:05:12,360 --> 00:05:14,899
conceptualmente están para reflejar situaciones

112
00:05:14,899 --> 00:05:16,220
que no interesa capturar.

113
00:05:17,839 --> 00:05:20,319
Entonces, por ejemplo,

114
00:05:20,779 --> 00:05:23,160
la que hemos dicho de que la memoria se satura.

115
00:05:23,959 --> 00:05:26,300
Situación típica en la que memoria se satura,

116
00:05:26,680 --> 00:05:28,480
habitual, si hemos programado mal.

117
00:05:28,920 --> 00:05:31,220
Cuando hacemos una recursión de la que no salimos.

118
00:05:33,040 --> 00:05:35,699
Vale, la recursividad vamos a dedicar solo 10-15 minutos.

119
00:05:35,819 --> 00:05:36,819
A eso ahora lo es interesante.

120
00:05:37,459 --> 00:05:40,000
La recursividad es un recurso para programar

121
00:05:40,000 --> 00:05:42,899
que es muy interesante

122
00:05:42,899 --> 00:05:44,600
porque es muy fácil

123
00:05:44,600 --> 00:05:46,879
cuando tú te das cuenta de que un programa

124
00:05:46,879 --> 00:05:49,339
es recursivo, lo programas

125
00:05:49,339 --> 00:05:51,199
directamente con la misma

126
00:05:51,199 --> 00:05:53,120
es facilísimo, sin embargo

127
00:05:53,120 --> 00:05:54,899
pasar la versión iterativa

128
00:05:54,899 --> 00:05:56,120
con bucles es más complicado

129
00:05:56,120 --> 00:05:57,759
pero ¿cuál es el problema?

130
00:05:58,579 --> 00:06:01,180
una vez que has programado esa solución recursiva

131
00:06:01,180 --> 00:06:02,759
de la situación

132
00:06:02,759 --> 00:06:05,319
que si no la has programado bien

133
00:06:05,319 --> 00:06:07,120
y no sales de la recursión

134
00:06:07,120 --> 00:06:08,360
te cargas la memoria

135
00:06:08,360 --> 00:06:10,180
la petas, ¿vale?

136
00:06:10,959 --> 00:06:12,379
Entonces, es muy bueno

137
00:06:12,379 --> 00:06:14,560
como recurso de desarrollo, para programar

138
00:06:14,560 --> 00:06:16,420
es muy fácil, pero

139
00:06:16,420 --> 00:06:18,779
a efectos computacionales,

140
00:06:18,839 --> 00:06:20,600
a efectos de rendimiento, por un lado

141
00:06:20,600 --> 00:06:22,399
es peor porque carga más la memoria,

142
00:06:22,620 --> 00:06:24,279
ahora veremos por qué, y si encima

143
00:06:24,279 --> 00:06:26,620
no lo has programado bien, pues ya puedes petarla

144
00:06:26,620 --> 00:06:28,579
del todo. Vale, pues

145
00:06:28,579 --> 00:06:30,519
entonces, ¿cuándo un programa

146
00:06:30,519 --> 00:06:32,360
es recursivo? A ti te van a

147
00:06:32,360 --> 00:06:34,259
plantear una situación.

148
00:06:34,500 --> 00:06:36,480
Tienes que hacerme un programa que haga no sé qué.

149
00:06:36,480 --> 00:06:38,120
Pues venga, me pongo a pensar

150
00:06:38,120 --> 00:06:40,319
Me cruzo ahí de brazos y me pongo a pensar

151
00:06:40,319 --> 00:06:41,139
¿Qué es lo que tenemos que hacer?

152
00:06:41,220 --> 00:06:44,279
En ese cruzarse de brazos

153
00:06:44,279 --> 00:06:46,920
Uno se cruza de brazos con un lápiz y un papel

154
00:06:46,920 --> 00:06:47,800
¿Vale?

155
00:06:48,120 --> 00:06:49,480
Que es como programa uno

156
00:06:49,480 --> 00:06:52,000
Pues usando la cabeza con un lápiz y un papel

157
00:06:52,000 --> 00:06:54,399
¿Vale? Cuando lleva ya mucho rato

158
00:06:54,399 --> 00:06:56,240
Usando la cabeza y con un lápiz y un papel

159
00:06:56,240 --> 00:06:57,720
Pues ya bueno

160
00:06:57,720 --> 00:06:59,899
Empieza a garabatear en el papel

161
00:06:59,899 --> 00:07:02,060
Y ya cuando ya lo tiene muy garabateado

162
00:07:02,060 --> 00:07:04,319
Y ya pasa mucho tiempo, pues ya se acerca a algún ordenador

163
00:07:04,319 --> 00:07:05,360
Si hay por ahí, ¿vale?

164
00:07:05,360 --> 00:07:06,699
pero antes está ahí con su papelillo

165
00:07:06,699 --> 00:07:07,879
bueno, pues entonces

166
00:07:07,879 --> 00:07:09,660
en esa fase de pensar

167
00:07:09,660 --> 00:07:11,060
cuando se da cuenta uno

168
00:07:11,060 --> 00:07:12,699
de que puede ser que un problema

169
00:07:12,699 --> 00:07:15,360
admita una solución recursiva

170
00:07:15,360 --> 00:07:17,259
pues cuando el problema

171
00:07:17,259 --> 00:07:19,100
para unos datos concretos

172
00:07:19,100 --> 00:07:20,800
podría ser resuelto

173
00:07:20,800 --> 00:07:22,500
si yo lo tuviera resuelto

174
00:07:22,500 --> 00:07:25,000
para un conjunto de datos más pequeñito

175
00:07:25,000 --> 00:07:25,959
por ejemplo

176
00:07:25,959 --> 00:07:29,079
el típico problema

177
00:07:29,079 --> 00:07:32,779
que se usa siempre

178
00:07:32,779 --> 00:07:33,980
de

179
00:07:33,980 --> 00:07:42,800
por ejemplo

180
00:07:42,800 --> 00:07:47,879
vale, lo que pasa es que

181
00:07:47,879 --> 00:07:50,819
se me ha roto la cámara

182
00:07:50,819 --> 00:07:52,819
no sé sacar aquí la cámara

183
00:07:52,819 --> 00:07:54,680
entonces los que sepan de informática

184
00:07:54,680 --> 00:08:04,500
yo le pongo cámara

185
00:08:04,500 --> 00:08:05,879
y aquí

186
00:08:05,879 --> 00:08:07,639
no me sale nada

187
00:08:07,639 --> 00:08:13,050
Espera, un momentito

188
00:08:13,050 --> 00:08:18,170
Venga, vamos

189
00:08:18,170 --> 00:08:19,730
Vale

190
00:08:32,809 --> 00:08:33,210
Vale

191
00:08:33,210 --> 00:08:33,950
Pues cuando

192
00:08:33,950 --> 00:08:37,129
Cuando se da cuenta

193
00:08:37,129 --> 00:08:38,370
Silencio ya

194
00:08:38,370 --> 00:08:40,070
venga, llegamos a un día muy tonto

195
00:08:40,070 --> 00:08:40,549
muy tonto

196
00:08:40,549 --> 00:08:45,789
bueno, es que hoy lo has contagiado al resto del mundo

197
00:08:45,789 --> 00:08:48,350
bueno, cuando se da cuenta uno

198
00:08:48,350 --> 00:08:49,809
mira, y el otro durmiéndose

199
00:08:49,809 --> 00:08:52,090
esto es un desastre, de verdad

200
00:08:52,090 --> 00:08:55,549
no hay forma de movilizarlo aquí

201
00:08:55,549 --> 00:08:58,070
no sé, me da igual

202
00:08:58,070 --> 00:09:00,289
venga, no, no, no

203
00:09:00,289 --> 00:09:01,549
no me imagino nada

204
00:09:01,549 --> 00:09:03,730
problemas recursivos

205
00:09:03,730 --> 00:09:04,990
¿cuándo problemas recursivos?

206
00:09:05,549 --> 00:09:06,610
hay que plantear un problema

207
00:09:06,610 --> 00:09:10,970
Entonces yo, a ver, ¿cómo elaboro yo el algoritmo para solucionar esto?

208
00:09:11,049 --> 00:09:13,450
Pues a uno rápidamente, o no tan rápidamente, se le puede,

209
00:09:13,590 --> 00:09:15,970
ah, pues mira, me hago un bucle, que no sé qué, patatín,

210
00:09:16,350 --> 00:09:19,049
y desarrollo el algoritmo, anax, cállate,

211
00:09:19,350 --> 00:09:21,309
y desarrollo el algoritmo y ya está, vale.

212
00:09:21,769 --> 00:09:25,470
Pero a veces me doy cuenta de, a ver, yo no sé cómo se tiene el problema,

213
00:09:26,230 --> 00:09:29,470
pero sé que si yo tuviera el problema resuelto

214
00:09:29,470 --> 00:09:32,629
para un conjunto de datos más pequeño,

215
00:09:33,110 --> 00:09:35,750
el problema para un conjunto de datos mayor

216
00:09:35,750 --> 00:09:38,929
lo puedo resolver apoyándome en la solución

217
00:09:38,929 --> 00:09:40,210
de un conjunto de datos más pequeño.

218
00:09:40,889 --> 00:09:43,470
Entonces, identifico esa relación medio extraña

219
00:09:43,470 --> 00:09:44,750
y me doy cuenta de que es recursiva.

220
00:09:45,409 --> 00:09:46,710
Entonces, empiezo a explorar por ahí.

221
00:09:47,509 --> 00:09:49,529
Por ejemplo, nos han planteado,

222
00:09:49,629 --> 00:09:52,929
pues mira, hazme un algoritmo

223
00:09:52,929 --> 00:09:55,590
que me haga la potencia,

224
00:09:56,610 --> 00:09:58,850
un método que me devuelva la potencia

225
00:09:58,850 --> 00:10:01,029
de una base A elevada a un exponente B.

226
00:10:02,309 --> 00:10:05,009
Entonces, ahí nosotros hemos pensado diciendo,

227
00:10:05,009 --> 00:10:13,149
a ver qué es a elevado a b, pues a elevado a b es a por a un montón de veces, entonces

228
00:10:13,149 --> 00:10:17,330
ya nos hemos dado cuenta que es hacer varias veces una multiplicación, pues entonces hemos

229
00:10:17,330 --> 00:10:22,809
llegado a la conclusión de que hacíamos un bucle, porque hemos visto que es hacer

230
00:10:22,809 --> 00:10:26,929
varias veces algo y bueno, lo hicimos con un bucle y ya está, ¿vale? Pues este algoritmo

231
00:10:26,929 --> 00:10:32,230
tenía una solución iterativa, que es mediante un bucle, porque nos hemos dado cuenta que

232
00:10:32,230 --> 00:10:33,909
se puede hacer haciendo varias veces algo

233
00:10:33,909 --> 00:10:36,450
pero hay problemas en los cuales no es tan fácil

234
00:10:36,450 --> 00:10:37,809
encontrar la solución iterativa

235
00:10:37,809 --> 00:10:40,230
y de repente sí que vemos lo siguiente

236
00:10:40,230 --> 00:10:41,710
y es, a ver

237
00:10:41,710 --> 00:10:43,950
yo no sé

238
00:10:43,950 --> 00:10:46,649
cómo resolver la potencia

239
00:10:46,649 --> 00:10:47,470
de a elevado a b

240
00:10:47,470 --> 00:10:49,909
pero sé que si

241
00:10:49,909 --> 00:10:52,450
tuviera

242
00:10:52,450 --> 00:10:54,429
la potencia de a

243
00:10:54,429 --> 00:10:55,730
elevado a b menos 1

244
00:10:55,730 --> 00:10:57,870
si la tuviera por casualidad

245
00:10:57,870 --> 00:11:00,169
pues esta sería igual

246
00:11:00,169 --> 00:11:01,830
a a por esta otra

247
00:11:01,830 --> 00:11:05,710
entonces uno se da cuenta

248
00:11:05,710 --> 00:11:06,769
de que hay una relación

249
00:11:06,769 --> 00:11:08,629
entre la solución del problema

250
00:11:08,629 --> 00:11:10,809
para un conjunto concreto de los datos

251
00:11:10,809 --> 00:11:12,850
y la solución del problema

252
00:11:12,850 --> 00:11:14,889
para otro conjunto de los datos

253
00:11:14,889 --> 00:11:15,889
más reducido

254
00:11:15,889 --> 00:11:19,370
pues aquí nos hemos dado cuenta

255
00:11:19,370 --> 00:11:20,570
de que esa relación la hay

256
00:11:20,570 --> 00:11:22,590
es decir

257
00:11:22,590 --> 00:11:25,389
la solución del problema para a y b-1

258
00:11:25,389 --> 00:11:27,090
me permitiría obtener

259
00:11:27,090 --> 00:11:29,190
la solución del problema para a y b

260
00:11:29,190 --> 00:11:30,309
me lo permitiría

261
00:11:30,309 --> 00:11:33,230
luego esta es la primera cosa que nos damos cuenta

262
00:11:33,230 --> 00:11:35,610
parece ser que admite una solución recursiva

263
00:11:35,610 --> 00:11:37,690
¿por qué se la llama recursiva?

264
00:11:38,370 --> 00:11:39,870
porque para resolver

265
00:11:39,870 --> 00:11:41,409
el problema en general

266
00:11:41,409 --> 00:11:42,590
para datos genéricos

267
00:11:42,590 --> 00:11:45,190
te apoyas en ti mismo

268
00:11:45,190 --> 00:11:47,730
te estás apoyando en ti mismo para otros datos

269
00:11:47,730 --> 00:11:49,590
entonces como

270
00:11:49,590 --> 00:11:51,490
se está apoyando en sí mismo

271
00:11:51,490 --> 00:11:53,730
aunque con otros datos, por eso es recursivo

272
00:11:53,730 --> 00:11:54,830
porque se apoya en

273
00:11:54,830 --> 00:11:56,269
en sí mismo

274
00:11:56,269 --> 00:11:59,490
nos hemos dado cuenta de la primera cosa importante

275
00:11:59,490 --> 00:12:01,629
que están dentro de una solución recursiva.

276
00:12:01,909 --> 00:12:02,850
Qué bien, ¿vale?

277
00:12:02,889 --> 00:12:04,049
Pero ¿con esto a dónde llego?

278
00:12:04,509 --> 00:12:07,409
Claro, esto parte de la base de si yo tuviera esto.

279
00:12:08,029 --> 00:12:09,149
Pero es que yo no tengo esto.

280
00:12:09,250 --> 00:12:10,909
Es precisamente lo que quiero resolver.

281
00:12:11,490 --> 00:12:14,009
Quiero resolver un algoritmo para la función potencia.

282
00:12:14,730 --> 00:12:15,230
No lo tenemos.

283
00:12:15,389 --> 00:12:17,169
Pero entonces nos damos cuenta de la segunda cosa.

284
00:12:18,590 --> 00:12:21,350
De que hay un conjunto concreto de los datos,

285
00:12:21,350 --> 00:12:24,830
un conjunto concreto para el cual la solución es inmediata.

286
00:12:25,450 --> 00:12:26,409
Que no tengo que hacer nada.

287
00:12:27,190 --> 00:12:28,429
Que ese sería el caso base.

288
00:12:29,490 --> 00:12:32,389
¿Vale? Es decir, me doy cuenta de que existe un caso base.

289
00:12:35,580 --> 00:12:37,019
¿Y cuál es el caso base?

290
00:12:38,360 --> 00:12:43,360
Cuando b es 0, cuando el segundo parámetro es 0, no tengo que hacer nada.

291
00:12:43,659 --> 00:12:46,539
Sé que el resultado de la potencia es 1.

292
00:12:47,279 --> 00:12:47,659
Lo sé.

293
00:12:48,220 --> 00:12:57,860
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.

294
00:12:58,399 --> 00:12:58,779
Lo sé.

295
00:12:59,279 --> 00:13:00,100
Tengo el resultado.

296
00:13:00,100 --> 00:13:03,059
no tengo que hacer nada.

297
00:13:04,240 --> 00:13:05,639
Luego ya he encontrado

298
00:13:05,639 --> 00:13:07,259
las dos condiciones

299
00:13:07,259 --> 00:13:09,559
que me llevan ya

300
00:13:09,559 --> 00:13:12,159
a la solución recursiva

301
00:13:12,159 --> 00:13:12,779
de un problema.

302
00:13:13,899 --> 00:13:15,379
Ahora ya pasar esto a código

303
00:13:15,379 --> 00:13:17,139
es inmediato.

304
00:13:18,399 --> 00:13:19,600
No tengo que pensar nada más.

305
00:13:21,539 --> 00:13:21,700
¿Vale?

306
00:13:21,779 --> 00:13:23,919
Entonces, hay que identificar

307
00:13:23,919 --> 00:13:24,600
dos cosas.

308
00:13:25,440 --> 00:13:27,980
Primero, que la solución genérica

309
00:13:27,980 --> 00:13:29,559
se puede obtener

310
00:13:29,559 --> 00:13:31,820
en función de la solución para otro conjunto

311
00:13:31,820 --> 00:13:32,320
de datos.

312
00:13:33,360 --> 00:13:34,679
Y esa es la relación recursiva.

313
00:13:35,580 --> 00:13:37,000
Y luego que existe un caso

314
00:13:37,000 --> 00:13:39,299
para el cual la solución es inmediata.

315
00:13:40,720 --> 00:13:41,639
Pues entonces ahora ya

316
00:13:41,639 --> 00:13:43,620
programar esto es, vale,

317
00:13:44,899 --> 00:13:45,919
potencia de elevado a B.

318
00:13:46,259 --> 00:13:47,159
Tengo dos opciones.

319
00:13:48,720 --> 00:13:49,820
Que B sea 0.

320
00:13:50,179 --> 00:13:50,980
Pues si B es 0,

321
00:13:51,840 --> 00:13:53,240
retuno 1. Punto pelota.

322
00:13:53,740 --> 00:13:54,940
Si B no es 0,

323
00:13:55,279 --> 00:13:56,399
retuno A por,

324
00:13:56,899 --> 00:13:58,019
me llamo a mí mismo,

325
00:13:58,700 --> 00:13:59,440
A por B menos 1.

326
00:13:59,559 --> 00:14:00,980
Y ya está

327
00:14:00,980 --> 00:14:02,759
Y se acabó el programa

328
00:14:02,759 --> 00:14:05,059
Si a este no lo que sea

329
00:14:05,059 --> 00:14:07,980
Entonces ahora programar esto

330
00:14:07,980 --> 00:14:09,899
Es única y exclusivamente

331
00:14:09,899 --> 00:14:10,899
Escribir esto de aquí

332
00:14:10,899 --> 00:14:13,000
¿El qué?

333
00:14:15,080 --> 00:14:16,139
Bueno, no es la idea

334
00:14:16,139 --> 00:14:18,740
Bueno, pero según en esa forma

335
00:14:18,740 --> 00:14:19,899
Puede ser

336
00:14:19,899 --> 00:14:27,100
Te voy a meter una leche

337
00:14:27,100 --> 00:14:29,000
Pero gorda, ¿eh?

338
00:14:30,399 --> 00:14:30,879
Segundo

339
00:14:30,879 --> 00:14:33,080
que sí, que según esta fórmula sí

340
00:14:33,080 --> 00:14:34,559
pero a ver, que uno usa este algoritmo

341
00:14:34,559 --> 00:14:36,779
pues lo habrás usado en un código en el cual

342
00:14:36,779 --> 00:14:38,460
lo estés llamando cuando B sea

343
00:14:38,460 --> 00:14:40,860
positivo, etcétera, ¿vale? no está pensado

344
00:14:40,860 --> 00:14:41,259
para eso

345
00:14:41,259 --> 00:14:45,200
que todas las

346
00:14:45,200 --> 00:14:47,000
la validación de datos es algo

347
00:14:47,000 --> 00:14:48,360
que nosotros ahora mismo estamos ignorando

348
00:14:48,360 --> 00:14:51,059
tú pondrás tu validación de datos en el momento en que lo necesites

349
00:14:51,059 --> 00:14:53,259
¿vale? antes de llamar a la función

350
00:14:53,259 --> 00:14:54,799
validarás los datos o lo que sea

351
00:14:54,799 --> 00:14:57,659
vale, pues entonces

352
00:14:57,659 --> 00:15:01,539
vamos a programar esta función

353
00:15:01,539 --> 00:15:07,700
por ejemplo

354
00:15:07,700 --> 00:15:08,519
pues ven

355
00:15:08,519 --> 00:15:12,840
vamos a hacerlo nuestro método

356
00:15:28,210 --> 00:15:29,370
a la primera

357
00:15:29,370 --> 00:15:59,350
Vale, pues entonces

358
00:15:59,350 --> 00:16:00,929
Ya

359
00:16:00,929 --> 00:16:03,769
hemos llegado a esas dos conclusiones de ahí

360
00:16:03,769 --> 00:16:05,429
las que estaban en la pizarra y debajo

361
00:16:05,429 --> 00:16:08,470
y ahora ya nos podemos poner a programar

362
00:16:08,470 --> 00:16:11,850
si, me voy a hacer ahora ya

363
00:16:11,850 --> 00:16:14,110
esta función, este método que me han pedido hacer

364
00:16:14,110 --> 00:16:16,429
me lo voy a hacer ya en una clase para poder usarla

365
00:16:16,429 --> 00:16:18,129
pues venga

366
00:16:18,129 --> 00:16:19,370
ahora ya nos vamos a hacer esta función

367
00:16:19,370 --> 00:16:22,190
y ahora yo ya programo

368
00:16:22,190 --> 00:16:24,269
lo que he escrito

369
00:16:24,269 --> 00:16:24,570
ahí

370
00:16:24,570 --> 00:16:26,230
ahora

371
00:16:26,230 --> 00:16:30,389
que b es igual a 0

372
00:16:30,389 --> 00:16:34,710
no

373
00:16:34,710 --> 00:16:36,389
no tiene nada que ver

374
00:16:36,389 --> 00:16:38,710
esto es otra cosa

375
00:16:38,710 --> 00:16:40,610
no tiene nada que ver, yo para qué te voy a explicar esto

376
00:16:40,610 --> 00:16:46,830
vale, ahora estoy programando

377
00:16:46,830 --> 00:16:47,830
ahora ya lo que he dicho antes

378
00:16:47,830 --> 00:16:50,690
vamos a ver, método potencia de A elevado a B

379
00:16:50,690 --> 00:16:51,649
B es igual a 0

380
00:16:51,649 --> 00:16:53,990
devuélveme 1, no hay ningún problema

381
00:16:53,990 --> 00:16:55,230
no es igual a 0

382
00:16:55,230 --> 00:16:57,870
pues entonces devuélveme

383
00:16:57,870 --> 00:17:00,149
A por la

384
00:17:00,149 --> 00:17:01,830
propia función potencia

385
00:17:01,830 --> 00:17:03,309
pero para b-1

386
00:17:03,309 --> 00:17:08,339
y ya está, y más limpio

387
00:17:08,339 --> 00:17:10,400
más claro, incluso que con bucles

388
00:17:10,400 --> 00:17:11,160
con for

389
00:17:11,160 --> 00:17:19,240
bueno, a ver, muy grande tiene que ser

390
00:17:19,240 --> 00:17:22,640
claro

391
00:17:22,640 --> 00:17:26,740
sí, ahora vamos a eso, vamos a

392
00:17:26,740 --> 00:17:27,660
petarlo ahora

393
00:17:27,660 --> 00:17:44,140
bueno, pues esto es

394
00:17:44,140 --> 00:17:45,700
una

395
00:17:45,700 --> 00:17:48,019
esto es un método recursivo

396
00:17:48,019 --> 00:17:50,140
es un método que se llama

397
00:17:50,140 --> 00:17:50,900
a sí mismo

398
00:17:50,900 --> 00:17:53,279
para obtener su solución

399
00:17:53,279 --> 00:17:56,359
y métodos recursivos

400
00:17:56,359 --> 00:17:58,259
lógicamente podemos hacer

401
00:17:58,259 --> 00:18:00,000
los métodos recursivos que nos interesen

402
00:18:00,000 --> 00:18:02,319
cuando nos interesen, si los necesitamos y nos vienen bien

403
00:18:02,319 --> 00:18:04,140
cualquier método

404
00:18:04,140 --> 00:18:05,900
que se llame a sí mismo es recursivo

405
00:18:05,900 --> 00:18:06,980
y ya está

406
00:18:06,980 --> 00:18:10,980
vale

407
00:18:10,980 --> 00:18:14,019
bueno

408
00:18:14,019 --> 00:18:15,220
es que aquí

409
00:18:15,220 --> 00:18:16,960
si o si

410
00:18:16,960 --> 00:18:23,210
vale, pues entonces

411
00:18:23,210 --> 00:18:25,849
está claro que esto funcionaría

412
00:18:25,849 --> 00:18:27,390
¿no? porque esto, ¿qué es lo que va a hacer?

413
00:18:27,930 --> 00:18:29,970
por ejemplo, le ponemos 2 elevado a 3

414
00:18:29,970 --> 00:18:31,869
pues la primera vez que entra

415
00:18:31,869 --> 00:18:33,349
como no es 0

416
00:18:33,349 --> 00:18:35,509
hace a por

417
00:18:35,509 --> 00:18:37,670
y ahora hace la segunda llamada

418
00:18:37,670 --> 00:18:40,150
con b una menor

419
00:18:40,150 --> 00:18:41,930
entonces el a por se queda aquí

420
00:18:41,930 --> 00:18:42,529
como a la espera

421
00:18:42,529 --> 00:18:45,869
a la espera de que se resuelva el potencia

422
00:18:45,869 --> 00:18:47,450
con b menos 1

423
00:18:47,450 --> 00:18:50,650
potencia vuelve a entrar pero con b menos 1

424
00:18:50,650 --> 00:18:51,849
como sigue sin ser 0

425
00:18:51,849 --> 00:18:54,430
hace otro a por que se acumula

426
00:18:54,430 --> 00:18:56,890
la anterior y se vuelve a llamar

427
00:18:56,890 --> 00:18:58,809
pero con un exponente menor

428
00:18:58,809 --> 00:19:00,450
entonces a lo mejor

429
00:19:00,450 --> 00:19:01,589
si b es igual a 3

430
00:19:01,589 --> 00:19:04,849
pues habrá necesitado ser llamado 3 veces

431
00:19:04,849 --> 00:19:06,630
y cada vez que ha sido

432
00:19:06,630 --> 00:19:08,869
llamado pues se ha acumulado

433
00:19:08,869 --> 00:19:09,609
hay un a por

434
00:19:09,609 --> 00:19:10,710
¿vale?

435
00:19:12,329 --> 00:19:12,809
entonces

436
00:19:12,809 --> 00:19:17,720
es

437
00:19:17,720 --> 00:19:20,539
a ver, no es un

438
00:19:20,539 --> 00:19:22,420
bucle de programación, pero es un bucle

439
00:19:22,420 --> 00:19:24,460
en el sentido de que es algo que se hace varias veces

440
00:19:24,460 --> 00:19:25,880
¿qué se hace varias veces?

441
00:19:26,259 --> 00:19:27,299
llamar a este método

442
00:19:27,299 --> 00:19:29,740
varias veces se llama a este método

443
00:19:29,740 --> 00:19:32,420
y cada vez que llamas al método

444
00:19:32,420 --> 00:19:34,299
hay otro

445
00:19:34,299 --> 00:19:36,039
arriba que está esperando que tú acabes

446
00:19:36,039 --> 00:19:38,119
la primera llamada a potencia

447
00:19:38,119 --> 00:19:40,500
que te llama con 2 elevado a 3, por ejemplo

448
00:19:40,500 --> 00:19:43,500
vamos a hacer el main para

449
00:19:43,500 --> 00:19:47,440
vamos a hacer el

450
00:19:47,440 --> 00:19:48,640
main

451
00:19:48,640 --> 00:19:57,349
vamos a ponerle

452
00:19:57,349 --> 00:19:59,029
aquí un siso para verlo

453
00:19:59,029 --> 00:19:59,670
al menos

454
00:19:59,670 --> 00:20:36,470
efectivamente

455
00:20:36,470 --> 00:20:39,940
y el punto y coma no

456
00:20:39,940 --> 00:20:42,400
por ejemplo, vamos a ejecutarlo

457
00:20:42,400 --> 00:20:44,779
bueno, le he puesto

458
00:20:44,779 --> 00:20:46,700
antes de que se vuelva a llamar a sí mismo

459
00:20:46,700 --> 00:20:48,519
le he dicho, voy a llamar a potencia otra vez

460
00:20:48,519 --> 00:20:50,920
para lo que vale en ese momento A y B

461
00:20:50,920 --> 00:20:54,890
muy grande tiene que ser

462
00:20:54,890 --> 00:20:56,490
de hecho

463
00:20:56,490 --> 00:20:58,369
va a desbordar antes el tamaño del log

464
00:20:58,369 --> 00:20:59,130
que la rama

465
00:20:59,130 --> 00:21:01,730
Con lo cual eso no da error

466
00:21:01,730 --> 00:21:04,089
Sino que simplemente se pierde el significado del número

467
00:21:04,089 --> 00:21:06,470
Vale, entonces si llamamos ahora

468
00:21:06,470 --> 00:21:08,910
A matemáticas

469
00:21:08,910 --> 00:21:10,849
Punto potencia

470
00:21:10,849 --> 00:21:13,170
Para 2 elevado a 3

471
00:21:13,170 --> 00:21:15,490
Y bueno, lo mostramos

472
00:21:15,490 --> 00:21:16,529
Porque si no lo mostramos

473
00:21:16,529 --> 00:21:17,769
Así para que

474
00:21:17,769 --> 00:21:21,250
Es así

475
00:21:21,250 --> 00:21:24,750
Madre mía, ya

476
00:21:24,750 --> 00:21:26,130
Vamos teniendo años todos

477
00:21:26,130 --> 00:21:28,490
Venga

478
00:21:28,490 --> 00:21:34,609
¿Veis? Primero, la primera llamada

479
00:21:34,609 --> 00:21:36,650
que se hace, pues para 2 elevado a 3

480
00:21:36,650 --> 00:21:38,589
y este ya hace un a por

481
00:21:38,589 --> 00:21:40,609
y se queda esperando la llamada

482
00:21:40,609 --> 00:21:41,670
para 2 elevado a 2

483
00:21:41,670 --> 00:21:44,730
y luego se queda esperando la llamada

484
00:21:44,730 --> 00:21:45,690
para 2 elevado a 1

485
00:21:45,690 --> 00:21:48,089
hasta que al final ya me devuelve el valor final

486
00:21:48,089 --> 00:21:54,029
8, luego esta es la idea

487
00:21:54,029 --> 00:21:56,190
no es mi objetivo ahora que entendáis la recursividad

488
00:21:56,190 --> 00:21:58,069
del dedillo porque tampoco es tan sencillo

489
00:21:58,069 --> 00:21:59,890
porque lo que está ocurriendo aquí

490
00:21:59,890 --> 00:22:01,670
cada vez que llamas al método

491
00:22:01,670 --> 00:22:03,849
es que un método se queda a medias

492
00:22:03,849 --> 00:22:05,769
el primero empieza

493
00:22:05,769 --> 00:22:07,470
su código, B3

494
00:22:07,470 --> 00:22:10,130
entro por aquí, hago el system out

495
00:22:10,130 --> 00:22:12,009
hago a por potencia

496
00:22:12,009 --> 00:22:13,910
y me quedo cruzado de brazos

497
00:22:13,910 --> 00:22:15,910
sin terminar, porque ahora tiene que

498
00:22:15,910 --> 00:22:17,470
terminar el potencia para

499
00:22:17,470 --> 00:22:19,730
B2, potencia

500
00:22:19,730 --> 00:22:21,809
para B2, que ya tiene al de B3

501
00:22:21,809 --> 00:22:24,029
esperando arriba, al de B2

502
00:22:24,029 --> 00:22:25,309
él lo llama

503
00:22:25,309 --> 00:22:27,049
voy por el else

504
00:22:27,049 --> 00:22:29,150
tengo que poner una por

505
00:22:29,150 --> 00:22:32,309
hay, tengo que llamar a potencia para b igual a 1

506
00:22:32,309 --> 00:22:34,490
pues otro segundo que se ha quedado a medias

507
00:22:34,490 --> 00:22:36,210
lo que tenemos esperando al primer potencia

508
00:22:36,210 --> 00:22:37,349
que era para b igual a 3

509
00:22:37,349 --> 00:22:40,529
que estáis medias esperando que le den el valor para multiplicarlo por a

510
00:22:40,529 --> 00:22:42,529
luego tenemos esperando

511
00:22:42,529 --> 00:22:44,509
al segundo potencia para b igual a 2

512
00:22:44,509 --> 00:22:45,769
que estáis esperando

513
00:22:45,769 --> 00:22:47,950
al otro potencia

514
00:22:47,950 --> 00:22:49,910
para multiplicarlo por su propio a

515
00:22:49,910 --> 00:22:52,410
así hasta el último potencia

516
00:22:52,410 --> 00:22:53,109
para 0

517
00:22:53,109 --> 00:22:54,849
que se ya hace el retun

518
00:22:54,849 --> 00:22:56,930
veis, por eso aquí

519
00:22:56,930 --> 00:22:59,549
no me aparece llamando a potencia

520
00:22:59,549 --> 00:23:00,349
para 2, 1

521
00:23:00,349 --> 00:23:03,190
porque llamando a potencia para 2, 1

522
00:23:03,190 --> 00:23:04,869
para 2, 0, perdón

523
00:23:04,869 --> 00:23:07,349
claro, no me aparece

524
00:23:07,349 --> 00:23:09,269
para 2, 0, porque cuando ya llamamos

525
00:23:09,269 --> 00:23:11,289
a potencia para 2, 0, con el 0 ya ha entrado

526
00:23:11,289 --> 00:23:13,190
aquí, ya está, me devuelve el 1 y ya se va

527
00:23:13,190 --> 00:23:15,210
haciendo la multiplicación, luego aquí

528
00:23:15,210 --> 00:23:17,529
que está ocurriendo en la rama, aunque no lo veamos

529
00:23:17,529 --> 00:23:19,210
que cada vez

530
00:23:19,210 --> 00:23:19,589
que

531
00:23:19,589 --> 00:23:22,130
la máquina virtual

532
00:23:22,130 --> 00:23:24,609
llama un potencia

533
00:23:24,609 --> 00:23:26,170
el otro se queda esperando

534
00:23:26,170 --> 00:23:35,789
Y como se queda esperando, ¿dónde estaba el famoso, recordáis de sistemas operativos o de por ahí, el registro contador de programa?

535
00:23:37,250 --> 00:23:38,109
Os suena.

536
00:23:38,630 --> 00:23:44,990
El contador de programa es un registro interno de la CPU que te dice la dirección de la sentencia que estás ejecutando.

537
00:23:46,190 --> 00:23:50,710
Entonces, aquí estamos ejecutando este método, pero saltamos a este.

538
00:23:50,710 --> 00:23:53,210
Pero no podemos perder la dirección del otro

539
00:23:53,210 --> 00:23:54,609
Porque cuando este haya terminado

540
00:23:54,609 --> 00:23:56,549
Hay que volver al otro para multiplicar por el A

541
00:23:56,549 --> 00:23:58,950
Ahora, cuando este llamemos

542
00:23:58,950 --> 00:23:59,890
Este entrará

543
00:23:59,890 --> 00:24:01,710
Y volverá a llamar al otro

544
00:24:01,710 --> 00:24:03,509
Pero no podemos perder la dirección de este

545
00:24:03,509 --> 00:24:06,529
Porque cuando el termine hay que multiplicar por el A del de arriba

546
00:24:06,529 --> 00:24:08,910
Luego se van metiendo en una pila

547
00:24:08,910 --> 00:24:09,710
De la RAM

548
00:24:09,710 --> 00:24:12,069
Un montón de contadores de programa

549
00:24:12,069 --> 00:24:13,150
Un montón de contadores

550
00:24:13,150 --> 00:24:15,650
Para que cada vez que acaba una versión potencia

551
00:24:15,650 --> 00:24:17,829
Poderme ir a la de arriba que estaba ahí esperando

552
00:24:17,829 --> 00:24:18,509
Que yo acabara

553
00:24:18,509 --> 00:24:19,789
si saturas la caché no pasa nada

554
00:24:19,789 --> 00:24:22,910
entonces

555
00:24:22,910 --> 00:24:24,990
sí, eso creo

556
00:24:24,990 --> 00:24:26,430
vale, entonces aquí

557
00:24:26,430 --> 00:24:30,849
sí, pero es que me da lo mismo

558
00:24:30,849 --> 00:24:32,769
que me da igual

559
00:24:32,769 --> 00:24:34,890
en fin, conclusión

560
00:24:34,890 --> 00:24:37,750
vale, pues

561
00:24:37,750 --> 00:24:40,849
bueno, pues entonces

562
00:24:40,849 --> 00:24:45,269
bueno, retomemos

563
00:24:45,269 --> 00:24:47,509
para qué hemos contado todo este rollo

564
00:24:47,509 --> 00:24:49,390
de métodos recursivos

565
00:24:49,390 --> 00:24:53,450
que tened ahí presente que existe esta forma de programar

566
00:24:53,450 --> 00:24:54,589
cuando el problema lo admite.

567
00:24:55,329 --> 00:24:56,809
Pues para provocar un error.

568
00:24:57,190 --> 00:24:58,950
Son fáciles de programar, como veis,

569
00:24:59,009 --> 00:25:00,829
una vez que he identificado la relación recursiva.

570
00:25:01,329 --> 00:25:02,630
Es facilísimo de programar,

571
00:25:03,569 --> 00:25:07,609
pero si yo cometo un error, lo pago pues muy caro.

572
00:25:08,250 --> 00:25:15,069
Por ejemplo, vamos a, aprovechando el caso de Ana,

573
00:25:16,190 --> 00:25:17,589
vamos a pasarle un B negativo.

574
00:25:17,589 --> 00:25:19,710
o sea se han hecho una validación

575
00:25:19,710 --> 00:25:21,250
de datos mal hecha

576
00:25:21,250 --> 00:25:23,529
entonces nosotros hemos llegado a este

577
00:25:23,529 --> 00:25:24,930
punto del programa

578
00:25:24,930 --> 00:25:27,349
hemos llegado a este main

579
00:25:27,349 --> 00:25:29,250
aquí, a llamar a potencia

580
00:25:29,250 --> 00:25:31,210
y no hemos validado que

581
00:25:31,210 --> 00:25:33,930
esto sea positivo

582
00:25:33,930 --> 00:25:35,490
porque esto no me debería valer para números

583
00:25:35,490 --> 00:25:37,150
negativos, pero para números negativos

584
00:25:37,150 --> 00:25:39,309
no eso es lo que funciona, es uno entre

585
00:25:39,309 --> 00:25:41,029
y luego hago eso

586
00:25:41,029 --> 00:25:43,269
luego este método solo me funciona

587
00:25:43,269 --> 00:25:45,230
si es positivo, si es negativo

588
00:25:45,230 --> 00:25:45,750
No tiene sentido.

589
00:25:45,890 --> 00:25:48,069
Bueno, yo no he hecho bien la validación de datos aquí.

590
00:25:49,970 --> 00:25:50,369
¿Vale?

591
00:25:50,549 --> 00:25:52,849
Y le voy a dar un número negativo.

592
00:25:54,549 --> 00:25:54,950
¿Vale?

593
00:25:54,990 --> 00:25:55,910
2 elevado a menos 3.

594
00:25:56,950 --> 00:25:59,210
Entonces, vamos a ejecutar esto.

595
00:26:05,309 --> 00:26:07,430
Entonces, primero ha estado un montón de rato.

596
00:26:10,089 --> 00:26:11,029
Pero un huevo.

597
00:26:11,609 --> 00:26:13,250
Ahí, popopopopopopopopopopopo.

598
00:26:13,309 --> 00:26:14,650
Todo esto son llamadas recursivas.

599
00:26:15,170 --> 00:26:17,309
En las que ha ido bajando el valor del b.

600
00:26:18,109 --> 00:26:18,849
Los ha ido bajando.

601
00:26:18,849 --> 00:26:19,990
Pa, pa, pa, pa, pa, pa, pa, pa.

602
00:26:19,990 --> 00:26:20,750
Menos 3, 3, 5.

603
00:26:20,829 --> 00:26:21,430
Menos 3, 3, 6.

604
00:26:21,490 --> 00:26:22,210
Menos 3, 3, 7.

605
00:26:22,529 --> 00:26:24,950
¿Qué pasa? Que jamás va a llegar a cero, lógicamente.

606
00:26:25,349 --> 00:26:27,009
Entonces, como jamás va a llegar a cero,

607
00:26:27,750 --> 00:26:29,809
nunca jamás va a salir la recursión.

608
00:26:30,329 --> 00:26:31,589
Nunca jamás va a salir por aquí.

609
00:26:32,210 --> 00:26:32,569
Nunca.

610
00:26:33,029 --> 00:26:34,750
Porque como nunca va a llegar a cero,

611
00:26:35,809 --> 00:26:37,549
luego esto es una recursión que no termina.

612
00:26:38,509 --> 00:26:41,210
Puede ser un fallo de que yo me he equivocado haciendo esto

613
00:26:41,210 --> 00:26:43,890
y aquí en lugar de b igual a cero me he equivocado

614
00:26:43,890 --> 00:26:46,829
y he puesto un b distinto y me he equivocado por una errata,

615
00:26:46,829 --> 00:26:50,109
con lo cual nunca va a llegar a salir de la recursión.

616
00:26:50,109 --> 00:26:52,910
o puede ser porque no he hecho bien la validación

617
00:26:52,910 --> 00:26:54,349
de datos, por lo que sea

618
00:26:54,349 --> 00:26:56,650
el problema es

619
00:26:56,650 --> 00:26:58,609
que si una función recursiva no termina

620
00:26:58,609 --> 00:27:00,450
no termina, se está ahí primero un buen rato

621
00:27:00,450 --> 00:27:02,410
llamando, llamando, llamando

622
00:27:02,410 --> 00:27:04,150
y llega un momento en que ya, pam

623
00:27:04,150 --> 00:27:06,650
la pila de contadores de programa

624
00:27:06,650 --> 00:27:07,210
salta

625
00:27:07,210 --> 00:27:10,349
y te dice, error de

626
00:27:10,349 --> 00:27:12,150
te has cargado la pila

627
00:27:12,150 --> 00:27:14,549
bueno, pues esto no es una excepción

628
00:27:14,549 --> 00:27:15,630
esto es un error

629
00:27:15,630 --> 00:27:18,470
y también, sí, bueno, porque

630
00:27:18,470 --> 00:27:21,029
en la traza, que dificilito sois

631
00:27:21,029 --> 00:27:22,730
vale, porque en la traza

632
00:27:22,730 --> 00:27:24,930
aparece excepción, pero el objeto

633
00:27:24,930 --> 00:27:26,869
que se ha lanzado es un objeto de tipo

634
00:27:26,869 --> 00:27:28,470
error, que hereda de error

635
00:27:28,470 --> 00:27:30,269
que a su vez hereda de throwable

636
00:27:30,269 --> 00:27:32,910
luego de throwable hay excepciones

637
00:27:32,910 --> 00:27:34,829
errores, ambas pueden ser lanzadas

638
00:27:34,829 --> 00:27:36,670
y los errores nos pueden

639
00:27:36,670 --> 00:27:38,710
aparecer a veces, pero se asocian

640
00:27:38,710 --> 00:27:41,009
conceptualmente a situaciones más raras

641
00:27:41,009 --> 00:27:42,650
entonces hombre, yo no debería

642
00:27:42,650 --> 00:27:43,430
capturar esto

643
00:27:43,430 --> 00:27:45,930
porque si mi programa

644
00:27:45,930 --> 00:27:48,329
le pasa esto, es que lo he hecho fatal

645
00:27:48,329 --> 00:27:50,509
Entonces que pete

646
00:27:50,509 --> 00:27:51,589
Y entonces yo ya lo cambio

647
00:27:51,589 --> 00:27:54,089
No, la idea no es darle una salida

648
00:27:54,089 --> 00:27:56,130
Pero aún así

649
00:27:56,130 --> 00:27:58,490
Entiendo

650
00:27:58,490 --> 00:27:59,809
Que

651
00:27:59,809 --> 00:28:07,460
Si yo

652
00:28:07,460 --> 00:28:10,539
Eh

653
00:28:10,539 --> 00:28:12,420
Capturar

654
00:28:12,420 --> 00:28:15,519
Trogable a las secas

655
00:28:15,519 --> 00:28:17,200
No sé

656
00:28:17,200 --> 00:28:18,799
Eh, vamos a

657
00:28:18,799 --> 00:28:21,680
No, yo, tienes que capturar una excepción

658
00:28:21,680 --> 00:28:23,180
Entonces voy, vamos a capturar

659
00:28:23,180 --> 00:28:25,019
Error

660
00:28:25,019 --> 00:28:26,640
Vale

661
00:28:26,640 --> 00:28:30,000
Para que capture cualquier error que salga ahí

662
00:28:30,000 --> 00:28:36,460
Y el programa seguiría

663
00:28:36,460 --> 00:28:38,039
Tranquilamente, pero seguiría

664
00:28:38,039 --> 00:28:39,440
En ese momento con la pila desbordada

665
00:28:39,440 --> 00:28:40,859
Lo que pasa es que luego en cuanto has

666
00:28:40,859 --> 00:28:43,319
Acabado la recursión la has limpiado

667
00:28:43,319 --> 00:28:43,759
Claro

668
00:28:43,759 --> 00:28:53,019
Vale, entonces

669
00:28:53,019 --> 00:28:57,559
Pues bueno, ha estado ahí un montonazo

670
00:28:57,559 --> 00:28:59,119
Muchos intentos, muchos intentos

671
00:28:59,119 --> 00:29:00,200
Cuando ha desbordado

672
00:29:00,200 --> 00:29:02,299
lo ha capturado

673
00:29:02,299 --> 00:29:03,339
y el programa ha seguido

674
00:29:03,339 --> 00:29:06,740
pero los errores normalmente no los

675
00:29:06,740 --> 00:29:07,839
capturamos

676
00:29:07,839 --> 00:29:10,559
en tiempo de desarrollo la idea es que te salgan

677
00:29:10,559 --> 00:29:12,319
y dices, uy es que he programado mal esto

678
00:29:12,319 --> 00:29:13,480
y lo cambias para que no

679
00:29:13,480 --> 00:29:15,380
pero se podrían capturar

680
00:29:15,380 --> 00:29:19,259
y ahora ya sí que sí

681
00:29:19,259 --> 00:29:27,500
podría

682
00:29:27,500 --> 00:29:29,700
haber capturado este específicamente

683
00:29:29,700 --> 00:29:31,799
no lo he puesto por vaguería

684
00:29:31,799 --> 00:29:34,259
eso

685
00:29:34,259 --> 00:29:38,359
vale

686
00:29:38,359 --> 00:29:40,259
pues ahora ya sí que de excepciones errores

687
00:29:40,259 --> 00:29:45,180
todo lo que necesitamos, queremos, interesa saber, pues estaría.