1
00:00:00,820 --> 00:00:07,059
Vale, pues ahora ya sí, vamos a abrir nuestro eclipse, para no aburrirnos tanto.

2
00:00:11,119 --> 00:00:15,019
Vamos a hacer unas pruebitas chorras con variables, así que da igual.

3
00:00:16,280 --> 00:00:21,780
Son nada, 4, 5, 6 líneas chorras para experimentar un poquito con variables, nada más.

4
00:00:28,500 --> 00:00:35,340
Bueno, pues que... Ah, que no he compartido aquí nada. A ver...

5
00:00:35,340 --> 00:00:39,409
Vale

6
00:00:39,409 --> 00:00:45,000
Vale, pues a nadie

7
00:00:45,000 --> 00:00:47,439
Se le olvida que todo esto

8
00:00:47,439 --> 00:00:48,439
Pues porque sí

9
00:00:48,439 --> 00:00:51,939
Y aquí entre estas llaves correctamente colocadas

10
00:00:51,939 --> 00:00:53,780
Está lo que es

11
00:00:53,780 --> 00:00:55,600
Nuestro bloque de código

12
00:00:55,600 --> 00:00:56,359
¿Vale?

13
00:00:57,060 --> 00:00:59,259
Que para nosotros ahora mismo es nuestro programa

14
00:00:59,259 --> 00:01:01,979
No va a haber más programa que lo que no haya ahí dentro

15
00:01:01,979 --> 00:01:03,640
Y ahí dentro habrá

16
00:01:03,640 --> 00:01:04,980
Una línea una tras otra

17
00:01:04,980 --> 00:01:07,340
Con las sentencias que pongamos

18
00:01:07,340 --> 00:01:10,000
Bueno, pues sacar algo por consola

19
00:01:10,000 --> 00:01:23,989
ya sabemos. Pues ya está. Vale, pues resulta que mi programa necesito yo una variable numérica

20
00:01:23,989 --> 00:01:33,569
para guardar una edad. Pues ya está. Selecciono el tipo de dato, número entero. Normalmente

21
00:01:33,569 --> 00:01:44,200
seleccionaré siempre edad, int y cojo el nombrecito y punto y coma y ya está. Y automáticamente

22
00:01:44,200 --> 00:01:48,500
Te apareció en la memoria RAM una variable edad.

23
00:01:49,500 --> 00:01:51,780
Que no tiene nada, que está indefinida.

24
00:01:53,260 --> 00:01:57,500
Vale, mi System.out.println, aparte de para mostrar texto,

25
00:01:58,980 --> 00:02:01,980
también vale para que yo muestre contenidos de variables.

26
00:02:02,140 --> 00:02:04,620
Me vale para mostrar cualquier cosa.

27
00:02:07,150 --> 00:02:10,210
Pues, vamos a intentar mostrar el contenido de esta variable.

28
00:02:11,030 --> 00:02:17,240
Entonces, un, vale.

29
00:02:18,419 --> 00:02:24,460
¿Qué pongo yo aquí si quiero mostrar el contenido de una variable?

30
00:02:25,379 --> 00:02:28,360
Pues pongo su nombre, el nombre de la variable.

31
00:02:28,800 --> 00:02:29,919
Pongo el nombre de la variable.

32
00:02:31,060 --> 00:02:34,099
Yo quiero mostrar el contenido de la variable edad.

33
00:02:34,740 --> 00:02:37,120
Pues pongo el nombre de la variable edad.

34
00:02:38,879 --> 00:02:42,639
Entonces, el system out de arriba y el de abajo son distintos

35
00:02:42,639 --> 00:02:45,759
porque el de arriba, al estar entrecomillado,

36
00:02:45,759 --> 00:02:48,360
yo le estoy diciendo, oye, muéstrame

37
00:02:48,360 --> 00:02:50,439
literalmente ese texto, ese texto

38
00:02:50,439 --> 00:02:52,539
tal cual, pero lo de

39
00:02:52,539 --> 00:02:54,599
abajo como no está entrecomillado

40
00:02:54,599 --> 00:02:56,520
entonces me

41
00:02:56,520 --> 00:02:58,120
refiero a un nombre de variable

42
00:02:58,120 --> 00:03:00,300
claro, si yo le pongo

43
00:03:00,300 --> 00:03:02,419
esto, ahora es

44
00:03:02,419 --> 00:03:04,539
distinto, ahora no tiene nada que ver

45
00:03:04,539 --> 00:03:06,539
ahora le estoy diciendo, oye

46
00:03:06,539 --> 00:03:08,560
muéstrame directamente

47
00:03:08,560 --> 00:03:12,719
el texto edad

48
00:03:12,719 --> 00:03:14,460
si yo

49
00:03:14,460 --> 00:03:15,599
ejecuto este código

50
00:03:15,599 --> 00:03:19,319
esto funciona perfectamente

51
00:03:19,319 --> 00:03:21,219
y

52
00:03:21,219 --> 00:03:33,810
vale, si yo ejecuto este código

53
00:03:33,810 --> 00:03:35,770
me muestra el primer texto

54
00:03:35,770 --> 00:03:37,729
y el segundo texto que yo

55
00:03:37,729 --> 00:03:39,810
le he puesto, edad, porque le he dicho

56
00:03:39,810 --> 00:03:41,909
oye, muéstrame literalmente el texto

57
00:03:41,909 --> 00:03:43,849
edad, pero no es lo que yo

58
00:03:43,849 --> 00:03:44,449
quiero hacer ahora

59
00:03:44,449 --> 00:03:47,430
lo que yo quiero hacer ahora es mostrar el

60
00:03:47,430 --> 00:03:49,030
contenido de la variable

61
00:03:49,030 --> 00:03:50,669
que se llame edad

62
00:03:50,669 --> 00:03:53,490
pues entonces para decirle a java

63
00:03:53,490 --> 00:03:54,710
oye tú

64
00:03:54,710 --> 00:03:57,050
quiero el contenido de esa variable

65
00:03:57,050 --> 00:03:59,210
pues entonces le doy

66
00:03:59,210 --> 00:04:00,310
el nombre de la variable

67
00:04:00,310 --> 00:04:06,680
¿vale? ¿qué ocurre?

68
00:04:07,020 --> 00:04:08,659
que aún así me ha salido

69
00:04:08,659 --> 00:04:09,919
un error de compilación

70
00:04:09,919 --> 00:04:12,840
veréis que se os ha

71
00:04:12,840 --> 00:04:13,979
puesto aquí rojito

72
00:04:13,979 --> 00:04:16,540
¿por qué se ha puesto

73
00:04:16,540 --> 00:04:18,540
rojito? porque

74
00:04:18,540 --> 00:04:20,759
claro, porque el

75
00:04:20,759 --> 00:04:22,800
compilador que está compilando

76
00:04:22,800 --> 00:04:24,319
sobre la marcha ha visto que hay un error.

