1
00:00:00,000 --> 00:00:03,200
bueno, pues

2
00:00:03,200 --> 00:00:11,119
vale, pues todos o casi todos

3
00:00:11,119 --> 00:00:12,980
recordáis lo que estábamos mirando

4
00:00:12,980 --> 00:00:13,779
¿verdad?

5
00:00:14,580 --> 00:00:17,219
pues ahora mismo antes de podernos

6
00:00:17,219 --> 00:00:18,760
poner a hacer cosas

7
00:00:18,760 --> 00:00:21,359
tenemos que tener lógicamente los conceptos básicos

8
00:00:21,359 --> 00:00:22,120
y entre ellos

9
00:00:22,120 --> 00:00:25,440
el fundamental era el concepto de variable

10
00:00:25,440 --> 00:00:27,120
que ya todo el mundo

11
00:00:27,120 --> 00:00:28,620
lo tiene claro, ¿verdad?

12
00:00:28,620 --> 00:00:30,800
en el aula virtual

13
00:00:30,800 --> 00:00:32,399
bueno, he subido

14
00:00:32,399 --> 00:00:34,240
un pequeño documento un poco con

15
00:00:34,240 --> 00:00:36,439
resumen de estas cositas de

16
00:00:36,439 --> 00:00:37,920
programación estructurada, pero vamos

17
00:00:37,920 --> 00:00:39,500
no hay ni que mirarlo

18
00:00:39,500 --> 00:00:42,679
entonces el concepto

19
00:00:42,679 --> 00:00:44,539
de variable, todo el mundo lo tiene

20
00:00:44,539 --> 00:00:46,820
claro, un espacio en memoria RAM

21
00:00:46,820 --> 00:00:48,579
donde se van a

22
00:00:48,579 --> 00:00:50,299
guardar los datos con los que el programa

23
00:00:50,299 --> 00:00:52,460
trabaja, el programa tiene que

24
00:00:52,460 --> 00:00:54,240
trabajar con datos, esos datos tienen que estar

25
00:00:54,240 --> 00:00:55,640
obligatoriamente en memoria RAM

26
00:00:55,640 --> 00:00:58,240
y en

27
00:00:58,240 --> 00:01:00,859
espacios de memoria RAM que se llaman variables

28
00:01:00,859 --> 00:01:04,359
a nuestro programa Java, antes

29
00:01:04,359 --> 00:01:07,219
de acceder a esos espacios hay que hacer una cosa

30
00:01:07,219 --> 00:01:10,459
llamamos declararlos, que era poner el nombre

31
00:01:10,459 --> 00:01:14,819
de la variable, el tipo de dato

32
00:01:14,819 --> 00:01:17,780
que va a contener la variable, terminado en punto y coma

33
00:01:17,780 --> 00:01:20,920
y en cuanto a la máquina virtual ya se pone a ejecutar un programa

34
00:01:20,920 --> 00:01:24,159
en cuanto encuentra esta sentencia de declaración

35
00:01:24,159 --> 00:01:26,099
que esto ya es una sentencia válida en Java

36
00:01:26,099 --> 00:01:28,379
pues crea el espacio en memoria

37
00:01:28,379 --> 00:01:30,560
este espacio en memoria RAM

38
00:01:30,560 --> 00:01:31,920
¿de cuánto tamaño?

39
00:01:32,019 --> 00:01:32,879
el que le dé la gana

40
00:01:32,879 --> 00:01:35,420
no, porque nosotros estamos obligados

41
00:01:35,420 --> 00:01:37,760
a especificar el tipo de dato

42
00:01:37,760 --> 00:01:39,359
que va a contener esa variable

43
00:01:39,359 --> 00:01:41,459
entonces estos tipos de datos

44
00:01:41,459 --> 00:01:43,180
ya dijimos que eran 8

45
00:01:43,180 --> 00:01:56,659
byte, short, int y long

46
00:01:56,659 --> 00:01:59,879
para contener números enteros

47
00:01:59,879 --> 00:02:02,519
¿vale? para contener números decimales

48
00:02:02,519 --> 00:02:05,040
el float y el double

49
00:02:05,040 --> 00:02:06,659
que todavía no hemos puesto

50
00:02:06,659 --> 00:02:07,620
ningún ejemplito

51
00:02:07,620 --> 00:02:09,740
vale

52
00:02:09,740 --> 00:02:12,740
si no es números lo que queremos

53
00:02:12,740 --> 00:02:14,620
sino texto

54
00:02:14,620 --> 00:02:16,780
entendiendo por texto cualquiera

55
00:02:16,780 --> 00:02:18,780
de los caracteres que están en esa

56
00:02:18,780 --> 00:02:19,620
tabla ASCII

57
00:02:19,620 --> 00:02:24,879
en esa tabla ASCII famosa que hemos abierto

58
00:02:24,879 --> 00:02:26,539
alguna vez que identifica

59
00:02:26,539 --> 00:02:28,080
todos los caracteres

60
00:02:28,080 --> 00:02:30,699
que se pueden escribir en un fichero

61
00:02:30,699 --> 00:02:34,360
de texto, todos los caracteres que pueden escribir, pues si queremos

62
00:02:34,360 --> 00:02:38,280
para comunicarnos con un lenguaje natural, si queremos

63
00:02:38,280 --> 00:02:42,400
alguno de esos caracteres, el tipo es el char

64
00:02:42,400 --> 00:02:46,439
y luego ya teníamos este otro tipo, boolean

65
00:02:46,439 --> 00:02:55,879
que describimos un poquito el sentido que tenía

66
00:02:55,879 --> 00:02:59,500
aunque todavía sin ver ningún ejemplo

67
00:02:59,500 --> 00:03:04,080
vale, hicimos ejemplos de esto

68
00:03:04,080 --> 00:03:07,580
y estábamos con esto, ¿vale?

69
00:03:08,120 --> 00:03:09,900
Ninguna duda de lo del otro día, ¿no?

70
00:03:12,300 --> 00:03:31,860
Vale, pues este era el programita con el que estábamos el otro día, ¿verdad?

71
00:03:31,919 --> 00:03:37,580
En el que vimos pequeños matices del trabajo con números enteros, ¿verdad?

72
00:03:37,580 --> 00:03:42,439
Sobre todo aquí es importante entender la diferencia entre int y long.

73
00:03:42,439 --> 00:03:46,400
Recordad que la diferencia es la cantidad de bits para su representación

74
00:03:46,400 --> 00:03:50,379
Y por tanto la cantidad de números que caben

75
00:03:50,379 --> 00:03:51,620
¿Vale?

76
00:03:52,080 --> 00:03:55,840
Entonces si queremos almacenar un número en 64 bits

77
00:03:55,840 --> 00:03:59,960
Ponemos la L después para que la máquina virtual diga

78
00:03:59,960 --> 00:04:02,199
Ah, esto es un número en 64 bits

79
00:04:02,199 --> 00:04:02,800
Vale

80
00:04:02,800 --> 00:04:04,960
Si no poníamos la L

81
00:04:04,960 --> 00:04:08,460
Recordad que la máquina virtual coge el numerito y dice

82
00:04:08,460 --> 00:04:11,020
Por defecto asumo que lo quieres en 32

83
00:04:11,020 --> 00:04:13,500
porque ese es su funcionamiento por defecto

84
00:04:13,500 --> 00:04:16,300
en 32 este número tan grande no me cabe

85
00:04:16,300 --> 00:04:17,899
por eso te lo ponía en rojo

86
00:04:17,899 --> 00:04:21,579
no, no, oye, cuidado que yo lo quiero en 64

87
00:04:21,579 --> 00:04:24,920
vale, pones la L y ya te lo hace en 64

88
00:04:24,920 --> 00:04:28,060
ahora otro problema era la asignación

89
00:04:28,060 --> 00:04:30,339
una vez que la máquina virtual ha construido el número

90
00:04:30,339 --> 00:04:33,360
mediante la sentencia de asignación

91
00:04:33,360 --> 00:04:37,300
que era esta, nombre de la variable a la izquierda

92
00:04:37,300 --> 00:04:41,660
operador igual valor que yo le doy a la derecha

93
00:04:41,660 --> 00:04:44,060
mediante la sentencia de asignación

94
00:04:44,060 --> 00:04:47,879
ahora ya ese número construido

95
00:04:47,879 --> 00:04:49,720
la máquina virtual lo asigna

96
00:04:49,720 --> 00:04:54,160
aquí como este lo va a haber construido

97
00:04:54,160 --> 00:04:55,639
en 64 bits

98
00:04:55,639 --> 00:05:00,360
hay que guardarlo en una variable declarada de 64 bits

99
00:05:00,360 --> 00:05:01,920
porque si no, no va a caber

100
00:05:01,920 --> 00:05:04,879
por eso decíamos

101
00:05:04,879 --> 00:05:07,199
y si yo intento guardar este numerito

102
00:05:07,199 --> 00:05:09,019
en mi variable edad

103
00:05:09,019 --> 00:05:11,500
pues el compilador

104
00:05:11,500 --> 00:05:13,519
que es el vigilante

105
00:05:13,519 --> 00:05:15,060
de errores

106
00:05:15,060 --> 00:05:17,360
de sintaxis, errores

107
00:05:17,360 --> 00:05:18,699
de incoherencias

108
00:05:18,699 --> 00:05:21,160
es el vigilante de las incoherencias

109
00:05:21,160 --> 00:05:23,459
el compilador no es el vigilante

110
00:05:23,459 --> 00:05:25,699
de que nuestro programa haga lo que tiene que hacer

111
00:05:25,699 --> 00:05:26,720
en absoluto

112
00:05:26,720 --> 00:05:29,060
el programa hará lo que tiene que hacer

113
00:05:29,060 --> 00:05:31,620
si nosotros hemos establecido correctamente el algoritmo

114
00:05:31,620 --> 00:05:33,040
y

115
00:05:33,040 --> 00:05:35,500
no nos hemos equivocado a la hora de hacer

116
00:05:35,500 --> 00:05:37,220
algoritmo. El compilador

117
00:05:37,220 --> 00:05:39,420
no es el vigilante de que el programa

118
00:05:39,420 --> 00:05:41,500
haga lo que tenga que ejecutar. Ese es nuestro

119
00:05:41,500 --> 00:05:43,480
problema. El compilador es el

120
00:05:43,480 --> 00:05:45,680
vigilante de que eso tenga una coherencia

121
00:05:45,680 --> 00:05:46,639
sintáctica

122
00:05:46,639 --> 00:05:49,519
y semántica en el sentido de que si tú

123
00:05:49,519 --> 00:05:51,459
me has dado una variable log, no me des un valor

124
00:05:51,459 --> 00:05:55,399
long. Si me has dado una variable char, no me des

125
00:05:55,399 --> 00:05:56,639
un valor float.

126
00:05:57,779 --> 00:05:59,699
De que no te has equivocado poniendo

127
00:05:59,699 --> 00:06:01,759
el nombre

128
00:06:01,759 --> 00:06:03,500
de una variable. Es el

129
00:06:03,500 --> 00:06:05,620
vigilante de la sintaxis

130
00:06:05,620 --> 00:06:07,519
luego el programa una vez

131
00:06:07,519 --> 00:06:09,160
que no tiene errores de coherencia

132
00:06:09,160 --> 00:06:10,860
sintáctica ni semántica

133
00:06:10,860 --> 00:06:12,759
ya se podrá ejecutar

134
00:06:12,759 --> 00:06:15,199
y puede ocurrir que una vez ejecutándose

135
00:06:15,199 --> 00:06:16,959
no hagan nada de lo que tienen que hacer

136
00:06:16,959 --> 00:06:18,740
y además generen errores de ejecución

137
00:06:18,740 --> 00:06:20,800
vale, pero es que es más problema de confinamiento

138
00:06:20,800 --> 00:06:22,019
es problema nuestro, claro

139
00:06:22,019 --> 00:06:31,879
cuando ve una secuencia de cifras

140
00:06:31,879 --> 00:06:32,480
sin más

141
00:06:32,480 --> 00:06:35,180
sabe que le toca construir un número

142
00:06:35,180 --> 00:06:38,699
Vale, pues ese número lo construye en 32 bits

143
00:06:38,699 --> 00:06:47,810
Ya, sí, tienes razón

144
00:06:47,810 --> 00:06:52,759
Tienes razón

