1
00:00:01,010 --> 00:00:19,570
Vale, pues del tipo char, poco más que esto que hemos dicho, el tipo char admite un carácter de los de la tabla ASCII, ese carácter se lo puedo dar entre comillas simples en la asignación o le puedo dar un numerito entero, 13, 14, ¿vale?

2
00:00:19,570 --> 00:00:21,449
pero cuidado con

3
00:00:21,449 --> 00:00:24,370
el matiz de darle una variable

4
00:00:24,370 --> 00:00:25,870
entera, entonces ya no

5
00:00:25,870 --> 00:00:28,289
entonces ya no

6
00:00:28,289 --> 00:00:30,329
porque el compilador

7
00:00:30,329 --> 00:00:31,570
trabaja por reglas

8
00:00:31,570 --> 00:00:34,149
y la regla dice el número entero podría

9
00:00:34,149 --> 00:00:35,750
tener algo mucho más grande

10
00:00:35,750 --> 00:00:38,189
que los numeritos de la

11
00:00:38,189 --> 00:00:38,810
tabla ASTI

12
00:00:38,810 --> 00:00:42,210
y esto se extiende a no sé

13
00:00:42,210 --> 00:00:43,929
quién ha preguntado lo del byte y el short

14
00:00:43,929 --> 00:00:46,030
entonces yo le doy no tampoco, porque la regla es que

15
00:00:46,030 --> 00:00:47,090
tiene el compilador es

16
00:00:47,090 --> 00:00:49,829
Algo que tú has declarado con Ochar

17
00:00:49,829 --> 00:00:52,170
Solamente le puedes dar

18
00:00:52,170 --> 00:00:54,630
O un carácter así

19
00:00:54,630 --> 00:00:55,990
¿Vale?

20
00:00:56,509 --> 00:00:57,829
O se lo das en número

21
00:00:57,829 --> 00:00:59,570
Pero un número que ya de partida

22
00:00:59,570 --> 00:01:01,810
76 sea de los

23
00:01:01,810 --> 00:01:03,329
Que están en la tabla ASCII

24
00:01:03,329 --> 00:01:07,219
Pero no le podemos dar

25
00:01:07,219 --> 00:01:08,959
Por ejemplo, tengo mi variable byte

26
00:01:08,959 --> 00:01:10,939
Que tiene igual al 76

27
00:01:10,939 --> 00:01:11,700
Por ejemplo

28
00:01:11,700 --> 00:01:14,299
Entonces, a carácter

29
00:01:14,299 --> 00:01:17,319
Le podría dar

30
00:01:17,319 --> 00:01:19,140
la variable b

31
00:01:19,140 --> 00:01:21,680
porque un byte

32
00:01:21,680 --> 00:01:22,980
se guarda en 8 bits

33
00:01:22,980 --> 00:01:25,459
entonces el compilador podría decir

34
00:01:25,459 --> 00:01:27,379
no sé que hay en byte pero es imposible

35
00:01:27,379 --> 00:01:28,200
que sea un número

36
00:01:28,200 --> 00:01:30,840
que no esté en la tabla ASCII

37
00:01:30,840 --> 00:01:32,920
pues no, las reglas son

38
00:01:32,920 --> 00:01:34,799
a una variable char

39
00:01:34,799 --> 00:01:37,400
no puedes darle nada que no sea

40
00:01:37,400 --> 00:01:39,859
un tipo compatible exactamente

41
00:01:39,859 --> 00:01:41,459
bien un char

42
00:01:41,459 --> 00:01:43,140
entre comillas o el número

43
00:01:43,140 --> 00:01:44,959
¿vale?

44
00:01:44,959 --> 00:01:49,689
entonces estos casos tan raros

45
00:01:49,689 --> 00:01:51,370
pues nos olvidamos, no los tenemos presentes

46
00:01:51,370 --> 00:01:52,549
porque ni siquiera los usamos

47
00:01:52,549 --> 00:01:56,069
y lo único que hay que tener en cuenta

48
00:01:56,069 --> 00:01:57,370
es que a la inversa sí

49
00:01:57,370 --> 00:01:59,870
a una variable entera

50
00:01:59,870 --> 00:02:01,730
a la inversa sí es lo que acabamos de ver

51
00:02:01,730 --> 00:02:03,629
a una variable entera

52
00:02:03,629 --> 00:02:05,930
le puedes asignar

53
00:02:05,930 --> 00:02:07,590
lo que tenga una variable char

54
00:02:07,590 --> 00:02:09,110
eso sí que puedes

55
00:02:09,110 --> 00:02:11,490
y esa variable entera

56
00:02:11,490 --> 00:02:13,889
se va a quedar con el número entero

57
00:02:13,889 --> 00:02:16,250
que codifica este carácter

58
00:02:16,250 --> 00:02:19,990
por eso aquí cuando hemos mostrado esto

59
00:02:19,990 --> 00:02:22,229
carácter me mostraba el char

60
00:02:22,229 --> 00:02:24,909
y este me mostraba el número entero

61
00:02:24,909 --> 00:02:26,330
porque la variable es entera

62
00:02:26,330 --> 00:02:27,849
y se ha quedado con el número entero

63
00:02:27,849 --> 00:02:30,210
bueno, es lo que hemos dicho antes

64
00:02:30,210 --> 00:02:31,430
repasado así un poquito

65
00:02:31,430 --> 00:02:33,650
un poquito por encima

66
00:02:33,650 --> 00:02:34,710
¿vale?

67
00:02:36,710 --> 00:02:37,310
entonces

68
00:02:37,310 --> 00:02:39,969
¿qué ventajas tiene

69
00:02:39,969 --> 00:02:42,009
el poder trabajar

70
00:02:42,009 --> 00:02:46,469
con los caracteres

71
00:02:46,469 --> 00:02:47,729
con las variables char

72
00:02:47,729 --> 00:02:49,370
indistintamente

73
00:02:49,370 --> 00:02:52,189
con el carácter

74
00:02:52,189 --> 00:02:53,990
entre comillas simples o el numerito

75
00:02:53,990 --> 00:02:56,509
pues bueno, tiene algunas ventajas

76
00:02:56,509 --> 00:02:57,830
a la hora de operar

77
00:02:57,830 --> 00:03:08,650
por ejemplo

78
00:03:08,650 --> 00:03:12,110
vale, por ejemplo

79
00:03:12,110 --> 00:03:15,050
aunque luego ya, y está recogido en los documentos

80
00:03:15,050 --> 00:03:15,810
de la JOSIBA de la virtual

81
00:03:15,810 --> 00:03:19,150
aunque ya tendremos que ver más en detalle

82
00:03:19,150 --> 00:03:42,830
En la sentencia de asignación, ¿qué es eso de valor que yo le pongo a la derecha? En una sentencia de asignación como esta, ya sabemos, ya nos está quedando en la cabeza y nos empieza a sonar que la sentencia de asignación siempre es el nombre de variable a la izquierda.