77
00:04:24,899 --> 00:04:26,639
¿Vale? ¿Ese error cuál es? Ya lo podemos

78
00:04:26,639 --> 00:04:27,800
intuir, pero si uno

79
00:04:27,800 --> 00:04:30,879
quiere ver qué información

80
00:04:30,879 --> 00:04:32,779
le da el compilador, pone

81
00:04:32,779 --> 00:04:34,579
el cursor

82
00:04:34,579 --> 00:04:36,819
apoyado en la

83
00:04:36,819 --> 00:04:38,879
cosita roja, que sale a la izquierda,

84
00:04:39,540 --> 00:04:40,879
pone el cursor apoyado ahí

85
00:04:40,879 --> 00:04:43,139
y te sale el mensaje que te da el compilador.

86
00:04:43,800 --> 00:04:44,819
Y el compilador

87
00:04:44,819 --> 00:04:46,120
te dice, perdóname,

88
00:04:46,740 --> 00:04:48,620
pero la variabilidad me da

89
00:04:48,620 --> 00:04:49,600
que no tiene ningún valor.

90
00:04:51,339 --> 00:04:52,540
Justo es lo que está pasando.

91
00:04:52,540 --> 00:05:16,759
Yo he creado el espacio en memoria, edad, pero dentro está indefinido, con lo cual, si yo le digo muéstrame lo que contiene edad, me dice, es que edad no tiene nada, claro, porque antes de usar una variable, antes de acceder al contenido de una variable, para mostrarla, para lo que sea, tengo que darle un valor, ¿vale?

92
00:05:16,759 --> 00:05:21,860
Entonces, mi variable edad, ¿vale?

93
00:05:21,879 --> 00:05:23,399
Voy a ir introduciendo ya comentarios.

94
00:05:23,980 --> 00:05:26,319
Los comentarios ya más o menos sabéis lo que son.

95
00:05:26,420 --> 00:05:29,680
Comentarios es texto que uno pone en el programa,

96
00:05:30,160 --> 00:05:32,819
pero que no es para ejecutarse ni es para nada.

97
00:05:33,240 --> 00:05:34,720
Es una ayuda para el programador.

98
00:05:35,339 --> 00:05:37,060
Son los comentarios en el código.

99
00:05:38,160 --> 00:05:41,680
Yo comento mi código poniendo, explicando cosas.

100
00:05:42,220 --> 00:05:44,959
Pero lo explico para mí, me lo explico a mí.

101
00:05:44,959 --> 00:05:47,480
o se lo explico al que lo lea

102
00:05:47,480 --> 00:05:49,279
pero en la máquina virtual

103
00:05:49,279 --> 00:05:51,240
los comentarios no los ve obviamente

104
00:05:51,240 --> 00:05:52,319
para ella no existen

105
00:05:52,319 --> 00:05:55,000
los comentarios son explicaciones

106
00:05:55,000 --> 00:05:57,699
que puedo dejar ahí en el código colocaditos

107
00:05:57,699 --> 00:05:58,720
porque son muy útiles

108
00:05:58,720 --> 00:06:00,339
para cuando lo vuelva a mirar enterarme

109
00:06:00,339 --> 00:06:02,759
vale, entonces todas las explicaciones

110
00:06:02,759 --> 00:06:04,040
que pueda poner en un código

111
00:06:04,040 --> 00:06:05,959
todos los comentarios mejor

112
00:06:05,959 --> 00:06:07,800
cuando lo vuelva a abrir me acordaré

113
00:06:07,800 --> 00:06:09,300
de por qué narices hice yo eso

114
00:06:09,300 --> 00:06:11,959
bueno, pues entonces voy a poner aquí un comentario

115
00:06:11,959 --> 00:06:14,120
que en Java hay varias maneras

116
00:06:14,120 --> 00:06:24,519
pero la más sencilla es estas dos barras un comentario declaró la variable edad pero se

117
00:06:24,519 --> 00:06:39,699
queda como se queda sin valor se ha quedado sin ningún valor luego antes de mostrar edad tengo

118
00:06:39,699 --> 00:06:55,569
que darle un valor si no le doy un valor con toda la razón del mundo si no le doy un valor

119
00:06:55,569 --> 00:06:58,029
con toda la razón del mundo

120
00:06:58,029 --> 00:06:59,870
el compilador se queja

121
00:06:59,870 --> 00:07:02,509
y no te deja ejecutar nada, se queja

122
00:07:02,509 --> 00:07:05,129
porque mientras haya errores de compilación

123
00:07:05,129 --> 00:07:06,610
pues no ejecutes

124
00:07:06,610 --> 00:07:08,329
vale

125
00:07:08,329 --> 00:07:10,089
¿cómo arreglo esto?

126
00:07:10,430 --> 00:07:11,610
vamos a darle un valor

127
00:07:11,610 --> 00:07:16,660
vale, darle un valor

128
00:07:16,660 --> 00:07:18,399
a una variable, meter un valor

129
00:07:18,399 --> 00:07:20,259
en la cajita, en el espacio en round

130
00:07:20,259 --> 00:07:22,319
darle un valor, se llama

131
00:07:22,319 --> 00:07:24,540
asignar un valor

132
00:07:24,540 --> 00:07:26,259
vale, sería

133
00:07:26,259 --> 00:07:30,600
y se haría mediante una sentencia de asignación.

134
00:07:31,139 --> 00:07:33,220
Vamos a ponerlo aquí, ¿vale?

135
00:07:36,120 --> 00:07:43,319
Para dar un valor a una variable, ¿qué hacemos?

136
00:07:44,000 --> 00:07:50,639
Usamos la sentencia de asignación,

137
00:07:51,000 --> 00:07:54,660
que como su propio nombre indica,

138
00:07:55,680 --> 00:07:58,660
sirve para asignar un valor a una variable.

139
00:07:58,660 --> 00:08:02,519
La sentencia de asignación, que no la hemos usado todavía,

140
00:08:02,519 --> 00:08:04,220
sentencia de asignación

141
00:08:04,220 --> 00:08:09,879
la sentencia de asignación

142
00:08:09,879 --> 00:08:11,720
sirve para dar valor a una variable

143
00:08:11,720 --> 00:08:15,240
vale, ¿cómo es?

144
00:08:15,500 --> 00:08:16,939
¿cómo se usa

145
00:08:16,939 --> 00:08:18,399
la sentencia de asignación?

146
00:08:19,540 --> 00:08:20,560
se usa

147
00:08:20,560 --> 00:08:21,740
como todo en Java

148
00:08:21,740 --> 00:08:23,939
con unas reglas muy estrictas

149
00:08:23,939 --> 00:08:26,480
exclusivamente lo vamos a hacer ahora

150
00:08:26,480 --> 00:08:27,740
y solo así