145
00:06:52,759 --> 00:06:54,480
Tú te refieres, si pones esto

146
00:06:54,480 --> 00:06:56,600
B igual a 9, por ejemplo

147
00:06:56,600 --> 00:06:57,519
Vale

148
00:06:57,519 --> 00:06:59,180
Tienes razón

149
00:06:59,180 --> 00:07:01,639
Lo que pasa es que normalmente como trabajamos siempre en int

150
00:07:01,639 --> 00:07:04,019
Entonces, él te va a construir el numerito

151
00:07:04,019 --> 00:07:06,079
Luego a la hora de asignarlo

152
00:07:06,079 --> 00:07:07,500
A la hora de asignarlo

153
00:07:07,500 --> 00:07:09,100
Si ve que es

154
00:07:09,100 --> 00:07:11,839
Byte

155
00:07:11,839 --> 00:07:13,500
short o long

156
00:07:13,500 --> 00:07:15,920
en ambos, en los tres casos

157
00:07:15,920 --> 00:07:17,939
hace la adaptación

158
00:07:17,939 --> 00:07:19,600
¿vale? entonces

159
00:07:19,600 --> 00:07:21,879
en el caso de byte y short

160
00:07:21,879 --> 00:07:23,439
hará la adaptación

161
00:07:23,439 --> 00:07:26,079
si el numerito

162
00:07:26,079 --> 00:07:27,860
cabe, si no, no

163
00:07:27,860 --> 00:07:30,139
¿vale? si el numerito cabe, si no, no

164
00:07:30,139 --> 00:07:31,879
así no la hace y te dice

165
00:07:31,879 --> 00:07:33,980
lo siento no puedes porque este número

166
00:07:33,980 --> 00:07:35,480
no cabe en byte ¿vale?

167
00:07:35,779 --> 00:07:37,279
pero si le ponemos este

168
00:07:37,279 --> 00:07:40,000
como este si cabe en byte, este te deja

169
00:07:40,000 --> 00:07:41,699
¿vale? entonces

170
00:07:41,699 --> 00:07:42,839
con el short igual

171
00:07:42,839 --> 00:07:45,639
tú puedes declarar una variable

172
00:07:45,639 --> 00:07:50,899
short, ¿vale?

173
00:07:51,040 --> 00:07:51,920
este te cabe

174
00:07:51,920 --> 00:07:58,300
pero este no, no, no, no

175
00:07:58,300 --> 00:07:59,139
no, no, no, no

176
00:07:59,139 --> 00:08:02,000
él ve el número

177
00:08:02,000 --> 00:08:03,779
él asume

178
00:08:03,779 --> 00:08:05,939
que por defecto es un número

179
00:08:05,939 --> 00:08:08,160
entero, entonces lo construye

180
00:08:08,160 --> 00:08:10,459
bueno, entonces ahora ya llega la asignación

181
00:08:10,459 --> 00:08:12,100
entonces ahora ya hay varias

182
00:08:12,100 --> 00:08:14,079
situaciones, varias casuísticas para él

183
00:08:14,079 --> 00:08:16,199
entonces, una casuística

184
00:08:16,199 --> 00:08:18,100
es, que identifique que es un int

185
00:08:18,100 --> 00:08:20,139
no hay nada más que tocar

186
00:08:20,139 --> 00:08:22,500
el espacio en memoria se queda de 32 bits

187
00:08:22,500 --> 00:08:24,620
con ese numerito entero, se queda de 32 bits

188
00:08:24,620 --> 00:08:25,019
ahora

189
00:08:25,019 --> 00:08:28,579
que vea que es un byte, donde lo tiene que guardar

190
00:08:28,579 --> 00:08:29,519
pues mira

191
00:08:29,519 --> 00:08:31,639
pues lo aporta

192
00:08:31,639 --> 00:08:34,039
porque si tú has llegado a la máquina virtual

193
00:08:34,039 --> 00:08:36,580
es porque no tienes un error de compilación

194
00:08:36,580 --> 00:08:37,940
o sea, me refiero

195
00:08:37,940 --> 00:08:40,399
tú no podrías haber llegado nunca a la máquina virtual

196
00:08:40,399 --> 00:08:41,820
con esto así

197
00:08:41,820 --> 00:08:44,179
porque ya el compilador

198
00:08:44,179 --> 00:08:45,200
te ha frenado antes

199
00:08:45,200 --> 00:08:47,379
entonces a la máquina virtual

200
00:08:47,379 --> 00:08:49,879
nunca habrías llegado asignando

201
00:08:49,879 --> 00:08:51,419
a una variable byte esto

202
00:08:51,419 --> 00:08:54,039
entonces si has llegado

203
00:08:54,039 --> 00:08:56,139
a la máquina virtual, o dicho de otra manera

204
00:08:56,139 --> 00:08:58,159
si has llegado a ejecutar este programa

205
00:08:58,159 --> 00:09:00,259
es obligatoriamente

206
00:09:00,259 --> 00:09:02,000
porque aquí hay un número

207
00:09:02,000 --> 00:09:02,779
que cabe en byte

208
00:09:02,779 --> 00:09:06,000
entonces si lo construye, como tiene que

209
00:09:06,000 --> 00:09:08,100
guardarlo en byte, se pulen

210
00:09:08,100 --> 00:09:09,840
los tres bytes más significativos

211
00:09:09,840 --> 00:09:11,980
y no pasa nada porque se los haya pulido

212
00:09:11,980 --> 00:09:13,779
porque es que no eran necesarios

213
00:09:13,779 --> 00:09:15,039
para representar ese número

214
00:09:15,039 --> 00:09:18,100
porque si no, no habrías llegado a poder ejecutarlo

215
00:09:18,100 --> 00:09:20,200
solo puedes ejecutar un programa sin errores de ejecución

216
00:09:20,200 --> 00:09:21,779
con el short

217
00:09:21,779 --> 00:09:23,600
es igual, vale

218
00:09:23,600 --> 00:09:26,120
tú solo vas a haber llegado a ejecutar

219
00:09:26,120 --> 00:09:27,799
el programa si el numerito este

220
00:09:27,799 --> 00:09:29,700
solo necesita 16 bits

221
00:09:29,700 --> 00:09:31,440
entonces él lo construye

222
00:09:31,440 --> 00:09:33,879
lo tengo que guardar en short, me pulo eso

223
00:09:33,879 --> 00:09:35,899
y ya está, pero Fizz responde a tu pregunta

224
00:09:35,899 --> 00:09:37,080
en memoria

225
00:09:37,080 --> 00:09:40,000
esta variable va a ocupar

226
00:09:40,000 --> 00:09:42,120
16 siempre por ser short

227
00:09:42,120 --> 00:09:44,139
y esta variable va a ocupar

228
00:09:44,139 --> 00:09:45,759
8, siempre, ¿vale?

229
00:09:45,840 --> 00:09:47,639
Y la int va a ocupar 32

230
00:09:47,639 --> 00:09:49,100
Siempre

231
00:09:49,100 --> 00:09:50,320
Vale

232
00:09:50,320 --> 00:09:53,919
Entonces, este problema, sobre todo

233
00:09:53,919 --> 00:09:56,299
Ataña el compilador

234
00:09:56,299 --> 00:09:57,960
Con los int y con los long

235
00:09:57,960 --> 00:10:00,220
Y es eso, el compilador

236
00:10:00,220 --> 00:10:06,000
Aquí es que

237
00:10:06,000 --> 00:10:08,440
Al compilador ya sí que le sale ambigüedad

238
00:10:08,440 --> 00:10:09,279
Y es, vamos a ver

239
00:10:09,279 --> 00:10:10,840
Este numerito

240
00:10:10,840 --> 00:10:12,700
Este numerito

241
00:10:12,700 --> 00:10:16,259
Yo lo construyo por defecto como int

242
00:10:16,259 --> 00:10:18,379
Y este numerito

243
00:10:18,379 --> 00:10:21,019
no me va a caber en un int, entonces aquí el compilador

244
00:10:21,019 --> 00:10:22,740
ya como él ya sabe que la máquina

245
00:10:22,740 --> 00:10:24,679
virtual por defecto te construye

246
00:10:24,679 --> 00:10:26,539
32, como

247
00:10:26,539 --> 00:10:28,679
ya sabe que la máquina virtual te construye

248
00:10:28,679 --> 00:10:30,679
32 por defecto, pues

249
00:10:30,679 --> 00:10:32,679
él te dice, uy ese número, cuando la

250
00:10:32,679 --> 00:10:34,720
máquina virtual te haga construirlo, es que no va a

251
00:10:34,720 --> 00:10:37,159
poder, ya se está adelantando

252
00:10:37,159 --> 00:10:38,620
y te está diciendo, cuando la

253
00:10:38,620 --> 00:10:40,460
máquina virtual vaya a construir ese número

254
00:10:40,460 --> 00:10:42,659
lo siento pero no va a poder, porque la máquina virtual

255
00:10:42,659 --> 00:10:44,639
lo mete por defecto cuando ve una secuencia

256
00:10:44,639 --> 00:10:45,659
de cifras en 32

257
00:10:45,659 --> 00:10:48,299
entonces ya se adelanta lo que

258
00:10:48,299 --> 00:10:50,919
te dice, no, lo siento, no te dejo

259
00:10:50,919 --> 00:10:52,919
que tires con este programa porque la máquina

260
00:10:52,919 --> 00:10:54,519
virtual no va a poder meter eso en 32

261
00:10:54,519 --> 00:10:56,679
pero tú le dices al compilador

262
00:10:56,679 --> 00:10:58,940
no, espérate, es que yo voy

263
00:10:58,940 --> 00:11:00,340
a añadir esta indicación

264
00:11:00,340 --> 00:11:02,419
voy a añadir esta indicación

265
00:11:02,419 --> 00:11:12,970
entonces tú le dices, no, no, espérate

266
00:11:12,970 --> 00:11:15,210
ya sé que la máquina virtual cuando ejecute esto

267
00:11:15,210 --> 00:11:17,210
ya sé que al ver una secuencia

268
00:11:17,210 --> 00:11:18,470
de cifras lo va a meter en

269
00:11:18,470 --> 00:11:21,409
va a crear un espacio de 32 bits

270
00:11:21,409 --> 00:11:22,490
para él, ya lo sé

271
00:11:22,490 --> 00:11:24,830
y ya sé que, y entonces

272
00:11:24,830 --> 00:11:27,090
le doy una pequeña indicación

273
00:11:27,090 --> 00:11:28,789
a la máquina virtual, le digo

274
00:11:28,789 --> 00:11:30,830
no, pero espérate, le indico

275
00:11:30,830 --> 00:11:33,090
desde ya L mayúscula, minúscula es lo de menos

276
00:11:33,090 --> 00:11:34,850
¿vale? con L mayúscula

277
00:11:34,850 --> 00:11:36,610
está más claro porque

278
00:11:36,610 --> 00:11:38,169
no se confunde con el 1

279
00:11:38,169 --> 00:11:40,649
¿vale? por eso siempre usamos la L mayúscula

280
00:11:40,649 --> 00:11:42,830
para que, aunque el carácter es distinto

281
00:11:42,830 --> 00:11:44,850
y la máquina virtual y el copiador nunca se van a ejecutar

282
00:11:44,850 --> 00:11:46,350
porque es un carácter así diferente

283
00:11:46,350 --> 00:11:48,029
la L minúscula y el 1

284
00:11:48,029 --> 00:11:50,289
a la vista sí puede generar confusión

285
00:11:50,289 --> 00:11:52,610
Por eso usamos el L mayúsculo

286
00:11:52,610 --> 00:11:55,149
Entonces tú ya desde tiempo de compilación

287
00:11:55,149 --> 00:11:56,350
Antes de ejecutar ya dices

288
00:11:56,350 --> 00:11:58,129
No, no, perdona, es que tengo una forma de avisar

289
00:11:58,129 --> 00:11:59,830
Tengo una forma de avisar

290
00:11:59,830 --> 00:12:01,909
Para que esto lo haga en 64

291
00:12:01,909 --> 00:12:04,669
Dice, ah, vale, vale, que estás avisando

292
00:12:04,669 --> 00:12:06,330
Que lo haga de partida en 64

293
00:12:06,330 --> 00:12:07,590
Vale, entonces te dejo

294
00:12:07,590 --> 00:12:09,750
Aquí no avisas de partida

295
00:12:09,750 --> 00:12:11,490
Lo que he puesto yo antes