83
00:03:42,830 --> 00:03:45,349
un nombre de variable que esté previamente

84
00:03:45,349 --> 00:03:46,969
declarada y que exista

85
00:03:46,969 --> 00:03:49,409
¿vale? eso ya lo vamos dejando

86
00:03:49,409 --> 00:03:50,409
grabado en la cabeza

87
00:03:50,409 --> 00:03:52,469
entonces las cosas que

88
00:03:52,469 --> 00:03:55,310
digo, eso ya se va quedando grabado en la cabeza

89
00:03:55,310 --> 00:03:57,289
es así que se quedan grabadas

90
00:03:57,289 --> 00:03:58,870
en la cabeza, ¿vale? no en el papel

91
00:03:58,870 --> 00:04:01,389
¿vale? y otras cosas que os digo

92
00:04:01,389 --> 00:04:03,189
bueno, son pequeños matices, que no espero

93
00:04:03,189 --> 00:04:05,270
que todo el mundo tenga los matices en la cabeza

94
00:04:05,270 --> 00:04:07,490
siempre, si los ha oído

95
00:04:07,490 --> 00:04:09,389
alguna vez, cuando está haciendo

96
00:04:09,389 --> 00:04:11,530
un programa y le sale un error afinado con eso

97
00:04:11,530 --> 00:04:13,270
pues hace la conexión cerebral

98
00:04:13,270 --> 00:04:15,370
¡Ah! Esto me sonaba que era

99
00:04:15,370 --> 00:04:17,509
porque había una promoción automática

100
00:04:17,509 --> 00:04:19,189
y no sé qué me sonaba, entonces

101
00:04:19,189 --> 00:04:21,009
con que te suenen ciertas cosas

102
00:04:21,009 --> 00:04:23,269
ya tienes el punto para tirar del hilo

103
00:04:23,269 --> 00:04:25,389
¿vale? Pero hay cosas que no

104
00:04:25,389 --> 00:04:26,350
basta con que suenen

105
00:04:26,350 --> 00:04:29,370
hay muchísimas que tienen

106
00:04:29,370 --> 00:04:31,430
que estar grabadas y memorizadas en la cabeza

107
00:04:31,430 --> 00:04:33,149
no en el papel, ¿vale?

108
00:04:33,250 --> 00:04:34,850
Pues una por ejemplo es

109
00:04:34,850 --> 00:04:37,350
cómo se declara una variable, cómo es una

110
00:04:37,350 --> 00:04:39,389
sentencia de asignación, bueno pues

111
00:04:39,389 --> 00:04:41,509
eso ya a fuerza de decirlo

112
00:04:41,509 --> 00:04:42,829
ya lo tenemos grabado en la cabeza

113
00:04:42,829 --> 00:04:46,089
a la izquierda, nombre de una variable

114
00:04:46,089 --> 00:04:47,629
que previamente

115
00:04:47,629 --> 00:04:49,189
tiene que estar declarada

116
00:04:49,189 --> 00:04:51,550
porque si no el compilador va a decir

117
00:04:51,550 --> 00:04:53,509
esa variable no sé cuál es

118
00:04:53,509 --> 00:04:54,990
con lo cual cómo voy a meter algo

119
00:04:54,990 --> 00:04:57,029
en una variable que no existe

120
00:04:57,029 --> 00:04:59,529
espacio operador de asignación

121
00:04:59,529 --> 00:05:01,689
bueno, el espacio es por cuestión de estilo, no por obligación

122
00:05:01,689 --> 00:05:02,670
operador de asignación

123
00:05:02,670 --> 00:05:04,550
y aquí hemos dicho

124
00:05:04,550 --> 00:05:06,230
un valor

125
00:05:06,230 --> 00:05:09,550
del mismo tipo

126
00:05:09,550 --> 00:05:12,730
y pongo mismo tipo entre comillas

127
00:05:12,730 --> 00:05:15,370
porque aquí hemos visto algunas excepciones

128
00:05:15,370 --> 00:05:17,850
como la promoción automática de int a long

129
00:05:17,850 --> 00:05:20,509
o como a un int le puedo dar un sub

130
00:05:20,509 --> 00:05:22,430
hemos visto algunas excepciones

131
00:05:22,430 --> 00:05:26,209
valor del mismo tipo que la variable

132
00:05:26,209 --> 00:05:32,620
esto es lo que sí que hemos incorporado

133
00:05:32,620 --> 00:05:37,740
algunos matices a que el valor tenga que ser del mismo tipo

134
00:05:37,740 --> 00:05:40,439
pues la promoción automática que hemos visto antes

135
00:05:40,439 --> 00:05:42,040
que se puede hacer de un int a un long

136
00:05:42,040 --> 00:05:43,899
o de un sort a un int

137
00:05:43,899 --> 00:05:46,459
lo de asignar a un int

138
00:05:46,459 --> 00:05:48,160
se le puede dar un char

139
00:05:48,160 --> 00:05:49,459
y no pasa nada

140
00:05:49,459 --> 00:05:51,680
porque el int se queda con el valor numérico

141
00:05:51,680 --> 00:05:53,420
que codifique el char, o sea, hay matices

142
00:05:53,420 --> 00:05:55,839
que son excepciones

143
00:05:55,839 --> 00:05:58,339
para que el valor que hay aquí

144
00:05:58,339 --> 00:06:00,139
tenga que ser del mismo tipo

145
00:06:00,139 --> 00:06:01,740
idéntico que la variable, son excepciones

146
00:06:01,740 --> 00:06:02,560
pero en general

147
00:06:02,560 --> 00:06:06,279
si las variables se declaran

148
00:06:06,279 --> 00:06:06,800
de un tipo

149
00:06:06,800 --> 00:06:09,879
es para asegurarse

150
00:06:09,879 --> 00:06:11,759
para que el programa se asegure de que

151
00:06:11,759 --> 00:06:13,459
solo vas a meter cosas de ese tipo.

152
00:06:14,680 --> 00:06:15,980
Y así se evitan errores

153
00:06:15,980 --> 00:06:16,680
de ejecución.

154
00:06:17,459 --> 00:06:19,620
¿Del mismo tipo te refieres a qué?

155
00:06:22,079 --> 00:06:23,279
Que si es un boolean,

156
00:06:23,879 --> 00:06:25,720
solo puede ir algo que sea un boolean.

157
00:06:25,819 --> 00:06:27,860
Ya veremos lo que es. Si es un número entero,

158
00:06:28,439 --> 00:06:29,920
solo algo que sea un número entero.

159
00:06:30,019 --> 00:06:32,019
Si es un número decimal, solo algo

160
00:06:32,019 --> 00:06:32,939
que sea un número decimal.

161
00:06:34,500 --> 00:06:36,240
Si es un char, solo algo