151
00:08:27,740 --> 00:08:31,000
la sentencia de asignación siempre es

152
00:08:31,000 --> 00:08:32,820
la voy a poner primero

153
00:08:32,820 --> 00:08:34,720
en comentarios y luego la escribimos

154
00:08:34,720 --> 00:08:46,870
A la izquierda, nombre de la variable, el que sea, nombre de la variable a la que yo quiero asignar un valor.

155
00:08:48,110 --> 00:08:56,370
Luego pongo el igual, luego pongo el valor que quiero darle y termino con un punto y coma.

156
00:08:57,909 --> 00:09:03,730
¿Vale? Así es la sentencia de asignación y siempre es así.

157
00:09:03,730 --> 00:09:06,669
izquierda

158
00:09:06,669 --> 00:09:08,409
un nombre de variable

159
00:09:08,409 --> 00:09:10,409
una cajita, un nombre de variable

160
00:09:10,409 --> 00:09:12,830
igual

161
00:09:12,830 --> 00:09:16,200
y a la derecha

162
00:09:16,200 --> 00:09:17,659
el valor que yo quiera

163
00:09:17,659 --> 00:09:19,379
el que me dé la gana

164
00:09:19,379 --> 00:09:22,500
terminado en punto y coma

165
00:09:22,500 --> 00:09:24,659
esa es la sentencia

166
00:09:24,659 --> 00:09:25,399
de asignación

167
00:09:25,399 --> 00:09:27,840
y por eso al operador igual

168
00:09:27,840 --> 00:09:30,059
se le llama el operador de

169
00:09:30,059 --> 00:09:31,460
asignación

170
00:09:31,460 --> 00:09:37,750
ese es el operador igual

171
00:09:37,750 --> 00:09:38,789
El operador de asignación.

172
00:09:47,830 --> 00:09:51,210
Bueno, pues vamos a asignar un primer valor a mi variable edad.

173
00:09:52,690 --> 00:09:56,690
Pues edad igual el valor.

174
00:09:57,870 --> 00:10:03,330
Pero claro, el valor tiene que ser del tipo para el que yo he declarado la variable.

175
00:10:04,169 --> 00:10:05,309
Tiene que ser de ese tipo.

176
00:10:05,950 --> 00:10:10,690
Si no es de ese tipo, el compilador se va a quejar otra vez.

177
00:10:11,690 --> 00:10:15,029
Si yo pongo 45, maravilloso.

178
00:10:15,909 --> 00:10:17,830
Porque 45 es un número entero.

179
00:10:18,610 --> 00:10:19,230
No se queja.

180
00:10:20,470 --> 00:10:21,509
Termino con punto y coma.

181
00:10:22,049 --> 00:10:25,649
Y ahora ya el errorcito que me daba aquí se quitó.

182
00:10:26,070 --> 00:10:27,809
Porque ahora ya edad tiene un valor.

183
00:10:30,039 --> 00:10:30,259
¿Vale?

184
00:10:31,159 --> 00:10:33,639
Que pongo menos 45.

185
00:10:35,259 --> 00:10:35,820
También.

186
00:10:36,419 --> 00:10:36,659
¿Vale?

187
00:10:37,019 --> 00:10:38,360
No se queja el compilador.

188
00:10:39,320 --> 00:10:43,299
No se queja porque menos 45 es un número entero válido.

189
00:10:43,899 --> 00:10:46,259
Cualquier cosa que sea un número entero, maravilloso.

190
00:10:46,259 --> 00:10:47,779
porque edad está como entera

191
00:10:47,779 --> 00:10:50,639
y los números enteros

192
00:10:50,639 --> 00:10:51,860
¿cómo los escribimos en Java?

193
00:10:52,100 --> 00:10:53,580
pues como los escribimos sobre el papel

194
00:10:53,580 --> 00:10:56,120
las cifras que sean y un menos delante

195
00:10:56,120 --> 00:10:58,139
y el negativo, ya está, no hay ninguna duda

196
00:10:58,139 --> 00:10:59,500
sobre cómo escribir un número entero

197
00:10:59,500 --> 00:11:01,059
la cifra que sea

198
00:11:01,059 --> 00:11:04,500
con los dígitos que sean, menos el negativo

199
00:11:04,500 --> 00:11:05,179
y ya está

200
00:11:05,179 --> 00:11:08,220
yo le doy un número entero tal y como lo escribo

201
00:11:08,220 --> 00:11:09,059
yo sobre el papel

202
00:11:09,059 --> 00:11:11,700
y Java ya lo entiende, lo asigna

203
00:11:11,700 --> 00:11:13,000
y se acabó, dime

204
00:11:13,000 --> 00:11:15,399
¿cómo lo ponemos en el primer instante?

205
00:11:15,399 --> 00:11:17,840
no, porque eso no es un número entero

206
00:11:17,840 --> 00:11:20,279
y aparte para ponerlo

207
00:11:20,279 --> 00:11:22,220
tendría que poder ponerlo

208
00:11:22,220 --> 00:11:24,259
y en logaritmo neperiano de 5 no hay un operador

209
00:11:24,259 --> 00:11:25,220
para hacer logaritmo neperiano

210
00:11:25,220 --> 00:11:27,720
tendría que llamar a un objeto

211
00:11:27,720 --> 00:11:28,840
que sea capaz de hacerlo

212
00:11:28,840 --> 00:11:31,919
porque solamente se pueden hacer

213
00:11:31,919 --> 00:11:33,960
sin utilizar objetos adicionales

214
00:11:33,960 --> 00:11:35,899
las operaciones aritméticas básicas

215
00:11:35,899 --> 00:11:37,120
como revisar el número

216
00:11:37,120 --> 00:11:38,740
entonces

217
00:11:38,740 --> 00:11:42,080
¿qué pasa si yo

218
00:11:42,080 --> 00:11:42,980
pretendo poner

219
00:11:42,980 --> 00:11:45,860
45.9

220
00:11:45,860 --> 00:11:50,139
claro, 45.9

221
00:11:50,139 --> 00:11:51,820
sería la forma

222
00:11:51,820 --> 00:11:53,659
en la que ponemos en Java los decimales

223
00:11:53,659 --> 00:11:55,399
en lugar de una copita ponemos un punto

224
00:11:55,399 --> 00:12:00,259
bueno, pues Java entiende

225
00:12:00,259 --> 00:12:03,419
45.9 o menos 12.7

226
00:12:03,419 --> 00:12:05,259
como números decimales

227
00:12:05,259 --> 00:12:06,980
y me dice

228
00:12:06,980 --> 00:12:09,039
no, no, no, error de compilación

229
00:12:09,039 --> 00:12:10,259
no te dejo

230
00:12:10,259 --> 00:12:12,659
entonces efectivamente nos restringe

231
00:12:12,659 --> 00:12:14,919
un montón la libertad, a mi me encantaría una variable

