1
00:00:00,000 --> 00:00:18,879
Bueno, antes de completar con los flow, add, double y los boolean básicos, vamos a revisar por encima lo que dijimos de char, que lo tenemos en el ejemplo de ayer, que fue cuando nos fuimos ya al final pitando, ¿verdad? Con lo de la letra mayúscula, minúscula, etcétera, etcétera, ¿vale?

2
00:00:18,879 --> 00:00:33,740
Entonces, de char recordamos rápidamente que una variable char admite un único carácter. La asignación se puede hacer directa.

3
00:00:33,740 --> 00:00:50,899
La asignación se puede hacer con el carácter entre comillas

4
00:00:50,899 --> 00:00:55,500
o se puede hacer asignando un número entero

5
00:00:55,500 --> 00:00:58,020
y entonces ya sabemos que en el char

6
00:00:58,020 --> 00:01:01,700
se guardan el carácter de la tabla

7
00:01:01,700 --> 00:01:03,659
así, silencio, ¿vale?

8
00:01:04,680 --> 00:01:07,560
Entonces, el hecho de que en los char

9
00:01:07,560 --> 00:01:11,040
puedan ir tanto, silencio, enteros

10
00:01:11,040 --> 00:01:15,400
como char básicos, permite que podamos hacer sumas y restas

11
00:01:15,400 --> 00:01:19,219
con char, porque también tiene enteros dentro, que es la codificación entera

12
00:01:19,219 --> 00:01:23,379
del ASCII, y eso nos permite hacer, pues, tonterías

13
00:01:23,379 --> 00:01:25,620
como esta, ¿vale? Si yo tenía una letra

14
00:01:25,620 --> 00:01:31,319
a esta letra, como en realidad lo que tiene dentro es el

15
00:01:31,319 --> 00:01:34,640
entero, que según la tabla ASCII codifica B

16
00:01:34,640 --> 00:01:36,680
si le resto 32

17
00:01:36,680 --> 00:01:38,700
lo que se queda

18
00:01:38,700 --> 00:01:40,579
adentro es el

19
00:01:40,579 --> 00:01:42,620
entero que en la

20
00:01:42,620 --> 00:01:44,480
tabla ASCII codifica la mayúscula

21
00:01:44,480 --> 00:01:46,939
porque entre minúscula y mayúscula hay una diferencia de 32

22
00:01:46,939 --> 00:01:47,739
¿vale?

23
00:01:48,260 --> 00:01:49,939
y lo comprobábamos

24
00:01:49,939 --> 00:01:52,140
haciendo el system out println

25
00:01:52,140 --> 00:01:54,500
y aquí fue cuando nos fuimos

26
00:01:54,500 --> 00:01:56,099
ya deprisa y corriendo, vamos a

27
00:01:56,099 --> 00:01:58,640
dejarlo para que no se quede así tan deprisa

28
00:01:58,640 --> 00:02:00,340
y corriendo y luego ya vamos al float y al double

29
00:02:00,340 --> 00:02:02,719
¿vale? recordáis esto de ayer

30
00:02:02,719 --> 00:02:02,920
¿no?

31
00:02:07,040 --> 00:02:12,479
Sí, sí, sí, tú puedes hacer, pero no sería next int, sería otra cosa, ¿vale?

32
00:02:12,580 --> 00:02:18,219
Vamos, podemos incorporarlo aquí para que este programa sea poner en mayúscula la letra que tú quieras, ¿vale?

33
00:02:18,259 --> 00:02:19,539
Pero vamos a completarlo antes.

34
00:02:20,439 --> 00:02:25,300
Entonces, aquí, ¿qué dos problemillas nos encontrábamos para este programa?

35
00:02:26,379 --> 00:02:26,900
¿Qué?

36
00:02:28,280 --> 00:02:33,479
Para restar 32 a este char, yo tenía que hacer menos 32.

37
00:02:33,479 --> 00:02:36,060
aquí otra vez

38
00:02:36,060 --> 00:02:38,180
nos aparecía el problema

39
00:02:38,180 --> 00:02:41,020
de esa conversión automática

40
00:02:41,020 --> 00:02:42,979
entonces puse esa situación a propósito

41
00:02:42,979 --> 00:02:43,800
a propósito

42
00:02:43,800 --> 00:02:46,539
para que viéramos que es otra situación

43
00:02:46,539 --> 00:02:47,860
en la que Java necesita

44
00:02:47,860 --> 00:02:49,319
promocionar variables

45
00:02:49,319 --> 00:02:50,800
aquí tenemos

46
00:02:50,800 --> 00:02:52,979
esto que es char

47
00:02:52,979 --> 00:02:56,680
al que yo puedo sumar y restar

48
00:02:56,680 --> 00:02:58,159
porque en el fondo es un int

49
00:02:58,159 --> 00:03:00,719
y aquí tengo el 32

50
00:03:00,719 --> 00:03:30,139
Cuando la máquina virtual de Java ejecuta esto, recordad que cuando hay una sucesión de cifras, él construye un int, construye un int, vale, entonces como él aquí tiene char e int, el char le añade ceros para que sea ese mismo char pero en int, en 32 bits, con lo cual no nos dejaba guardarlo en letra mayúscula si letra mayúscula se guardaba como char, ¿verdad?

51
00:03:30,139 --> 00:03:32,460
esto es lo que estábamos viendo cuando nos íbamos ayer

52
00:03:32,460 --> 00:03:34,379
si lo guardamos

53
00:03:34,379 --> 00:03:35,020
como char

54
00:03:35,020 --> 00:03:37,400
no nos deja

55
00:03:37,400 --> 00:03:39,020
porque

56
00:03:39,020 --> 00:03:42,199
esto es un int

57
00:03:42,199 --> 00:03:44,340
decíamos, no pasa nada

58
00:03:44,340 --> 00:03:46,240
int y char son intercambiables

59
00:03:46,240 --> 00:03:48,639
pues venga

60
00:03:48,639 --> 00:03:50,020
como int ya si me deja

61
00:03:50,020 --> 00:03:52,840
y ahora cuando mostrábamos

62
00:03:52,840 --> 00:03:53,460
la letra

63
00:03:53,460 --> 00:03:57,699
vamos a mostrar la letra mayúscula

64
00:03:57,699 --> 00:03:59,979
ejecutábamos esto

65
00:03:59,979 --> 00:04:10,780
no nos sacaba

66
00:04:10,780 --> 00:04:13,259
lo último que nos muestra

67
00:04:13,259 --> 00:04:15,400
es

68
00:04:15,400 --> 00:04:17,459
el último system out

69
00:04:17,459 --> 00:04:19,319
que es el último del programa, este

70
00:04:19,319 --> 00:04:21,560
no nos muestra la B mayúscula

71
00:04:21,560 --> 00:04:22,439
que fallaba aquí

72
00:04:22,439 --> 00:04:25,519
pues fallaba lo que habíamos dicho

73
00:04:25,519 --> 00:04:26,620
unas horitas antes

74
00:04:26,620 --> 00:04:29,199
y es que yo una letra cualquiera

75
00:04:29,199 --> 00:04:30,040
esta letra B

76
00:04:30,040 --> 00:04:33,699
la puedo guardar en char o la puedo guardar en int

77
00:04:33,699 --> 00:04:34,639
¿vale? es decir

78
00:04:34,639 --> 00:04:36,519
yo a led

79
00:04:36,519 --> 00:04:37,959
puedo hacer esto

80
00:04:37,959 --> 00:04:39,860
y puedo hacer esto

81
00:04:39,860 --> 00:04:47,959
¿vale?

82
00:04:49,100 --> 00:04:50,740
las dos cosas son válidas

83
00:04:50,740 --> 00:04:52,560
porque un char

84
00:04:52,560 --> 00:04:55,439
también es el int dentro que codifica

85
00:04:55,439 --> 00:04:57,459
esta b

86
00:04:57,459 --> 00:04:59,120
la puedo guardar en char

87
00:04:59,120 --> 00:05:01,819
o esta b la puedo guardar en int

88
00:05:01,819 --> 00:05:02,980
me da lo mismo

89
00:05:02,980 --> 00:05:05,660
¿qué implicación tiene guardarla

90
00:05:05,660 --> 00:05:06,360
en char o en int?

91
00:05:06,740 --> 00:05:08,579
cuando la voy a mostrar por consola

92
00:05:08,579 --> 00:05:10,639
si nosotros ahora

93
00:05:10,639 --> 00:05:13,279
mostramos letra

94
00:05:13,279 --> 00:05:15,079
no lo voy a ejecutar

95
00:05:15,079 --> 00:05:16,980
porque tenemos este programa, tantas cosas metidas

96
00:05:16,980 --> 00:05:19,360
no se ve claro, si ejecutamos letra

97
00:05:19,360 --> 00:05:20,360
creedme

98
00:05:20,360 --> 00:05:23,100
si os digo que entonces mostrará la B

99
00:05:23,100 --> 00:05:24,680
¿por qué?

100
00:05:25,079 --> 00:05:26,399
porque el system out

101
00:05:26,399 --> 00:05:28,980
mira como está declarada la variable

102
00:05:28,980 --> 00:05:31,300
y está declarada como char

103
00:05:31,300 --> 00:05:32,899
entonces tú

104
00:05:32,899 --> 00:05:34,540
lo que te interesa es el char

105
00:05:34,540 --> 00:05:36,160
y te muestra B

106
00:05:36,160 --> 00:05:38,160
esto es de hace un par de días

107
00:05:38,160 --> 00:05:39,720
pero sin embargo