162
00:06:36,240 --> 00:06:36,920
que sea un char.

163
00:06:38,379 --> 00:06:38,620
¿Vale?

164
00:06:38,620 --> 00:06:42,079
entonces, este es el principio básico

165
00:06:42,079 --> 00:06:43,120
de asignación de variables

166
00:06:43,120 --> 00:06:44,899
este valor

167
00:06:44,899 --> 00:06:48,259
tiene que ser del mismo tipo

168
00:06:48,259 --> 00:06:50,160
del tipo del que se ha declarado

169
00:06:50,160 --> 00:06:52,379
pero hay algunas excepciones

170
00:06:52,379 --> 00:06:53,480
en esta asignación

171
00:06:53,480 --> 00:06:55,519
como algunas que hemos mencionado

172
00:06:55,519 --> 00:06:57,920
esta

173
00:06:57,920 --> 00:07:00,079
la que viene de la promoción automática que hemos dicho

174
00:07:00,079 --> 00:07:02,300
la variable está declarada como long

175
00:07:02,300 --> 00:07:03,620
te le doy un int

176
00:07:03,620 --> 00:07:05,879
no pasa nada, eso te lo tolero

177
00:07:05,879 --> 00:07:08,100
porque yo puedo expandir el valor int

178
00:07:08,100 --> 00:07:09,920
con ceros a la izquierda y meterlo en long

179
00:07:09,920 --> 00:07:12,220
la variable está declarada como en short

180
00:07:12,220 --> 00:07:13,480
y te he puesto un byte

181
00:07:13,480 --> 00:07:16,079
no pasa nada, eso te lo tolero

182
00:07:16,079 --> 00:07:18,379
porque el byte puedes tenderlo con ceros

183
00:07:18,379 --> 00:07:19,819
a la izquierda y te cabe en short

184
00:07:19,819 --> 00:07:22,019
entonces es una excepción

185
00:07:22,019 --> 00:07:24,459
para que esto de aquí no sea el mismo tipo

186
00:07:24,459 --> 00:07:26,060
otra

187
00:07:26,060 --> 00:07:27,600
la que hemos visto

188
00:07:27,600 --> 00:07:29,420
la variable está declarada como int

189
00:07:29,420 --> 00:07:30,779
y me estás dando un char

190
00:07:30,779 --> 00:07:34,139
esa también te dejo, yo cojo el valor

191
00:07:34,139 --> 00:07:36,300
numérico que codifica ese char en la tabla

192
00:07:36,300 --> 00:07:38,560
y pongo el semáforo en la variable i.

193
00:07:39,819 --> 00:07:42,819
Hay excepciones que hacen más operativa la escritura de código.

194
00:07:43,560 --> 00:07:47,100
Pero en general, si el lenguaje es tipado,

195
00:07:47,279 --> 00:07:49,660
o lo que es lo mismo, te obliga a especificar un tipo,

196
00:07:50,259 --> 00:07:53,339
es precisamente para que tú no hagas cosas extrañas

197
00:07:53,339 --> 00:07:59,120
y metas en las variables cosas para lo cual están pensadas esas variables.

198
00:07:59,560 --> 00:08:02,139
Si una variable está pensada para que tenga un nombre,

199
00:08:02,139 --> 00:08:04,620
no le metas un 7

200
00:08:04,620 --> 00:08:06,579
porque un 7 no es un nombre

201
00:08:06,579 --> 00:08:07,199
es un número

202
00:08:07,199 --> 00:08:09,779
para hacer eso están otros lenguajes

203
00:08:09,779 --> 00:08:11,259
con otros objetivos

204
00:08:11,259 --> 00:08:13,720
pero no está Java para eso

205
00:08:13,720 --> 00:08:16,180
Java está para hacer aplicaciones robustas

206
00:08:16,180 --> 00:08:18,519
entonces, si desde partida

207
00:08:18,519 --> 00:08:19,980
te obliga que si tú una variable

208
00:08:19,980 --> 00:08:21,540
va a tener un nombre

209
00:08:21,540 --> 00:08:23,480
una cadena de caracteres, ya veremos cómo

210
00:08:23,480 --> 00:08:25,000
solo le puedes meter un nombre

211
00:08:25,000 --> 00:08:27,199
tú eso ya

212
00:08:27,199 --> 00:08:29,339
en el momento que estás escribiendo código

213
00:08:29,339 --> 00:08:31,759
ya estás cumpliendo esa obligación

214
00:08:31,759 --> 00:08:32,580
La estás cumpliendo.

215
00:08:33,620 --> 00:08:36,360
Luego, cuando ya lo ejecutes, como has hecho tus deberes,

216
00:08:37,000 --> 00:08:38,059
la ejecución va a estar bien.

217
00:08:38,419 --> 00:08:41,399
Porque has hecho los deberes en tiempo de escritura de código,

218
00:08:41,519 --> 00:08:43,220
que es que todo encaje, que todo esté bien.

219
00:08:43,840 --> 00:08:46,539
Si el compilador te dejara poner cualquier cosa,

220
00:08:47,679 --> 00:08:50,559
podrías no hacer tus deberes y en una cadena de caracteres

221
00:08:50,559 --> 00:08:54,539
meter un 7, te dejaría no hacer tus deberes.

222
00:08:54,679 --> 00:08:57,840
Cuando eso se ejecuta, seguramente te salgan cosas

223
00:08:57,840 --> 00:08:59,220
fruto de esa incoherencia.

224
00:08:59,220 --> 00:09:01,980
me estás diciendo que este alumno se llama 7

225
00:09:01,980 --> 00:09:04,220
eso te va a fallar

226
00:09:04,220 --> 00:09:05,419
¿vale?

227
00:09:05,779 --> 00:09:07,279
en Java todo eso

228
00:09:07,279 --> 00:09:10,159
no va a ocurrir porque ya en tiempo de escritura

229
00:09:10,159 --> 00:09:12,120
del código has tenido que cumplir unas reglas

230
00:09:12,120 --> 00:09:13,740
porque si no el compilador te dice

231
00:09:13,740 --> 00:09:15,399
no, no puedo

232
00:09:15,399 --> 00:09:17,940
no voy a compilar, si no compilo

233
00:09:17,940 --> 00:09:19,340
porque hay errores de compilación

234
00:09:19,340 --> 00:09:21,379
pues no ejecuto, no ejecutas

235
00:09:21,379 --> 00:09:24,059
solo se puede ejecutar lo que previamente se ha compilado

236
00:09:24,059 --> 00:09:25,480
como ya sabemos del primer día

237
00:09:25,480 --> 00:09:28,200
vale, pues entonces

238
00:09:28,200 --> 00:09:31,039
todo esto venía a cuento de la sentencia de asignación

239
00:09:31,039 --> 00:09:32,000
que estábamos aquí

240
00:09:32,000 --> 00:09:35,779
repasando