232
00:12:14,919 --> 00:12:17,600
en la que le pueda poner

233
00:12:17,600 --> 00:12:19,279
a un entero, a un decimal,

234
00:12:19,480 --> 00:12:21,419
lo que me dé la gana. Maravilloso,

235
00:12:21,500 --> 00:12:23,480
eso hace Python. Vale, me meto lo que

236
00:12:23,480 --> 00:12:25,399
quiera. Los códigos

237
00:12:25,399 --> 00:12:27,159
me salen señores de compilación a la primera.

238
00:12:28,000 --> 00:12:29,080
Ojo con las ejecuciones.

239
00:12:30,779 --> 00:12:31,220
Aquí,

240
00:12:31,460 --> 00:12:33,480
desde el principio, tienes que ser tan

241
00:12:33,480 --> 00:12:35,059
cuidadoso,

242
00:12:35,059 --> 00:12:37,179
porque como cometas errores,

243
00:12:37,299 --> 00:12:39,759
como no está todo bien diseñado, bien pensado,

244
00:12:40,159 --> 00:12:41,399
el compilador no te deja

245
00:12:41,399 --> 00:12:43,279
seguir. Gracias a eso,

246
00:12:43,279 --> 00:12:45,200
el programa cuando ya está hecho y se ejecuta

247
00:12:45,200 --> 00:12:45,899
es más robusto.

248
00:12:46,940 --> 00:12:49,179
Pues 45.9 no podemos

249
00:12:49,179 --> 00:12:50,779
porque no es un tipo compatible.

250
00:12:51,460 --> 00:12:51,659
¿Vale?

251
00:12:53,379 --> 00:12:53,860
Pero

252
00:12:53,860 --> 00:12:55,940
45 sí.

253
00:12:57,539 --> 00:12:59,100
Y de hecho, si ahora ejecutamos

254
00:12:59,100 --> 00:12:59,820
este programa,

255
00:13:01,940 --> 00:13:02,620
pues ahora

256
00:13:02,620 --> 00:13:04,279
efectivamente

257
00:13:04,279 --> 00:13:07,340
me ha mostrado

258
00:13:07,340 --> 00:13:09,100
el contenido de la variable.

259
00:13:09,700 --> 00:13:10,179
¿Vale?

260
00:13:10,960 --> 00:13:11,480
45.

261
00:13:13,279 --> 00:13:17,490
¿Hasta dónde?

262
00:13:27,879 --> 00:13:28,480
Vale

263
00:13:28,480 --> 00:13:34,720
Aquí ahora ya hay

264
00:13:34,720 --> 00:13:37,100
Pues pequeñas

265
00:13:37,100 --> 00:13:39,039
Cositas de manejo

266
00:13:39,039 --> 00:13:40,139
De números enteros

267
00:13:40,139 --> 00:13:42,639
Vamos, pues bueno, para entretenernos

268
00:13:42,639 --> 00:13:43,399
Algunas

269
00:13:43,399 --> 00:13:47,850
En edad, cabe hasta donde cabe

270
00:13:47,850 --> 00:13:50,789
Si aquí va aumentando la esperanza de vida

271
00:13:50,789 --> 00:13:52,009
Aumentando la esperanza de vida

272
00:13:52,009 --> 00:13:54,149
Pues vale

273
00:13:54,149 --> 00:13:55,750
Uy, llega un momento en que ya

274
00:13:55,750 --> 00:13:59,610
Este número

275
00:13:59,610 --> 00:14:01,789
Me cabe en un int

276
00:14:01,789 --> 00:14:03,690
si hacemos las operaciones

277
00:14:03,690 --> 00:14:05,250
matemáticas entre

278
00:14:05,250 --> 00:14:07,509
menos 2 a la 31

279
00:14:07,509 --> 00:14:09,269
este cabe

280
00:14:09,269 --> 00:14:11,929
pero como sigo aumentando la esperanza de vida

281
00:14:11,929 --> 00:14:13,289
y yo pretendo

282
00:14:13,289 --> 00:14:14,590
en edades así

283
00:14:14,590 --> 00:14:18,289
como veis, este ya el compilador

284
00:14:18,289 --> 00:14:19,269
dice

285
00:14:19,269 --> 00:14:20,889
nanay, ¿por qué?

286
00:14:21,429 --> 00:14:23,529
porque este número no cabe en 32 bits

287
00:14:23,529 --> 00:14:25,610
luego te dice

288
00:14:25,610 --> 00:14:26,990
no puede seguir

289
00:14:26,990 --> 00:14:29,629
si tú quieres usar una edad así de

290
00:14:29,629 --> 00:14:31,509
grandota, tendrás que

291
00:14:31,509 --> 00:14:33,070
declararte una variable long

292
00:14:33,070 --> 00:14:34,730
porque esto no cabe

293
00:14:34,730 --> 00:14:36,289
en 32 bits

294
00:14:36,289 --> 00:14:44,120
¿vale? por curiosidad

295
00:14:44,120 --> 00:14:46,399
para que veamos cuál es el margen

296
00:14:46,399 --> 00:14:47,039
de enteros

297
00:14:47,039 --> 00:14:53,629
vamos a ver aquí

298
00:14:53,629 --> 00:14:55,730
menor número

299
00:14:55,730 --> 00:14:57,970
almacenable

300
00:14:58,649 --> 00:14:59,889
en int

301
00:14:59,889 --> 00:15:08,649
vale, aunque ahora no entendamos muy bien

302
00:15:08,649 --> 00:15:09,070
por qué

303
00:15:09,070 --> 00:15:12,450
esta cosita de aquí, esta variable

304
00:15:12,450 --> 00:15:13,289
que ya está hecha

305
00:15:13,289 --> 00:15:18,059
esto, porque

306
00:15:18,059 --> 00:15:20,179
Java, como todos los

307
00:15:20,179 --> 00:15:22,159
lenguajes, tiene

308
00:15:22,159 --> 00:15:23,860
algunas variables

309
00:15:23,860 --> 00:15:27,860
que están en un contexto

310
00:15:27,860 --> 00:15:29,659
de este integer. Olvidaos,

311
00:15:29,779 --> 00:15:32,159
como si no hubiera dicho nada. Esto es

312
00:15:32,159 --> 00:15:34,240
solo, lo he puesto

313
00:15:34,240 --> 00:15:36,039
solo, porque os digo

314
00:15:36,039 --> 00:15:38,379
y os tenéis que creer, porque ahí no podemos entenderlo,

315
00:15:38,919 --> 00:15:39,519
que esto

316
00:15:39,519 --> 00:15:42,399
tiene el menor valor entero posible.

317
00:15:42,399 --> 00:15:44,600
Lo he puesto solo para que veamos por curiosidad

318
00:15:44,600 --> 00:15:45,059
cuál es.

319
00:15:46,740 --> 00:15:48,659
Sí, voy a poner también el máximo,