108
00:05:39,720 --> 00:05:41,420
yo ahora muestro letra 1

109
00:05:41,420 --> 00:05:46,100
pues si yo muestro letra 1

110
00:05:46,100 --> 00:05:47,980
no va a mostrar la B

111
00:05:47,980 --> 00:05:50,660
va a mostrar el numerito entero

112
00:05:50,660 --> 00:05:52,759
que según la tabla ASCII codifica la B

113
00:05:52,759 --> 00:05:54,600
¿por qué? porque el system

114
00:05:54,600 --> 00:05:56,379
out println mira esto

115
00:05:56,379 --> 00:05:58,459
y dice esto como está declarado o como int

116
00:05:58,459 --> 00:06:00,500
ah, entonces te interesa su versión

117
00:06:00,500 --> 00:06:02,579
entera, entonces como te interesa

118
00:06:02,579 --> 00:06:04,680
su versión entera, te muestro el numerito

119
00:06:04,680 --> 00:06:06,160
que la tabla ASCII codifica la B

120
00:06:06,160 --> 00:06:08,160
entonces esa es la diferencia entre

121
00:06:08,160 --> 00:06:10,420
declarar como char

122
00:06:10,420 --> 00:06:12,240
o como int y luego asignar un char

123
00:06:12,240 --> 00:06:14,579
que a la hora de mostrar el valor

124
00:06:14,579 --> 00:06:16,220
pues

125
00:06:16,220 --> 00:06:18,639
me muestra o su versión

126
00:06:18,639 --> 00:06:20,339
entera de la tabla ASCII

127
00:06:20,339 --> 00:06:22,740
o su versión char de la tabla ASCII

128
00:06:22,740 --> 00:06:24,579
que hay una

129
00:06:24,579 --> 00:06:26,579
de cada, ¿verdad?

130
00:06:27,199 --> 00:06:28,560
Vale, pues aquí nos está pasando

131
00:06:28,560 --> 00:06:28,980
esto.

132
00:06:30,100 --> 00:06:31,800
Aquí nos está pasando esto.

133
00:06:34,269 --> 00:06:35,870
Que yo aquí, esta letra

134
00:06:35,870 --> 00:06:38,089
menos 32 lo he tenido que guardar

135
00:06:38,089 --> 00:06:39,550
obligatoriamente en int

136
00:06:39,550 --> 00:06:40,990
obligatoriamente

137
00:06:40,990 --> 00:06:43,730
porque si no la asignación no me dejaba

138
00:06:43,730 --> 00:06:45,769
hacerla, si lo paso

139
00:06:45,769 --> 00:06:47,550
al system out, él interpreta

140
00:06:47,550 --> 00:06:49,870
que me interesa la versión int de este carácter

141
00:06:49,870 --> 00:06:51,870
y por eso me saca

142
00:06:51,870 --> 00:06:54,750
el 66

143
00:06:54,750 --> 00:06:57,230
que es la versión int

144
00:06:57,230 --> 00:06:58,750
de la B mayúscula

145
00:06:58,750 --> 00:07:01,610
entonces, ¿cómo puedo

146
00:07:01,610 --> 00:07:02,689
salvar esta situación?

147
00:07:03,889 --> 00:07:05,629
ya lo ponemos ya todos juntos en un programa

148
00:07:05,629 --> 00:07:06,550
¿cómo puedo salvarla?

149
00:07:07,550 --> 00:07:09,310
poniendo el char delante

150
00:07:09,310 --> 00:07:10,750
¿vale?

151
00:07:11,569 --> 00:07:19,449
Entonces, si yo hago esto, esto es hacer una cosa que se llama

152
00:07:19,449 --> 00:07:21,910
casting, que ya nos tendremos que meter en ella más adelante

153
00:07:21,910 --> 00:07:24,089
cuando tengamos que usarla para otras cosas.

154
00:07:25,189 --> 00:07:27,730
Pero que para los char no tendré que usar desde ya.

155
00:07:28,449 --> 00:07:31,649
Si yo tengo un char en versión int y quiero mostrarlo.

156
00:07:32,189 --> 00:07:36,009
Si yo tengo un char en versión int y quiero mostrarlo y quiero

157
00:07:36,009 --> 00:07:39,649
que el system out me muestre la versión char, no la versión int,

158
00:07:39,649 --> 00:07:41,529
Dejo ese in, claro

159
00:07:41,529 --> 00:07:44,029
Y le digo, cuidado, pero no su versión

160
00:07:44,029 --> 00:07:46,170
Como está declarada, no como está declarada

161
00:07:46,170 --> 00:07:47,930
Sino su versión esta

162
00:07:47,930 --> 00:07:49,990
Quiero su versión esta

163
00:07:49,990 --> 00:07:51,750
Entonces, ahora ya sí

164
00:07:51,750 --> 00:07:53,629
Si ejecutamos esto

165
00:07:53,629 --> 00:07:55,910
Pues ahora ya sí que me saca

166
00:07:55,910 --> 00:07:57,209
La B mayúscula, ¿vale?

167
00:07:57,889 --> 00:08:00,110
Lo que tiene esto por dentro

168
00:08:00,110 --> 00:08:01,490
Es lo mismo

169
00:08:01,490 --> 00:08:03,410
Tiene

170
00:08:03,410 --> 00:08:05,970
Lo que la tabla ASCII codifica

171
00:08:05,970 --> 00:08:06,889
La B, tiene lo mismo

172
00:08:06,889 --> 00:08:12,069
La diferencia es cómo me lo muestra el System.out, si como número o como char.

173
00:08:12,689 --> 00:08:14,529
Y eso va a depender de cómo está declarado.

174
00:08:15,910 --> 00:08:20,709
Si está como int y quiero su versión char, pues así, sí o sí.

175
00:08:21,430 --> 00:08:21,610
¿Vale?

176
00:08:22,610 --> 00:08:35,740
Entonces, vale, lo de los char más o menos, las cosas que hemos visto, está más o menos clara, ¿no?

177
00:08:36,620 --> 00:08:39,779
Entonces, tenemos los cuatro tipos de datos de enteros.

178
00:08:39,779 --> 00:08:42,220
El char

179
00:08:42,220 --> 00:08:44,940
Conocemos más o menos

180
00:08:44,940 --> 00:08:47,399
Las casuísticas más interesantes

181
00:08:47,399 --> 00:08:48,340
De cada uno de ellos

182
00:08:48,340 --> 00:08:50,000
En cuanto a promoción automática, etc

183
00:08:50,000 --> 00:08:51,980
Nos falta

184
00:08:51,980 --> 00:08:54,000
Float, Double y Boolean

185
00:08:54,000 --> 00:08:55,840
Pues venga

186
00:08:55,840 --> 00:08:58,399
Vamos a hacer aquí otra clase

187
00:08:58,399 --> 00:09:02,159
Para trabajar con números decimales

188
00:09:02,159 --> 00:09:06,379
Si la vais haciendo vosotros

189
00:09:06,379 --> 00:09:07,220
Pues tendréis ese

190
00:09:07,220 --> 00:09:11,340
Claro, para irlo practicando vosotros es lo mejor, ¿no?

191
00:09:11,820 --> 00:09:14,039
Uy, va, eso está a punto de irse al suelo.

192
00:09:14,779 --> 00:09:15,259
¿Vale?

193
00:09:20,230 --> 00:09:26,700
Venga, pues ahora queremos hacer un programa que haga eso mismo.

194
00:09:27,679 --> 00:09:35,159
A lo mejor multiplicar por 2 un número que yo te dé, pero quiero, ya que trabajé con decimales, no solo con enteros, con decimales.

195
00:09:35,600 --> 00:09:44,480
Pues entonces, ¿qué dos tipos de datos tengo para guardar un número decimal?

196
00:09:44,480 --> 00:09:49,700
Hemos dicho que teníamos dos, el float y el dabble, ¿vale?

197
00:09:52,279 --> 00:10:01,779
Float usa 32 bits para guardar el dato y dabble usa 64 bits.

198
00:10:05,210 --> 00:10:14,690
¿Cuál es la diferencia entre usar 32 o 64? La cantidad de cifras decimales que caben, ¿vale?

199
00:10:14,690 --> 00:10:17,049
el float, no sé si son 7 cifras

200
00:10:17,049 --> 00:10:18,450
decimales, 7 u 8

201
00:10:18,450 --> 00:10:20,669
y el dabble pues

202
00:10:20,669 --> 00:10:22,169
son unas cuantas más

203
00:10:22,169 --> 00:10:24,429
¿vale? la precisión

204
00:10:24,429 --> 00:10:25,889
¿se incluye la parte entera?

205
00:10:26,570 --> 00:10:28,149
si hombre, claro, claro

206
00:10:28,149 --> 00:10:34,159
un millón

207
00:10:34,159 --> 00:10:37,240
a ver, es que esto va con el complemento

208
00:10:37,240 --> 00:10:38,799
a 2, la forma

209
00:10:38,799 --> 00:10:40,799
de, que no sé cuál es

210
00:10:40,799 --> 00:10:41,919
vamos a ver si tuviera

211
00:10:41,919 --> 00:10:44,980
una constante java

212
00:10:44,980 --> 00:10:46,879
para darte el máximo

213
00:10:46,879 --> 00:10:48,019
y el mínimo de

214
00:10:48,019 --> 00:10:50,639
a ver

215
00:10:50,639 --> 00:10:55,629
mira, si que tiene

216
00:10:55,629 --> 00:10:59,379
max value