296
00:12:11,490 --> 00:12:13,950
Que lo he borrado

297
00:12:13,950 --> 00:12:23,350
Byte B igual a 9

298
00:12:23,350 --> 00:12:27,080
O short

299
00:12:27,080 --> 00:12:27,740
S

300
00:12:27,740 --> 00:12:30,539
igual a 120 o lo que sea

301
00:12:30,539 --> 00:12:32,639
aquí no tienes que avisar

302
00:12:32,639 --> 00:12:34,320
de partida a la máquina virtual

303
00:12:34,320 --> 00:12:36,779
que lo construya

304
00:12:36,779 --> 00:12:38,679
en 8 bits o en

305
00:12:38,679 --> 00:12:40,559
16, no hace falta, lo puede construir

306
00:12:40,559 --> 00:12:42,200
en 32, porque luego

307
00:12:42,200 --> 00:12:43,980
lo que se pula

308
00:12:43,980 --> 00:12:46,299
para dejarlo en 8 o en 16

309
00:12:46,299 --> 00:12:48,539
lo que se pula no valía para nada, porque no hacía

310
00:12:48,539 --> 00:12:50,480
falta, no hacían falta

311
00:12:50,480 --> 00:12:52,440
esos bits, entonces aquí no tienes que

312
00:12:52,440 --> 00:12:54,419
avisar con antelación a la máquina virtual

313
00:12:54,419 --> 00:12:56,580
no, no, que no es de 32 el espacio, cuidado

314
00:12:56,580 --> 00:12:58,279
que va a ser de 8 al final

315
00:12:58,279 --> 00:12:59,940
o cuidado que va a ser de 16

316
00:12:59,940 --> 00:13:02,559
no hace falta, por eso el compilador te deja

317
00:13:02,559 --> 00:13:03,779
que lo metas

318
00:13:03,779 --> 00:13:06,500
sin avisar que esto va a acabar siendo

319
00:13:06,500 --> 00:13:08,440
de 8 y esto va a acabar siendo de 16

320
00:13:08,440 --> 00:13:10,899
no hace falta que tú avises

321
00:13:10,899 --> 00:13:13,889
pero aquí sí

322
00:13:13,889 --> 00:13:17,190
aquí sí

323
00:13:17,190 --> 00:13:19,570
tienes que darle el aviso, no, espérate

324
00:13:19,570 --> 00:13:21,669
es que ya sé que este número no cabe en 32

325
00:13:21,669 --> 00:13:23,669
ya lo sé, entonces te aviso

326
00:13:23,669 --> 00:13:25,830
desde ya, máquina virtual

327
00:13:25,830 --> 00:13:27,090
que hagas un espacio de 64

328
00:13:27,090 --> 00:13:29,549
y ahora ya viene la asignación

329
00:13:29,549 --> 00:13:31,409
En estas asignaciones

330
00:13:31,409 --> 00:13:33,830
Toca asignar a bytes

331
00:13:33,830 --> 00:13:36,049
Se pulen los 3 bytes más significativos

332
00:13:36,049 --> 00:13:37,950
En esta toca asignar a short

333
00:13:37,950 --> 00:13:40,490
Se pulen los 2 bytes más significativos

334
00:13:40,490 --> 00:13:41,710
No pasa nada porque se los pula

335
00:13:41,710 --> 00:13:42,850
Si es que no era necesario

336
00:13:42,850 --> 00:13:43,909
No tenía ni información

337
00:13:43,909 --> 00:13:46,909
Porque estos números ya caben en 8 y 16

338
00:13:46,909 --> 00:13:50,110
Aquí ya tiene el número de 64

339
00:13:50,110 --> 00:13:51,330
Toca asignar

340
00:13:51,330 --> 00:13:54,049
Aquí ya no hay más tutía

341
00:13:54,049 --> 00:13:54,950
De asignar a long

342
00:13:54,950 --> 00:13:57,230
No hay otra posibilidad

343
00:13:57,230 --> 00:13:59,409
Porque este número está construido en 64

344
00:13:59,409 --> 00:14:01,409
¿por qué le hemos dado el aviso a la máquina virtual

345
00:14:01,409 --> 00:14:02,629
de que tiene que conseguir los 64?

346
00:14:03,549 --> 00:14:05,929
bueno, pues bien, magnífico

347
00:14:05,929 --> 00:14:07,929
el compilador de partida

348
00:14:07,929 --> 00:14:09,610
ya te prohibiría otra cosa

349
00:14:09,610 --> 00:14:11,490
ya te lo prohíbe de partida el compilador

350
00:14:11,490 --> 00:14:13,149
te dice, es que esto en la máquina virtual

351
00:14:13,149 --> 00:14:15,690
solo va a funcionar correctamente

352
00:14:15,690 --> 00:14:17,490
si lo guardas en un alón

353
00:14:17,490 --> 00:14:19,750
¿por qué?

354
00:14:19,990 --> 00:14:22,129
porque podríamos decir, ah vale, no pasa nada

355
00:14:22,129 --> 00:14:26,090
podríamos dejar compiladores abiertos

356
00:14:26,090 --> 00:14:27,370
lenguajes de programación

357
00:14:27,370 --> 00:14:29,710
Poco protegidos, por decirlo así

358
00:14:29,710 --> 00:14:30,490
Espera

359
00:14:30,490 --> 00:14:32,129
Como Python

360
00:14:32,129 --> 00:14:35,690
Que lo deja que encaje todo

361
00:14:35,690 --> 00:14:37,629
En tiempo de compilación

362
00:14:37,629 --> 00:14:39,289
Entonces uno podría decir

363
00:14:39,289 --> 00:14:41,730
A ver, edad es int, que la tengo aquí arriba

364
00:14:41,730 --> 00:14:43,889
Edad la tengo aquí arriba

365
00:14:43,889 --> 00:14:44,590
Declarada

366
00:14:44,590 --> 00:14:46,649
Edad es int

367
00:14:46,649 --> 00:14:49,259
Vale

368
00:14:49,259 --> 00:14:53,019
Podría haber otra forma

369
00:14:53,019 --> 00:14:54,620
De programar

370
00:14:54,620 --> 00:14:55,580
Que es

371
00:14:55,580 --> 00:14:57,500
Construido en 64

372
00:14:57,500 --> 00:14:59,779
me estás diciendo que lo guarden in

373
00:14:59,779 --> 00:15:01,500
no pasa nada, vale

374
00:15:01,500 --> 00:15:04,259
me pulo los 4 bytes más significativos

375
00:15:04,259 --> 00:15:06,539
y dejo los 4 bytes más pequeñitos

376
00:15:06,539 --> 00:15:08,179
los 32, claro

377
00:15:08,179 --> 00:15:10,379
me lo pulo y caben 32, pero he perdido

378
00:15:10,379 --> 00:15:12,000
el número, lógicamente, porque he quitado

379
00:15:12,000 --> 00:15:14,399
un montón de información, he perdido el número

380
00:15:14,399 --> 00:15:16,639
si este número necesitaba

381
00:15:16,639 --> 00:15:17,720
de los

382
00:15:17,720 --> 00:15:19,600
8 bytes

383
00:15:19,600 --> 00:15:21,519
necesitaba

384
00:15:21,519 --> 00:15:26,200
¿dónde la he escrito?

385
00:15:26,679 --> 00:15:27,000
aquí

386
00:15:27,000 --> 00:15:37,240
si este número

387
00:15:37,240 --> 00:15:38,600
necesitaba

388
00:15:38,600 --> 00:15:43,409
estos son 64 bits, 8 bytes

389
00:15:43,409 --> 00:15:45,409
este número ha necesitado

390
00:15:45,409 --> 00:15:47,389
esto para codificarse, 5

391
00:15:47,389 --> 00:15:49,409
estos 3 no los ha necesitado

392
00:15:49,409 --> 00:15:50,669
todos ceros, ningún problema

393
00:15:50,669 --> 00:15:53,250
entonces una alternativa

394
00:15:53,250 --> 00:15:54,929
podría ser que este lenguaje

395
00:15:54,929 --> 00:15:56,529
de programación funcionara

396
00:15:56,529 --> 00:15:58,950
ya he construido el numerito en estos 5 bytes

397
00:15:58,950 --> 00:16:01,509
me dices que lo guarde en edad

398
00:16:01,509 --> 00:16:03,409
que es int, con lo cual es una

399
00:16:03,409 --> 00:16:05,190
variable que solo tiene reservado 4

400
00:16:05,190 --> 00:16:07,950
no pasa nada, lo guardo en 4

401
00:16:07,950 --> 00:16:09,629
y esto lo tiro a la basura

402
00:16:09,629 --> 00:16:11,870
vale, pero he destrozado el número

403
00:16:11,870 --> 00:16:13,730
el número que he guardado aquí

404
00:16:13,730 --> 00:16:15,470
ya no es este, es otro

405
00:16:15,470 --> 00:16:17,730
entonces eso ya

406
00:16:17,730 --> 00:16:19,649
desde tiempo de compilación de escritura

407
00:16:19,649 --> 00:16:21,210
de código tiene que estar prohibido

408
00:16:21,210 --> 00:16:22,909
lógicamente el cambio de información

409
00:16:22,909 --> 00:16:24,250
vale

410
00:16:24,250 --> 00:16:27,730
el lenguaje te pone muchas restricciones

411
00:16:28,309 --> 00:16:29,809
pero precisamente

412
00:16:29,809 --> 00:16:31,929
para evitar que en tiempo de ejecución

413
00:16:31,929 --> 00:16:33,049
pasen cosas

414
00:16:33,049 --> 00:16:35,789
que pueden generar errores

415
00:16:35,789 --> 00:16:36,909
como que un numerito

416
00:16:36,909 --> 00:16:39,330
pierda parte de su contenido

417
00:16:39,330 --> 00:16:41,590
en el caso que hemos

418
00:16:41,590 --> 00:16:43,509
puesto antes, el 9

419
00:16:43,509 --> 00:16:45,490
el 9 de los

420
00:16:45,490 --> 00:16:46,570
32 bits

421
00:16:46,570 --> 00:16:48,470
solo necesita esto

422
00:16:48,470 --> 00:16:51,330
para codificarse, el resto son ceros

423
00:16:51,330 --> 00:16:53,389
con lo cual cuando

424
00:16:53,389 --> 00:16:55,350
la máquina virtual tenga que guardar esto

425
00:16:55,350 --> 00:16:57,210
en byte, tira esto a la basura, no pasa nada

426
00:16:57,210 --> 00:16:59,370
que lo tire, si ahí no había nada más que

427
00:16:59,370 --> 00:17:00,870
ceros, el 120

428
00:17:00,870 --> 00:17:03,789
o bueno, el 120 o el 230

429
00:17:03,789 --> 00:17:05,809
solo necesita

430
00:17:05,809 --> 00:17:07,670
estos bytes, el resto

431
00:17:07,670 --> 00:17:08,650
serán todos ceros

432
00:17:08,650 --> 00:17:11,769
cuando la máquina virtual lo guarde en short

433
00:17:11,769 --> 00:17:13,589
dirá, esto fuera, la basura

434
00:17:13,589 --> 00:17:15,829
pero no pasa nada, porque el número no se ve

435
00:17:15,829 --> 00:17:17,990
modificado porque lo que ha perdido son los ceros

436
00:17:17,990 --> 00:17:19,930
¿vale? pero en este

437
00:17:19,930 --> 00:17:21,650
caso, en este caso

438
00:17:21,650 --> 00:17:23,329
el compilador te dice, ojo

439
00:17:23,329 --> 00:17:25,789
que si le dejáramos a la máquina

440
00:17:25,789 --> 00:17:26,950
virtual hacer eso

441
00:17:26,950 --> 00:17:29,109
estarías perdiendo información

442
00:17:29,109 --> 00:17:31,210
Pues el compilador te pone reglas

443
00:17:31,210 --> 00:17:32,490
Te pone reglas

444
00:17:32,490 --> 00:17:35,549
Para que las respetes desde el momento de escribir el código

445
00:17:35,549 --> 00:17:39,250
Si no cumples con esas reglas

446
00:17:39,250 --> 00:17:40,769
No puedes ejecutar

447
00:17:40,769 --> 00:17:42,089
¿Vale?

448
00:17:42,809 --> 00:17:44,710
Bueno, pues una de esas reglas es esta