241
00:09:35,779 --> 00:09:36,639
vale

242
00:09:36,639 --> 00:09:39,000
esta se ha quedado tonta

243
00:09:39,000 --> 00:09:49,519
vale

244
00:09:49,519 --> 00:09:52,039
entonces

245
00:09:52,039 --> 00:09:54,340
en la sentencia de asignación por tanto

246
00:09:54,340 --> 00:09:56,320
el compilador va a mirar que aquí haya un valor

247
00:09:56,320 --> 00:09:57,039
como hemos dicho

248
00:09:57,039 --> 00:10:00,220
del mismo tipo salvo estos matices

249
00:10:00,220 --> 00:10:02,519
que nos están surgiendo y estamos viendo

250
00:10:02,519 --> 00:10:05,059
vale entonces

251
00:10:05,059 --> 00:10:12,320
esto de aquí que es

252
00:10:12,320 --> 00:10:13,360
lo que hemos llamado

253
00:10:13,360 --> 00:10:14,779
el valor

254
00:10:14,779 --> 00:10:19,659
ya hemos visto dos formas

255
00:10:19,659 --> 00:10:21,440
de darlo

256
00:10:21,440 --> 00:10:23,840
dos formas de proveer ese valor

257
00:10:23,840 --> 00:10:24,960
ya hemos visto dos maneras

258
00:10:24,960 --> 00:10:28,440
a través de dos ejemplos

259
00:10:28,440 --> 00:10:30,240
una

260
00:10:30,240 --> 00:10:35,570
directamente el valor que sea

261
00:10:35,570 --> 00:10:42,309
¿vale? como cuando hemos hecho

262
00:10:42,309 --> 00:10:44,570
n igual a 7

263
00:10:44,570 --> 00:10:46,710
directamente el valor

264
00:10:46,710 --> 00:10:47,309
tal cual

265
00:10:47,309 --> 00:10:50,690
o cuando hemos hecho c que era un char

266
00:10:50,690 --> 00:10:53,330
igual a G

267
00:10:53,330 --> 00:10:55,870
directamente, el valor tal cual

268
00:10:55,870 --> 00:10:57,330
¿vale?

269
00:10:57,389 --> 00:10:59,190
pero hemos visto también otras formas

270
00:10:59,190 --> 00:11:01,049
de dar el valor

271
00:11:01,049 --> 00:11:03,110
en una sentencia de asignación

272
00:11:03,110 --> 00:11:05,350
la otra forma que hemos dicho

273
00:11:05,350 --> 00:11:06,529
es dando una variable

274
00:11:06,529 --> 00:11:13,070
por ejemplo, cuando hemos hecho

275
00:11:13,070 --> 00:11:16,289
N igual a M

276
00:11:16,289 --> 00:11:17,970
lo hemos hecho con las edades

277
00:11:17,970 --> 00:11:19,129
edad tocha igual a edad

278
00:11:19,129 --> 00:11:21,990
esta es otra asignación válida

279
00:11:21,990 --> 00:11:22,389
¿vale?

280
00:11:22,389 --> 00:11:25,250
aquí la forma de dar el valor

281
00:11:25,250 --> 00:11:26,690
no es darlo directamente

282
00:11:26,690 --> 00:11:28,990
7g el valor exacto

283
00:11:28,990 --> 00:11:30,750
la forma de dar el valor

284
00:11:30,750 --> 00:11:32,490
es dar otra variable

285
00:11:32,490 --> 00:11:34,690
doy otra variable y ya hemos visto

286
00:11:34,690 --> 00:11:37,330
que es lo que hace la máquina virtual cuando ejecute esto

287
00:11:37,330 --> 00:11:39,470
se va a la RAM

288
00:11:39,470 --> 00:11:41,429
a mirar la variable que se llama así

289
00:11:41,429 --> 00:11:42,289
m

290
00:11:42,289 --> 00:11:44,570
mira lo que hay dentro

291
00:11:44,570 --> 00:11:47,149
y ese mismo valor, ese mismo

292
00:11:47,149 --> 00:11:48,210
lo copia aquí

293
00:11:48,210 --> 00:11:51,370
¿vale? se quedan las dos variables

294
00:11:51,370 --> 00:11:52,190
con el mismo valor

295
00:11:52,190 --> 00:11:55,769
pero las variables siguen siendo independientes

296
00:11:55,769 --> 00:11:57,850
luego yo a M le puedo asignar otra cosa

297
00:11:57,850 --> 00:11:58,950
a N otra, ¿vale?

298
00:11:59,009 --> 00:12:00,950
hemos hecho asignaciones

299
00:12:00,950 --> 00:12:03,110
de las dos maneras

300
00:12:03,110 --> 00:12:04,389
¿vale?

301
00:12:06,990 --> 00:12:08,990
pero tenemos una tercera manera

302
00:12:08,990 --> 00:12:10,470
de dar valores

303
00:12:10,470 --> 00:12:13,889
de otorgar aquí un valor

304
00:12:13,889 --> 00:12:16,029
porque eso es lo que va ahí, ¿verdad?

305
00:12:16,570 --> 00:12:17,230
ahí va un valor

306
00:12:17,230 --> 00:12:19,029
tenemos otra manera de dar un valor

307
00:12:19,029 --> 00:12:21,830
que es construir una expresión

308
00:12:21,830 --> 00:12:24,009
una expresión con operadores

309
00:12:24,009 --> 00:12:27,250
que de tal manera

310
00:12:27,250 --> 00:12:29,169
que cuando esa expresión se evalúe

311
00:12:29,169 --> 00:12:31,309
el resultado de la evaluación

312
00:12:31,309 --> 00:12:33,190
de esa expresión sea un valor compatible

313
00:12:33,190 --> 00:12:37,549
es decir, una expresión

314
00:12:37,549 --> 00:12:41,669
con operadores

315
00:12:41,669 --> 00:12:44,899
ahora lo vamos a ver

316
00:12:44,899 --> 00:12:45,519
con un ejemplo

317
00:12:45,519 --> 00:12:48,820
yo puedo poner una expresión que involucra operadores

318
00:12:48,820 --> 00:12:50,899
están los básicos

319
00:12:50,899 --> 00:12:52,100
sumas y restas

320
00:12:52,100 --> 00:12:54,259
y los hay luego más complejos

321
00:12:54,259 --> 00:12:55,960
que están todos recogidos en el aula virtual

322
00:12:55,960 --> 00:12:57,860
puedo conseguir una expresión

323
00:12:57,860 --> 00:13:00,120
pues 3 más 12

324
00:13:00,120 --> 00:13:03,019
3 más 12 ahora ya es una expresión

325
00:13:03,019 --> 00:13:04,539
no es un valor tal cual

326
00:13:04,539 --> 00:13:05,700
no es 15

327
00:13:05,700 --> 00:13:08,240
3 más 12 es una expresión