217
00:10:59,379 --> 00:11:19,179
uy

218
00:11:19,179 --> 00:11:23,649
max value

219
00:11:23,649 --> 00:11:26,250
esto lo hago

220
00:11:26,250 --> 00:11:28,649
solo para ver el mayor y menor

221
00:11:28,649 --> 00:11:30,230
número que se puede

222
00:11:30,230 --> 00:11:32,090
codificar con estos valores

223
00:11:32,090 --> 00:11:34,490
vale, esto me va a

224
00:11:34,490 --> 00:11:36,389
mostrar, esto es un valor que tiene ya java

225
00:11:36,389 --> 00:11:38,409
configurado, que es el mayor valor

226
00:11:38,409 --> 00:11:40,470
float posible y este es el

227
00:11:40,470 --> 00:11:41,909
menor valor float posible

228
00:11:41,909 --> 00:11:44,809
y este es un valor que tiene ya configurado

229
00:11:44,809 --> 00:11:46,470
que es el mayor valor float

230
00:11:46,470 --> 00:11:47,789
double posible y el menor

231
00:11:47,789 --> 00:11:50,409
entonces si ejecutamos esto

232
00:11:50,409 --> 00:11:51,669
para ver cuáles son estos valores

233
00:11:51,669 --> 00:11:57,879
vale

234
00:11:57,879 --> 00:12:03,620
pues el mayor float es

235
00:12:03,620 --> 00:12:05,700
3, esto

236
00:12:05,700 --> 00:12:08,080
por 10 elevado a 38

237
00:12:08,080 --> 00:12:09,940
o sea

238
00:12:09,940 --> 00:12:10,500
mucho

239
00:12:10,500 --> 00:12:14,000
pero como veis solo admite estas cifras

240
00:12:14,000 --> 00:12:15,879
decimales que son

241
00:12:15,879 --> 00:12:16,639
7

242
00:12:16,639 --> 00:12:19,299
sin embargo

243
00:12:19,299 --> 00:12:20,559
el mayor número

244
00:12:20,559 --> 00:12:21,899
de Abel posible

245
00:12:21,899 --> 00:12:24,759
es 1, no sé cuántos

246
00:12:24,759 --> 00:12:27,220
por 10 elevado a 308

247
00:12:27,220 --> 00:12:28,519
que es una barbaridad

248
00:12:28,519 --> 00:12:31,059
como lo está diciendo ahí

249
00:12:31,059 --> 00:12:31,799
lo estoy leyendo de ahí

250
00:12:31,799 --> 00:12:34,639
la anotación científica no la conocéis

251
00:12:34,639 --> 00:12:37,139
la E significa

252
00:12:37,139 --> 00:12:37,919
10 elevado a

253
00:12:37,919 --> 00:12:39,340
¿vale?

254
00:12:41,909 --> 00:12:43,529
¿pero qué mates habéis estudiado vosotros?

255
00:12:43,889 --> 00:12:44,909
¿qué bachillerato habéis estudiado?

256
00:12:45,389 --> 00:12:47,789
¿qué bachillerato habéis estudiado?

257
00:12:47,789 --> 00:12:49,429
es un 10 elevado

258
00:12:49,429 --> 00:12:50,629
es un 10 elevado

259
00:12:50,629 --> 00:12:51,549
y ya está calculado

260
00:12:51,549 --> 00:12:57,490
pero a ver, hay una cultura científica

261
00:12:57,490 --> 00:12:58,350
mínima

262
00:12:58,350 --> 00:13:00,629
el 10 elevado a

263
00:13:00,629 --> 00:13:02,490
pero a ver, en realidad

264
00:13:02,490 --> 00:13:07,070
no nos importa especialmente

265
00:13:07,070 --> 00:13:07,590
pero hombre

266
00:13:07,590 --> 00:13:11,529
si vais a ser programadores

267
00:13:11,529 --> 00:13:12,950
y os vais a meter de lleno en el mundo

268
00:13:12,950 --> 00:13:14,690
la inteligencia artificial y los números

269
00:13:14,690 --> 00:13:15,330
y todo eso

270
00:13:15,330 --> 00:13:19,409
Pues hay ciertas notaciones que si vais conociendo mejor

271
00:13:19,409 --> 00:13:20,309
¿Vale?

272
00:13:21,409 --> 00:13:22,629
Si vais conociendo mejor

273
00:13:22,629 --> 00:13:28,769
Pues esto es un número tocho

274
00:13:28,769 --> 00:13:29,889
10 a la 38

275
00:13:29,889 --> 00:13:31,570
Y este es muy pequeñajo

276
00:13:31,570 --> 00:13:34,809
Porque es 10 elevado a menos 45

277
00:13:34,809 --> 00:13:39,129
Y este es por 10 elevado a menos 324

278
00:13:39,129 --> 00:13:41,169
O sea, es muy enano

279
00:13:41,169 --> 00:13:43,029
Muy enano, ¿vale?

280
00:13:43,029 --> 00:13:48,950
Y como veis, la precisión del float son siete cifras y la del dabble son muchas más.

281
00:13:50,450 --> 00:13:52,789
A ver, no nos importan los detalles.

282
00:13:53,389 --> 00:13:58,330
Lo único que nos importa es que tanto float como dabble son para guardar números con decimales.

283
00:13:59,309 --> 00:14:03,950
Si yo necesito muchísima precisión en mis números, dabble.

284
00:14:04,289 --> 00:14:09,909
Si no necesito tanta precisión con siete cifras, pues floa.

285
00:14:09,909 --> 00:14:12,789
en general no lo sé, la verdad es que esto no sabría

286
00:14:12,789 --> 00:14:14,370
decirlo con mucho criterio

287
00:14:14,370 --> 00:14:16,730
a mí me gusta más el dabble

288
00:14:16,730 --> 00:14:18,850
y supongo

289
00:14:18,850 --> 00:14:20,809
que porque por tradición lo he visto

290
00:14:20,809 --> 00:14:23,110
más, no sé si significa que se usa más

291
00:14:23,110 --> 00:14:25,309
da un poco

292
00:14:25,309 --> 00:14:28,570
igual, igual que sí que os digo que cuando uno

293
00:14:28,570 --> 00:14:30,490
tiene que usar un entero, pone int siempre

294
00:14:30,490 --> 00:14:32,750
por sistema, pues floato dabble

295
00:14:32,750 --> 00:14:34,370
da un poco

296
00:14:34,370 --> 00:14:35,389
igual

297
00:14:35,389 --> 00:14:38,710
¿vale? venga pues entonces

298
00:14:38,710 --> 00:14:41,029
esto que estaba aquí, vamos a quitarlo

299
00:14:41,029 --> 00:14:43,049
ahora

300
00:14:43,049 --> 00:14:46,669
si yo tengo por ejemplo

301
00:14:46,669 --> 00:14:48,350
un número

302
00:14:48,350 --> 00:14:49,509
decimal

303
00:14:49,509 --> 00:14:55,240
lo declaro poniendo el double delante

304
00:14:55,240 --> 00:14:56,779
lógicamente si quiero que sea double

305
00:14:56,779 --> 00:14:59,700
y le puedo asignar un valor

306
00:14:59,700 --> 00:15:01,860
exactamente igual que a los enteros

307
00:15:01,860 --> 00:15:04,539
pues por ejemplo

308
00:15:04,539 --> 00:15:09,590
la 5.7

309
00:15:09,590 --> 00:15:11,029
luego

310
00:15:11,029 --> 00:15:13,070
la coma decimal para java

311
00:15:13,070 --> 00:15:13,769
es el punto

312
00:15:13,769 --> 00:15:16,929
como para la mayoría de los lenguajes de programación

313
00:15:16,929 --> 00:15:19,309
para la mayoría de los lenguajes de programación

314
00:15:19,309 --> 00:15:20,990
la coma decimal es el punto

315
00:15:20,990 --> 00:15:21,509
en realidad

316
00:15:21,509 --> 00:15:26,820
¿vale? y también podría usar

317
00:15:26,820 --> 00:15:28,840
un float para un numerito decimal

318
00:15:28,840 --> 00:15:33,309
¿vale?

319
00:15:34,649 --> 00:15:35,129
pero

320
00:15:35,129 --> 00:15:36,929
aquí pasa

321
00:15:36,929 --> 00:15:39,809
algo similar a lo que nos encontramos

322
00:15:39,809 --> 00:15:41,929
con los indios y los dabels, aquí me ha dado error, ¿por qué?

323
00:15:42,830 --> 00:15:43,870
cuando yo a java

324
00:15:43,870 --> 00:15:46,289
le doy un numerito con un punto

325
00:15:46,289 --> 00:15:48,269
un número decimal, él asume

326
00:15:48,269 --> 00:15:49,309
que por defecto es dabel

327
00:15:49,309 --> 00:15:51,649
entonces aquí lo ha

328
00:15:51,649 --> 00:15:54,610
clavado en dabel, perfecto

329
00:15:54,610 --> 00:15:56,090
dabel cabe en dabel

330
00:15:56,090 --> 00:15:58,090
yo aquí le he dado 7.8

331
00:15:58,090 --> 00:16:00,169
él asume que por defecto es dabel

332
00:16:00,169 --> 00:16:01,690
y lo codifica en 64

333
00:16:01,690 --> 00:16:04,330
pero al revés

334
00:16:04,330 --> 00:16:06,490
porque en los números enteros

335
00:16:06,490 --> 00:16:08,090
él le das 37

336
00:16:08,090 --> 00:16:09,850
y por defecto asume que sí