449
00:17:44,710 --> 00:17:47,150
Ahora, vale, pues sí, efectivamente

450
00:17:47,150 --> 00:17:49,109
En id no puedo, pero aquí sí

451
00:17:49,109 --> 00:17:51,190
En esta sí, porque esta es long

452
00:17:51,190 --> 00:17:53,109
Y fenomenal

453
00:17:53,109 --> 00:17:56,019
Vale

454
00:17:56,019 --> 00:17:59,000
Y lo otro que habíamos dicho

455
00:17:59,000 --> 00:18:02,319
Tú no puedes asignar

456
00:18:02,319 --> 00:18:04,000
un número long a una

457
00:18:04,000 --> 00:18:05,920
¿dónde está esto?

458
00:18:08,819 --> 00:18:10,839
no puedes asignar un número long

459
00:18:10,839 --> 00:18:11,920
a una variable int

460
00:18:11,920 --> 00:18:15,039
eso lo acabamos de volver a ejemplificar

461
00:18:15,039 --> 00:18:16,519
¿por qué? no puedes

462
00:18:16,519 --> 00:18:18,160
pero esto

463
00:18:18,160 --> 00:18:23,319
esto sí puedes

464
00:18:23,319 --> 00:18:25,720
esto es

465
00:18:25,720 --> 00:18:27,839
a una variable declarada

466
00:18:27,839 --> 00:18:28,539
como long

467
00:18:28,539 --> 00:18:30,240
y por tanto

468
00:18:30,240 --> 00:18:33,680
con un espacio reservado

469
00:18:33,680 --> 00:18:36,720
de 64 bits

470
00:18:36,720 --> 00:18:39,559
y edad tocha está declarada

471
00:18:39,559 --> 00:18:41,460
como long, con lo cual

472
00:18:41,460 --> 00:18:43,380
el espacio que ha reservado la máquina virtual

473
00:18:43,380 --> 00:18:45,279
que reservará la máquina

474
00:18:45,279 --> 00:18:47,759
virtual para 64, a este

475
00:18:47,759 --> 00:18:49,380
sí que puedes darle

476
00:18:49,380 --> 00:18:51,099
cualquier cosa que esté construida

477
00:18:51,099 --> 00:18:53,240
en menos espacio. En 32

478
00:18:53,240 --> 00:18:55,359
como este, porque al ser

479
00:18:55,359 --> 00:18:57,480
una sucesión de cifras, la máquina

480
00:18:57,480 --> 00:18:59,940
virtual lo habrá guardado en 32 bits.

481
00:19:00,559 --> 00:19:01,480
En el momento de construirlo,

482
00:19:02,059 --> 00:19:03,319
en el momento de construirlo, luego otra cosa

483
00:19:03,319 --> 00:19:05,559
es asignarlo, lo construye

484
00:19:05,559 --> 00:19:08,220
en 32 bits, bueno pues esto

485
00:19:08,220 --> 00:19:10,339
es una asignación en la que

486
00:19:10,339 --> 00:19:12,200
un valor de tipo entero

487
00:19:12,200 --> 00:19:14,240
en 32 bits, se lo asignas

488
00:19:14,240 --> 00:19:15,079
a uno long

489
00:19:15,079 --> 00:19:18,420
y como veis el compilador te dice, aquí no tengo problema

490
00:19:18,420 --> 00:19:20,039
no tengo problema, aunque

491
00:19:20,039 --> 00:19:21,819
los tipos no son el mismo

492
00:19:21,819 --> 00:19:24,500
un int va a un long

493
00:19:24,500 --> 00:19:25,920
aunque el tipo no es el mismo

494
00:19:25,920 --> 00:19:27,420
la regla

495
00:19:27,420 --> 00:19:30,180
del lenguaje te dice, es que no pasa nada

496
00:19:30,180 --> 00:19:31,859
porque lo único que voy a tener que hacer yo va a ser

497
00:19:31,859 --> 00:19:34,019
meter aquí el numerito, el 78

498
00:19:34,019 --> 00:19:35,559
y el resto

499
00:19:35,559 --> 00:19:38,359
lo completo con ceros

500
00:19:38,359 --> 00:19:40,579
ya está, lo completo con ceros

501
00:19:40,579 --> 00:19:41,680
y ya lo tengo 64

502
00:19:41,680 --> 00:19:44,299
¿que tú lo quieres en una variable de 64?

503
00:19:44,859 --> 00:19:45,920
no pasa nada

504
00:19:45,920 --> 00:19:49,099
porque 32 cabe en 64

505
00:19:49,099 --> 00:19:50,680
¿vale?

506
00:19:50,720 --> 00:19:51,880
y esto es lo que se llama

507
00:19:51,880 --> 00:19:54,680
está en el documento

508
00:19:54,680 --> 00:19:56,099
ese que os he subido para que tengáis

509
00:19:56,099 --> 00:19:58,759
estos primeros conceptos más o menos organizados

510
00:19:58,759 --> 00:20:00,539
promoción automática

511
00:20:00,539 --> 00:20:01,220
de variables

512
00:20:01,220 --> 00:20:06,000
Promoción automática

513
00:20:06,000 --> 00:20:09,000
No digo variables porque aquí no se promociona ninguna variable

514
00:20:09,000 --> 00:20:09,900
La variable sigue igual

515
00:20:09,900 --> 00:20:10,400
Dime

516
00:20:10,400 --> 00:20:13,240
Es un programa que tiene que asignarle un valor

517
00:20:13,240 --> 00:20:15,259
Más a la de, digamos

518
00:20:15,259 --> 00:20:19,680
A poner un valor

519
00:20:19,680 --> 00:20:21,740
Por ejemplo

520
00:20:21,740 --> 00:20:23,940
Si ponemos un valor

521
00:20:23,940 --> 00:20:25,420
Que sea un long, por ejemplo

522
00:20:25,420 --> 00:20:27,119
Lo que asigna más memoria, digamos

523
00:20:27,119 --> 00:20:28,759
No puedes

524
00:20:28,759 --> 00:20:31,980
Tú a un int no puedes asignarle un valor que sea un long

525
00:20:31,980 --> 00:20:32,940
No, perdón, a un long

526
00:20:32,940 --> 00:20:35,259
Sí, a un long sí porque cabe

527
00:20:35,259 --> 00:20:36,660
Esto

528
00:20:36,660 --> 00:20:41,660
Sí, claro

529
00:20:41,660 --> 00:20:43,519
Estás usando el doble

530
00:20:43,519 --> 00:20:45,019
De memoria RAM

531
00:20:45,019 --> 00:20:47,400
Cuando necesitarías solo la mitad

532
00:20:47,400 --> 00:20:49,680
Pero bueno, a lo mejor es que

533
00:20:49,680 --> 00:20:51,200
En otros momentos a esta variable

534
00:20:51,200 --> 00:20:53,259
Sí que vas a necesitar asignar números mayores

535
00:20:53,259 --> 00:20:54,460
Como los datos son variables

536
00:20:54,460 --> 00:20:56,920
Claro, esta variable no va a tener

537
00:20:56,920 --> 00:20:59,640
Contenido siempre 68, a lo mejor dentro de no sé cuánto

538
00:20:59,640 --> 00:21:01,960
Pues contiene 200.000 millones

539
00:21:01,960 --> 00:21:10,940
Ya, pero tú reservas espacio

540
00:21:10,940 --> 00:21:13,200
en función de las expectativas

541
00:21:13,200 --> 00:21:14,339
de hasta dónde puedes llegar

542
00:21:14,339 --> 00:21:17,079
entonces tú, una aplicación

543
00:21:17,079 --> 00:21:18,119
que maneja usuarios

544
00:21:18,119 --> 00:21:20,200
a lo mejor una variable es para

545
00:21:20,200 --> 00:21:22,180
contabilizar el número de usuarios

546
00:21:22,180 --> 00:21:24,700
tú en cada ejecución no sabes

547
00:21:24,700 --> 00:21:26,660
qué va a tener de partida, pero te dice

548
00:21:26,660 --> 00:21:28,420
el que ha hecho el análisis del sistema, el analista

549
00:21:28,420 --> 00:21:30,359
te dice, yo he estudiado el problema, la situación

550
00:21:30,359 --> 00:21:32,680
Me he entrevistado con los que me han pedido esta aplicación

551
00:21:32,680 --> 00:21:34,819
Y me han dicho que podría haber

552
00:21:34,819 --> 00:21:37,079
Hasta 200.000 millones de usuarios

553
00:21:37,079 --> 00:21:38,460
Podría, a lo mejor no los hay

554
00:21:38,460 --> 00:21:39,119
Pero podría

555
00:21:39,119 --> 00:21:41,039
Entonces tú reservas un log

556
00:21:41,039 --> 00:21:42,980
Para que el programa no falle

557
00:21:42,980 --> 00:21:45,740
En caso de que en alguna ejecución en concreto

558
00:21:45,740 --> 00:21:47,000
Ese número tenga que tener

559
00:21:47,000 --> 00:21:47,920
¿Vale?

560
00:21:47,980 --> 00:21:49,900
Tú reservas el tipo de atón función

561
00:21:49,900 --> 00:21:52,359
De lo que prevés que puede llegar a ocurrir

562
00:21:52,359 --> 00:21:55,019
Porque cada ejecución es distinta

563
00:21:55,019 --> 00:21:56,859
Cada ejecución trabaja con datos distintos

564
00:21:56,859 --> 00:21:58,160
¿Vale?

565
00:21:58,160 --> 00:22:00,680
¿me vas a preguntar algo?

566
00:22:00,880 --> 00:22:02,859
si, y si fuese en vez de

567
00:22:02,859 --> 00:22:03,900
200.000 usuarios

568
00:22:03,900 --> 00:22:07,160
o sea que no cabe en long

569
00:22:07,160 --> 00:22:09,200
si no cabe en long

570
00:22:09,200 --> 00:22:11,099
pues lo que no quepa en long

571
00:22:11,099 --> 00:22:12,799
ya lo tienes que manejar tú por programa

572
00:22:12,799 --> 00:22:15,640
pues dividiéndolo en dos variables

573
00:22:15,640 --> 00:22:17,119
ya tendrás que tú ver

574
00:22:17,119 --> 00:22:17,880
cómo gestionarlo

575
00:22:17,880 --> 00:22:20,460
o sea que long es el máximo que lleva

576
00:22:20,460 --> 00:22:22,819
el mayor número

577
00:22:22,819 --> 00:22:25,059
que se puede almacenar en una variable

578
00:22:25,059 --> 00:22:27,259
única es el mayor valor de long

579
00:22:27,259 --> 00:22:30,420
el que nos salía ayer en el otro día, ¿vale?

580
00:22:31,559 --> 00:22:35,480
Entonces, ya que hemos mencionado esta de la promoción automática,

581
00:22:37,480 --> 00:22:42,339
pues podemos enunciar el principio básico de las asignaciones, ¿vale?

582
00:22:44,079 --> 00:22:48,160
Es decir, ahora ya que sabemos una variable

583
00:22:48,160 --> 00:22:51,299
y sabemos lo que es la sentencia de asignación,

584
00:22:51,299 --> 00:22:55,900
que es a nombre de variable vamos a darle un valor concreto,

585
00:22:55,900 --> 00:22:58,259
a través de este operador

586
00:22:58,259 --> 00:22:59,579
que es el operador de asignación

587
00:22:59,579 --> 00:23:01,680
bueno, pues

588
00:23:01,680 --> 00:23:04,039
en general es de cajón

589
00:23:04,039 --> 00:23:05,920
porque para eso el lenguaje te obliga

590
00:23:05,920 --> 00:23:06,980
a especificar los tipos

591
00:23:06,980 --> 00:23:09,960
que el valor que tú des

592
00:23:09,960 --> 00:23:12,180
sea del mismo tipo que la variable

593
00:23:12,180 --> 00:23:14,140
declarada, ese sería el principio

594
00:23:14,140 --> 00:23:15,160
básico, ¿vale?

595
00:23:21,230 --> 00:23:34,920
Sí, ¿vale?

596
00:23:34,940 --> 00:23:36,240
Entonces el compilador

597
00:23:36,240 --> 00:23:39,559
a la hora de poner

598
00:23:39,559 --> 00:23:41,380
sus reglas y fijar sus reglas

599
00:23:41,380 --> 00:23:43,319
cuando vea una sentencia