328
00:13:08,240 --> 00:13:09,779
¿por qué?

329
00:13:10,279 --> 00:13:12,799
porque involucra valores y operadores

330
00:13:12,799 --> 00:13:15,899
en este caso el operador de suma

331
00:13:15,899 --> 00:13:16,320
¿vale?

332
00:13:16,659 --> 00:13:17,820
eso es una expresión

333
00:13:17,820 --> 00:13:21,399
la máquina virtual cuando se encuentra una expresión

334
00:13:21,399 --> 00:13:22,659
correctamente

335
00:13:22,659 --> 00:13:24,100
escrita

336
00:13:24,100 --> 00:13:26,940
porque claro, de nuevo también hay que satisfacer

337
00:13:26,940 --> 00:13:29,480
las reglas sintácticas para construir expresiones.

338
00:13:30,259 --> 00:13:32,379
Que ya tendremos que detallar una por una.

339
00:13:32,980 --> 00:13:34,639
Pero bueno, lo básico lo podemos usar ahora

340
00:13:34,639 --> 00:13:36,059
para hacer unos primeros ejemplos.

341
00:13:36,620 --> 00:13:38,960
Pues la máquina virtual cuando se encuentra una expresión

342
00:13:38,960 --> 00:13:41,980
la evalúa, es decir, hace la operación.

343
00:13:43,340 --> 00:13:45,440
El resultado de esa evaluación

344
00:13:45,440 --> 00:13:47,840
o de hacer esa operación

345
00:13:47,840 --> 00:13:49,200
me da un valor.

346
00:13:49,820 --> 00:13:52,279
Y ahora ese valor ya sí que lo asigno a la variable.

347
00:13:54,299 --> 00:13:56,659
Luego, recopilando

348
00:13:56,659 --> 00:13:59,519
yo le asigno valores a una variable

349
00:13:59,519 --> 00:14:01,539
en general de tres maneras

350
00:14:01,539 --> 00:14:03,559
bueno, hay más

351
00:14:03,559 --> 00:14:05,500
a través de una interfaz gráfica, a través de no sé qué

352
00:14:05,500 --> 00:14:06,679
pero eso ya es otra tarea

353
00:14:06,679 --> 00:14:09,120
directamente el valor

354
00:14:09,120 --> 00:14:10,419
tal cual

355
00:14:10,419 --> 00:14:13,679
eso es asignar por código, por programa

356
00:14:13,679 --> 00:14:15,659
le asigno el 7

357
00:14:15,659 --> 00:14:16,740
lo que sea

358
00:14:16,740 --> 00:14:18,700
vale

359
00:14:18,700 --> 00:14:21,620
asignárselo a través de otra variable

360
00:14:21,620 --> 00:14:23,980
asignárselo a través de otra

361
00:14:23,980 --> 00:14:25,820
vale

362
00:14:25,820 --> 00:14:28,100
esto nos ha quedado claro

363
00:14:28,100 --> 00:14:28,860
lo que significa

364
00:14:28,860 --> 00:14:31,860
o construí una expresión

365
00:14:31,860 --> 00:14:32,980
que tendré que

366
00:14:32,980 --> 00:14:35,879
repito, cumplir las reglas

367
00:14:35,879 --> 00:14:38,039
sintácticas para construir expresiones

368
00:14:38,039 --> 00:14:40,000
construí una expresión

369
00:14:40,000 --> 00:14:41,740
esa expresión

370
00:14:41,740 --> 00:14:44,159
le tocará a la máquina virtual evaluarla

371
00:14:44,159 --> 00:14:46,000
y cuando la tenga

372
00:14:46,000 --> 00:14:48,220
evaluada el valor que ha resultado

373
00:14:48,220 --> 00:14:49,139
de esa evaluación

374
00:14:49,139 --> 00:14:52,039
se va a la variable

375
00:14:52,039 --> 00:14:53,139
y ya está

376
00:14:53,139 --> 00:15:37,809
¿Vale? Pues por ejemplo, entonces, si yo, vale, aquí ejemplo con operaciones que estábamos, pues venga, para cambiar con variables nuevas, me voy a coger una variable número, le doy el 34, por ejemplo, número 1.

377
00:15:37,809 --> 00:16:03,110
Y ahora me voy a hacer una variable número 2. Bueno, pues a número 2 yo le puedo asignar, por ejemplo, esta expresión, número 1 más 12.

378
00:16:03,110 --> 00:16:20,190
Entonces, aunque ya veremos los operadores, podemos imaginar que Java entiende los aritméticos básicos, claro, los aritméticos básicos los entiende.

379
00:16:20,889 --> 00:16:28,490
Entiende la suma, la resta, la multiplicación con el asterisco y la división.

380
00:16:29,490 --> 00:16:34,629
Lo que pasa es que este funciona diferente en función de si le das números enteros o decimales.

381
00:16:34,629 --> 00:16:36,289
ahora mismo como solo estamos con enteros

382
00:16:36,289 --> 00:16:39,710
esta operación te da la división entera

383
00:16:39,710 --> 00:16:41,110
es decir, el cociente

384
00:16:41,110 --> 00:16:44,070
este sería el operador cociente

385
00:16:44,070 --> 00:16:44,909
te da el cociente

386
00:16:44,909 --> 00:16:46,429
ya está, el cociente

387
00:16:46,429 --> 00:16:50,129
entonces podemos, eso lo podíamos deducir

388
00:16:50,129 --> 00:16:51,909
que hombre, que menos que te entienda

389
00:16:51,909 --> 00:16:53,149
los operadores básicos

390
00:16:53,149 --> 00:16:55,889
no te entiende el operador potencia

391
00:16:55,889 --> 00:16:57,990
no tiene el logaritmo

392
00:16:57,990 --> 00:16:59,269
esos operadores no los entiende

393
00:16:59,269 --> 00:17:01,929
para eso hay que construir

394
00:17:01,929 --> 00:17:03,649
hay que usar objetos

395
00:17:03,649 --> 00:17:04,609
patatín patatán

396
00:17:04,609 --> 00:17:07,029
Pero estos los entiende tal cual

397
00:17:07,029 --> 00:17:08,210
No hay que complicarse la vida

398
00:17:08,210 --> 00:17:09,670
Bueno, pues

399
00:17:09,670 --> 00:17:11,910
Estos son operadores

400
00:17:11,910 --> 00:17:14,029
Los aritméticos básicos

401
00:17:14,029 --> 00:17:15,369
Estos serían

402
00:17:15,369 --> 00:17:18,410
Los operadores aritméticos básicos

403
00:17:18,410 --> 00:17:19,309
¿Vale?

404
00:17:19,930 --> 00:17:31,819
Que estos serían los operadores

405
00:17:31,819 --> 00:17:33,880
Aritméticos básicos que se llaman