320
00:15:49,279 --> 00:15:50,220
que es el max value.

321
00:15:58,090 --> 00:15:59,470
Sí, esto es

322
00:15:59,470 --> 00:16:01,409
solo para que lo veamos por curiosidad.

323
00:16:02,590 --> 00:16:03,990
Mayor número almacenable

324
00:16:03,990 --> 00:16:07,279
en int. Vale.

325
00:16:07,639 --> 00:16:10,059
Entonces, si yo hago este system.out.println,

326
00:16:11,379 --> 00:16:11,759
esto

327
00:16:11,759 --> 00:16:13,039
es una variable,

328
00:16:13,159 --> 00:16:15,460
hemos creado nosotros, pero creámoslo,

329
00:16:15,620 --> 00:16:17,299
es una variable, está por ahí, ya entenderemos

330
00:16:17,299 --> 00:16:19,200
por qué está por ahí, por qué puede acceder a ella,

331
00:16:19,279 --> 00:16:21,240
ya lo entenderemos, que guarda

332
00:16:21,240 --> 00:16:23,139
el menor número posible almacenable

333
00:16:23,139 --> 00:16:30,539
Y esta es una variable que está por ahí, ya veremos por qué la podemos usar sin haberla creado nosotros, que guarda el mayor número almacenable en int.

334
00:16:30,799 --> 00:16:39,299
Vamos a ejecutar esto a ver qué contenido tiene esto y qué contenido tiene esto para ver cuáles son estos dos valores.

335
00:16:40,980 --> 00:16:50,440
Pues este es el menor número posible almacenable en int y este es el mayor número posible almacenable en int.

336
00:16:50,440 --> 00:16:52,620
Según el complemento a dos

337
00:16:52,620 --> 00:16:58,740
Si necesitamos programas

338
00:16:58,740 --> 00:17:01,100
Que trabajen con números enteros

339
00:17:01,100 --> 00:17:02,500
Más grandotes que estos

340
00:17:02,500 --> 00:17:04,559
Tenemos que usarlo

341
00:17:04,559 --> 00:17:06,079
¿Vale?

342
00:17:07,839 --> 00:17:11,579
Porque long ya sí que

343
00:17:11,579 --> 00:17:13,359
Son un montón más

344
00:17:13,359 --> 00:17:14,700
Vamos a ponerlos por curiosidad

345
00:17:14,700 --> 00:17:19,650
Voy a copiar y pegar esto

346
00:17:19,650 --> 00:17:27,900
Mayor número almacenable en long

347
00:17:27,900 --> 00:17:31,319
Acto de fe

348
00:17:31,319 --> 00:17:33,980
que hacéis

349
00:17:33,980 --> 00:17:36,559
para creeros que en esa variable

350
00:17:36,559 --> 00:17:38,500
que está ahí se guarda el menor número

351
00:17:38,500 --> 00:17:39,319
almacenable en long.

352
00:17:40,059 --> 00:17:42,259
Mayor número almacenable en long.

353
00:17:42,920 --> 00:17:44,420
De nuevo, acto de fe

354
00:17:44,420 --> 00:17:45,259
que hacéis

355
00:17:45,259 --> 00:17:48,519
para creeros que en esta variable extraña

356
00:17:48,519 --> 00:17:49,700
que no sabemos de dónde ha salido,

357
00:17:49,759 --> 00:17:52,259
se guarda el mayor

358
00:17:52,259 --> 00:17:53,480
número almacenable en long.

359
00:17:54,660 --> 00:17:56,319
Vamos a ejecutarlo solo para

360
00:17:56,319 --> 00:17:58,019
conocer esos datos, solo para eso.

361
00:18:01,049 --> 00:18:01,950
Pues hombre, muy gordo.

362
00:18:05,029 --> 00:18:05,829
Es muy grandote.

363
00:18:07,309 --> 00:18:09,269
Eso sí, si alguien intenta almacenar

364
00:18:09,269 --> 00:18:11,210
un número mayor que ese,

365
00:18:11,990 --> 00:18:12,690
tiene ya

366
00:18:12,690 --> 00:18:15,609
que hacer su propio código

367
00:18:15,609 --> 00:18:17,730
que desmonte el número,

368
00:18:17,910 --> 00:18:19,589
lo guarde en diferentes partes, etc.

369
00:18:20,069 --> 00:18:20,549
¿Por qué no?

370
00:18:21,109 --> 00:18:22,710
En una variable primitiva tal cual,

371
00:18:23,109 --> 00:18:24,130
en una variable long,

372
00:18:25,049 --> 00:18:26,450
ese es el mayor número entero que se puede guardar.

373
00:18:26,549 --> 00:18:30,509
Digamos que tenemos una cantidad de datos.

374
00:18:30,589 --> 00:18:31,950
Si tú tienes un...

375
00:18:31,950 --> 00:18:34,109
No, una cosa es una cantidad de datos enorme

376
00:18:34,109 --> 00:18:36,269
y otra cosa es el mayor valor posible.

377
00:18:36,410 --> 00:18:37,109
de cada número

378
00:18:37,109 --> 00:18:39,650
de cada número long

379
00:18:39,650 --> 00:18:42,670
que tú guardes, el mayor valor posible

380
00:18:42,670 --> 00:18:44,710
que puede alcanzar ese número es este

381
00:18:44,710 --> 00:18:46,549
pero realmente hay alguna

382
00:18:46,549 --> 00:18:48,609
situación en la que tú

383
00:18:48,609 --> 00:18:49,930
tengas una cantidad

384
00:18:49,930 --> 00:18:52,569
de cosas que gestionar

385
00:18:52,569 --> 00:18:54,269
de ordenadores, de alumnos

386
00:18:54,269 --> 00:18:56,210
que sea más grande que esta

387
00:18:56,210 --> 00:18:57,250
es difícil

388
00:18:57,250 --> 00:19:00,710
pero bueno, tendrá sus propios

389
00:19:00,710 --> 00:19:02,650
lenguajes de programación con sus propias cosas

390
00:19:02,650 --> 00:19:04,609
la NASA no programajaba

391
00:19:04,609 --> 00:19:07,589
eso seguro

392
00:19:07,589 --> 00:19:09,990
pues estrellarían todos los cohetes

393
00:19:09,990 --> 00:19:11,490
tendrán su fron

394
00:19:11,490 --> 00:19:13,789
un punto y coma mal puesto

395
00:19:13,789 --> 00:19:14,630
y ya se estrelló

396
00:19:14,630 --> 00:19:17,630
bueno, un punto y coma no llegaría

397
00:19:17,630 --> 00:19:19,930
a ejecutarse el programa, pero el tema no es ese

398
00:19:19,930 --> 00:19:21,829
no es por problemas

399
00:19:21,829 --> 00:19:23,710
de Java, sino es por la lentitud