337
00:16:09,850 --> 00:16:11,029
que es más pequeño que el long

338
00:16:11,029 --> 00:16:12,690
Pues aquí al revés

339
00:16:12,690 --> 00:16:14,169
Si tú das un número decimal

340
00:16:14,169 --> 00:16:16,009
Por defecto asume que es la versión más grande

341
00:16:16,009 --> 00:16:16,570
Que es la label

342
00:16:16,570 --> 00:16:19,789
Por defecto asume que es la grande, la label

343
00:16:19,789 --> 00:16:22,169
Entonces, yo aquí le he puesto

344
00:16:22,169 --> 00:16:23,330
7.8

345
00:16:23,330 --> 00:16:26,190
Él lo construye con 64 bits

346
00:16:26,190 --> 00:16:28,269
¿Y qué ocurre? Que no cabe en float

347
00:16:28,269 --> 00:16:30,190
Pues por eso me da error

348
00:16:30,190 --> 00:16:32,070
De compilación, me dice no cabe

349
00:16:32,070 --> 00:16:34,129
¿Cómo le digo yo? No, no, no

350
00:16:34,129 --> 00:16:36,049
Por favor, construyelo en

351
00:16:36,049 --> 00:16:37,330
32

352
00:16:37,330 --> 00:16:39,409
Pues poniendo una F

353
00:16:39,409 --> 00:16:42,169
poniendo una F

354
00:16:42,169 --> 00:16:42,850
¿vale?

355
00:16:43,529 --> 00:16:44,649
pongo ahí una F

356
00:16:44,649 --> 00:16:46,889
y con esto digo

357
00:16:46,889 --> 00:16:50,870
ojo, construye el número en 32

358
00:16:50,870 --> 00:16:54,029
como cuando le damos una L

359
00:16:54,029 --> 00:16:54,830
a un número entero

360
00:16:54,830 --> 00:16:56,330
le damos una L y le decíamos

361
00:16:56,330 --> 00:16:57,509
construye en 64

362
00:16:57,509 --> 00:16:59,909
porque si no le damos nada

363
00:16:59,909 --> 00:17:00,809
lo construye en 32

364
00:17:00,809 --> 00:17:03,110
pues aquí si no le damos nada

365
00:17:03,110 --> 00:17:05,769
lo construye en double, 64

366
00:17:05,769 --> 00:17:07,990
y si le queremos decir

367
00:17:07,990 --> 00:17:08,990
que lo construya en 32

368
00:17:08,990 --> 00:17:10,829
que es el más pequeño, hay que decirlo en f

369
00:17:10,829 --> 00:17:11,849
hay que ponerle en f

370
00:17:11,849 --> 00:17:16,609
ya sabía yo que había alguna razón

371
00:17:16,609 --> 00:17:18,490
por la que siempre usamos dabel

372
00:17:18,490 --> 00:17:22,170
para no arrastrar la f

373
00:17:22,170 --> 00:17:23,569
yo le quiero dar un valor calcado

374
00:17:23,569 --> 00:17:28,470
bueno, para no ocupar tanta memoria

375
00:17:28,470 --> 00:17:32,549
imagínate que tuvieras una aplicación

376
00:17:32,549 --> 00:17:34,430
crítica con tropecientos mil números

377
00:17:34,430 --> 00:17:36,470
pues es que es la mitad de memoria

378
00:17:36,470 --> 00:17:38,630
tal cual, porque son 32 bits

379
00:17:38,630 --> 00:17:40,670
por cada número en lugar de 64

380
00:17:40,670 --> 00:17:42,730
¿Vale? Entonces

381
00:17:42,730 --> 00:17:44,750
Ya no solo que el número ocupe menos

382
00:17:44,750 --> 00:17:47,109
Sino que la operativa con esos números

383
00:17:47,109 --> 00:17:48,009
Va a ser más rápida

384
00:17:48,009 --> 00:17:50,990
Entonces, por cuestiones de rendimiento

385
00:17:50,990 --> 00:17:53,549
El float rinde mejor

386
00:17:53,549 --> 00:17:54,849
Por lo que ocupa

387
00:17:54,849 --> 00:17:58,009
Pero a la hora de escribir código

388
00:17:58,009 --> 00:17:59,930
Es más cómodo

389
00:17:59,930 --> 00:18:00,990
Cuando tienes que arrastrar la F

390
00:18:00,990 --> 00:18:02,829
¿Es crítico el rendimiento?

391
00:18:02,890 --> 00:18:04,470
Depende, si en tu aplicación lo es

392
00:18:04,470 --> 00:18:06,109
Y en tu hardware lo es

393
00:18:06,109 --> 00:18:09,069
Pero si no lo es, pues es más cómodo

394
00:18:09,069 --> 00:18:09,869
Trabajar con W

395
00:18:09,869 --> 00:18:17,220
Bueno, pues igual que hemos hecho con los enteros

396
00:18:17,220 --> 00:18:18,880
Uno puede operar

397
00:18:18,880 --> 00:18:20,920
Y asignar

398
00:18:20,920 --> 00:18:23,440
Por ejemplo, vamos a

399
00:18:23,440 --> 00:18:25,539
A otro numerito 3

400
00:18:25,539 --> 00:18:28,299
Le vamos a dar el resultado de

401
00:18:28,299 --> 00:18:32,000
Dividir num1 entre num2

402
00:18:32,000 --> 00:18:33,240
Vale

403
00:18:33,240 --> 00:18:35,500
Estupendo

404
00:18:35,500 --> 00:18:37,640
Num1 entre num2

405
00:18:37,640 --> 00:18:39,200
Ahora este operador

406
00:18:39,200 --> 00:18:41,519
Ya no es el cociente

407
00:18:41,519 --> 00:18:44,460
porque el cociente

408
00:18:44,460 --> 00:18:46,119
entre números decimales no existe

409
00:18:46,119 --> 00:18:48,779
el cociente es sólo entre enteros

410
00:18:48,779 --> 00:18:50,140
tú un entero

411
00:18:50,140 --> 00:18:52,119
tienes cociente y resto

412
00:18:52,119 --> 00:18:53,000
por toda la vida

413
00:18:53,000 --> 00:18:56,619
pero entre números decimales no hay cociente

414
00:18:56,619 --> 00:18:58,839
entre números decimales hay división con sus decimales

415
00:18:58,839 --> 00:19:01,509
entonces si

416
00:19:01,509 --> 00:19:02,710
dividimos esto

417
00:19:02,710 --> 00:19:05,670
pues nos dará el numerito con decimales

418
00:19:05,670 --> 00:19:06,230
que nos dé

419
00:19:06,230 --> 00:19:15,160
pues este es la división entera

420
00:19:15,160 --> 00:19:17,579
mogollón de cifras decimales

421
00:19:17,579 --> 00:19:19,819
porque es un dabble

422
00:19:19,819 --> 00:19:21,500
porque es un dabble

423
00:19:21,500 --> 00:19:27,299
¿vale? fijaos

424
00:19:27,299 --> 00:19:29,900
he mezclado

425
00:19:29,900 --> 00:19:31,680
variables de diferente

426
00:19:31,680 --> 00:19:32,799
tipo en la expresión

427
00:19:32,799 --> 00:19:34,980
esta es dabble, esta es float

428
00:19:34,980 --> 00:19:37,500
igual que en expresiones

429
00:19:37,500 --> 00:19:38,680
con números enteros

430
00:19:38,680 --> 00:19:41,640
en el ejemplo de antes hemos mezclado int y long

431
00:19:41,640 --> 00:19:43,480
no pasa nada, lo que hace

432
00:19:43,480 --> 00:19:45,519
con el int es subirlo a long, ya está

433
00:19:45,519 --> 00:19:47,579
no pasa nada, pues aquí

434
00:19:47,579 --> 00:19:49,799
lo mismo, lo que hace con este

435
00:19:49,799 --> 00:19:53,079
es subirlo a dabel, no pasa nada

436
00:19:53,079 --> 00:19:54,940
se puede promocionar

437
00:19:54,940 --> 00:19:56,599
de float a dabel, añades ceros

438
00:19:56,599 --> 00:19:57,359
como cifra decimal

439
00:19:57,359 --> 00:20:00,779
promocionar

440
00:20:00,779 --> 00:20:02,759
yo tengo, o yo no

441
00:20:02,759 --> 00:20:03,759
la máquina virtual

442
00:20:03,759 --> 00:20:07,119
este numerito

443
00:20:07,119 --> 00:20:07,920
a lo mejor es

444
00:20:07,920 --> 00:20:10,859
7,82, está guardado como

445
00:20:10,859 --> 00:20:12,779
float, lo quiero

446
00:20:12,779 --> 00:20:15,039
como dabel, la máquina virtual lo tiene que promocionar

447
00:20:15,039 --> 00:20:16,799
a dabel para irlo con este dabel

448
00:20:16,799 --> 00:20:18,339
no pasa nada

449
00:20:18,339 --> 00:20:20,460
mogollón de ceros

450
00:20:20,460 --> 00:20:22,720
ala, ya está promocionado a dabel

451
00:20:22,720 --> 00:20:25,960
a la inversa sin embargo no

452
00:20:25,960 --> 00:20:27,920
tengo un numerito dabel

453
00:20:27,920 --> 00:20:34,380
7,81569324675

454
00:20:34,380 --> 00:20:35,859
este es un dabel

455
00:20:35,859 --> 00:20:37,880
para cambiarlo a float

456
00:20:37,880 --> 00:20:38,720
¿qué tendría que hacer?