406
00:17:33,880 --> 00:17:42,019
Pero vamos, de estos hay que explicar

407
00:17:42,019 --> 00:17:42,980
Cómo funcionan

408
00:17:42,980 --> 00:17:45,940
¿Qué regla sintáctica tenemos que seguir

409
00:17:45,940 --> 00:17:46,839
Cuando los usamos?

410
00:17:47,460 --> 00:17:49,500
Pues hombre, que tienen que tener un operador delante

411
00:17:49,500 --> 00:17:50,519
y otro detrás, ya está

412
00:17:50,519 --> 00:17:54,920
entonces si ponemos un operador delante

413
00:17:54,920 --> 00:17:56,680
y otro detrás, pues estamos siguiendo

414
00:17:56,680 --> 00:17:57,839
la regla sintáctica

415
00:17:57,839 --> 00:17:59,940
que necesita Java

416
00:17:59,940 --> 00:18:05,470
entonces esta expresión es válida

417
00:18:05,470 --> 00:18:07,829
porque tenemos un operador delante

418
00:18:07,829 --> 00:18:08,569
y otro detrás

419
00:18:08,569 --> 00:18:11,569
y de nuevo, exactamente igual que hemos dicho antes

420
00:18:11,569 --> 00:18:12,750
cuando yo doy un valor

421
00:18:12,750 --> 00:18:14,329
cuando doy un valor

422
00:18:14,329 --> 00:18:17,710
o bien doy el valor directamente

423
00:18:17,710 --> 00:18:19,589
tal cual, o bien lo puedo

424
00:18:19,589 --> 00:18:20,809
dar mediante una variable

425
00:18:20,809 --> 00:18:23,430
o sea, yo siempre que dé un valor a alguien

426
00:18:23,430 --> 00:18:26,670
sea dentro de una expresión

427
00:18:26,670 --> 00:18:29,450
o sea directamente un valor a una variable.

428
00:18:29,950 --> 00:18:30,950
Siempre que yo quiera,

429
00:18:31,190 --> 00:18:32,549
siempre que yo necesite un valor

430
00:18:32,549 --> 00:18:35,569
en una expresión o donde sea,

431
00:18:36,390 --> 00:18:37,829
tengo dos formas de obtenerlo.

432
00:18:38,569 --> 00:18:39,650
Poniéndolo tal cual

433
00:18:39,650 --> 00:18:42,750
o poniendo una variable que lo tenga dentro.

434
00:18:43,289 --> 00:18:43,930
Me da lo mismo.

435
00:18:44,690 --> 00:18:44,890
¿Vale?

436
00:18:47,269 --> 00:18:48,650
El valor tal cual

437
00:18:48,650 --> 00:18:51,109
y una variable que lo tiene

438
00:18:51,109 --> 00:18:52,529
es lo mismo.

439
00:18:52,529 --> 00:18:56,130
de cara a las expresiones, a las asignaciones, a todo.

440
00:18:56,250 --> 00:18:56,710
Es lo mismo.

441
00:18:58,470 --> 00:19:04,769
Entonces, poner número 1 o poner 34, en este caso,

442
00:19:05,490 --> 00:19:07,130
es exactamente igual.

443
00:19:07,829 --> 00:19:10,809
La operación va a obtener el mismo resultado

444
00:19:10,809 --> 00:19:13,569
porque número 1 tiene dentro 34.

445
00:19:15,009 --> 00:19:15,230
¿Vale?

446
00:19:15,230 --> 00:19:17,130
Entonces, siempre que yo necesite un valor,

447
00:19:19,650 --> 00:19:22,190
ese valor puede provenir de calcarlo tal cual

448
00:19:22,190 --> 00:19:23,970
o de poner una variable que lo contiene.

449
00:19:24,230 --> 00:19:37,119
¿Vale? Hasta ahí está entendido, ¿no? Lo que pasa es que, claro, lógicamente aquí estamos programando. Se trata de hacer cosas que tengan sentido.

450
00:19:37,119 --> 00:19:53,809
Porque, por ejemplo, estas dos sentencias, vosotros ponéis aquí, número 2 igual a 34 más 12, ¿vale?

451
00:19:54,369 --> 00:19:57,170
Las dos hacen lo mismo.

452
00:19:58,329 --> 00:20:05,650
Las dos suman 12 a 34 y el resultado lo guardan en número 2.

453
00:20:06,410 --> 00:20:09,490
Eso es lo que hace la máquina virtual cuando se encuentra una expresión, ¿no?

454
00:20:09,490 --> 00:20:15,970
Se encuentra la expresión, hace la operación correspondiente y el resultado va aquí.

455
00:20:17,130 --> 00:20:25,130
Número 2 tendrá aquí su espacio, número 1 aquí su espacio.

456
00:20:25,730 --> 00:20:28,130
Número 1 resulta que tiene 34, muy bien.

457
00:20:29,150 --> 00:20:30,470
Vale, llegamos a este punto.

458
00:20:31,230 --> 00:20:33,710
La máquina virtual, número 1 más 12.

459
00:20:34,549 --> 00:20:40,450
El compilador nos ha dado vía libre para ejecutar porque es una expresión correctamente elaborada.

460
00:20:41,190 --> 00:21:01,130
Vale, pues ¿qué hace la máquina virtual? ¿Me has dado la variable? Pues me voy a mirar la variable que tiene, 34. Cojo el 34. Lo sumo al 12. Pues nada, lo que me dé, 46. ¿Qué hago con ese 46? Lo guardo en número 2.

461
00:21:01,130 --> 00:21:04,390
Se acaba la sentencia

462
00:21:04,390 --> 00:21:09,589
Si en lugar de esta de arriba

463
00:21:09,589 --> 00:21:11,230
Hubiéramos tenido la de abajo

464
00:21:11,230 --> 00:21:15,619
Hubiera sido lo mismo

465
00:21:15,619 --> 00:21:16,599
¿Verdad?

466
00:21:17,720 --> 00:21:19,460
La máquina virtual se encuentra

467
00:21:19,460 --> 00:21:20,660
Esta operación que es válida

468
00:21:20,660 --> 00:21:23,400
Es un operador suma con dos valores a los lados

469
00:21:23,400 --> 00:21:25,599
Hace la suma

470
00:21:25,599 --> 00:21:27,140
46

471
00:21:27,140 --> 00:21:29,319
Bueno, pues el 46

472
00:21:29,319 --> 00:21:30,279
¿Dónde quieres que vaya?

473
00:21:30,440 --> 00:21:31,299
A número 2

474
00:21:31,299 --> 00:21:35,420
Entonces, claro, podríais decir

475
00:21:35,420 --> 00:21:56,279
Pues es lo mismo. Esta sentencia y esta son lo mismo. No son lo mismo, tienen nada que ver. Esta es una mierda, esta sentencia está bien. ¿Qué quiero decir con eso? Que esta sentencia, este programa mío, solamente va a hacer 34 más 12 siempre. No puede hacer otra cosa. 34 más 12.