400
00:19:23,710 --> 00:19:25,670
de la máquina virtual, hasta que el programa

401
00:19:25,670 --> 00:19:27,210
arranca, pues la

402
00:19:27,210 --> 00:19:29,910
nave ya se ha salido de la atmósfera

403
00:19:29,910 --> 00:19:31,750
y ya le da igual que le den la trayectoria

404
00:19:31,750 --> 00:19:32,549
porque ya se ha salido

405
00:19:32,549 --> 00:19:35,789
Es por la lentitud del código el problema

406
00:19:35,789 --> 00:19:37,529
La lentitud de la ejecución

407
00:19:37,529 --> 00:19:41,029
Vale, pues resulta

408
00:19:41,029 --> 00:19:42,450
Que aún así

409
00:19:42,450 --> 00:19:44,130
Nosotros queremos

410
00:19:44,130 --> 00:19:46,690
Un número más grandote que este

411
00:19:46,690 --> 00:19:49,430
Este es el más grande almacenable

412
00:19:49,430 --> 00:19:50,069
En int, ¿verdad?

413
00:19:51,450 --> 00:19:52,609
Pues entonces

414
00:19:52,609 --> 00:19:54,769
Vamos a darle a nuestra variable edad

415
00:19:54,769 --> 00:19:57,509
Este número

416
00:19:57,509 --> 00:20:00,849
Y este lo coge

417
00:20:00,849 --> 00:20:02,329
Este lo coge

418
00:20:02,329 --> 00:20:04,690
Pero como yo me salté al 8

419
00:20:04,690 --> 00:20:08,170
como ya me saltea el 8 ese ya no le gusta

420
00:20:08,170 --> 00:20:09,990
porque ese ya se ha salido

421
00:20:09,990 --> 00:20:11,950
de lo máximo almacenable

422
00:20:11,950 --> 00:20:15,890
que pasa si yo

423
00:20:15,890 --> 00:20:17,529
quiero guardar este numerito

424
00:20:17,529 --> 00:20:20,029
necesito una variable

425
00:20:20,029 --> 00:20:20,450
long

426
00:20:20,450 --> 00:20:23,930
no hay tu tía, una variable long

427
00:20:23,930 --> 00:20:29,019
este numerito

428
00:20:29,019 --> 00:20:31,400
ya lo puedo

429
00:20:31,400 --> 00:20:33,279
guardar en

430
00:20:33,279 --> 00:20:35,160
una variable long

431
00:20:35,160 --> 00:20:37,279
vale

432
00:20:37,279 --> 00:20:41,150
este no, sigue saliendo

433
00:20:41,150 --> 00:20:43,009
rojo, ahora os explico por qué, ¿vale?

434
00:20:44,190 --> 00:20:45,150
Entonces, ahora

435
00:20:45,150 --> 00:20:47,029
os lo digo, pero está claro, ¿no?

436
00:20:47,109 --> 00:20:49,029
Aquí ya con el 8 ya no puedo.

437
00:20:50,089 --> 00:20:51,049
Este ya sí

438
00:20:51,049 --> 00:20:53,089
que me cabe en long, sí que me cabe

439
00:20:53,089 --> 00:20:54,730
en long, pero

440
00:20:54,730 --> 00:20:55,890
cosita,

441
00:20:57,349 --> 00:20:58,670
la máquina virtual

442
00:20:58,670 --> 00:21:01,009
¿cómo funciona? Porque luego el funcionamiento

443
00:21:01,009 --> 00:21:03,089
de la máquina virtual tiene sus cositas.

444
00:21:04,150 --> 00:21:05,250
La máquina virtual

445
00:21:05,250 --> 00:21:06,349
lo primero que hace es

446
00:21:06,349 --> 00:21:11,250
coge

447
00:21:11,250 --> 00:21:14,170
Este identificador

448
00:21:14,170 --> 00:21:16,190
Crea el espacio en memoria

449
00:21:16,190 --> 00:21:17,750
Bueno, en este caso era de 32

450
00:21:17,750 --> 00:21:19,670
Que lo creo de antes, en este de 64

451
00:21:19,670 --> 00:21:21,289
Y ahí lo deja esperando

452
00:21:21,289 --> 00:21:24,170
Bueno, a ver, perdón, os he liado

453
00:21:24,170 --> 00:21:25,990
He asignado la vez que he declarado

454
00:21:25,990 --> 00:21:27,750
Que esto se puede hacer

455
00:21:27,750 --> 00:21:30,289
Pero vamos por partes

456
00:21:30,289 --> 00:21:31,130
Para no liaros

457
00:21:31,130 --> 00:21:33,130
Declaro longe edad tocha

458
00:21:33,130 --> 00:21:35,289
Y ahora ya sí, a edad tocha

459
00:21:35,289 --> 00:21:37,069
Le asigno el valor

460
00:21:37,069 --> 00:21:39,710
Que era este, para hacerlo igual que antes

461
00:21:39,710 --> 00:21:44,859
y no complicar la vida al que se líe.

462
00:21:45,880 --> 00:21:46,160
Vale.

463
00:21:47,299 --> 00:21:48,940
A edad tocha le doy el 8.

464
00:21:49,519 --> 00:21:52,180
Y ahora me diréis, pero Jolines, que no puede ser.

465
00:21:52,619 --> 00:21:53,920
Que esto cabe en long.

466
00:21:53,920 --> 00:21:57,980
Que hemos visto antes los posibles valores de long

467
00:21:57,980 --> 00:21:58,859
y ese cabe.

468
00:21:59,099 --> 00:22:00,140
¿Por qué me sale en rojo?

469
00:22:01,019 --> 00:22:02,680
Bueno, por una chorradita que se arregla rápido,

470
00:22:02,819 --> 00:22:03,660
pero os voy a explicar por qué.

471
00:22:04,259 --> 00:22:05,640
Bueno, la máquina virtual, ¿qué hace?

472
00:22:06,480 --> 00:22:07,259
Ha cogido esta.

473
00:22:07,400 --> 00:22:08,519
Primero ha declarado la variable.

474
00:22:08,660 --> 00:22:09,079
Fenomenal.

475
00:22:09,079 --> 00:22:11,660
ha creado un espacio de 64 bits

476
00:22:11,660 --> 00:22:12,920
en RAM muy grande

477
00:22:12,920 --> 00:22:14,960
le ha puesto el nombrecito

478
00:22:14,960 --> 00:22:16,960
edadtoche y se acabó

479
00:22:16,960 --> 00:22:19,039
vale, siguiente sentencia

480
00:22:19,039 --> 00:22:20,200
dice

481
00:22:20,200 --> 00:22:22,740
aquí tenemos una asignación

482
00:22:22,740 --> 00:22:24,700
maravilloso, una asignación

483
00:22:24,700 --> 00:22:27,079
él se pone ya en chip de asignación