457
00:20:39,759 --> 00:20:40,980
esto a la basura

458
00:20:40,980 --> 00:20:43,720
porque el float solo me admite 7 cifras

459
00:20:43,720 --> 00:20:45,380
eso a la basura, hombre eso no

460
00:20:45,380 --> 00:20:47,319
eso no lo podemos hacer porque

461
00:20:47,319 --> 00:20:48,880
perdemos información.

462
00:20:49,799 --> 00:20:51,660
Toda esta precisión la estamos tirando

463
00:20:51,660 --> 00:20:53,680
a la basura. Luego de

464
00:20:53,680 --> 00:20:55,680
dabel, perdón, de float

465
00:20:55,680 --> 00:20:56,180
a dabel,

466
00:20:57,240 --> 00:21:00,099
la máquina virtual lo hace automáticamente

467
00:21:00,099 --> 00:21:03,880
porque se trata de añadir ceros.

468
00:21:04,059 --> 00:21:05,500
No se pierde información.

469
00:21:07,220 --> 00:21:07,880
De dabel

470
00:21:07,880 --> 00:21:09,700
a float no te deja

471
00:21:09,700 --> 00:21:11,680
porque, claro, que estás

472
00:21:11,680 --> 00:21:13,579
perdiendo información, estás perdiendo precisión.

473
00:21:15,119 --> 00:21:15,920
Aquí, por tanto,

474
00:21:15,920 --> 00:21:17,460
teníamos el dabble

475
00:21:17,460 --> 00:21:19,480
el float

476
00:21:19,480 --> 00:21:21,259
¿qué ha hecho?

477
00:21:21,960 --> 00:21:23,180
ha cogido el float

478
00:21:23,180 --> 00:21:25,740
le añade ceros, no pasa nada

479
00:21:25,740 --> 00:21:28,160
con lo cual lo ha promocionado

480
00:21:28,160 --> 00:21:30,160
a dabble y la operación

481
00:21:30,160 --> 00:21:31,720
cae en un dabble, ya está

482
00:21:31,720 --> 00:21:32,680
no pasa nada

483
00:21:32,680 --> 00:21:42,460
sí que habría sido un problema

484
00:21:42,460 --> 00:21:43,660
el siguiente

485
00:21:43,660 --> 00:21:46,539
float num3

486
00:21:46,539 --> 00:21:48,900
igual a num1

487
00:21:48,900 --> 00:21:49,559
entre

488
00:21:49,559 --> 00:21:52,500
num4

489
00:21:52,500 --> 00:21:53,779
que num3 ya lo tengo

490
00:21:53,779 --> 00:21:56,700
num1

491
00:21:56,700 --> 00:21:58,779
entre num2

492
00:21:58,779 --> 00:22:00,779
esto

493
00:22:00,779 --> 00:22:01,900
si habría sido un problema

494
00:22:01,900 --> 00:22:07,200
esta sí, esta no

495
00:22:07,200 --> 00:22:09,240
esta no

496
00:22:09,240 --> 00:22:10,339
porque claro

497
00:22:10,339 --> 00:22:13,920
aquí la máquina virtual primero evalúa la expresión

498
00:22:13,920 --> 00:22:15,500
luego ya después se mete

499
00:22:15,500 --> 00:22:16,740
a ver a qué variables lo das

500
00:22:16,740 --> 00:22:19,279
float double

501
00:22:19,279 --> 00:22:20,140
al revés

502
00:22:20,140 --> 00:22:22,960
el float

503
00:22:22,960 --> 00:22:25,140
lo estiro con ceros al double

504
00:22:25,140 --> 00:22:27,079
hago la división

505
00:22:27,079 --> 00:22:28,400
me queda el double

506
00:22:28,400 --> 00:22:30,819
¿un double puede ir a un float?

507
00:22:31,519 --> 00:22:32,000
no

508
00:22:32,000 --> 00:22:34,859
¿un float puede ir a un double? sí

509
00:22:34,859 --> 00:22:36,500
exactamente igual que

510
00:22:36,500 --> 00:22:38,579
¿un int puede ir a un long? sí

511
00:22:38,579 --> 00:22:40,619
¿un long puede ir a un int? no

512
00:22:40,619 --> 00:22:43,319
pues aquí aplican los mismos

513
00:22:43,319 --> 00:22:44,319
principios, dime

514
00:22:44,319 --> 00:22:52,650
te lo va a truncar a la precisión que sea

515
00:22:52,650 --> 00:22:54,910
si es double te lo truncará

516
00:22:54,910 --> 00:22:56,930
a las 14 cifras decimales

517
00:22:56,930 --> 00:22:58,430
que tenga, que no recuerdo cuantas son

518
00:22:58,430 --> 00:22:59,390
te lo trunca

519
00:22:59,390 --> 00:23:06,390
siempre te lo va a truncar

520
00:23:06,390 --> 00:23:08,410
si el resultado te da un número periódico

521
00:23:08,410 --> 00:23:09,990
la operación te da un número periódico

522
00:23:09,990 --> 00:23:12,009
te va a obtener un resultado

523
00:23:12,009 --> 00:23:14,430
pero truncando solo

524
00:23:14,430 --> 00:23:16,490
a los decimales que admite

525
00:23:16,490 --> 00:23:18,630
el resto no

526
00:23:18,630 --> 00:23:19,809
el resto no te lo va

527
00:23:19,809 --> 00:23:21,210
por ejemplo

528
00:23:21,210 --> 00:23:24,450
a ver esto

529
00:23:24,450 --> 00:23:26,250
no se puede hacer, aquí podríamos

530
00:23:26,250 --> 00:23:29,980
vamos a

531
00:23:29,980 --> 00:23:31,839
entonces aquí haría

532
00:23:31,839 --> 00:23:34,339
Vamos a dejar esto

533
00:23:34,339 --> 00:23:36,779
Promoción automática

534
00:23:36,779 --> 00:23:39,259
De Float a Dabble

535
00:23:39,259 --> 00:23:40,839
Esta se puede

536
00:23:40,839 --> 00:23:45,309
Esto si se puede y no hay problema

537
00:23:45,309 --> 00:23:46,710
Sin embargo

538
00:23:46,710 --> 00:23:51,690
De Float a Dabble

539
00:23:51,690 --> 00:23:53,009
La promoción automática se puede

540
00:23:53,009 --> 00:23:54,430
Sin embargo

541
00:23:54,430 --> 00:23:56,950
No se puede

542
00:23:56,950 --> 00:23:59,750
Promocionar

543
00:23:59,750 --> 00:24:01,829
De Dabble a Float

544
00:24:01,829 --> 00:24:02,990
Eso no

545
00:24:02,990 --> 00:24:05,509
Porque perderíamos información

546
00:24:05,509 --> 00:24:07,569
¿Vale? Esto no se puede y me daba error

547
00:24:07,569 --> 00:24:09,890
Vale, entonces

548
00:24:09,890 --> 00:24:11,490
Vamos a crear un número periódico

549
00:24:11,490 --> 00:24:12,690
Para ver cómo te lo muestra

550
00:24:12,690 --> 00:24:14,849
Por ejemplo, num3

551
00:24:14,849 --> 00:24:17,950
Igual a

552
00:24:17,950 --> 00:24:22,089
1 entre 3

553
00:24:22,089 --> 00:24:23,990
¿No? Es 0,33333

554
00:24:23,990 --> 00:24:24,150
¿No?

555
00:24:25,210 --> 00:24:27,630
1 entre 3

556
00:24:27,630 --> 00:24:29,750
Y vamos a mostrar

557
00:24:29,750 --> 00:24:32,529
Num3

558
00:24:32,529 --> 00:24:44,849
Ah, perdón

559
00:24:44,849 --> 00:24:45,869
Ah, mira, qué

560
00:24:45,869 --> 00:24:48,470
Buen ejemplo, nos ha salido antes de

561
00:24:48,470 --> 00:24:50,009
De tiempo, vale

562
00:24:50,009 --> 00:24:54,609
Porque además viene al pelo

563
00:24:54,609 --> 00:24:56,710
Justo de lo que teníamos que contar ahora

564
00:24:56,710 --> 00:24:58,930
Vale, generando el ejemplo suyo

565
00:24:58,930 --> 00:25:00,210
Este de número periódico

566
00:25:00,210 --> 00:25:01,630
Vale, hemos dicho

567
00:25:01,630 --> 00:25:03,809
1 entre 3

568
00:25:03,809 --> 00:25:06,609
Es 0,333333

569
00:25:06,609 --> 00:25:07,589
Hasta el infinito, ¿verdad?

570
00:25:10,170 --> 00:25:11,049
Lo hemos

571
00:25:11,049 --> 00:25:12,430
Hemos hecho la división

572
00:25:12,430 --> 00:25:14,630
La hemos guardado en este numerito de Abel

573
00:25:14,630 --> 00:25:16,849
Y vamos a mostrar este número

574
00:25:16,849 --> 00:25:17,309
¿Cuál es?

575
00:25:18,210 --> 00:25:21,230
Esperábamos encontrar 0.3333

576
00:25:21,230 --> 00:25:23,009
Así hasta las cifras decimales

577
00:25:23,009 --> 00:25:24,009
Que quepan en Abel

578
00:25:24,009 --> 00:25:26,849
Que son las que me han salido

579
00:25:26,849 --> 00:25:27,950
Antes ahí que no las he contado

580
00:25:27,950 --> 00:25:30,890
12 o 13 serán

581
00:25:30,890 --> 00:25:32,650
Vale, entonces lo hemos ejecutado