476
00:21:56,279 --> 00:21:57,960
pero que ocurre

477
00:21:57,960 --> 00:22:01,599
si yo quiero que este primer operador

478
00:22:01,599 --> 00:22:03,460
a veces sea una cosa

479
00:22:03,460 --> 00:22:04,539
y a veces sea otra

480
00:22:04,539 --> 00:22:06,660
pues esa es la clave de la programación

481
00:22:06,660 --> 00:22:09,079
yo en lugar de darle el 34

482
00:22:09,079 --> 00:22:09,980
exactamente

483
00:22:09,980 --> 00:22:12,640
le doy el nombre de la variable

484
00:22:12,640 --> 00:22:15,099
y esta variable

485
00:22:15,099 --> 00:22:17,480
en cada ejecución que tenga lo que quiera

486
00:22:17,480 --> 00:22:19,440
aquí lo que pasa es que en esta ejecución

487
00:22:19,440 --> 00:22:20,559
como todavía no sé leer

488
00:22:20,559 --> 00:22:23,279
por teclado, le he puesto el 34

489
00:22:23,279 --> 00:22:25,259
siempre, pero normal será

490
00:22:25,259 --> 00:22:27,059
que esta sentencia

491
00:22:27,059 --> 00:22:29,279
lea el valor del exterior

492
00:22:29,279 --> 00:22:31,259
rápidamente incorporaremos como

493
00:22:31,259 --> 00:22:33,099
para poder hacer un programa que trabaje con

494
00:22:33,099 --> 00:22:35,079
diferentes valores en cada ejecución

495
00:22:35,079 --> 00:22:36,759
entonces

496
00:22:36,759 --> 00:22:38,140
la sentencia de arriba

497
00:22:38,140 --> 00:22:40,779
es una ejecución que en función

498
00:22:40,779 --> 00:22:42,299
de lo que tenga número uno

499
00:22:42,299 --> 00:22:45,319
me hace una cosa o me hace otra, como tiene que ser

500
00:22:45,319 --> 00:22:46,700
los programas

501
00:22:46,700 --> 00:22:49,660
a datos distintos, cosas distintas

502
00:22:49,660 --> 00:22:51,579
lógicamente

503
00:22:51,579 --> 00:22:53,299
los datos que son los valores

504
00:22:53,299 --> 00:22:53,920
de las variables

505
00:22:53,920 --> 00:22:56,299
si los valores de las variables cambian

506
00:22:56,299 --> 00:22:59,480
las operaciones cambian en consecuencia

507
00:22:59,480 --> 00:23:01,400
¿vale? los programas

508
00:23:01,400 --> 00:23:03,079
dependen de los valores

509
00:23:03,079 --> 00:23:05,359
de las variables y hacen cosas diferentes para ellas

510
00:23:05,359 --> 00:23:07,099
o sea, esta sentencia no tiene ningún

511
00:23:07,099 --> 00:23:09,140
sentido, porque yo no voy a querer

512
00:23:09,140 --> 00:23:10,799
siempre 34 más 12

513
00:23:10,799 --> 00:23:13,359
no, voy a querer cada vez

514
00:23:13,359 --> 00:23:15,059
lo que tenga número 1

515
00:23:15,059 --> 00:23:16,259
más 12, ¿y qué tiene número 1?

516
00:23:16,640 --> 00:23:18,980
no lo sé, cada ejecución tendrá una cosa, ni qué más me da

517
00:23:18,980 --> 00:23:20,099
lo único que sé

518
00:23:20,099 --> 00:23:23,019
es que yo quiero lo que tenga

519
00:23:23,019 --> 00:23:24,039
número 1 más 12

520
00:23:24,039 --> 00:23:26,140
en cada ejecución lo que sea

521
00:23:26,140 --> 00:23:28,460
¿vale? entonces

522
00:23:28,460 --> 00:23:30,740
lo natural, lógicamente, para que esto de

523
00:23:30,740 --> 00:23:32,079
programar tenga algún sentido

524
00:23:32,079 --> 00:23:35,200
es que las expresiones

525
00:23:35,200 --> 00:23:36,720
involucren

526
00:23:36,720 --> 00:23:38,519
dentro variables

527
00:23:38,519 --> 00:23:40,720
para que esa expresión haga

528
00:23:40,720 --> 00:23:42,259
unas cosas o haga otras

529
00:23:42,259 --> 00:23:44,660
en función de mis datos de entrada

530
00:23:44,660 --> 00:23:46,900
no siempre las mismas, lógicamente

531
00:23:46,900 --> 00:23:48,619
un programa si te hace siempre lo mismo

532
00:23:48,619 --> 00:23:50,700
con que lo hagas una vez, ya está

533
00:23:50,700 --> 00:23:51,859
no tienes que ejecutarlo nunca más

534
00:23:51,859 --> 00:23:53,700
la idea es que el programa

535
00:23:53,700 --> 00:23:56,160
te haga cosas distintas

536
00:23:56,160 --> 00:23:57,700
dependiendo de tus datos de entrada

537
00:23:57,700 --> 00:23:59,359
si te autentica Pepito

538
00:23:59,359 --> 00:24:01,960
te hace lo que sea para Pepito

539
00:24:01,960 --> 00:24:03,279
si se autentica Juanito

540
00:24:03,279 --> 00:24:05,180
hace lo que sea para Juanito

541
00:24:05,180 --> 00:24:07,700
entonces el nombre Pepito Juanito

542
00:24:07,700 --> 00:24:08,420
irá a una variable

543
00:24:08,420 --> 00:24:10,940
y el programa hará lo que sea

544
00:24:10,940 --> 00:24:12,859
dependiendo de lo que tenga la variable

545
00:24:12,859 --> 00:24:17,210
por eso tiene sentido programar

546
00:24:17,210 --> 00:24:19,230
porque yo te doy cosas

547
00:24:19,230 --> 00:24:21,069
y tú haces lo que sea

548
00:24:21,069 --> 00:24:22,089
para esas cosas

549
00:24:22,089 --> 00:24:24,569
pues aquí igual yo te doy

550
00:24:24,569 --> 00:24:26,109
valores para las variables

551
00:24:26,109 --> 00:24:28,250
y tú haces lo que sea

552
00:24:28,250 --> 00:24:29,690
para esos valores que yo te he dado

553
00:24:29,690 --> 00:24:31,849
cada vez serán unos distintos

554
00:24:31,849 --> 00:24:33,910
los que yo te doy aquí en cada ejecución

555
00:24:33,910 --> 00:24:35,410
en cada ejecución te doy unos distintos

556
00:24:35,410 --> 00:24:37,549
¿vale? luego

557
00:24:37,549 --> 00:24:39,650
en las expresiones

558
00:24:39,650 --> 00:24:41,470
siempre habrá variables