484
00:22:27,079 --> 00:22:29,160
en ese chip que hace la máquina virtual

485
00:22:29,160 --> 00:22:30,819
mira a ver

486
00:22:30,819 --> 00:22:31,920
lo que hay aquí

487
00:22:31,920 --> 00:22:35,200
si eso es una lista de cifras

488
00:22:35,200 --> 00:22:36,960
normal y corriente, sin puntos

489
00:22:36,960 --> 00:22:38,880
y sin nada, una lista

490
00:22:38,880 --> 00:22:40,440
de cifras normales y corrientes

491
00:22:40,440 --> 00:22:43,140
3, 5, 8 o menos 4, 3, 2

492
00:22:43,140 --> 00:22:44,940
pues él

493
00:22:44,940 --> 00:22:46,700
interpreta que tú le quieres dar

494
00:22:46,700 --> 00:22:48,259
un número entero

495
00:22:48,259 --> 00:22:50,640
interpreta que le quieres dar un índice

496
00:22:50,640 --> 00:22:52,680
entonces lo construye

497
00:22:52,680 --> 00:22:53,700
en 32 bits

498
00:22:53,700 --> 00:22:57,230
pero claro

499
00:22:57,230 --> 00:23:00,230
él está intentando construir esto

500
00:23:00,230 --> 00:23:01,269
en 32 bits

501
00:23:01,269 --> 00:23:02,849
y no puede

502
00:23:02,849 --> 00:23:06,789
entonces cuando le damos un numerito

503
00:23:06,789 --> 00:23:08,970
que queremos que lo construya

504
00:23:08,970 --> 00:23:11,470
en 64, porque luego

505
00:23:11,470 --> 00:23:13,230
se lo vamos a pasar a una variable

506
00:23:13,230 --> 00:23:15,450
compatible, que la asignación ya

507
00:23:15,450 --> 00:23:16,950
viene después, primero lo construye

508
00:23:16,950 --> 00:23:18,970
y luego ya decide a quién se lo mete

509
00:23:18,970 --> 00:23:21,650
pues hay que decirle

510
00:23:21,650 --> 00:23:23,309
oye, construyemelo

511
00:23:23,309 --> 00:23:24,569
en 64 bits

512
00:23:24,569 --> 00:23:27,690
y eso se lo decimos poniendo

513
00:23:27,690 --> 00:23:29,430
una L al final

514
00:23:29,430 --> 00:23:30,609
¿vale?

515
00:23:32,680 --> 00:23:35,079
entonces, lo ponemos

516
00:23:35,079 --> 00:23:39,950
aquí abajo, la L

517
00:23:39,950 --> 00:23:40,869
del final

518
00:23:40,869 --> 00:23:44,190
es para que la

519
00:23:44,190 --> 00:23:46,369
máquina virtual de Java

520
00:23:46,369 --> 00:23:52,710
construya

521
00:23:52,710 --> 00:23:53,710
ese número

522
00:23:53,710 --> 00:23:56,890
con 64 bits

523
00:23:56,890 --> 00:23:58,009
no con 32

524
00:23:58,009 --> 00:24:00,990
ve la L y dice

525
00:24:00,990 --> 00:24:03,329
ah, que lo vas a guardar en un long

526
00:24:03,329 --> 00:24:05,269
tus intenciones con este número

527
00:24:05,269 --> 00:24:07,089
tus intenciones es llevarlo a un long

528
00:24:07,089 --> 00:24:08,309
es tus intenciones

529
00:24:08,309 --> 00:24:11,250
lo ve con la L, dice vale, muy bien

530
00:24:11,250 --> 00:24:13,150
me voy a coger 64 bits

531
00:24:13,150 --> 00:24:15,349
codifico y ya que lo tengo construido

532
00:24:15,349 --> 00:24:17,190
ahora ya me voy a ver

533
00:24:17,190 --> 00:24:18,349
a quién se lo quieres dar

534
00:24:18,349 --> 00:24:19,589
a edad tocha

535
00:24:19,589 --> 00:24:22,369
menos mal que edad tocha está declarada como long

536
00:24:22,369 --> 00:24:25,089
porque después de que me lo has hecho construir en 64

537
00:24:25,089 --> 00:24:26,990
me das una que no es long

538
00:24:26,990 --> 00:24:28,049
y te vuelvo a decir que no

539
00:24:28,049 --> 00:24:30,170
pero como edad tocha está como long

540
00:24:30,170 --> 00:24:32,650
eso que ella ha construido en 64 bits

541
00:24:32,650 --> 00:24:35,269
cabe aquí, lo asigna y ningún problema

542
00:24:35,269 --> 00:24:36,109
un segundito

543
00:24:36,109 --> 00:24:39,309
si yo aquí me hubiera

544
00:24:39,309 --> 00:24:40,269
vuelto a equivocar

545
00:24:40,269 --> 00:24:42,589
y hubiera vuelto un int

546
00:24:42,589 --> 00:24:48,740
Me volvería a salir un error

547
00:24:48,740 --> 00:24:51,079
Porque claro, él ve la L

548
00:24:51,079 --> 00:24:52,700
Dice, ah, vale

549
00:24:52,700 --> 00:24:54,099
Quieres construir un número 64

550
00:24:54,099 --> 00:24:57,259
Construye el numerito en 64 bits

551
00:24:57,259 --> 00:24:58,220
Ningún problema

552
00:24:58,220 --> 00:24:59,839
Siguiente paso

553
00:24:59,839 --> 00:25:03,079
A ver, ¿dónde quieres que meta este número que he construido en 64?

554
00:25:03,359 --> 00:25:04,059
Porque tiene una L

555
00:25:04,059 --> 00:25:04,960
¿Dónde quieres que lo meta?

556
00:25:05,759 --> 00:25:07,440
Edad tocha, vale, voy a meterlo

557
00:25:07,440 --> 00:25:08,039
Edad tocha

558
00:25:08,039 --> 00:25:10,980
Uy, no me cabe

559
00:25:10,980 --> 00:25:12,720
No me cabe porque lo he declarado como L

560
00:25:12,720 --> 00:25:14,279
Pues eso es lo que te dice

561
00:25:14,279 --> 00:25:15,980
¿Vale?

562
00:25:19,829 --> 00:25:20,230
Dime

563
00:25:20,230 --> 00:25:22,730
¿Por qué no es suficiente con declarar el valor?

564
00:25:23,470 --> 00:25:24,309
¿Por qué hay que poner la E?

565
00:25:25,269 --> 00:25:28,109
Porque la máquina virtual

566
00:25:28,109 --> 00:25:29,210
Actúa en secuencia

567
00:25:29,210 --> 00:25:30,789
O sea, una cosa es el compilador

568
00:25:30,789 --> 00:25:32,410
Y otra cosa es la máquina virtual

569
00:25:32,410 --> 00:25:34,150
Entonces, la máquina virtual