600
00:23:43,319 --> 00:23:45,579
de asignación, por supuesto

601
00:23:45,579 --> 00:23:47,259
lo primero, el compilador

602
00:23:47,259 --> 00:23:49,480
que es el que pone las reglas, también no estamos ejecutando nada

603
00:23:49,480 --> 00:23:51,299
el compilador empieza

604
00:23:51,299 --> 00:23:52,700
a seguir, a ver, vamos a ver si esta persona

605
00:23:52,700 --> 00:23:55,460
ha cumplido todas sus obligaciones

606
00:23:55,460 --> 00:23:57,720
para que esta sentencia de asignación

607
00:23:57,720 --> 00:23:59,160
yo la dé por correcta

608
00:23:59,160 --> 00:24:01,160
y no la marque en rojito como

609
00:24:01,160 --> 00:24:02,400
error de compilación

610
00:24:02,400 --> 00:24:05,039
pues primero, mirará

611
00:24:05,039 --> 00:24:07,200
lo que hay a la izquierda que será

612
00:24:07,200 --> 00:24:09,380
el identificador de la variable

613
00:24:09,380 --> 00:24:10,339
el nombre de la variable

614
00:24:10,339 --> 00:24:29,339
¿Qué es lo que hará? Se pondrá a buscar en el código, antes de esa sentencia irá hacia arriba, a ver dónde está esa variable declarada, porque si esa variable no está declarada, dice, ¿y esta variable quién es? No existe, ¿cómo voy a dar yo un valor a algo que no existe?

615
00:24:29,339 --> 00:24:32,339
entonces el compilador, primera regla que mira

616
00:24:32,339 --> 00:24:34,099
bueno, por supuesto

617
00:24:34,099 --> 00:24:35,960
que esto esté correctamente

618
00:24:35,960 --> 00:24:37,980
nombre de variable

619
00:24:37,980 --> 00:24:39,839
igual valor terminado en punto y coma

620
00:24:39,839 --> 00:24:42,220
o sea que esa sintaxis básica se cumple

621
00:24:42,220 --> 00:24:44,279
ahora ya se va a mirar

622
00:24:44,279 --> 00:24:45,839
lo que pone en concreto

623
00:24:45,839 --> 00:24:48,319
a ver, ¿existe

624
00:24:48,319 --> 00:24:49,740
alguna variable con este nombre?

625
00:24:50,359 --> 00:24:52,319
porque si no existe ninguna variable con ese

626
00:24:52,319 --> 00:24:54,400
nombre, ¿cómo voy a dar yo un valor a algo

627
00:24:54,400 --> 00:24:56,039
a una cajita que no existe?

628
00:24:56,039 --> 00:24:58,039
¿cómo voy a meter algo en una caja que no tengo?

629
00:24:58,039 --> 00:25:00,599
no me puedes dar algo para tener una caja que no tengo

630
00:25:00,599 --> 00:25:02,599
entonces el compilador se pone a mirar

631
00:25:02,599 --> 00:25:04,700
para arriba, pa pa pa pa pa pa, a ver si existe

632
00:25:04,700 --> 00:25:07,119
si no existiera, ahí ya la hemos cagado

633
00:25:07,119 --> 00:25:07,740
por ejemplo

634
00:25:07,740 --> 00:25:10,559
imaginaos que esta variable int edad

635
00:25:10,559 --> 00:25:12,819
yo no la hubiera declarado, porque se me ha olvidado

636
00:25:12,819 --> 00:25:14,880
automáticamente

637
00:25:14,880 --> 00:25:16,500
no hay ninguna

638
00:25:16,500 --> 00:25:18,539
cajita ni espacio en memoria

639
00:25:18,539 --> 00:25:20,559
RAM de 32 bits que se

640
00:25:20,559 --> 00:25:21,519
llame edad, no la hay

641
00:25:21,519 --> 00:25:24,539
¿vale? luego, si yo

642
00:25:24,539 --> 00:25:26,960
tratara de hacer esta sentencia de asignación

643
00:25:26,960 --> 00:25:29,259
ahí ya el compilador diría

644
00:25:29,259 --> 00:25:31,220
¿qué es esto?

645
00:25:32,059 --> 00:25:33,180
no hay ninguna variable

646
00:25:33,180 --> 00:25:34,700
declarada con ese nombre

647
00:25:34,700 --> 00:25:37,279
entonces imposible

648
00:25:37,279 --> 00:25:38,200
asignar, ¿vale?

649
00:25:38,859 --> 00:25:40,960
bueno, eso es lo primero que mira el compilador

650
00:25:40,960 --> 00:25:42,700
que la variable esté declarada

651
00:25:42,700 --> 00:25:44,359
antes de su primer uso

652
00:25:44,359 --> 00:25:46,640
no vale que la declare después

653
00:25:46,640 --> 00:25:48,819
no vale que yo la declare después, ¿vale?

654
00:25:48,839 --> 00:25:51,240
tiene que estar declarada antes de su primer uso

655
00:25:51,240 --> 00:25:52,900
ah, vale, uno mira

656
00:25:52,900 --> 00:25:54,980
y aparte el mensajito

657
00:25:54,980 --> 00:25:55,900
que sale es bien claro

658
00:25:55,900 --> 00:25:58,700
para que uno se vaya acostumbrado porque

659
00:25:58,700 --> 00:26:00,700
es normal, pues uno

660
00:26:00,700 --> 00:26:02,819
escribe código y se olvida de cosas

661
00:26:02,819 --> 00:26:04,460
entonces rápidamente

662
00:26:04,460 --> 00:26:07,099
vamos asociando

663
00:26:07,099 --> 00:26:08,880
los mensajes del compilador con las

664
00:26:08,880 --> 00:26:10,440
cosas para ahí no perdemos tiempo

665
00:26:10,440 --> 00:26:12,220
en cuanto algo te dice

666
00:26:12,220 --> 00:26:14,759
no puedo resolverlo, si te dice que

667
00:26:14,759 --> 00:26:16,140
un término no lo puedes resolver

668
00:26:16,140 --> 00:26:18,519
se refiere a que no está declarado

669
00:26:18,519 --> 00:26:20,759
que no está declarado, entonces puede ser

670
00:26:20,759 --> 00:26:23,039
que realmente se te ha olvidado declararlo

671
00:26:23,039 --> 00:26:24,700
o puede ser que

672
00:26:24,700 --> 00:26:26,819
te hayas equivocado escribiéndolo

673
00:26:26,819 --> 00:26:28,140
porque hayas tecleado muy rápido

674
00:26:28,140 --> 00:26:30,680
puede ser mil cosas, pero lo que

675
00:26:30,680 --> 00:26:32,619
importa es que entendamos que

676
00:26:32,619 --> 00:26:34,440
esa variable con ese nombre no existe

677
00:26:34,440 --> 00:26:36,599
entonces revisamos, ah vale

678
00:26:36,599 --> 00:26:38,680
es que se me olvidó, ya está

679
00:26:38,680 --> 00:26:41,490
¿vale?

680
00:26:41,789 --> 00:26:44,470
de nuevo, otra restricción

681
00:26:44,470 --> 00:26:46,309
de Java, otros lenguajes no la tienen

682
00:26:46,309 --> 00:26:47,789
como Python

683
00:26:47,789 --> 00:26:50,230
que tú usas una variable

684
00:26:50,230 --> 00:26:52,269
pues

685
00:26:52,269 --> 00:26:53,670
se la inventa en ese momento

686
00:26:53,670 --> 00:26:56,369
entonces por eso se hizo Python

687
00:26:56,369 --> 00:26:58,269
se hizo un lenguaje rápido, que lo trague todo

688
00:26:58,269 --> 00:27:00,450
que lo coja todo, que sea muy fácil de aprender

689
00:27:00,450 --> 00:27:02,190
y entonces hace

690
00:27:02,190 --> 00:27:04,230
es más operativo y más rápido

691
00:27:04,230 --> 00:27:06,970
pero claro, las aplicaciones

692
00:27:06,970 --> 00:27:08,750
comerciales

693
00:27:08,750 --> 00:27:10,849
son muy poco robustas en Python

694
00:27:10,849 --> 00:27:12,690
por eso Python tiene otro

695
00:27:12,690 --> 00:27:14,650
campo, que es más el universitario

696
00:27:14,650 --> 00:27:15,930
el científico, todo eso

697
00:27:15,930 --> 00:27:24,710
bueno, pues seguimos con la asignación

698
00:27:24,710 --> 00:27:25,589
que decíamos para

699
00:27:25,589 --> 00:27:30,049
una vez que ve que esta variable

700
00:27:30,049 --> 00:27:31,369
existe

701
00:27:31,369 --> 00:27:35,279
operador igual

702
00:27:35,279 --> 00:27:38,119
y se pone

703
00:27:38,119 --> 00:27:38,799
a mirar el valor

704
00:27:38,799 --> 00:27:41,819
coge el valor, lo construye

705
00:27:41,819 --> 00:27:43,839
si es un, hasta ahora

706
00:27:43,839 --> 00:27:45,960
como solamente hemos usado valores números, pues construye

707
00:27:45,960 --> 00:27:46,559
el numerito

708
00:27:46,559 --> 00:27:49,480
y mira a ver

709
00:27:49,480 --> 00:27:52,119
si es un valor del mismo tipo

710
00:27:52,119 --> 00:27:53,119
el que hemos dado ahí

711
00:27:53,119 --> 00:27:55,380
que la variable declarada

712
00:27:55,380 --> 00:27:58,079
¿vale? del mismo tipo

713
00:27:58,079 --> 00:27:59,039
entonces

714
00:27:59,039 --> 00:28:01,380
en general, ahora

715
00:28:01,380 --> 00:28:03,539
vamos incorporando los matices

716
00:28:03,539 --> 00:28:06,259
el valor tiene que ser del mismo

717
00:28:06,259 --> 00:28:08,220
tipo que la variable en la que yo lo voy a meter

718
00:28:08,220 --> 00:28:09,900
porque si no es del mismo tipo

719
00:28:09,900 --> 00:28:11,960
pues va a decir, lo siento

720
00:28:11,960 --> 00:28:14,019
no me puedes dar que meta una

721
00:28:14,019 --> 00:28:15,980
botella en el espacio para meter

722
00:28:15,980 --> 00:28:17,980
un vaso, lo siento

723
00:28:17,980 --> 00:28:19,960
pero no, en el espacio

724
00:28:19,960 --> 00:28:22,019
para meter una botella, dame una botella

725
00:28:22,019 --> 00:28:24,140
si no, nada, eso es lo que te dice

726
00:28:24,140 --> 00:28:24,759
el compilador

727
00:28:24,759 --> 00:28:27,339
por en general

728
00:28:27,339 --> 00:28:29,319
pero en determinadas situaciones

729
00:28:29,319 --> 00:28:32,099
a lo mejor puede él deformar

730
00:28:32,099 --> 00:28:34,059
un poquito, dice vale

731
00:28:34,059 --> 00:28:36,119
tengo espacio con la botella y me has dado un vaso

732
00:28:36,119 --> 00:28:38,400
es una de las situaciones

733
00:28:38,400 --> 00:28:40,259
contadas 1, 2, 3, 4, 5

734
00:28:40,259 --> 00:28:42,119
en las que yo puedo hacer

735
00:28:42,119 --> 00:28:43,119
esa deformación

736
00:28:43,119 --> 00:28:45,960
no es que la haga siempre, por defecto no

737
00:28:45,960 --> 00:28:48,400
esa deformación para que un vaso

738
00:28:48,400 --> 00:28:49,640
quepa en el espacio de una botella

739
00:28:49,640 --> 00:28:52,759
esa deformación la hace en 1, 2, 3, 4, 5

740
00:28:52,759 --> 00:28:53,380
situaciones

741
00:28:53,380 --> 00:28:55,880
Si es alguna de esas, lo hace

742
00:28:55,880 --> 00:28:56,400
Si no, no

743
00:28:56,400 --> 00:28:58,920
Vale, pues algunas situaciones ya las hemos visto

744
00:28:58,920 --> 00:29:01,160
Cuando

745
00:29:01,160 --> 00:29:03,799
Queremos meter un numerito que ha construido

746
00:29:03,799 --> 00:29:05,519
Como int en un byte

747
00:29:05,519 --> 00:29:08,099
Esa adaptación la hace

748
00:29:08,099 --> 00:29:10,440
Pudiéndose los dos bytes más significativos