559
00:24:41,470 --> 00:24:42,569
porque si no hay variables

560
00:24:42,569 --> 00:24:45,930
esa operación siempre da

561
00:24:45,930 --> 00:24:48,109
el mismo valor, luego la ejecuto

562
00:24:48,109 --> 00:24:49,450
una vez y ya está, ese programa ya no

563
00:24:49,450 --> 00:24:52,029
hace falta nunca jamás, con una ejecución

564
00:24:52,029 --> 00:24:54,750
Ya tengo el valor, no hace falta nunca jamás ejecutarlo otra vez.

565
00:24:57,099 --> 00:24:58,160
¿Vale? ¿Está claro esto?

566
00:25:08,789 --> 00:25:10,250
Entonces, claro, eso sí.

567
00:25:12,990 --> 00:25:17,670
Cuando yo meto variables en una expresión, como siempre,

568
00:25:18,390 --> 00:25:23,809
esas variables tienen que ser compatibles en tipo, claro.

569
00:25:25,109 --> 00:25:30,730
Con la operación que se está haciendo y con dónde se va a guardar, lógicamente.

570
00:25:30,730 --> 00:25:32,450
si no el compilador ya me va a avisar

571
00:25:32,450 --> 00:25:35,170
si yo a 12

572
00:25:35,170 --> 00:25:36,430
le quiero sumar algo

573
00:25:36,430 --> 00:25:38,470
ese algo

574
00:25:38,470 --> 00:25:40,890
pues debería ser un número

575
00:25:40,890 --> 00:25:42,970
debería ser un valor numérico

576
00:25:42,970 --> 00:25:44,849
entonces debería ser una variable que tenga

577
00:25:44,849 --> 00:25:45,690
un valor numérico

578
00:25:45,690 --> 00:25:47,150
¿vale?

579
00:25:48,430 --> 00:25:50,450
ahí no podría meter un boolean por ejemplo

580
00:25:50,450 --> 00:25:52,690
aunque ese número todavía no lo hemos visto

581
00:25:52,690 --> 00:25:54,549
no podría meter un boolean porque los boolean

582
00:25:54,549 --> 00:25:55,750
no se suman y se restan

583
00:25:55,750 --> 00:25:58,269
lo que se suman y se restan son los números

584
00:25:58,269 --> 00:26:00,250
luego a los lados

585
00:26:00,250 --> 00:26:02,670
de un operador

586
00:26:02,670 --> 00:26:03,910
de suma o de resta

587
00:26:03,910 --> 00:26:05,470
de multiplicación o de cociente

588
00:26:05,470 --> 00:26:06,809
tienen que ir números

589
00:26:06,809 --> 00:26:09,630
y lo que es más

590
00:26:09,630 --> 00:26:11,170
eso es lo primero

591
00:26:11,170 --> 00:26:13,210
que las variables que yo ponga

592
00:26:13,210 --> 00:26:14,670
tienen que ser compatibles en tipo

593
00:26:14,670 --> 00:26:16,430
con las operaciones que estoy haciendo

594
00:26:16,430 --> 00:26:19,329
y lo que se suman son números

595
00:26:19,329 --> 00:26:20,430
no otras cosas

596
00:26:20,430 --> 00:26:22,349
eso por un lado

597
00:26:22,349 --> 00:26:29,140
bueno, tú puedes poner aquí la variable que quieras

598
00:26:29,140 --> 00:26:30,599
según lo que tú quieras hacer, claro

599
00:26:30,599 --> 00:26:41,299
Claro, tú la expresión

600
00:26:41,299 --> 00:26:42,619
Haces lo que quieras

601
00:26:42,619 --> 00:26:44,359
Involucrando las variables que quieras

602
00:26:44,359 --> 00:26:45,279
Claro

603
00:26:45,279 --> 00:26:48,799
Esta sería otra expresión

604
00:26:48,799 --> 00:26:50,880
Para conseguir

605
00:26:50,880 --> 00:26:52,960
Otra cosa, depende de lo que tú quieras

606
00:26:52,960 --> 00:26:53,819
Que haga tu programa

607
00:26:53,819 --> 00:26:55,759
Pues haces una cosa u otra

608
00:26:55,759 --> 00:26:58,180
Y esa expresión puede involucrar

609
00:26:58,180 --> 00:26:59,900
Una variable, dos, tres, todas

610
00:26:59,900 --> 00:27:02,019
las que hagan falta, siempre y cuando sea

611
00:27:02,019 --> 00:27:04,019
una expresión correctamente escrita

612
00:27:04,019 --> 00:27:06,420
esta expresión también está correctamente

613
00:27:06,420 --> 00:27:08,079
escrita, número 1 más

614
00:27:08,079 --> 00:27:10,059
número 3, porque es

615
00:27:10,059 --> 00:27:11,519
el operador más que existe

616
00:27:11,519 --> 00:27:14,420
a un operador

617
00:27:14,420 --> 00:27:15,680
a un lado y otro operador a otro

618
00:27:15,680 --> 00:27:17,640
el más necesita un operador a la derecha y otro a la izquierda

619
00:27:17,640 --> 00:27:19,819
y además

620
00:27:19,819 --> 00:27:21,880
lo que está a los lados son valores

621
00:27:21,880 --> 00:27:24,259
numéricos, porque lo que se suma

622
00:27:24,259 --> 00:27:25,519
son valores numéricos

623
00:27:25,519 --> 00:27:27,779
muy bien, pues es correcto

624
00:27:27,779 --> 00:27:29,720
entonces la parte 1

625
00:27:29,720 --> 00:27:31,299
satisfecha

626
00:27:31,299 --> 00:27:33,059
pero no solo

627
00:27:33,059 --> 00:27:35,500
para que el compilador se quede tranquilo

628
00:27:35,500 --> 00:27:37,359
y te compile eso ya y se ejecute

629
00:27:37,359 --> 00:27:40,460
una vez que la expresión

630
00:27:40,460 --> 00:27:42,819
sintácticamente es válida

631
00:27:42,819 --> 00:27:45,579
el compilador verifica

632
00:27:45,579 --> 00:27:47,619
que el valor resultante

633
00:27:47,619 --> 00:27:49,279
también es compatible

634
00:27:49,279 --> 00:27:50,799
con el tipo al que vas

635
00:27:50,799 --> 00:27:53,359
en este caso no hay duda

636
00:27:53,359 --> 00:27:55,480
número uno es un int

637
00:27:55,480 --> 00:27:56,900
número tres

638
00:27:56,900 --> 00:27:59,559
imaginaos que es un int que está por ahí declarado

639
00:27:59,559 --> 00:28:05,700
Número 3 es un IN. La suma es un IN. Puede ir a un IN. Vale. No hay duda.

640
00:28:07,579 --> 00:28:14,809
Pero, ¿qué pasaría si la batería se...