582
00:25:32,650 --> 00:25:34,430
¿Y qué corte?

583
00:25:35,230 --> 00:25:36,289
Nos ha salido 0

584
00:25:36,289 --> 00:25:38,849
En lugar de 0,33333

585
00:25:39,430 --> 00:25:41,349
Vale, pues en realidad

586
00:25:41,349 --> 00:25:43,710
¿sabemos por qué?

587
00:25:44,089 --> 00:25:44,890
si lo pensamos

588
00:25:44,890 --> 00:25:46,609
¿sabemos por qué?

589
00:25:49,549 --> 00:25:50,210
¿vale? a ver

590
00:25:50,210 --> 00:25:51,730
no

591
00:25:51,730 --> 00:25:54,109
cuando

592
00:25:54,109 --> 00:25:56,710
estamos viendo enteros, yo os he dicho

593
00:25:56,710 --> 00:25:57,990
cuando la máquina virtual

594
00:25:57,990 --> 00:25:59,890
ve una sucesión

595
00:25:59,890 --> 00:26:03,950
de cifras

596
00:26:03,950 --> 00:26:06,009
lo construye como IN

597
00:26:06,009 --> 00:26:08,650
es justo lo que ha visto aquí

598
00:26:08,650 --> 00:26:09,910
una sucesión de cifras

599
00:26:09,910 --> 00:26:12,450
lo ha construido como IN

600
00:26:12,450 --> 00:26:13,990
vale

601
00:26:13,990 --> 00:26:15,869
ahora ve aquí un 3

602
00:26:15,869 --> 00:26:18,250
lo ha construido como int

603
00:26:18,250 --> 00:26:20,369
porque es una sucesión de cifras normal y corriente

604
00:26:20,369 --> 00:26:20,730
int

605
00:26:20,730 --> 00:26:23,730
barrita int

606
00:26:23,730 --> 00:26:26,250
lo interpreta como cociente

607
00:26:26,250 --> 00:26:28,369
porque cuando esta barra

608
00:26:28,369 --> 00:26:30,490
mezcla números enteros

609
00:26:30,490 --> 00:26:33,690
entonces es el cociente

610
00:26:33,690 --> 00:26:35,130
no es la división entera

611
00:26:35,130 --> 00:26:38,089
es el cociente, otra cosa que también sabemos

612
00:26:38,089 --> 00:26:40,750
cociente de dividir 1 entre 3

613
00:26:40,750 --> 00:26:41,630
0

614
00:26:41,630 --> 00:26:43,309
0

615
00:26:43,309 --> 00:26:46,950
Ahora, le ha salido el numerito int 0

616
00:26:46,950 --> 00:26:49,930
Lo tiene que guardar en double

617
00:26:49,930 --> 00:26:51,049
Porque en un 3 es double

618
00:26:51,049 --> 00:26:51,950
No pasa nada

619
00:26:51,950 --> 00:26:54,109
Un int en double cabe

620
00:26:54,109 --> 00:26:56,910
Le pongo 0.0 y ya está

621
00:26:56,910 --> 00:26:59,069
Como si hubiera salido 3

622
00:26:59,069 --> 00:27:00,990
Un 3 en double cabe

623
00:27:00,990 --> 00:27:03,049
Le pongo 3.0 y ya está

624
00:27:03,049 --> 00:27:05,009
A la inversa no

625
00:27:05,009 --> 00:27:06,109
Un double en int no

626
00:27:06,109 --> 00:27:08,490
Porque un double podría 3.7

627
00:27:08,490 --> 00:27:10,589
Para que cupiera en un int

628
00:27:10,589 --> 00:27:12,710
Tendría que quitarle el .7

629
00:27:12,710 --> 00:27:15,269
Eso es perder información, eso nunca se puede hacer

630
00:27:15,269 --> 00:27:17,450
Pero un int en un double

631
00:27:17,450 --> 00:27:19,549
Ningún problema, le pones el .0 y ya está

632
00:27:19,549 --> 00:27:21,269
Pues eso es lo que ha pasado

633
00:27:21,269 --> 00:27:22,910
Esto es un int

634
00:27:22,910 --> 00:27:24,269
Esto es un int

635
00:27:24,269 --> 00:27:26,430
Esto por tanto es división entera

636
00:27:26,430 --> 00:27:29,230
Me da 0, como tiene que ir a un double

637
00:27:29,230 --> 00:27:30,549
Le pongo 0.0

638
00:27:30,549 --> 00:27:31,910
Que es justo

639
00:27:31,910 --> 00:27:33,990
Lo que nos ha salido

640
00:27:33,990 --> 00:27:36,230
Luego entendemos lo que ha pasado

641
00:27:36,230 --> 00:27:37,809
Ahora

642
00:27:37,809 --> 00:27:41,529
Perdona, yo no quiero que me interpretes

643
00:27:41,529 --> 00:27:42,130
Esto como

644
00:27:42,130 --> 00:27:44,549
int, sino como dable

645
00:27:44,549 --> 00:27:46,769
si os ocurre que podríamos poner

646
00:27:46,769 --> 00:27:52,390
podríamos, pero no hace falta

647
00:27:52,390 --> 00:27:54,309
más sencillo, punto cero

648
00:27:54,309 --> 00:28:01,190
punto cero

649
00:28:01,190 --> 00:28:03,450
claro, ya está, ahora ya

650
00:28:03,450 --> 00:28:05,650
la máquina virtual no se encuentra

651
00:28:05,650 --> 00:28:07,069
unas cifras enteras y más

652
00:28:07,069 --> 00:28:09,609
se encuentra una parte entera

653
00:28:09,609 --> 00:28:11,109
punto una parte decimal

654
00:28:11,109 --> 00:28:13,009
que la parte decimal es cero, me da igual

655
00:28:13,009 --> 00:28:16,069
esto ya jamás lo va a construir como un entero

656
00:28:16,069 --> 00:28:19,369
porque se ha encontrado el carácter clave de los decimales

657
00:28:19,369 --> 00:28:20,730
que es este

658
00:28:20,730 --> 00:28:21,950
entonces

659
00:28:21,950 --> 00:28:25,049
al encontrarse

660
00:28:25,049 --> 00:28:26,990
el carácter clave de los decimales

661
00:28:26,990 --> 00:28:28,470
que es el puntito

662
00:28:28,470 --> 00:28:31,049
dice, ah, hay que construir un double

663
00:28:31,049 --> 00:28:33,230
genial, se ha construido

664
00:28:33,230 --> 00:28:34,890
el double 1.0

665
00:28:34,890 --> 00:28:37,109
y aquí el double 3.0

666
00:28:37,109 --> 00:28:38,829
ahora ya son dos doubles

667
00:28:38,829 --> 00:28:40,829
esto ya por tanto

668
00:28:40,829 --> 00:28:41,730
ya no es cociente

669
00:28:41,730 --> 00:28:44,750
eso ahora es división con decimales

670
00:28:44,750 --> 00:28:46,710
porque lo que tienen los dados

671
00:28:46,710 --> 00:28:47,710
son dabel

672
00:28:47,710 --> 00:28:50,769
luego poniendo

673
00:28:50,769 --> 00:28:51,630
el punto cero

674
00:28:51,630 --> 00:28:54,269
ya forzamos a que la máquina virtual

675
00:28:54,269 --> 00:28:55,450
lo construya como dabel

676
00:28:55,450 --> 00:28:57,650
porque le estamos dando el puntito

677
00:28:57,650 --> 00:28:59,950
si no le damos esto

678
00:28:59,950 --> 00:29:01,730
ve

679
00:29:01,730 --> 00:29:03,950
una sucesión de cifras

680
00:29:03,950 --> 00:29:05,069
en este caso solo una

681
00:29:05,069 --> 00:29:08,250
y para él eso es un número entero

682
00:29:08,250 --> 00:29:09,230
y lo construye como entero

683
00:29:09,230 --> 00:29:12,670
entonces ahora sí

684
00:29:12,670 --> 00:29:16,150
ejecutamos este programa

685
00:29:16,150 --> 00:29:20,319
ahora ya esto

686
00:29:20,319 --> 00:29:23,579
lo ha truncado

687
00:29:23,579 --> 00:29:25,799
a las cifras decimales

688
00:29:25,799 --> 00:29:26,640
que admite de Abel

689
00:29:26,640 --> 00:29:29,319
que son 5

690
00:29:29,319 --> 00:29:31,460
10

691
00:29:31,460 --> 00:29:34,119
16

692
00:29:34,119 --> 00:29:39,740
¿vale? si fuera 0, 7, 7, 7

693
00:29:39,740 --> 00:29:41,279
7, 7, 7, al truncarlo veríamos

694
00:29:41,279 --> 00:29:43,660
que la última es 8, porque al redondearlo

695
00:29:43,660 --> 00:29:44,119
pues

696
00:29:44,119 --> 00:29:47,319
lo va a redondear a 8 porque tiene muchos 7 detrás

697
00:29:47,319 --> 00:29:49,440
pero bueno, en este caso el redondeo es a 3

698
00:29:49,440 --> 00:29:54,039
Sí, pero esos son castings

699
00:29:54,039 --> 00:29:56,380
Que no nos ha quedado más remedio

700
00:29:56,380 --> 00:29:57,039
Que hacer aquí

701
00:29:57,039 --> 00:29:59,240
Porque ahí tenemos que hacerlo sí o sí

702
00:29:59,240 --> 00:30:01,819
Pero los castings vamos a evitarlos

703
00:30:01,819 --> 00:30:03,880
Hasta que, lo que tú me estás diciendo