749
00:29:10,440 --> 00:29:12,440
Que da igual porque todos solo tenían ceros

750
00:29:12,440 --> 00:29:16,019
Si le damos un numerito

751
00:29:16,019 --> 00:29:18,039
Que lo ha construido así

752
00:29:18,039 --> 00:29:20,799
Y lo tiene que meter en un short

753
00:29:20,799 --> 00:29:22,279
Pues de nuevo

754
00:29:22,279 --> 00:29:24,660
hace la adaptación en forma

755
00:29:24,660 --> 00:29:26,240
puliendo los 16 bits

756
00:29:26,240 --> 00:29:30,490
que le damos un long

757
00:29:30,490 --> 00:29:33,690
como este

758
00:29:33,690 --> 00:29:35,190
como hemos visto antes

759
00:29:35,190 --> 00:29:36,710
y lo queremos meter en un int

760
00:29:36,710 --> 00:29:38,250
no, ahí no lo hace

761
00:29:38,250 --> 00:29:39,509
es lo que acabamos de decir

762
00:29:39,509 --> 00:29:42,549
hay nada de aplastar el long para que quepa en int

763
00:29:42,549 --> 00:29:43,970
esa no la hace

764
00:29:43,970 --> 00:29:47,670
pero si hace la inversa

765
00:29:47,670 --> 00:29:49,150
si hace la inversa

766
00:29:49,150 --> 00:29:52,500
que es esta de aquí

767
00:29:52,500 --> 00:29:54,720
yo aquí le he dado un int

768
00:29:54,720 --> 00:29:56,579
y la inversa

769
00:29:56,579 --> 00:29:57,680
que es estirarlo

770
00:29:57,680 --> 00:30:01,059
para que quepa en los 64 bits

771
00:30:01,059 --> 00:30:02,299
de la variable dactocha

772
00:30:02,299 --> 00:30:03,980
la inversa sí que la hace

773
00:30:03,980 --> 00:30:06,220
y eso es

774
00:30:06,220 --> 00:30:08,859
lo que acabo de decir

775
00:30:08,859 --> 00:30:10,299
que esto se llama

776
00:30:10,299 --> 00:30:12,180
promoción automática

777
00:30:12,180 --> 00:30:21,380
la promoción automática en general es

778
00:30:21,380 --> 00:30:22,759
yo tengo un dato

779
00:30:22,759 --> 00:30:25,400
que me dicen que lo guarda

780
00:30:25,400 --> 00:30:27,200
en una variable que no es del mismo tipo

781
00:30:27,200 --> 00:30:29,460
pero esta variable

782
00:30:29,460 --> 00:30:31,400
en el caso

783
00:30:31,400 --> 00:30:32,759
de los números es muy fácil de ver

784
00:30:32,759 --> 00:30:35,160
esta variable, este dato

785
00:30:35,160 --> 00:30:37,440
perdón, es lo evidentemente pequeñito

786
00:30:37,440 --> 00:30:39,220
como para que me quepa en este espacio tan grande

787
00:30:39,220 --> 00:30:41,180
pues entonces lo estiro

788
00:30:41,180 --> 00:30:42,779
poniendo ceros, lo estiro

789
00:30:42,779 --> 00:30:44,900
pongo ceros, lo estiro y te vas a 64

790
00:30:44,900 --> 00:30:47,519
eso es lo que se llama general promoción automática

791
00:30:47,519 --> 00:30:48,880
que se hace no solo con números

792
00:30:48,880 --> 00:30:52,099
por ejemplo, si declaras

793
00:30:52,099 --> 00:30:53,720
una variable aquí

794
00:30:53,720 --> 00:30:54,940
y luego le pones un carácter

795
00:30:54,940 --> 00:30:55,720
eso también sería

796
00:30:55,720 --> 00:31:00,460
no exactamente

797
00:31:00,460 --> 00:31:03,259
le tienes que poner un carácter pero que sea cadena

798
00:31:03,259 --> 00:31:05,220
No, no, ahí no es promoción automática

799
00:31:05,220 --> 00:31:06,819
Porque si no es un objeto, eso es otra cosa

800
00:31:06,819 --> 00:31:09,000
¿Vale? Eso ahora ya lo miraremos

801
00:31:09,000 --> 00:31:11,599
No es exactamente promoción automática

802
00:31:11,599 --> 00:31:13,299
Vale, promoción automática

803
00:31:13,299 --> 00:31:15,440
Se hace esencialmente con números

804
00:31:15,440 --> 00:31:17,059
Con valores numéricos

805
00:31:17,059 --> 00:31:18,839
¿Vale? Porque el otro ya involucra objetos

806
00:31:18,839 --> 00:31:20,920
Y ahí ya la promoción a objetos no existe

807
00:31:20,920 --> 00:31:23,279
Se hace con números, la promoción automática

808
00:31:23,279 --> 00:31:25,099
Vale, sí

809
00:31:25,099 --> 00:31:29,210
¿Perdón?

810
00:31:31,650 --> 00:31:32,470
No, no, no

811
00:31:32,470 --> 00:31:33,809
Es que esto es una variable

812
00:31:33,809 --> 00:31:35,869
y una variable significa que su valor

813
00:31:35,869 --> 00:31:38,369
varía las veces que a mí me dé la gana

814
00:31:38,369 --> 00:31:40,230
en un momento dado me hace falta

815
00:31:40,230 --> 00:31:42,490
que tenga 13, ahora necesito que tenga 15

816
00:31:42,490 --> 00:31:44,109
ahora me apetece que tenga 28

817
00:31:44,109 --> 00:31:45,369
ahora me meten el dato

818
00:31:45,369 --> 00:31:48,069
por una base de datos y ahora tiene 37

819
00:31:48,069 --> 00:31:50,150
entonces coge el dato que el último dato

820
00:31:50,150 --> 00:31:50,950
que ha puesto lo pone

821
00:31:50,950 --> 00:31:53,730
claro, claro, cuando tú haces una asignación

822
00:31:53,730 --> 00:31:55,809
a esta variable, da tocha

823
00:31:55,809 --> 00:31:58,150
esta asignación, ¿qué ha hecho?

824
00:31:58,250 --> 00:32:00,289
pues mete el 21 este aquí

825
00:32:00,289 --> 00:32:01,910
lo que sea, ha metido este

826
00:32:01,910 --> 00:32:02,569
y se queda así

827
00:32:02,569 --> 00:32:04,650
y ahora la maquina virtual

828
00:32:04,650 --> 00:32:06,789
hace lo que sea, opera con ese valor lo que sea

829
00:32:06,789 --> 00:32:08,730
ahora llegamos a esta sentencia

830
00:32:08,730 --> 00:32:10,390
esta sentencia

831
00:32:10,390 --> 00:32:13,009
tira esto a la basura, ya ha desaparecido

832
00:32:13,009 --> 00:32:14,309
ese número y ahora

833
00:32:14,309 --> 00:32:16,349
se queda con el 78

834
00:32:16,349 --> 00:32:18,410
entonces cada vez que haces una asignación

835
00:32:18,410 --> 00:32:20,690
pisas el valor anterior

836
00:32:20,690 --> 00:32:21,809
el valor anterior ya

837
00:32:21,809 --> 00:32:26,690
desaparece y se queda

838
00:32:26,690 --> 00:32:27,390
el nuevo valor

839
00:32:27,390 --> 00:32:28,349
¿vale?

840
00:32:28,349 --> 00:32:29,130
Dime

841
00:32:29,130 --> 00:32:33,269
Esa

842
00:32:33,269 --> 00:32:37,650
No, no, no

843
00:32:37,650 --> 00:32:39,230
A ver, esa en particular lo hace

844
00:32:39,230 --> 00:32:40,849
Porque tú le has dicho que va en un byte

845
00:32:40,849 --> 00:32:43,269
Pero esa no se hace por defecto

846
00:32:43,269 --> 00:32:44,210
Vamos a

847
00:32:44,210 --> 00:32:47,410
Ir viendo ejemplos

848
00:32:47,410 --> 00:32:47,930
Aquí

849
00:32:47,930 --> 00:32:51,329
Esto, en realidad

850
00:32:51,329 --> 00:32:53,269
Esto no es

851
00:32:53,269 --> 00:32:54,849
Promoción es siempre ir

852
00:32:54,849 --> 00:32:57,150
De un valor con una información pequeñita

853
00:32:57,150 --> 00:33:00,789
a un espacio de memoria con un tamaño más grande.

854
00:33:00,890 --> 00:33:02,049
Eso es la promoción, ¿vale?

855
00:33:02,970 --> 00:33:07,069
Entonces, ¿dónde es?

856
00:33:07,849 --> 00:33:08,490
Ah, aquí.

857
00:33:09,250 --> 00:33:09,470
Vale.

858
00:33:10,130 --> 00:33:11,150
Entonces, esto de aquí,

859
00:33:11,930 --> 00:33:14,309
esto de aquí, aunque yo os he explicado por dentro

860
00:33:14,309 --> 00:33:15,049
cómo funciona,

861
00:33:15,710 --> 00:33:17,049
esto en realidad es transparente,

862
00:33:17,089 --> 00:33:17,950
lo podemos olvidar.

863
00:33:18,049 --> 00:33:19,970
O sea, nosotros cuando le asignamos,

864
00:33:20,069 --> 00:33:21,049
cuando estamos escribiendo código

865
00:33:21,049 --> 00:33:22,509
y seleccionamos una variable byte,

866
00:33:23,250 --> 00:33:25,869
porque sabemos que el numerito solamente va a ocupar 8 bits,

867
00:33:25,869 --> 00:33:28,329
o seleccionamos una variable short

868
00:33:28,329 --> 00:33:30,410
porque sabemos que el numerito se lo va a ocupar 16

869
00:33:30,410 --> 00:33:32,390
como mucho, pues lo único

870
00:33:32,390 --> 00:33:34,730
que nos tenemos que preocupar es de asignarle

871
00:33:34,730 --> 00:33:36,730
números que no se escapen

872
00:33:36,730 --> 00:33:38,690
de esos valores, es lo único que nos tenemos que preocupar

873
00:33:38,690 --> 00:33:40,849
que internamente la máquina virtual

874
00:33:40,849 --> 00:33:42,990
lo vaya a meter en 32

875
00:33:42,990 --> 00:33:44,289
y luego se pula al otro

876
00:33:44,289 --> 00:33:46,230
es que nos podemos olvidar desde ya

877
00:33:46,230 --> 00:33:48,609
nosotros, con preocuparnos de

878
00:33:48,609 --> 00:33:50,109
cuando decae una variable byte

879
00:33:50,109 --> 00:33:51,650
numerito

880
00:33:51,650 --> 00:33:54,210
que quepa en 16

881
00:33:54,210 --> 00:33:55,890
porque es en 8, perdón

882
00:33:55,890 --> 00:33:57,910
porque si no el compilador

883
00:33:57,910 --> 00:33:59,750
es que ya de partida no me va a dejar

884
00:33:59,750 --> 00:34:02,630
y me olvido

885
00:34:02,630 --> 00:34:04,269
no tengo que preocuparme de nada más

886
00:34:04,269 --> 00:34:06,750
short igual, declaro una variable short

887
00:34:06,750 --> 00:34:08,929
pues solo me tengo que preocupar

888
00:34:08,929 --> 00:34:10,730
que los valores que yo asigne

889
00:34:10,730 --> 00:34:12,210
los valores que yo asigne

890
00:34:12,210 --> 00:34:14,769
quepan en 16 bits

891
00:34:14,769 --> 00:34:16,269
porque si no

892
00:34:16,269 --> 00:34:18,809
el compilador ya de partida

893
00:34:18,809 --> 00:34:20,210
va a decir que no, vale

894
00:34:20,210 --> 00:34:22,389
entonces aquí no hay

895
00:34:22,389 --> 00:34:25,329
promoción ni despromoción automática

896
00:34:25,329 --> 00:34:27,110
aquí el numerito

897
00:34:27,110 --> 00:34:28,789
que yo le ponga

898
00:34:28,789 --> 00:34:30,849
cabrá en 8 e irá a 8

899
00:34:30,849 --> 00:34:32,170
aunque internamente

900
00:34:32,170 --> 00:34:34,389
haya una especie de valor temporal de i

901
00:34:34,389 --> 00:34:36,989
pero es que hasta podemos olvidar nuestro valor temporal de la máquina virtual