570
00:25:34,150 --> 00:25:37,849
No mira antes la variable a la que va

571
00:25:37,849 --> 00:25:40,289
Lo primero que hace es construirte el valor

572
00:25:40,289 --> 00:25:42,569
Entonces, para construirte el valor

573
00:25:42,569 --> 00:25:44,089
Tiene que tener ya la información

574
00:25:44,089 --> 00:25:46,990
De si lo quiere construir en 64 o en 16

575
00:25:46,990 --> 00:25:49,109
¿Vale? Entonces, como es lo primero

576
00:25:49,109 --> 00:25:50,930
que hace, si tú quieres que lo construya

577
00:25:50,930 --> 00:25:52,950
64, si tú quieres

578
00:25:52,950 --> 00:25:54,970
que este número vaya a 64, que en este

579
00:25:54,970 --> 00:25:56,890
caso tiene que ir por el

580
00:25:56,890 --> 00:25:59,009
direccionar la L, es por la forma de funcionamiento de la máquina

581
00:25:59,009 --> 00:26:00,930
virtual, ¿vale? No es que ya lo

582
00:26:00,930 --> 00:26:02,869
mire en conjunto y diga, ah, vale

583
00:26:02,869 --> 00:26:04,950
deduzco, lo expando

584
00:26:04,950 --> 00:26:06,990
a 64 porque va a lo, podría

585
00:26:06,990 --> 00:26:08,849
pero no, ¿vale?

586
00:26:12,420 --> 00:26:13,440
Eso no significa

587
00:26:13,440 --> 00:26:15,400
un segundito ya, eso no significa

588
00:26:15,400 --> 00:26:17,640
que yo aquí, en la variable

589
00:26:17,640 --> 00:26:19,160
log, tenga que ponerlo todo con L

590
00:26:19,160 --> 00:26:22,579
No, yo puedo darle 78

591
00:26:22,579 --> 00:26:25,720
¿Por qué?

592
00:26:27,099 --> 00:26:28,119
¿Aquí qué ocurrirá?

593
00:26:28,759 --> 00:26:30,279
Y ya terminamos

594
00:26:30,279 --> 00:26:31,960
Después de las preguntas terminamos con esto

595
00:26:31,960 --> 00:26:34,720
Aquí yo le he dado 78

596
00:26:34,720 --> 00:26:36,319
Pero le he puesto la L

597
00:26:36,319 --> 00:26:38,339
Pero ya sabemos que

598
00:26:38,339 --> 00:26:40,180
En la máquina virtual lo primero que hace es

599
00:26:40,180 --> 00:26:42,660
Que quieres construir un entero

600
00:26:42,660 --> 00:26:44,480
78, ah muy bien

601
00:26:44,480 --> 00:26:46,259
Como no está la L

602
00:26:46,259 --> 00:26:48,819
Te lo construyo en 32 bits

603
00:26:48,819 --> 00:26:50,500
Ningún problema porque cabe en 32

604
00:26:50,500 --> 00:26:51,500
te lo construye

605
00:26:51,500 --> 00:26:54,579
ahora ya dice, ya lo tengo construido en 32 bits

606
00:26:54,579 --> 00:26:55,779
porque no está la L, 32

607
00:26:55,779 --> 00:26:57,319
¿dónde quieres meterlo?

608
00:26:57,940 --> 00:26:58,779
en edad tocha

609
00:26:58,779 --> 00:27:02,559
edad tocha tiene espacio para 64

610
00:27:02,559 --> 00:27:04,799
lo que yo he construido

611
00:27:04,799 --> 00:27:06,200
cabe en 32

612
00:27:06,200 --> 00:27:08,160
no pasa nada, 32

613
00:27:08,160 --> 00:27:09,720
en 64 cabe

614
00:27:09,720 --> 00:27:11,440
y lo asigna igualmente

615
00:27:11,440 --> 00:27:15,640
¿vale? si lo hiciéramos al revés, no

616
00:27:15,640 --> 00:27:17,940
si yo una variable int

617
00:27:17,940 --> 00:27:20,400
como hemos hecho antes, le pasara un número de 64

618
00:27:20,400 --> 00:27:22,180
Ya hemos visto que ha dado el error

619
00:27:22,180 --> 00:27:24,420
Pero este sí

620
00:27:24,420 --> 00:27:27,019
Porque 32 bits

621
00:27:27,019 --> 00:27:28,779
Cabe en una variable de 64

622
00:27:28,779 --> 00:27:30,000
¿Vale?

623
00:27:32,829 --> 00:27:33,390
Preguntas

624
00:27:33,390 --> 00:27:36,690
O sea que, por cierto, el sistema

625
00:27:36,690 --> 00:27:39,049
Usa 32 bits

626
00:27:39,049 --> 00:27:40,569
A ver, cuando

627
00:27:40,569 --> 00:27:42,670
La máquina virtual ve que tiene que construir

628
00:27:42,670 --> 00:27:44,190
Un valor numérico que tú se le has dado

629
00:27:44,190 --> 00:27:45,970
Con una sucesión de cifras y más

630
00:27:45,970 --> 00:27:48,410
Automáticamente

631
00:27:48,410 --> 00:27:51,089
Él lo construye en 32 bits

632
00:27:51,089 --> 00:28:07,369
Bueno, a ver, para que no se salga de aquí

633
00:28:07,369 --> 00:28:08,109
Se ve más claro

634
00:28:08,109 --> 00:28:11,089
Por claridad, no es que sea una línea gigante

635
00:28:11,089 --> 00:28:11,869
No se ve

636
00:28:11,869 --> 00:28:16,950
Hombre, a ver, claro

637
00:28:16,950 --> 00:28:18,410
La norma es

638
00:28:18,410 --> 00:28:20,769
Que sea lo más legible posible

639
00:28:20,769 --> 00:28:22,769
entonces si hay diferentes líneas

640
00:28:22,769 --> 00:28:24,769
va a salir mejor, que es una línea gigante

641
00:28:24,769 --> 00:28:25,769
que tiene que llegar hasta el final

642
00:28:25,769 --> 00:28:29,150
en general los comentarios

643
00:28:29,150 --> 00:28:30,990
cuantos más haya

644
00:28:30,990 --> 00:28:32,670
y más legibles sean mejor

645
00:28:32,670 --> 00:28:33,549
¿vale?

646
00:28:34,789 --> 00:28:35,829
pues subir un poco

647
00:28:35,829 --> 00:28:41,049
subir es irse hacia

648
00:28:41,049 --> 00:28:43,410
acá

649
00:28:43,410 --> 00:28:47,269
vale, ¿más preguntas?

650
00:28:50,059 --> 00:28:50,220
no

651
00:28:50,220 --> 00:28:54,200
venga, pues nos vamos entonces

652
00:28:54,200 --> 00:28:56,460
Voy a parar esto y miramos a ver qué te pasa.