704
00:30:03,880 --> 00:30:05,059
Pon el label entre paréntesis

705
00:30:05,059 --> 00:30:06,880
Vamos a evitarlos hasta que no

706
00:30:06,880 --> 00:30:09,559
Tengamos que usarlos sí o sí

707
00:30:09,559 --> 00:30:11,559
Y hasta que no entendamos muy bien lo que significan

708
00:30:11,559 --> 00:30:16,839
Y aquí le has puesto

709
00:30:16,839 --> 00:30:18,640
Esta variable está declarada como

710
00:30:18,640 --> 00:30:20,779
Double, bueno es que si no te daría error de compilación

711
00:30:20,779 --> 00:30:22,640
Y esto es un

712
00:30:22,640 --> 00:30:24,500
¿Has puesto el punto cero y el punto cero?

713
00:30:25,079 --> 00:30:26,259
No, lo he puesto sin punto cero

714
00:30:26,259 --> 00:30:27,099
Ah, entonces no

715
00:30:27,099 --> 00:30:30,819
Claro, claro, es que si no son enteros

716
00:30:30,819 --> 00:30:32,859
Pasa lo que hemos dicho antes

717
00:30:32,859 --> 00:30:35,039
Si no se lo pones son entero

718
00:30:35,039 --> 00:30:36,160
Cociente entero

719
00:30:36,160 --> 00:30:39,380
Si se lo pones solo en uno de los dos

720
00:30:39,380 --> 00:30:40,559
También funciona

721
00:30:40,559 --> 00:30:42,640
Porque aquí haría entonces la promoción automática

722
00:30:42,640 --> 00:30:44,579
Entero entre double

723
00:30:44,579 --> 00:30:46,519
Lo que hace es

724
00:30:46,519 --> 00:30:48,440
Promocionar el entero a double poniendo punto cero

725
00:30:48,440 --> 00:30:50,720
No hace falta ponérselo a los dos

726
00:30:50,720 --> 00:30:52,980
vale

727
00:30:52,980 --> 00:30:55,720
vale, o sea en general

728
00:30:55,720 --> 00:30:58,160
cuando tenemos una expresión aritmética

729
00:30:58,160 --> 00:30:59,759
que involucra valores

730
00:30:59,759 --> 00:31:00,759
de diferente tipo

731
00:31:00,759 --> 00:31:03,299
él intenta promocionar

732
00:31:03,299 --> 00:31:06,019
unos a otros si es que se puede

733
00:31:06,019 --> 00:31:10,059
y esas reglas de promoción

734
00:31:10,059 --> 00:31:11,759
están claras

735
00:31:11,759 --> 00:31:13,779
vamos a recopilarlas aquí

736
00:31:13,779 --> 00:31:18,140
con versiones

737
00:31:18,140 --> 00:31:19,799
que puede hacer

738
00:31:19,799 --> 00:31:21,079
la máquina virtual

739
00:31:21,079 --> 00:31:23,619
directamente sin ningún problema

740
00:31:23,619 --> 00:31:29,630
Pues puede hacer, está claro

741
00:31:29,630 --> 00:31:31,650
Byte lo puede llevar

742
00:31:31,650 --> 00:31:35,369
A short

743
00:31:35,369 --> 00:31:37,470
Lo puede llevar a int

744
00:31:37,470 --> 00:31:39,490
Si hace falta, lo puede llevar a long

745
00:31:39,490 --> 00:31:40,829
¿Vale?

746
00:31:42,009 --> 00:31:42,569
Short

747
00:31:42,569 --> 00:31:44,670
Lo puede llevar

748
00:31:44,670 --> 00:31:47,089
A int, sin ningún problema

749
00:31:47,089 --> 00:31:48,289
Y lo puede llevar a long

750
00:31:48,289 --> 00:31:51,519
Int

751
00:31:51,519 --> 00:31:54,400
Lo puede llevar a long, sin problema

752
00:31:54,400 --> 00:31:55,859
Si la máquina virtual lo necesita

753
00:31:55,859 --> 00:31:57,420
¿Vale?

754
00:31:58,940 --> 00:31:59,500
Float

755
00:31:59,500 --> 00:32:01,880
lo puede llevar a double

756
00:32:01,880 --> 00:32:04,480
no hay ningún problema

757
00:32:04,480 --> 00:32:06,259
es añadir ceros en la cifra decimal

758
00:32:06,259 --> 00:32:08,759
pero lo que es más

759
00:32:08,759 --> 00:32:09,900
int

760
00:32:09,900 --> 00:32:12,079
también lo puede llevar a float

761
00:32:12,079 --> 00:32:13,920
poniendo .000

762
00:32:13,920 --> 00:32:15,960
e int

763
00:32:15,960 --> 00:32:18,180
también lo puede llevar a double

764
00:32:18,180 --> 00:32:21,240
poniendo el .0000

765
00:32:21,240 --> 00:32:24,559
todas estas conversiones

766
00:32:24,559 --> 00:32:26,519
se pueden hacer, las hace automáticamente

767
00:32:26,519 --> 00:32:28,400
si ve valores

768
00:32:28,400 --> 00:32:30,900
de tipos mezclados en una expresión

769
00:32:30,900 --> 00:32:32,140
él

770
00:32:32,140 --> 00:32:34,579
convierte lo que

771
00:32:34,579 --> 00:32:36,160
necesite siempre y cuando pueda

772
00:32:36,160 --> 00:32:38,660
estas conversiones se pueden hacer porque no pierde

773
00:32:38,660 --> 00:32:40,079
ninguna información

774
00:32:40,079 --> 00:32:42,299
para esta pone .0

775
00:32:42,299 --> 00:32:44,900
y ya está, para esta también pone .0

776
00:32:44,900 --> 00:32:46,500
he puesto solo in, pero de long a double

777
00:32:46,500 --> 00:32:47,720
sería igual, van a agarrarme

778
00:32:47,720 --> 00:32:50,500
un long puede un double, pone .0

779
00:32:50,500 --> 00:32:52,059
y ya está, ¿vale?

780
00:32:53,119 --> 00:32:54,500
este ya lo sabemos, de un in

781
00:32:54,500 --> 00:32:56,660
puede un long, pone ceros en los bits

782
00:32:56,660 --> 00:32:58,259
significativos y ya está

783
00:32:58,259 --> 00:33:00,680
Sin embargo, las inversas

784
00:33:00,680 --> 00:33:03,559
No las puede hacer automáticamente

785
00:33:03,559 --> 00:33:05,299
Y por eso hay un error de compilación previo

786
00:33:05,299 --> 00:33:06,420
Las inversas no puede

787
00:33:06,420 --> 00:33:10,420
El si necesitara cambiar de double a int

788
00:33:10,420 --> 00:33:11,559
Eso no puede hacerlo

789
00:33:11,559 --> 00:33:13,619
Ni de double a float

790
00:33:13,619 --> 00:33:14,200
Eso no puede

791
00:33:14,200 --> 00:33:16,460
Porque tiene que quitar cifras decimales

792
00:33:16,460 --> 00:33:18,019
Ni de long a int

793
00:33:18,019 --> 00:33:18,539
No puede

794
00:33:18,539 --> 00:33:21,099
Porque tiene que quitar bits que tienen valor

795
00:33:21,099 --> 00:33:36,319
Vale, a ver

796
00:33:36,319 --> 00:33:42,259
Vamos a incorporar

797
00:33:42,259 --> 00:33:47,410
Leer un decimal por teclado para poder hacer algo.

798
00:33:47,869 --> 00:33:49,930
Igual que ya sabemos leer números por teclado,

799
00:33:51,769 --> 00:33:55,910
pues podemos también, números enteros por teclado,

800
00:33:55,990 --> 00:33:57,569
podemos también leer decimales por teclado.

801
00:33:58,230 --> 00:33:59,250
Y lo haríamos igual.

802
00:34:00,970 --> 00:34:04,069
Tendríamos que hacer el objeto lector.

803
00:34:04,069 --> 00:34:25,440
Y ahora, por ejemplo, yo quiero leer un dabel,

804
00:34:25,980 --> 00:34:28,199
un numerito dabel del teclado.

805
00:34:28,199 --> 00:34:32,110
Pues doy la orden

806
00:34:32,110 --> 00:34:34,150
Pero la orden ahora no es next in

807
00:34:34,150 --> 00:34:36,829
La orden como nos podíamos imaginar es next double

808
00:34:36,829 --> 00:34:40,199
Entonces

809
00:34:40,199 --> 00:34:42,360
Cuando la máquina virtual llega aquí

810
00:34:42,360 --> 00:34:44,699
Se queda ahí quieta esperando

811
00:34:44,699 --> 00:34:45,800
Que alguien meta un número

812
00:34:45,800 --> 00:34:47,780
Y

813
00:34:47,780 --> 00:35:05,380
Variable double

814
00:35:05,380 --> 00:35:08,019
Vale, mete un decimal para variable double

815
00:35:08,019 --> 00:35:10,300
Y vamos a hacer lo mismo con el float

816
00:35:10,300 --> 00:35:17,739
Mete un decimal

817
00:35:17,739 --> 00:35:19,800
Para variable float

818
00:35:19,800 --> 00:35:25,420
Num6

819
00:35:25,420 --> 00:35:26,320
Ahora no será

820
00:35:26,320 --> 00:35:28,340
float

821
00:35:28,340 --> 00:35:31,199
ahora no será next double

822
00:35:31,199 --> 00:35:33,000
sino como nos podíamos imaginar