902
00:34:36,989 --> 00:34:39,289
aquí lo mismo, aquí no hay ni promoción

903
00:34:39,289 --> 00:34:40,090
ni despromoción

904
00:34:40,090 --> 00:34:41,869
el numerito que yo ponga i

905
00:34:41,869 --> 00:34:44,750
cabrá en 16 y va a 16

906
00:34:44,750 --> 00:34:47,250
vale, esta otra situación

907
00:34:47,250 --> 00:34:47,989
ya la hemos visto

908
00:34:47,989 --> 00:34:51,449
si yo aquí

909
00:34:51,449 --> 00:34:53,769
construye un valor de 64

910
00:34:53,769 --> 00:34:55,369
tiene que ir sí o sí

911
00:34:55,369 --> 00:34:56,650
a 64

912
00:34:56,650 --> 00:34:59,409
porque la despromoción no existe

913
00:34:59,409 --> 00:35:00,949
o sea, un valor

914
00:35:00,949 --> 00:35:03,670
que es así, que la máquina virtual

915
00:35:03,670 --> 00:35:05,710
lo encoja y lo meta en un espacio así

916
00:35:05,710 --> 00:35:07,550
eso sí que no existe

917
00:35:07,550 --> 00:35:09,289
la despromoción no existe

918
00:35:09,289 --> 00:35:11,309
la puedo forzar, pero es otra cosa que se llama casting

919
00:35:11,309 --> 00:35:13,690
que ya veremos, pues la forzo y me cargo el número

920
00:35:13,690 --> 00:35:15,289
pero eso no existe

921
00:35:15,289 --> 00:35:18,690
vale, pero

922
00:35:18,690 --> 00:35:20,909
otro caso de promoción automática

923
00:35:20,909 --> 00:35:25,210
por ejemplo, bueno, este que ya hemos visto

924
00:35:25,210 --> 00:35:27,210
ahora tenemos edad y edad tocha

925
00:35:27,210 --> 00:35:29,230
vale, imaginaos que ahora a edad tocha

926
00:35:29,230 --> 00:35:30,389
en lugar del 78

927
00:35:30,389 --> 00:35:33,090
yo le asigno edad

928
00:35:33,090 --> 00:35:34,050
¿vale?

929
00:35:37,369 --> 00:35:38,869
esta es la asignación

930
00:35:38,869 --> 00:35:42,570
ahora ya es un pelinín

931
00:35:42,570 --> 00:35:43,969
más

932
00:35:43,969 --> 00:35:47,380
sofisticada

933
00:35:47,380 --> 00:35:49,739
edad tocha

934
00:35:49,739 --> 00:35:51,320
igual a 13, todo el mundo lo entiende

935
00:35:51,320 --> 00:35:53,980
coges el 13 y se va a la variable

936
00:35:53,980 --> 00:35:56,400
ahora edad tocha igual a edad

937
00:35:56,400 --> 00:35:58,860
también es una sentencia de asignación

938
00:35:58,860 --> 00:36:00,920
la máquina virtual

939
00:36:00,920 --> 00:36:02,980
verificará, bueno el compilador

940
00:36:02,980 --> 00:36:04,420
que edad tocha

941
00:36:04,420 --> 00:36:06,739
y edad estén declaradas

942
00:36:06,739 --> 00:36:07,579
porque si no nada

943
00:36:07,579 --> 00:36:10,239
y lo están, edad tocha está aquí

944
00:36:10,239 --> 00:36:12,320
que tiene 64 bits

945
00:36:12,320 --> 00:36:15,820
y ahí está declarada

946
00:36:15,820 --> 00:36:18,440
edad también está declarada por ahí arriba

947
00:36:18,440 --> 00:36:21,690
edad tiene

948
00:36:21,690 --> 00:36:24,130
4 bytes

949
00:36:24,889 --> 00:36:26,090
32 bits

950
00:36:26,090 --> 00:36:28,449
edad, tocha y edad están ahí, con la diferencia

951
00:36:28,449 --> 00:36:30,130
de que estas son 64 y esta

952
00:36:30,130 --> 00:36:31,349
32, vale

953
00:36:31,349 --> 00:36:34,309
están las dos detonadas por ahí, con lo cual

954
00:36:34,309 --> 00:36:36,349
ya existen estos dos espacios en memoria

955
00:36:36,349 --> 00:36:38,230
existe el espacio edad con

956
00:36:38,230 --> 00:36:40,389
32 y existe el espacio edad

957
00:36:40,389 --> 00:36:42,389
con 64, vale, ahora vamos a

958
00:36:42,389 --> 00:36:43,989
hacer una sentencia de asignación

959
00:36:43,989 --> 00:36:45,570
como esta

960
00:36:45,570 --> 00:36:48,230
la sentencia de asignación

961
00:36:48,230 --> 00:36:50,329
cumple las reglas

962
00:36:50,329 --> 00:36:51,230
que es

963
00:36:51,230 --> 00:36:53,650
valor de la izquierda

964
00:36:53,650 --> 00:36:56,670
una variable declarada

965
00:36:56,670 --> 00:36:58,550
previamente, correcto

966
00:36:58,550 --> 00:37:00,530
edad tocha es una variable declarada

967
00:37:00,530 --> 00:37:02,489
previamente, esa primera regla

968
00:37:02,489 --> 00:37:04,170
el compilador dice, la has cumplido

969
00:37:04,170 --> 00:37:07,090
operador de asignación

970
00:37:07,090 --> 00:37:08,969
inciso

971
00:37:08,969 --> 00:37:10,849
esto ya es regla de estilo

972
00:37:10,849 --> 00:37:12,670
exclusivamente, recordad lo que hablábamos

973
00:37:12,670 --> 00:37:14,650
de reglas de estilo, tratad de seguirla

974
00:37:14,650 --> 00:37:16,469
siempre para que nuestros códigos sean legibles

975
00:37:16,469 --> 00:37:18,449
antes y después de los

976
00:37:18,449 --> 00:37:20,429
operadores, se suele poner

977
00:37:20,429 --> 00:37:22,369
un espacio para que no esté todavía piñado

978
00:37:22,369 --> 00:37:24,949
entonces acostumbrados a poner un espacio

979
00:37:24,949 --> 00:37:25,750
para que no esté todo piñado

980
00:37:25,750 --> 00:37:28,849
al compilador le da igual, como si yo lo pongo todo a piña en una línea

981
00:37:28,849 --> 00:37:30,809
pero bueno, es una regla de estilo

982
00:37:30,809 --> 00:37:32,289
que convendría que siguiéramos

983
00:37:32,289 --> 00:37:34,929
pero el compilador no va a mirar, el compilador va a mirar

984
00:37:34,929 --> 00:37:36,730
que después del identificador de variable

985
00:37:36,730 --> 00:37:39,010
que ya existe, esté el operador igual

986
00:37:39,010 --> 00:37:41,050
bien, y ahora hemos dicho

987
00:37:41,050 --> 00:37:42,869
que aquí tiene que haber un valor

988
00:37:42,869 --> 00:37:45,289
vale, entonces ese valor

989
00:37:45,289 --> 00:37:47,190
puede ser, bien porque

990
00:37:47,190 --> 00:37:49,329
solo hemos dado a tiro fijo nosotros, como aquí

991
00:37:49,329 --> 00:37:51,190
que le hemos dado

992
00:37:51,190 --> 00:37:53,170
el valor 37

993
00:37:53,170 --> 00:37:54,030
12

994
00:37:54,030 --> 00:37:55,949
o bien

995
00:37:55,949 --> 00:37:58,230
porque le hemos dado

996
00:37:58,230 --> 00:38:01,309
un nombre de variable

997
00:38:01,309 --> 00:38:03,030
donde ya hay un valor dentro

998
00:38:03,030 --> 00:38:05,190
entonces los valores

999
00:38:05,190 --> 00:38:07,389
no tenemos por qué dárselos a las asignaciones

1000
00:38:07,389 --> 00:38:08,670
directamente

1001
00:38:08,670 --> 00:38:10,889
nosotros el valor 97

1002
00:38:10,889 --> 00:38:13,369
12, 13, estoy ahora particularizando

1003
00:38:13,369 --> 00:38:15,449
solo en números porque nosotros estamos trabajando con números

1004
00:38:15,449 --> 00:38:17,510
¿vale? le podemos dar

1005
00:38:17,510 --> 00:38:19,849
un nombre de variable

1006
00:38:19,849 --> 00:38:21,670
porque el compilador

1007
00:38:21,670 --> 00:38:23,170
dirá, ah, me han dado

1008
00:38:23,170 --> 00:38:24,730
un identificador

1009
00:38:24,730 --> 00:38:27,989
pues será que esto es un nombre

1010
00:38:27,989 --> 00:38:29,869
de variable, se pone a buscar

1011
00:38:29,869 --> 00:38:31,809
primero que la variable

1012
00:38:31,809 --> 00:38:33,610
esté correctamente declarada

1013
00:38:33,610 --> 00:38:35,530
y después

1014
00:38:35,530 --> 00:38:37,630
va a mirar lo que hay dentro

1015
00:38:37,630 --> 00:38:39,389
eso es lo que va a hacer

1016
00:38:39,389 --> 00:38:43,960
¿vale? entonces

1017
00:38:43,960 --> 00:38:54,699
¿cómo se completa

1018
00:38:54,699 --> 00:38:55,920
la sentencia de asignación?

1019
00:38:56,860 --> 00:38:58,480
la máquina virtual dirá

1020
00:38:58,480 --> 00:38:59,940
a ver, edad

1021
00:38:59,940 --> 00:39:02,360
es una variable, voy a buscarla

1022
00:39:02,360 --> 00:39:03,460
donde está aquí

1023
00:39:03,460 --> 00:39:06,699
porque tiene que estar, porque si no el compilador

1024
00:39:06,699 --> 00:39:08,000
ya antes nos habría dicho

1025
00:39:08,000 --> 00:39:10,420
que edad no está declarada, ya habría cortado ahí

1026
00:39:10,420 --> 00:39:12,739
y no nos habría dejado ejecutar

1027
00:39:12,739 --> 00:39:14,239
si no se ha dejado ejecutar

1028
00:39:14,239 --> 00:39:16,019
es porque edad es una variable

1029
00:39:16,019 --> 00:39:17,980
correctamente declarada

1030
00:39:17,980 --> 00:39:20,360
bueno, pues se va a buscarla

1031
00:39:20,940 --> 00:39:24,519
y coge el valor que tiene dentro

1032
00:39:24,519 --> 00:39:26,500
coge el valor que tiene dentro

1033
00:39:26,500 --> 00:39:28,099
y ese valor

1034
00:39:28,099 --> 00:39:29,880
lo asigna este

1035
00:39:29,880 --> 00:39:32,599
Y se quedan las dos con el mismo valor

1036
00:39:32,599 --> 00:39:37,699
Esto es como decir

1037
00:39:37,699 --> 00:39:39,760
Por favor, pasa a esta caja

1038
00:39:39,760 --> 00:39:40,940
El contenido de esta otra

1039
00:39:40,940 --> 00:39:43,719
Tú puedes decirle, mete en esta caja

1040
00:39:43,719 --> 00:39:44,980
Este vaso

1041
00:39:44,980 --> 00:39:46,579
Das el vaso para la caja

1042
00:39:46,579 --> 00:39:49,659
Puedes decir, mete en esta caja lo que haya en esta caja

1043
00:39:49,659 --> 00:39:51,480
Si en esta caja hay un vaso

1044
00:39:51,480 --> 00:39:52,880
Coges el vaso y lo metes en

1045
00:39:52,880 --> 00:39:55,500
La diferencia es que en este caso

1046
00:39:55,500 --> 00:39:56,840
Estás duplicando el vaso

1047
00:39:56,840 --> 00:39:57,840
El vaso se queda en los dos lados

1048
00:39:57,840 --> 00:39:59,119
No mueves

1049
00:39:59,119 --> 00:40:00,480
No mueves, ¿vale?

1050
00:40:00,780 --> 00:40:03,300
Perfecto, yo te voy a ejecutar edad

1051
00:40:03,300 --> 00:40:07,320
Si pones que escriba la edad

1052
00:40:07,320 --> 00:40:08,800
¿Va a ser el 78 igual?

1053
00:40:09,099 --> 00:40:10,800
Sí, sí, sí, sí, o sea, esta variable