823
00:35:33,000 --> 00:35:34,960
next float

824
00:35:34,960 --> 00:35:41,199
entonces vamos a probar estas dos lecturas

825
00:35:41,199 --> 00:35:45,400
vamos a leerlo y mostramos el número leído

826
00:35:45,400 --> 00:35:53,239
y aquí lo mismo

827
00:35:53,239 --> 00:35:55,320
vamos a leerlo y vamos a mostrar

828
00:35:55,320 --> 00:35:56,260
el número leído

829
00:35:56,260 --> 00:35:59,940
entonces estos dos códigos

830
00:35:59,940 --> 00:36:03,940
primero este te mostrará el mensajito

831
00:36:03,940 --> 00:36:05,239
se quedará a la espera

832
00:36:05,239 --> 00:36:06,420
de que le metas un double

833
00:36:06,420 --> 00:36:08,980
y lo guardará en un 5

834
00:36:08,980 --> 00:36:10,039
y luego te lo muestra

835
00:36:10,039 --> 00:36:13,400
y aquí lo mismo, te muestra el mensajito

836
00:36:13,400 --> 00:36:14,880
se queda esperando que le metas

837
00:36:14,880 --> 00:36:16,739
un número decimal, lo guarda en este float

838
00:36:16,739 --> 00:36:17,440
y te lo muestra

839
00:36:17,440 --> 00:36:20,400
vamos a ejecutarlo

840
00:36:20,400 --> 00:36:25,480
bueno, esto es lo que ha hecho antes

841
00:36:25,480 --> 00:36:27,059
como veis ahí está esperando

842
00:36:27,059 --> 00:36:29,059
ahí está esperando

843
00:36:29,059 --> 00:36:31,280
cada vez que hay un next

844
00:36:31,280 --> 00:36:32,039
lo que sea

845
00:36:32,039 --> 00:36:36,059
el programa se queda ahí esperando

846
00:36:36,059 --> 00:36:37,539
vale

847
00:36:37,539 --> 00:36:56,340
Pues aquí cuidado, porque aquí el next double no funciona con el punto, el next double si yo le meto 76.8 no funciona con el punto, hay que poner una comita, es lo único que tenemos que recordar, ¿vale?

848
00:36:56,340 --> 00:37:05,900
Entonces, si yo quiero meter a través del teclado 76,8, pues tengo que poner coma, no punto, coma.

849
00:37:06,659 --> 00:37:11,920
Luego no es igual cuando lo asigno directamente por código que cuando lo meto por teclado con Nextavel.

850
00:37:12,099 --> 00:37:15,840
Por código es punto, como toda la vida de Dios en matemáticas.

851
00:37:16,539 --> 00:37:21,300
Por teclado es coma, porque el Nextavel lo tiene así porque cree que es más intuitivo.

852
00:37:21,300 --> 00:37:23,719
Vale, efectivamente

853
00:37:23,719 --> 00:37:25,519
Lo ha leído

854
00:37:25,519 --> 00:37:27,000
Y luego me lo ha mostrado

855
00:37:27,000 --> 00:37:30,320
El numerito que yo he leído es 76.8

856
00:37:30,320 --> 00:37:30,780
Muy bien

857
00:37:30,780 --> 00:37:33,719
Vamos a meter un decimal para variable flow

858
00:37:33,719 --> 00:37:35,659
76.8 otra vez

859
00:37:35,659 --> 00:37:38,039
Vale

860
00:37:38,039 --> 00:37:39,659
Lo ha leído

861
00:37:39,659 --> 00:37:42,199
No te obliga a poner la F

862
00:37:42,199 --> 00:37:44,960
Porque esto es para que un usuario lo escriba

863
00:37:44,960 --> 00:37:46,699
Y necesita que sea intuitivo

864
00:37:46,699 --> 00:37:48,840
Entonces

865
00:37:48,840 --> 00:37:51,039
Te lo lee y luego te muestra

866
00:37:51,039 --> 00:37:52,739
la variable float, vale

867
00:37:52,739 --> 00:37:58,940
vamos a ejecutarlo otra vez poniendo

868
00:37:58,940 --> 00:38:00,039
aquí un número que tenga

869
00:38:00,039 --> 00:38:02,780
muchas cifras decimales que no quepan en double

870
00:38:02,780 --> 00:38:05,079
a ver si redondea o peta

871
00:38:05,079 --> 00:38:08,099
mete un decimal

872
00:38:08,099 --> 00:38:09,880
para double, pues 4,6

873
00:38:09,880 --> 00:38:12,139
4,6, mete un decimal

874
00:38:12,139 --> 00:38:12,840
para float

875
00:38:12,840 --> 00:38:18,409
8, en float

876
00:38:18,409 --> 00:38:20,329
solo cabían, eran 7

877
00:38:20,329 --> 00:38:22,469
creo, 1, 2, 3, 4, 5, 6

878
00:38:22,469 --> 00:38:23,789
7, 8, 9

879
00:38:23,789 --> 00:38:25,730
vale

880
00:38:25,730 --> 00:38:28,570
Como no admite esa precisión

881
00:38:28,570 --> 00:38:31,150
Fijaos lo que ha hecho el next flow add

882
00:38:31,150 --> 00:38:33,429
Como tanta precisión no admite

883
00:38:33,429 --> 00:38:34,909
Te lo redondea

884
00:38:34,909 --> 00:38:36,849
Al double más cercano

885
00:38:36,849 --> 00:38:39,349
En este caso es esto

886
00:38:39,349 --> 00:38:41,230
Perdón, al flow add más cercano

887
00:38:41,230 --> 00:38:43,030
Te lo redondea a esto

888
00:38:43,030 --> 00:38:46,650
Porque no admite esa precisión

889
00:38:46,650 --> 00:38:48,769
Sin embargo, si yo

890
00:38:48,769 --> 00:38:51,150
Le dijera

891
00:38:51,150 --> 00:38:53,110
78,9

892
00:38:53,110 --> 00:38:56,190
Y ahora meto uno para variable flow add

893
00:38:56,190 --> 00:38:59,570
7, 1, 2, 3, 4, 5, 6, 7.

894
00:38:59,670 --> 00:39:00,789
7 si las coge, ¿verdad?

895
00:39:02,010 --> 00:39:03,909
Bueno, me ha redondeado a 6.

896
00:39:04,530 --> 00:39:08,289
Esos son ya matices internos de cómo funciona esta sentencia de leer del teclado.

897
00:39:09,590 --> 00:39:14,269
Pero vamos, lo que nos importa ahora es que cada vez que tengamos que hacer programas

898
00:39:14,269 --> 00:39:18,610
que necesiten datos de entrada del teclado,

899
00:39:18,969 --> 00:39:21,170
con estas tres sentencias que hemos visto,

900
00:39:22,269 --> 00:39:23,670
esta next in de aquí,

901
00:39:23,670 --> 00:39:26,449
Que no sé dónde estaba

902
00:39:26,449 --> 00:39:27,869
Aquí

903
00:39:27,869 --> 00:39:32,190
Y estas dos

904
00:39:32,190 --> 00:39:33,710
NextW y NextFloat

905
00:39:33,710 --> 00:39:35,949
Podemos meter números enteros y decimales

906
00:39:35,949 --> 00:39:38,010
Si metemos decimales

907
00:39:38,010 --> 00:39:39,130
Ojo con coma

908
00:39:39,130 --> 00:39:40,989
Acordémonos de con coma

909
00:39:40,989 --> 00:39:41,889
Porque si no va a salir error

910
00:39:41,889 --> 00:39:42,949
Ya está

911
00:39:42,949 --> 00:39:58,739
Teclado con coma

912
00:39:58,739 --> 00:40:00,960
En lugar de con punto

913
00:40:00,960 --> 00:40:02,480
¿Vale?

914
00:40:28,650 --> 00:40:31,269
Pues todavía podemos hacer muy

915
00:40:31,269 --> 00:40:32,929
Poquitas cosas

916
00:40:32,929 --> 00:40:34,250
Pero bueno

917
00:40:34,250 --> 00:40:40,789
Si del aula virtual

918
00:40:40,789 --> 00:40:51,800
A ver

919
00:40:51,800 --> 00:41:17,860
Vale, bueno, todo esto

920
00:41:17,860 --> 00:41:18,860
Todavía no lo hemos visto

921
00:41:18,860 --> 00:41:23,409
Aquí están algunos resúmenes que he subido

922
00:41:23,409 --> 00:41:24,989
Para que esté un poco más organizado

923
00:41:24,989 --> 00:41:27,570
Pues si abrís el PDF

924
00:41:27,570 --> 00:41:28,070
Este

925
00:41:28,070 --> 00:41:37,880
Esto es una chorradita

926
00:41:37,880 --> 00:41:39,420
Pero es que no podemos hacer más que esto

927
00:41:39,420 --> 00:41:41,659
Haced estos dos primeros

928
00:41:41,659 --> 00:41:43,840
Más que nada para asegurarnos todos

929
00:41:43,840 --> 00:41:46,420
de que tenéis conocido

930
00:41:46,420 --> 00:41:47,460
toda la dinámica.

931
00:41:48,500 --> 00:41:49,960
Sí, sí, en el aula virtual.

932
00:41:52,510 --> 00:41:53,989
Sí, a ver, cada ejercicio

933
00:41:53,989 --> 00:41:55,750
que hagáis, hacedlo en una clase.

934
00:41:56,550 --> 00:41:57,110
¿Vale?

935
00:41:58,989 --> 00:41:59,550
Entonces...