1054
00:40:10,800 --> 00:40:12,960
Solo ha servido para

1055
00:40:12,960 --> 00:40:15,360
Informar de qué valor

1056
00:40:15,360 --> 00:40:17,340
Hay que dar a la otra, pero ella no pierde

1057
00:40:17,340 --> 00:40:19,159
Su valor, ¿vale?

1058
00:40:19,179 --> 00:40:21,460
Ya no pierde su valor, no es que se traslade de una a otra

1059
00:40:21,460 --> 00:40:23,300
Es decir

1060
00:40:23,300 --> 00:40:25,139
Esto, esto es el nombre de una caja

1061
00:40:25,139 --> 00:40:27,460
Entonces la máquina virtual se va a ver

1062
00:40:27,460 --> 00:40:29,739
que hay dentro de la caja, dice hay un 78

1063
00:40:29,739 --> 00:40:31,239
pues

1064
00:40:31,239 --> 00:40:33,960
el valor 78

1065
00:40:33,960 --> 00:40:35,739
lo escribe aquí también

1066
00:40:35,739 --> 00:40:37,820
sin hacer desaparecer este

1067
00:40:37,820 --> 00:40:39,800
edad sigue teniendo 78

1068
00:40:39,800 --> 00:40:41,920
este no lo hace desaparecer

1069
00:40:41,920 --> 00:40:43,440
ahora las dos variables

1070
00:40:43,440 --> 00:40:44,579
tendrían 78

1071
00:40:44,579 --> 00:40:47,420
entonces una forma

1072
00:40:47,420 --> 00:40:49,760
de obtener

1073
00:40:49,760 --> 00:40:50,400
los valores

1074
00:40:50,400 --> 00:40:52,539
para las asignaciones

1075
00:40:52,539 --> 00:40:55,079
aparte de darlo tal cual

1076
00:40:55,079 --> 00:40:57,099
es dar

1077
00:40:57,099 --> 00:40:59,559
un nombre de identificador, variable

1078
00:40:59,559 --> 00:41:01,880
o cajita para decirte

1079
00:41:01,880 --> 00:41:02,599
el que está aquí

1080
00:41:02,599 --> 00:41:05,619
el que tienes que asignar es el que está

1081
00:41:05,619 --> 00:41:07,659
aquí, entonces la máquina virtual

1082
00:41:07,659 --> 00:41:08,800
se va a ver, ¿y cuál hay ahí?

1083
00:41:09,320 --> 00:41:11,539
se va a verlo, ah, que ahí hay un 78

1084
00:41:11,539 --> 00:41:13,800
vale, pues copio

1085
00:41:13,800 --> 00:41:15,000
un 78 aquí

1086
00:41:15,000 --> 00:41:17,340
y los dos se quedan con el mismo valor

1087
00:41:17,340 --> 00:41:19,840
¿vale? entonces es una asignación

1088
00:41:19,840 --> 00:41:21,179
puntual en ese momento

1089
00:41:21,179 --> 00:41:22,980
si ahora yo cambio

1090
00:41:22,980 --> 00:41:25,239
la variable edad

1091
00:41:25,239 --> 00:41:27,639
Aquí parece que he grabado

1092
00:41:27,639 --> 00:41:32,369
Si ahora yo cambio la variable edad

1093
00:41:32,369 --> 00:41:34,489
Y le pongo 89

1094
00:41:34,489 --> 00:41:35,849
Por ejemplo

1095
00:41:35,849 --> 00:41:39,030
Y previamente tenía 78

1096
00:41:39,030 --> 00:41:40,409
Para dejarlo así

1097
00:41:40,409 --> 00:41:44,449
¿Vale?

1098
00:41:44,630 --> 00:41:46,349
Por ejemplo estas tres sentencias

1099
00:41:46,349 --> 00:41:51,199
Estas tres sentencias de aquí

1100
00:41:51,199 --> 00:41:53,869
¿Vale?

1101
00:41:53,969 --> 00:41:56,050
Esas tres sentencias ya sabemos que efecto tienen

1102
00:41:56,050 --> 00:41:58,269
Aquí tenemos edad

1103
00:41:58,269 --> 00:42:01,690
Que resulta que tiene un 78

1104
00:42:01,690 --> 00:42:02,590
Porque se lo he puesto

1105
00:42:02,590 --> 00:42:04,610
aquí tenemos edad tocha

1106
00:42:04,610 --> 00:42:07,190
no sé lo que tiene, bueno, tiene eso

1107
00:42:07,190 --> 00:42:09,650
lo que tenga

1108
00:42:09,650 --> 00:42:10,170
de antes

1109
00:42:10,170 --> 00:42:13,250
ahora, hago esta asignación, ya sabemos que la asignación

1110
00:42:13,250 --> 00:42:15,369
implica que la máquina

1111
00:42:15,369 --> 00:42:17,090
virtual dice, uy, aquí hay una

1112
00:42:17,090 --> 00:42:19,349
hay una variable

1113
00:42:19,349 --> 00:42:20,949
voy a ver que tiene, se asoma

1114
00:42:20,949 --> 00:42:22,929
y dice, ah, tiene un 78

1115
00:42:22,929 --> 00:42:25,510
vale, pues voy a copiarlo

1116
00:42:25,510 --> 00:42:26,670
aquí, 78

1117
00:42:26,670 --> 00:42:29,190
después de esta segunda

1118
00:42:29,190 --> 00:42:30,590
sentencia nos quedamos así

1119
00:42:30,590 --> 00:42:33,170
y esas variables

1120
00:42:33,170 --> 00:42:34,710
no es que se queden ligadas de por vida

1121
00:42:34,710 --> 00:42:35,949
esto ha sido

1122
00:42:35,949 --> 00:42:39,349
una asignación puntual

1123
00:42:39,349 --> 00:42:41,269
ahora

1124
00:42:41,269 --> 00:42:43,210
a edad le ponemos

1125
00:42:43,210 --> 00:42:44,710
89, ¿vale?

1126
00:42:44,829 --> 00:42:47,170
¿qué significa eso? que el valor que tenía edad

1127
00:42:47,170 --> 00:42:48,130
fuera la basura

1128
00:42:48,130 --> 00:42:50,090
y ahora ya tiene 89

1129
00:42:50,090 --> 00:42:52,570
y el actocha sigue igual que tenía de antes

1130
00:42:52,570 --> 00:42:55,449
no se ve afectada, esto no significa

1131
00:42:55,449 --> 00:42:57,070
que estas variables

1132
00:42:57,070 --> 00:42:59,110
se queden ya unidas de por vida

1133
00:42:59,110 --> 00:43:00,869
y que una vaya a seguir a la otra siempre

1134
00:43:00,869 --> 00:43:03,190
nada que ver, siguen siendo dos variables

1135
00:43:03,190 --> 00:43:04,030
separadas

1136
00:43:04,030 --> 00:43:07,230
lo que pasa es que para esta asignación

1137
00:43:07,230 --> 00:43:09,030
puntual y solo para

1138
00:43:09,030 --> 00:43:10,489
esa asignación puntual

1139
00:43:10,489 --> 00:43:12,610
esta variable

1140
00:43:12,610 --> 00:43:14,750
ha recibido lo que en este momento

1141
00:43:14,750 --> 00:43:16,789
tenía esta otra, lo que tenía en este momento

1142
00:43:16,789 --> 00:43:18,630
y a partir de ahí

1143
00:43:18,630 --> 00:43:20,989
ya está, siguen cada una por libre con sus valores

1144
00:43:20,989 --> 00:43:21,730
¿vale?

1145
00:43:23,289 --> 00:43:23,909
¿pues aún bien?

1146
00:43:23,909 --> 00:43:25,210
sí, claro, es una cosa

1147
00:43:25,210 --> 00:43:27,829
ese signo de igual no funciona como

1148
00:43:27,829 --> 00:43:31,190
No, no, no, no.

1149
00:43:31,190 --> 00:43:33,670
No funciona como son la misma variable.

1150
00:43:33,929 --> 00:43:35,809
No. Es el operador asignación.

1151
00:43:36,329 --> 00:43:37,590
Edad tocha siempre va a ser

1152
00:43:37,590 --> 00:43:39,570
una variable y edad otra muy distinta.

1153
00:43:40,070 --> 00:43:41,550
Siempre van a ser distintas.

1154
00:43:42,650 --> 00:43:43,369
Iguales para

1155
00:43:43,369 --> 00:43:45,250
asignar puntualmente un valor.

1156
00:43:45,409 --> 00:43:47,130
No significa esta variable y esta

1157
00:43:47,130 --> 00:43:48,289
se convierten en la misma.

1158
00:43:49,030 --> 00:43:51,409
No significa automáticamente se funden

1159
00:43:51,409 --> 00:43:53,550
y son un único espacio en memoria.

1160
00:43:54,630 --> 00:43:55,610
No, no, no.

1161
00:43:56,510 --> 00:43:57,590
Claro, fundamental.

1162
00:43:57,590 --> 00:44:00,090
no significa se han fundido

1163
00:44:00,090 --> 00:44:01,610
y a partir de ahí son el mismo.

1164
00:44:02,190 --> 00:44:03,530
Porque si significara eso,

1165
00:44:03,750 --> 00:44:05,590
efectivamente, cuando yo hago ahora

1166
00:44:05,590 --> 00:44:07,829
el 89 aquí, el 89

1167
00:44:07,829 --> 00:44:09,730
también iría a la otra

1168
00:44:09,730 --> 00:44:11,289
variable. No, no, no, no.

1169
00:44:11,829 --> 00:44:13,389
Esto es un operador

1170
00:44:13,389 --> 00:44:14,889
para asignar

1171
00:44:14,889 --> 00:44:17,570
en ese momento el valor

1172
00:44:17,570 --> 00:44:19,809
que yo ponga aquí, que ese valor puede proceder

1173
00:44:19,809 --> 00:44:21,190
de una variable, de un número,

1174
00:44:21,349 --> 00:44:23,210
de operaciones, como después veremos,

1175
00:44:23,610 --> 00:44:25,449
de expresiones complejas. Ese valor

1176
00:44:25,449 --> 00:44:27,610
de donde sea procederá

1177
00:44:27,610 --> 00:44:29,750
de donde sea, pues en ese momento

1178
00:44:29,750 --> 00:44:31,030
ese valor va aquí

1179
00:44:31,030 --> 00:44:33,989
pero las variables que estén aquí involucradas

1180
00:44:33,989 --> 00:44:36,269
esas variables solo han servido

1181
00:44:36,269 --> 00:44:38,070
para enseñarte

1182
00:44:38,070 --> 00:44:39,769
lo que tiene, nada más

1183
00:44:39,769 --> 00:44:42,150
esa variable sigue ahí su vida libre

1184
00:44:42,150 --> 00:44:43,949
solo sirve aquí

1185
00:44:43,949 --> 00:44:45,510
para enseñar lo que tiene, dice oye

1186
00:44:45,510 --> 00:44:48,190
tengo un 78, te lo enseño

1187
00:44:48,190 --> 00:44:50,050
entonces tú ya lo coges

1188
00:44:50,050 --> 00:44:51,510
y lo asignas a este, la variable da

1189
00:44:51,510 --> 00:44:53,869
su vida independiente de la otra

1190
00:44:53,869 --> 00:44:54,489
¿Vale?

1191
00:44:55,070 --> 00:44:56,289
¿No has preguntado antes de parar?

1192
00:45:01,369 --> 00:45:01,929
No

1193
00:45:01,929 --> 00:45:05,070
¿Para qué querrías hacer eso?

1194
00:45:05,309 --> 00:45:05,570
No

1195
00:45:05,570 --> 00:45:09,190
Eso sería como hacer desaparecer una

1196
00:45:09,190 --> 00:45:11,329
Si ya no necesitas dos variables

1197
00:45:11,329 --> 00:45:14,769
Y no puedes hacer desaparecer una variable

1198
00:45:14,769 --> 00:45:16,610
O sea, modificar las variables

1199
00:45:16,610 --> 00:45:18,150
De repente una desaparezca

1200
00:45:18,150 --> 00:45:19,269
Una y otra sean la misma

1201
00:45:19,269 --> 00:45:24,210
Venga, pues vamos a parar entonces

1202
00:45:24,210 --> 00:45:26,650
Un momentico

1203
00:45:26,650 --> 00:45:26,949
Gracias.