1
00:00:01,459 --> 00:00:18,480
Vale, porque hay dos versiones. Vale, esta es la versión que hace el trabajo para la máquina virtual más ágil y esta lo hace más lento. Vamos a ver a qué significa eso.

2
00:00:18,899 --> 00:00:30,739
Pero en ambos casos los dos son unan y si las dos son ciertas, la resultante es cierta. Y en ambos casos estos dos son unor. Si una de las dos es cierta, la resultante es cierta.

3
00:00:31,460 --> 00:00:49,799
Es decir, el resultado que dan es el mismo, ambas son un AND lógico, ambas ciertas, la total cierta, alguna de las dos cierta, la total cierta, pues esta funciona igual que esta y esta funciona igual que esta.

4
00:00:50,539 --> 00:00:54,280
La diferencia es cómo las procesa la máquina virtual y eso tiene implicaciones.

5
00:00:54,280 --> 00:01:21,120
Ejemplo, ejemplo, a ver, esta misma condición de aquí, vamos a volver a ponerla aquí, vale, vamos, uy, vale, esta misma condición de aquí.

6
00:01:21,120 --> 00:01:30,200
Vamos a evaluar lo que me sale

7
00:01:30,200 --> 00:01:32,819
Ejecuto esto

8
00:01:32,819 --> 00:01:34,019
Falso

9
00:01:34,019 --> 00:01:36,299
Muy bien, me sale falso porque

10
00:01:36,299 --> 00:01:40,079
A no es menor que B y C simultáneamente

11
00:01:40,079 --> 00:01:41,920
Es de esperar que me salga falso

12
00:01:41,920 --> 00:01:44,560
Porque A es menor que B, sí

13
00:01:44,560 --> 00:01:46,939
Pero A no es menor que C

14
00:01:46,939 --> 00:01:48,200
Luego esta es true

15
00:01:48,200 --> 00:01:50,079
Esta es falso

16
00:01:50,079 --> 00:01:52,040
True y falso

17
00:01:52,040 --> 00:01:53,019
Falso

18
00:01:53,019 --> 00:01:54,159
¿Vale?

19
00:01:55,599 --> 00:02:22,520
¿Sí? Vale, voy a poner yo la versión abreviada del operador, a ver qué me sale, lo mismo, porque ambos son operadores lógicos idénticos en cuanto al resultado que producen, esta es true, pero esta es mentira, con lo cual, verdad y mentira, es mentira.

20
00:02:22,520 --> 00:02:24,879
Vale, pues efectivamente eso me ha salido

21
00:02:24,879 --> 00:02:28,599
Entonces, ¿por qué existe el doble si es más pesado de escribir?

22
00:02:30,180 --> 00:02:30,620
¿Vale?

23
00:02:31,379 --> 00:02:34,360
Porque el doble le quita trabajo a la máquina virtual

24
00:02:34,360 --> 00:02:34,719
¿Cómo?

25
00:02:35,500 --> 00:02:39,099
Vamos a cambiar estas para que la falsa sea la primera

26
00:02:39,099 --> 00:02:42,500
Voy a poner la falsa la primera

27
00:02:42,500 --> 00:02:48,110
Y la true la segunda

28
00:02:48,110 --> 00:02:49,669
Vale

29
00:02:49,669 --> 00:02:52,409
Pues con el doble operador

30
00:02:52,409 --> 00:02:54,509
Seguirá siendo falsa

31
00:02:54,509 --> 00:03:21,849
Porque ahí hay, son conmutativas, ¿no? Porque esta es falsa y esta es true, falso y true, falso, muy bien, lo ejecuto y falso, vale, pongo el operador sencillo y me seguirá dando false, porque esta es false y esta es true, false y true, false, muy bien, efectivamente me sigue saliendo false, vale.

32
00:03:21,849 --> 00:03:24,110
pero el funcionamiento interno ha sido

33
00:03:24,110 --> 00:03:24,650
distinto

34
00:03:24,650 --> 00:03:28,129
¿qué ha pasado cuando hemos puesto el doble ampersand?

35
00:03:28,569 --> 00:03:29,969
la máquina virtual ha llegado

36
00:03:29,969 --> 00:03:31,330
y se ha puesto a evaluar

37
00:03:31,330 --> 00:03:34,050
ha hecho A menor que C

38
00:03:34,050 --> 00:03:35,490
voy a ver lo que vale A

39
00:03:35,490 --> 00:03:38,229
8, voy a ver lo que vale

40
00:03:38,229 --> 00:03:38,789
C

41
00:03:38,789 --> 00:03:42,370
5, A menor que C

42
00:03:42,370 --> 00:03:43,189
false

43
00:03:43,189 --> 00:03:46,270
y luego ha visto que hay un AND

44
00:03:46,270 --> 00:03:47,330
y ha dicho

45
00:03:47,330 --> 00:03:49,169
me da igual lo que haya después

46
00:03:49,169 --> 00:03:51,909
false y cualquier otra cosa

47
00:03:51,909 --> 00:03:53,110
es que va a ser false

48
00:03:53,110 --> 00:03:54,810
es que me da igual

49
00:03:54,810 --> 00:03:57,090
en cuanto ha visto esto ha dicho

50
00:03:57,090 --> 00:03:59,229
como si esto es un true gigante

51
00:03:59,229 --> 00:03:59,990
que más me da

52
00:03:59,990 --> 00:04:02,770
false y cualquier otra cosa

53
00:04:02,770 --> 00:04:03,949
true o false es false

54
00:04:03,949 --> 00:04:07,270
con lo cual la máquina virtual esto ni lo mira

55
00:04:07,270 --> 00:04:09,330
pasa completamente de ello

56
00:04:09,330 --> 00:04:11,129
lo ignora completamente

57
00:04:11,129 --> 00:04:11,590
pasa

58
00:04:11,590 --> 00:04:14,650
con lo cual ahorramos ciclos de memoria

59
00:04:14,650 --> 00:04:15,330
ahorramos tiempo

60
00:04:15,330 --> 00:04:18,009
la máquina virtual no se ha entretenido

61
00:04:18,009 --> 00:04:23,009
a buscar el valor de A, ni a buscar el valor de B, a compararlos

62
00:04:23,009 --> 00:04:27,050
ha pasado, no se ha entretenido, hemos ahorrado tiempo

63
00:04:27,050 --> 00:04:29,509
vale

64
00:04:29,509 --> 00:04:36,480
esto en el caso, con el doble

65
00:04:36,480 --> 00:04:44,250
ampersand, si la primera es falsa

66
00:04:44,250 --> 00:04:48,029
no se detiene a mirar

67
00:04:48,029 --> 00:04:50,949
la segunda, porque le da igual, no se detiene a

68
00:04:50,949 --> 00:04:53,589
Mirar la segunda

69
00:04:53,589 --> 00:04:54,509
Ni se detiene

70
00:04:54,509 --> 00:04:55,790
Vale

71
00:04:55,790 --> 00:05:02,379
Vamos a hacer esto mismo pero con un ampersand simple

72
00:05:02,379 --> 00:05:13,420
Vale

73
00:05:13,420 --> 00:05:14,680
Con un ampersand simple

74
00:05:14,680 --> 00:05:18,000
Con el simple

75
00:05:18,000 --> 00:05:20,180
Ampersand

76
00:05:20,180 --> 00:05:24,019
Vamos a ver

77
00:05:24,019 --> 00:05:29,529
Vale

78
00:05:29,529 --> 00:05:31,269
Misma expresión, simple ampersand

79
00:05:31,269 --> 00:05:33,310
Me da falsa igualmente, ¿verdad?

80
00:05:34,050 --> 00:05:35,050
Me da falsa igual

81
00:05:35,050 --> 00:05:35,949
Eso no cambia

82
00:05:35,949 --> 00:05:37,730
Pero internamente, ¿qué ha ocurrido?

83
00:05:37,730 --> 00:05:40,329
Él ha evaluado todo sí o sí

84
00:05:40,329 --> 00:05:42,170
Si hay solo una en persán

85
00:05:42,170 --> 00:05:44,329
Aunque esto no le haga falta evaluarlo

86
00:05:44,329 --> 00:05:45,550
Aunque no le haga falta

87
00:05:45,550 --> 00:05:47,230
Lo evalúa igualmente

88
00:05:47,230 --> 00:05:49,970
Este es falso

89
00:05:49,970 --> 00:05:51,410
Dice

90
00:05:51,410 --> 00:05:53,689
Sé que me va a dar igual lo que haya detrás

91
00:05:53,689 --> 00:05:54,550
Sé que me va a dar igual

92
00:05:54,550 --> 00:05:56,290
El total va a ser falso, seguro

93
00:05:56,290 --> 00:05:59,889
Porque falso y cualquier otra cosa es falso

94
00:05:59,889 --> 00:06:00,829
¿Verdad que sí?

95
00:06:01,410 --> 00:06:02,310
Hasta ahí lo tenemos claro

96
00:06:02,310 --> 00:06:05,069
Entonces, me va a dar igual

97
00:06:05,069 --> 00:06:07,430
Pero voy a entrar a evaluarlo igualmente

98
00:06:07,430 --> 00:06:08,829
porque me están obligando

99
00:06:08,829 --> 00:06:10,290
o porque hay una empresa en simple

100
00:06:10,290 --> 00:06:12,850
me están obligando, pues entro y lo evalúo

101
00:06:12,850 --> 00:06:14,110
pero el resultado final es el mismo

102
00:06:14,110 --> 00:06:14,889
ahí no hay tutía

103
00:06:14,889 --> 00:06:17,069
esa es la diferencia

104
00:06:17,069 --> 00:06:19,610
y ahora

105
00:06:19,610 --> 00:06:22,550
debería surgir una pregunta natural en vosotros

106
00:06:22,550 --> 00:06:23,829
entendida la diferencia

107
00:06:23,829 --> 00:06:25,990
que esta la evalúa sí o sí

108
00:06:25,990 --> 00:06:28,730
aunque no le haga falta porque le estamos obligando

109
00:06:28,730 --> 00:06:31,110
¿qué pregunta me haríais?

110
00:06:34,490 --> 00:06:35,329
muy bien

111
00:06:35,329 --> 00:06:36,509
la pregunta natural es

112
00:06:36,509 --> 00:06:38,470
¿y de qué me sirve a mí

113
00:06:38,470 --> 00:06:41,129
obligarle a evaluar algo

114
00:06:41,129 --> 00:06:42,529
que no va a utilizar

115
00:06:42,529 --> 00:06:44,430
¿de qué me va a servir?

116
00:06:45,769 --> 00:06:46,649
bueno, pues

117
00:06:46,649 --> 00:06:48,009
nos puede servir

118
00:06:48,009 --> 00:06:51,009
porque dentro de una expresión

119
00:06:51,009 --> 00:06:52,189
de estas

120
00:06:52,189 --> 00:06:54,209
a la vez

121
00:06:54,209 --> 00:06:57,939
a la vez que ponemos

122
00:06:57,939 --> 00:07:00,240
una variable para que forme parte de la expresión

123
00:07:00,240 --> 00:07:02,000
podemos a la vez

124
00:07:02,000 --> 00:07:03,259
por ejemplo

125
00:07:03,259 --> 00:07:05,180
es un ejemplito, pero hay unas cosas

126
00:07:05,180 --> 00:07:06,720
asignarle un valor

127
00:07:06,720 --> 00:07:09,420
por ejemplo, podemos, si yo quiero

128
00:07:09,420 --> 00:07:12,980
vale, y esto sí que muchas veces lo hacemos

129
00:07:12,980 --> 00:07:15,660
pero bueno, ya estamos en contextos más adelante

130
00:07:15,660 --> 00:07:17,120
y lo iréis viendo, entonces por ejemplo

131
00:07:17,120 --> 00:07:22,040
yo puedo, esto de aquí a menor que b

132
00:07:22,040 --> 00:07:25,480
a la vez que uso una variable

133
00:07:25,480 --> 00:07:28,560
en cualquier expresión, a la vez que la uso

134
00:07:28,560 --> 00:07:31,680
en el momento de usarla, se me permite

135
00:07:31,680 --> 00:07:35,079
darle ahí un valor, en el momento de usarla en una expresión

136
00:07:35,079 --> 00:07:37,639
exactamente igual que hemos visto

137
00:07:37,639 --> 00:07:39,240
que en el momento de declararla

138
00:07:39,240 --> 00:07:40,839
se nos ha permitido darle un valor

139
00:07:40,839 --> 00:07:43,839
pues en el momento de usarla

140
00:07:43,839 --> 00:07:45,540
en una expresión se nos permite también

141
00:07:45,540 --> 00:07:47,519
darle un valor, en el momento de usarla

142
00:07:47,519 --> 00:07:49,660
aquí la estoy usando para compararla

143
00:07:49,660 --> 00:07:51,420
con B y en ese momento

144
00:07:51,420 --> 00:07:53,660
de usarla, si me da la gana

145
00:07:53,660 --> 00:07:55,639
puedo darle un valor

146
00:07:55,639 --> 00:07:56,819
mediante una asignación

147
00:07:56,819 --> 00:07:59,060
por ejemplo así

148
00:07:59,060 --> 00:08:01,540
a la vez que

149
00:08:01,540 --> 00:08:03,480
la estoy usando, le doy

150
00:08:03,480 --> 00:08:05,500
un valor, en el momento de

151
00:08:05,500 --> 00:08:06,399
usarla, puedo

152
00:08:06,399 --> 00:08:09,300
vale

153
00:08:09,300 --> 00:08:11,019
entonces

154
00:08:11,019 --> 00:08:13,180
¿qué implica?

155
00:08:14,100 --> 00:08:16,519
aquí, que cuando yo la compare

156
00:08:16,519 --> 00:08:18,279
con la b, cuando la compare

157
00:08:18,279 --> 00:08:20,740
la voy a comparar ahora con el valor 8

158
00:08:20,740 --> 00:08:21,860
no con el valor que tenía

159
00:08:21,860 --> 00:08:24,060
porque la acabo de reasignar

160
00:08:24,060 --> 00:08:26,279
la acabo de reasignar

161
00:08:26,279 --> 00:08:28,079
¿vale?

162
00:08:28,740 --> 00:08:30,420
entonces voy a hacerlo aquí también

163
00:08:30,420 --> 00:08:33,639
a igual a

164
00:08:33,639 --> 00:08:35,139
8

165
00:08:35,139 --> 00:08:39,580
¿vale? lo voy a hacer aquí también

166
00:08:39,580 --> 00:08:40,779
las dos versiones

167
00:08:40,779 --> 00:08:43,159
entonces

168
00:08:43,159 --> 00:08:46,139
son idénticas las dos expresiones

169
00:08:46,139 --> 00:08:49,700
entonces aquí en el momento

170
00:08:49,700 --> 00:08:51,080
de usarla la reasigno

171
00:08:51,080 --> 00:08:53,759
y una vez que ya la he asignado ya la uso

172
00:08:53,759 --> 00:08:54,580
en la expresión

173
00:08:54,580 --> 00:08:57,759
¿vale? pero ¿qué ocurre?

174
00:08:58,960 --> 00:08:59,960
el resultado

175
00:08:59,960 --> 00:09:00,980
final del AND

176
00:09:00,980 --> 00:09:03,460
ese es el mismo

177
00:09:03,460 --> 00:09:05,539
ponga yo el doble ampersand que el simple ampersand

178
00:09:05,539 --> 00:09:07,559
sigue siendo el mismo, como esta es

179
00:09:07,559 --> 00:09:09,340
falso, es que esto nos da igual

180
00:09:09,340 --> 00:09:10,840
lo que pase, es que nos da igual

181
00:09:10,840 --> 00:09:13,600
aunque sea a 8 o 7 nos da lo mismo

182
00:09:13,600 --> 00:09:14,860
va a ser falso, y aquí igual

183
00:09:14,860 --> 00:09:16,720
como esta es falso

184
00:09:16,720 --> 00:09:19,600
aquí esto nos da igual, va a ser

185
00:09:19,600 --> 00:09:21,720
falso, pero la diferencia

186
00:09:21,720 --> 00:09:23,639
es que aquí, aquí no

187
00:09:23,639 --> 00:09:25,620
entra, porque hay

188
00:09:25,620 --> 00:09:27,659
el doble ampersand, esto es como de repente

189
00:09:27,659 --> 00:09:28,960
ha desaparecido del mapa

190
00:09:28,960 --> 00:09:31,399
porque hay un doble ampersand y no lo necesito

191
00:09:31,399 --> 00:09:33,279
y con el simple ampersand

192
00:09:33,279 --> 00:09:34,440
le obligo a entrar

193
00:09:34,440 --> 00:09:37,379
con lo cual si pongo un simple ampersand

194
00:09:37,379 --> 00:09:39,919
la A se quedaría con 8

195
00:09:39,919 --> 00:09:41,840
porque le he obligado a entrar aquí

196
00:09:41,840 --> 00:09:44,519
pero si pongo un doble ampersand

197
00:09:44,519 --> 00:09:46,080
esto lo tira a la basura

198
00:09:46,080 --> 00:09:48,200
la A no se reasignaría

199
00:09:48,200 --> 00:09:49,879
se quedaría con el valor de arriba

200
00:09:49,879 --> 00:09:53,240
luego esa es la implicación

201
00:09:53,240 --> 00:09:54,779
de un doble ampersand y un simple ampersand

202
00:09:54,779 --> 00:09:56,879
el resultado final del boolean

203
00:09:56,879 --> 00:09:58,659
es idéntico en ambos casos

204
00:09:58,659 --> 00:10:02,240
pero si en la segunda parte

205
00:10:02,240 --> 00:10:04,519
hacemos alguna asignación

206
00:10:04,519 --> 00:10:06,379
además de comparar

207
00:10:06,379 --> 00:10:07,580
hacemos alguna asignación

208
00:10:07,580 --> 00:10:10,500
con el doble ampersand esa asignación se ignora

209
00:10:10,500 --> 00:10:12,360
porque ni entramos

210
00:10:12,360 --> 00:10:14,139
pero con el simple ampersand

211
00:10:14,139 --> 00:10:16,259
esa asignación no se ignora

212
00:10:16,259 --> 00:10:16,779
y se hace

213
00:10:16,779 --> 00:10:18,539
¿vale?

214
00:10:19,600 --> 00:10:22,019
vamos a comprobarlo aquí, yo aquí voy a mostrar

215
00:10:22,019 --> 00:10:24,460
a cuánto tenía, ojo es que qué casualidad

216
00:10:24,460 --> 00:10:25,700
a 8, pues le voy a poner

217
00:10:25,700 --> 00:10:28,000
a igual a

218
00:10:28,000 --> 00:10:30,200
15

219
00:10:30,200 --> 00:10:31,600
para cambiarle, a igual a 1

220
00:10:31,600 --> 00:10:34,559
¿vale? entonces voy a mostrar aquí

221
00:10:34,559 --> 00:10:38,879
el valor final de la condición y el valor de A

222
00:10:38,879 --> 00:10:45,429
A igual a

223
00:10:45,429 --> 00:10:52,289
el valor que tenga A, vale, y ahora voy a mostrarlo

224
00:10:52,289 --> 00:10:55,570
aquí, control V

225
00:10:55,570 --> 00:11:02,169
en ambos casos, vale, vale, pues

226
00:11:02,169 --> 00:11:05,929
cuando yo ejecute esto, me dará

227
00:11:05,929 --> 00:11:13,889
falso, porque a menor que c es falso, y al no haber entrado aquí, a no habrá modificado

228
00:11:13,889 --> 00:11:18,649
su valor, a no lo habrá modificado, porque aquí no ha entrado, con lo cual a me va a

229
00:11:18,649 --> 00:11:27,190
dar que vale 8, sigue valiendo 8, pero cuando haga esta parte, el condicional va a seguir

230
00:11:27,190 --> 00:11:31,990
siendo falso, eso no cambia, va a seguir siendo falso, porque a es menor que c va a seguir

231
00:11:31,990 --> 00:11:40,870
Pero aquí A sí se va a reasignar, porque aquí habremos entrado porque nos obliga el simple ampersand.

232
00:11:41,169 --> 00:11:46,029
Aquí sí que se va a reasignar, con lo cual aquí A habrá acabado valiendo 1.

233
00:11:47,789 --> 00:11:55,309
Vamos a ejecutarlo y efectivamente los valores resultantes del condicional van a ser siempre idénticos.

234
00:11:55,309 --> 00:12:20,970
Me da igual doble ampersand que simple, pero pueden pasar cosas distintas en las variables que haya a mi izquierda, porque si se están reasignando, que yo puedo reasignar a la vez que uso, a la vez que uso en una expresión puedo reasignar, si se están reasignando, esta reasignación se hace y esta no.

235
00:12:20,970 --> 00:12:26,549
si esta fuera true

236
00:12:26,549 --> 00:12:29,110
ahora sí que funcionarían

237
00:12:29,110 --> 00:12:30,769
idénticas las dos, por ejemplo

238
00:12:30,769 --> 00:12:33,529
si c es igual a

239
00:12:33,529 --> 00:12:34,129
15

240
00:12:34,129 --> 00:12:37,350
si fuera true

241
00:12:37,350 --> 00:12:40,809
ahora

242
00:12:40,809 --> 00:12:42,350
el doble ampersand

243
00:12:42,350 --> 00:12:43,990
también entraría aquí

244
00:12:43,990 --> 00:12:46,789
¿por qué? porque a menor que c le he dado true

245
00:12:46,789 --> 00:12:47,990
le he dado true

246
00:12:47,990 --> 00:12:50,389
con lo cual necesita saber la siguiente

247
00:12:50,389 --> 00:12:51,769
entonces ahí es que tiene que entrar

248
00:12:51,769 --> 00:12:54,330
para evaluar el condicional, tiene que entrar, sí o sí

249
00:12:54,330 --> 00:12:57,389
Entonces, al entrar aquí, ya reasignará a A1.

250
00:12:58,850 --> 00:12:59,110
¿Vale?

251
00:13:00,429 --> 00:13:06,750
Entonces, si ejecutamos esto, veremos que ya en la primera vez ha reasignado a A1.

252
00:13:08,049 --> 00:13:09,409
Porque ha tenido que entrar.

253
00:13:09,769 --> 00:13:13,889
Ha tenido que entrar porque estará true, con lo cual necesita la segunda parte.

254
00:13:14,750 --> 00:13:16,309
Para saber si es false o true.

255
00:13:16,429 --> 00:13:17,889
Si es false, el total será false.

256
00:13:18,029 --> 00:13:19,330
Y si es true, el total será true.

257
00:13:19,990 --> 00:13:21,149
El total será true, sí.

258
00:13:25,559 --> 00:13:25,960
¿Vale?

259
00:13:25,960 --> 00:13:28,539
bueno, pues por eso existen

260
00:13:28,539 --> 00:13:30,100
las dos variantes

261
00:13:30,100 --> 00:13:33,200
normalmente, pues veréis

262
00:13:33,200 --> 00:13:34,899
en la mayoría de los casos, pues depende

263
00:13:34,899 --> 00:13:36,940
porque hay muchos estilos de programación distintos

264
00:13:36,940 --> 00:13:38,259
en gustos de programación

265
00:13:38,259 --> 00:13:41,019
pues el ampersand simple, lógicamente es muy común

266
00:13:41,019 --> 00:13:43,100
pero claro, hay que

267
00:13:43,100 --> 00:13:45,000
tener cuidado cuando se usa de que yo

268
00:13:45,000 --> 00:13:47,159
en la segunda parte no haga instrucciones

269
00:13:47,159 --> 00:13:49,120
que cuando accedemos a ficheros

270
00:13:49,120 --> 00:13:51,080
a bases de datos, solemos meter

271
00:13:51,080 --> 00:13:53,059
las instrucciones de acceso ahí en esa

272
00:13:53,059 --> 00:13:55,000
segunda parte, con lo cual en ese caso

273
00:13:55,000 --> 00:13:56,279
doble ampersand, claro

274
00:13:56,279 --> 00:14:00,250
¿entendidísimo?

275
00:14:03,149 --> 00:14:03,929
muy bien

276
00:14:03,929 --> 00:14:09,129
bueno, pues ahora sí que sí

277
00:14:09,129 --> 00:14:11,049
para que podamos

278
00:14:11,049 --> 00:14:12,850
hacer alguno de los primerillos ejercicios

279
00:14:12,850 --> 00:14:15,210
sencillos de la hoja

280
00:14:15,210 --> 00:14:18,039
que ahora

281
00:14:18,039 --> 00:14:19,000
os paso

282
00:14:19,000 --> 00:14:21,440
¿no nos va a quedar más remedio que ver el input?

283
00:14:22,340 --> 00:14:23,620
vamos a tener que ver el input, ¿no?

284
00:14:23,720 --> 00:14:24,299
¿qué vamos a hacer?

285
00:14:25,559 --> 00:14:27,700
bueno, pues

286
00:14:27,700 --> 00:14:30,480
nosotros hasta ahora hemos asignado

287
00:14:30,480 --> 00:14:32,080
a nuestras variables

288
00:14:32,080 --> 00:14:34,659
valores directamente por programa

289
00:14:34,659 --> 00:14:36,620
no las hemos jarcodeado

290
00:14:36,620 --> 00:14:38,360
como se dice, las he metido ahí

291
00:14:38,360 --> 00:14:40,799
pero hombre, no metemos los datos

292
00:14:40,799 --> 00:14:41,899
a los programas así

293
00:14:41,899 --> 00:14:44,379
porque entonces si yo quiero hacer este programa

294
00:14:44,379 --> 00:14:45,659
con valores distintos

295
00:14:45,659 --> 00:14:48,860
tendría que irme al código fuente y cambiar el valor

296
00:14:48,860 --> 00:14:50,500
y no, el usuario de un código

297
00:14:50,500 --> 00:14:52,600
no tiene acceso al código fuente

298
00:14:52,600 --> 00:14:53,240
lógicamente

299
00:14:53,240 --> 00:14:55,720
entonces nosotros necesitamos

300
00:14:55,720 --> 00:14:57,960
poder dar los datos de trabajo

301
00:14:57,960 --> 00:15:00,279
en el momento de ejecutarlo

302
00:15:00,279 --> 00:15:03,320
y desde el teclado, entonces el programa te dirá

303
00:15:03,320 --> 00:15:06,919
¿qué valor quiere para la variable A?

304
00:15:07,799 --> 00:15:10,740
tú se lo asignas por teclado y ya tenemos que ver

305
00:15:10,740 --> 00:15:14,320
qué sentencia hacer para que el programa sea capaz de leer del teclado

306
00:15:14,320 --> 00:15:15,919
un valor y asignarse a la variable

307
00:15:15,919 --> 00:15:20,960
bueno, pues ahora para ver eso

308
00:15:20,960 --> 00:15:23,720
hay cosas que vamos a tener que creernos sí o sí

309
00:15:23,720 --> 00:15:25,940
porque nos falta información

310
00:15:25,940 --> 00:15:29,059
¿por qué? porque para leer del teclado necesitamos un objeto

311
00:15:29,059 --> 00:15:30,980
Y ni siquiera sabemos lo que es un objeto

312
00:15:30,980 --> 00:15:33,820
Con lo cual vamos a usar el objeto

313
00:15:33,820 --> 00:15:34,600
Sin más

314
00:15:34,600 --> 00:15:37,700
Aunque no entendamos que es un objeto

315
00:15:37,700 --> 00:15:39,059
Pero por ahora vamos a usarlo

316
00:15:39,059 --> 00:15:41,519
Para la tarea concreta de leer del teclado

317
00:15:41,519 --> 00:15:42,980
¿Vale?

318
00:15:44,259 --> 00:15:45,860
Venga, lo voy a hacer en

319
00:15:45,860 --> 00:15:46,460
Otra

320
00:15:46,460 --> 00:15:50,419
Otro

321
00:15:50,419 --> 00:16:00,009
Otro paquete

322
00:16:00,009 --> 00:16:01,149
Teclado, venga

323
00:16:01,149 --> 00:16:05,070
Entrada, salida

324
00:16:05,070 --> 00:16:10,419
Entrada, salida por consola

325
00:16:10,419 --> 00:16:11,940
La consola es el teclado y el monitor

326
00:16:11,940 --> 00:16:14,080
vamos, entrada y salida

327
00:16:14,080 --> 00:16:14,879
por consola

328
00:16:14,879 --> 00:16:29,919
vale, pues vengo

329
00:16:29,919 --> 00:16:31,919
yo tengo mi variable

330
00:16:31,919 --> 00:16:34,000
a, nombre muy feo elegido

331
00:16:34,000 --> 00:16:36,100
pero bueno, mi variable a

332
00:16:36,100 --> 00:16:38,220
venga voy a ponerle un nombre que tenga sentido

333
00:16:38,220 --> 00:16:39,860
para que no sea todo a, x, y

334
00:16:39,860 --> 00:16:41,600
tengo mi variable edad

335
00:16:41,600 --> 00:16:44,179
y yo con esta edad quiero hacer

336
00:16:44,179 --> 00:16:45,799
cosas, lo que sea

337
00:16:45,799 --> 00:16:48,519
pero el valor de la edad

338
00:16:48,519 --> 00:16:50,240
tiene que ser el valor del usuario

339
00:16:50,240 --> 00:16:50,940
de mi programa

340
00:16:50,940 --> 00:16:53,500
con lo cual yo no puedo

341
00:16:53,500 --> 00:16:55,460
ponerle aquí edad

342
00:16:55,460 --> 00:16:57,539
igual a 34, pues no

343
00:16:57,539 --> 00:16:59,320
porque a veces usará el programa

344
00:16:59,320 --> 00:17:01,460
alguien de 34, a veces alguien de 12, a veces alguien

345
00:17:01,460 --> 00:17:03,120
de 85, entonces

346
00:17:03,120 --> 00:17:04,740
el valor de la edad

347
00:17:04,740 --> 00:17:07,460
no se mete aquí, el valor

348
00:17:07,460 --> 00:17:09,039
de la edad tendremos que

349
00:17:09,039 --> 00:17:11,640
el usuario introducirlo en el momento

350
00:17:11,640 --> 00:17:13,099
de la ejecución del programa

351
00:17:13,099 --> 00:17:15,400
lo introduce y se

352
00:17:15,400 --> 00:17:17,460
asigna, entonces tendremos

353
00:17:17,460 --> 00:17:18,980
que ver como

354
00:17:18,980 --> 00:17:21,880
leer un valor del teclado

355
00:17:21,880 --> 00:17:23,680
vale, pues para leer

356
00:17:23,680 --> 00:17:24,660
un valor del teclado

357
00:17:24,660 --> 00:17:27,380
se puede hacer de muchas maneras, pero bueno

358
00:17:27,380 --> 00:17:29,160
vamos a la opción más cómoda

359
00:17:29,160 --> 00:17:31,980
necesitamos una cosa

360
00:17:31,980 --> 00:17:33,440
que se llama

361
00:17:33,440 --> 00:17:34,259
escáner

362
00:17:34,259 --> 00:17:35,859
vale

363
00:17:35,859 --> 00:17:39,599
entonces, igual que cuando necesitamos un int

364
00:17:39,599 --> 00:17:40,960
ponemos int a

365
00:17:40,960 --> 00:17:43,220
o cuando necesitamos un string

366
00:17:43,220 --> 00:17:44,759
ponemos string texto

367
00:17:44,759 --> 00:17:47,559
pues resulta que ahora no necesitamos

368
00:17:47,559 --> 00:17:50,700
un int a y un string text, ahora necesitamos un objeto scanner

369
00:17:50,700 --> 00:17:55,619
pues pongo scanner que es el tipo que necesito y aquí el nombre que le quiera dar yo a ese objeto

370
00:17:55,619 --> 00:17:58,180
el que me dé la gana, vale

371
00:17:58,180 --> 00:18:02,559
bueno pues scanner es otro tipo de dato

372
00:18:02,559 --> 00:18:07,420
igual que int, que string, pero en particular

373
00:18:07,420 --> 00:18:11,460
el tipo scanner es un tipo de dato objeto y sirve

374
00:18:11,460 --> 00:18:14,680
para una cosa en concreto, que es para leer del teclado

375
00:18:14,680 --> 00:18:21,839
Igual que string vale para guardar cadenas de caracteres, pues escáner vale para leer del teclado.

376
00:18:22,579 --> 00:18:28,019
Pues yo lo necesito y lo declaro ahí, igual que declaro una variable cualquiera.

377
00:18:29,559 --> 00:18:37,240
Pero claro, le tengo que dar un valor a ese objeto, para que ese objeto exista y pueda leer.

378
00:18:38,920 --> 00:18:41,140
Pues ¿cómo hago que ese objeto exista?

379
00:18:41,140 --> 00:18:42,640
igual que a texto

380
00:18:42,640 --> 00:18:44,660
yo hago que ese objeto exista

381
00:18:44,660 --> 00:18:45,720
dándole un valor concreto

382
00:18:45,720 --> 00:18:48,819
pues para hacer que el objeto escáner

383
00:18:48,819 --> 00:18:50,720
exista, tengo que hacer

384
00:18:50,720 --> 00:18:52,180
algo un pelín más complicado

385
00:18:52,180 --> 00:18:54,000
que es escribir esto

386
00:18:54,000 --> 00:19:01,410
¿vale?

387
00:19:02,150 --> 00:19:04,789
entonces escribiendo esto, hago que

388
00:19:04,789 --> 00:19:06,529
ese objeto exista

389
00:19:06,529 --> 00:19:09,960
de nuevo tenemos que creérnoslo

390
00:19:09,960 --> 00:19:12,079
no lo entendemos, porque ¿qué significa new?

391
00:19:12,200 --> 00:19:13,680
el espacio, ¿qué es esto?

392
00:19:14,400 --> 00:19:14,839
bueno, pues

393
00:19:14,839 --> 00:19:18,019
significa cosas muy concretas de la programación

394
00:19:18,019 --> 00:19:20,319
entrada objetos, que ya veremos

395
00:19:20,319 --> 00:19:22,160
ahora mismo nos tenemos

396
00:19:22,160 --> 00:19:23,920
que quedar con que para

397
00:19:23,920 --> 00:19:25,180
crear este objeto

398
00:19:25,180 --> 00:19:27,980
y yo poder usarlo para leer del teclado

399
00:19:27,980 --> 00:19:30,039
lo tengo que crear de esta

400
00:19:30,039 --> 00:19:30,400
manera

401
00:19:30,400 --> 00:19:34,180
igual que cuando creo un string lo creo de esta manera

402
00:19:34,180 --> 00:19:35,960
poniendo aquí la cadena

403
00:19:35,960 --> 00:19:37,859
de texto que yo quiera, pues cuando creo un

404
00:19:37,859 --> 00:19:39,759
escáner lo creo de esta manera, poniendo

405
00:19:39,759 --> 00:19:40,859
esto, sí o sí

406
00:19:40,859 --> 00:19:43,299
y

407
00:19:43,299 --> 00:19:45,500
vemos que nos sale rojito

408
00:19:45,500 --> 00:19:48,119
nos sale rojito

409
00:19:48,119 --> 00:19:49,519
porque este tipo de dato

410
00:19:49,519 --> 00:19:51,460
está ya creado

411
00:19:51,460 --> 00:19:53,039
pero guardado

412
00:19:53,039 --> 00:19:55,400
en una carpeta de cosas

413
00:19:55,400 --> 00:19:57,339
porque de nuevo, como ya entenderemos

414
00:19:57,339 --> 00:20:00,359
Java, la máquina virtual

415
00:20:00,359 --> 00:20:02,680
organiza todas las clases

416
00:20:02,680 --> 00:20:03,660
de las que dispone

417
00:20:03,660 --> 00:20:06,059
que string es una de ellas

418
00:20:06,059 --> 00:20:07,680
las organiza en carpetitas

419
00:20:07,680 --> 00:20:09,779
entonces, él sabe siempre

420
00:20:09,779 --> 00:20:11,079
en qué carpeta está esto

421
00:20:11,079 --> 00:20:12,420
en qué carpeta está esto

422
00:20:12,420 --> 00:20:15,319
pero no sabe en qué carpeta está scanner

423
00:20:15,319 --> 00:20:17,740
ni muchas otras cosas que usaremos, no las sabe

424
00:20:17,740 --> 00:20:19,619
entonces te dice

425
00:20:19,619 --> 00:20:21,359
no tengo ni idea

426
00:20:21,359 --> 00:20:23,319
de donde está esto que me has pedido

427
00:20:23,319 --> 00:20:24,960
que yo cree, no tengo ni idea

428
00:20:24,960 --> 00:20:27,319
vale, pues tenemos que decirle

429
00:20:27,319 --> 00:20:29,720
donde está y se lo decimos

430
00:20:29,720 --> 00:20:31,000
escribiendo esto

431
00:20:31,000 --> 00:20:41,029
eeeh

432
00:20:41,029 --> 00:20:42,670
donde está

433
00:20:42,670 --> 00:20:43,509
un momentito

434
00:20:43,509 --> 00:20:50,339
vale, escribiendo esto

435
00:20:50,339 --> 00:20:54,000
esto que tiene que ir

436
00:20:54,000 --> 00:20:55,759
después del package, obligatoriamente

437
00:20:55,759 --> 00:20:57,660
no antes, sino aquí

438
00:20:57,660 --> 00:20:59,099
justo después del package

439
00:20:59,099 --> 00:21:01,440
significa, oye este

440
00:21:01,440 --> 00:21:03,619
escáner que yo te estoy diciendo

441
00:21:03,619 --> 00:21:05,579
que me hagas, está aquí

442
00:21:05,579 --> 00:21:06,740
está aquí

443
00:21:06,740 --> 00:21:08,799
ah vale, ya lo encuentro

444
00:21:08,799 --> 00:21:11,140
y me sale aquí rojo

445
00:21:11,140 --> 00:21:13,500
que no entendemos por qué hay que

446
00:21:13,500 --> 00:21:15,420
decirle esto, que significa el in, por qué

447
00:21:15,420 --> 00:21:17,480
significa el útil, por qué he puesto el new, pues claro

448
00:21:17,480 --> 00:21:19,180
lógicamente no lo entendemos

449
00:21:19,180 --> 00:21:21,279
porque no sabemos cómo funciona el pronunciamiento de objetos

450
00:21:21,279 --> 00:21:23,500
pero ya lo entenderemos, ahora solamente

451
00:21:23,500 --> 00:21:25,640
nos importa saber cómo leer

452
00:21:25,640 --> 00:21:27,900
un dato de un teclado

453
00:21:27,900 --> 00:21:29,059
vale

454
00:21:29,059 --> 00:21:31,259
pues el primer paso está

455
00:21:31,259 --> 00:21:34,140
hemos creado esta cosa

456
00:21:34,140 --> 00:21:36,480
a la que le puedo dar el nombre

457
00:21:36,480 --> 00:21:37,200
que me dé la gana

458
00:21:37,200 --> 00:21:40,539
igual que a la variable cadena de texto

459
00:21:40,539 --> 00:21:42,140
le doy el nombre que me da la gana

460
00:21:42,140 --> 00:21:44,359
o a la variable a le doy el nombre que me da la gana

461
00:21:44,359 --> 00:21:46,900
pues a este objeto le doy el nombre que me da la gana

462
00:21:46,900 --> 00:21:47,660
vale

463
00:21:47,660 --> 00:21:50,400
vale, pues ahora que ya tengo este

464
00:21:50,400 --> 00:21:51,559
objetillo creado

465
00:21:51,559 --> 00:21:54,119
¿cómo puedo yo

466
00:21:54,119 --> 00:21:57,740
leer, por ejemplo, un número entero del teclado.

467
00:21:58,400 --> 00:22:01,059
Pues este objeto, por ser un objeto,

468
00:22:01,160 --> 00:22:02,519
de nuevo, aunque aún no lo entendamos,

469
00:22:03,059 --> 00:22:05,480
es capaz de ejecutar acciones.

470
00:22:07,119 --> 00:22:09,299
¿Vale? O sea, los objetos pueden ejecutar acciones.

471
00:22:09,539 --> 00:22:10,700
¿Y cómo las ejecutan?

472
00:22:10,980 --> 00:22:13,539
Con un punto poniendo el nombre de la acción,

473
00:22:13,539 --> 00:22:15,140
de la acción a ejecutar.

474
00:22:16,859 --> 00:22:20,539
Pues resulta que la acción nextInt

475
00:22:20,539 --> 00:22:27,740
Next int significa, oye, quédate ahí esperando a que alguien meta un número entero en el teclado

476
00:22:27,740 --> 00:22:30,220
y cuando lo metan, cógelo.

477
00:22:31,519 --> 00:22:33,420
Vale, pues eso es lo que hace esto, cógelo.

478
00:22:34,319 --> 00:22:35,660
¿Y ahí ese cógelo dónde?

479
00:22:36,140 --> 00:22:38,380
Hay que asignarlo a una variable, si no lo pierdo.

480
00:22:38,720 --> 00:22:39,900
Yo podría ejecutar esto.

481
00:22:41,599 --> 00:22:43,539
¿Y qué haría esta sentencia?

482
00:22:44,220 --> 00:22:46,900
Esta sentencia significa exactamente lo siguiente.

483
00:22:46,900 --> 00:23:11,640
Oye tú, Java, programa. Oye tú, programa. Quédate ahí cruzado de brazos, parado, atascado. Espera a que yo escriba un número en el teclado. Cuando yo lo escriba, cógelo y déjatelo ahí guardadito. Pero como no le he dicho nada más, lo ha tirado a la basura. Vamos a ejecutarlo. A ver qué pasa.

484
00:23:11,640 --> 00:23:13,259
yo ejecuto esto

485
00:23:13,259 --> 00:23:17,200
y efectivamente

486
00:23:17,200 --> 00:23:19,799
mirad mi consola

487
00:23:19,799 --> 00:23:22,220
mi consola no pone terminado

488
00:23:22,220 --> 00:23:24,140
el programa no ha terminado

489
00:23:24,140 --> 00:23:25,299
el programa tiene el cursor ahí

490
00:23:25,299 --> 00:23:27,660
este está cruzado de brazos hasta el infinito

491
00:23:27,660 --> 00:23:29,940
el programa se ha quedado aquí parado

492
00:23:29,940 --> 00:23:31,940
porque esta sentencia

493
00:23:31,940 --> 00:23:33,220
significa, oye

494
00:23:33,220 --> 00:23:35,500
quédate ahí parado esperando

495
00:23:35,500 --> 00:23:38,000
y no vamos a la siguiente sentencia

496
00:23:38,000 --> 00:23:39,960
por mucho que aquí haya cosas

497
00:23:39,960 --> 00:23:46,500
Por ejemplo, vamos a saludar aquí

498
00:23:46,500 --> 00:23:50,019
Voy a terminar este con cualquier cosa

499
00:23:50,019 --> 00:23:52,740
Voy a ejecutarlo de nuevo

500
00:23:52,740 --> 00:23:59,619
¡Hala! Ahí está para esperando

501
00:23:59,619 --> 00:24:01,960
Está parado en esta sentencia, ahí atascado

502
00:24:01,960 --> 00:24:05,960
Como veis, la siguiente, que es la de mostrar a Dios

503
00:24:05,960 --> 00:24:09,039
No la ha ejecutado, ¿por qué? Porque está aquí parado

504
00:24:09,039 --> 00:24:11,880
Ahí está, y de ahí no va a salir nunca jamás

505
00:24:11,880 --> 00:24:13,480
hasta que no tecleemos algo

506
00:24:13,480 --> 00:24:16,160
vale, pues vamos a teclearle el numerito

507
00:24:16,160 --> 00:24:17,279
que está esperando, lo que sea

508
00:24:17,279 --> 00:24:20,440
numerito y enter, para que se entere que he terminado

509
00:24:20,440 --> 00:24:21,240
claro, enter

510
00:24:21,240 --> 00:24:24,559
ala, ya sale a la siguiente

511
00:24:24,559 --> 00:24:25,980
¿y qué ha pasado con ese número?

512
00:24:27,400 --> 00:24:28,220
lo ha cogido

513
00:24:28,220 --> 00:24:30,240
pero como no le hemos dicho que hacer con él

514
00:24:30,240 --> 00:24:31,819
se ha perdido

515
00:24:31,819 --> 00:24:34,200
claro, es que yo

516
00:24:34,200 --> 00:24:36,039
tengo que asignar ese valor

517
00:24:36,039 --> 00:24:37,039
a alguna variable

518
00:24:37,039 --> 00:24:40,299
por ejemplo, si me da la gana edad

519
00:24:40,299 --> 00:24:45,720
ahora ya sí

520
00:24:45,720 --> 00:24:53,759
tu edad es

521
00:24:53,759 --> 00:24:55,799
más edad

522
00:24:55,799 --> 00:25:01,309
ahora ya sí

523
00:25:01,309 --> 00:25:02,990
el programa se quedará ahí parado

524
00:25:02,990 --> 00:25:05,250
y ahí se podría estar hasta siempre jamás

525
00:25:05,250 --> 00:25:06,190
nunca va a salir de ahí

526
00:25:06,190 --> 00:25:09,509
hasta que no tecleemos algo en el teclado y demos a enter

527
00:25:09,509 --> 00:25:11,329
cuando ya lo hayamos hecho

528
00:25:11,329 --> 00:25:13,450
lo coge, uy que bien

529
00:25:13,450 --> 00:25:15,390
tengo a quien asignárselo

530
00:25:15,390 --> 00:25:17,190
menos mal, pues no lo tiro a la basura

531
00:25:17,190 --> 00:25:19,369
lo asigna a esta variable

532
00:25:19,369 --> 00:25:21,869
a partir de aquí edad tiene eso

533
00:25:21,869 --> 00:25:24,170
y ahora ya el programa

534
00:25:24,170 --> 00:25:25,609
ya puede seguir, ya puede seguir

535
00:25:25,609 --> 00:25:28,009
porque ya hemos introducido el dato

536
00:25:28,009 --> 00:25:29,670
ya puede seguir, vale

537
00:25:29,670 --> 00:25:31,089
entonces

538
00:25:31,089 --> 00:25:34,049
ahora ya ejecutamos esto, ya está esperando

539
00:25:34,049 --> 00:25:36,009
hasta el infinito, introduce

540
00:25:36,009 --> 00:25:36,690
tu edad

541
00:25:36,690 --> 00:25:38,950
vale, y ya está

542
00:25:38,950 --> 00:25:51,339
lo normal es que antes de una

543
00:25:51,339 --> 00:25:52,680
sentencia que pide datos

544
00:25:52,680 --> 00:25:54,500
pongamos un mensaje

545
00:25:54,500 --> 00:25:57,160
para que el programa sea un poco más amigable

546
00:25:57,160 --> 00:25:59,099
porque si no, se queda el cursor esperando

547
00:25:59,099 --> 00:26:01,500
y el usuario no sabe que tiene que hacer

548
00:26:01,500 --> 00:26:03,599
lo normal es siempre

549
00:26:03,599 --> 00:26:04,859
acompañarlo de un mensaje

550
00:26:04,859 --> 00:26:05,819
delante

551
00:26:05,819 --> 00:26:08,240
vale

552
00:26:08,240 --> 00:26:10,779
lo acompañamos de un mensajito delante

553
00:26:10,779 --> 00:26:13,339
para que el usuario sepa

554
00:26:13,339 --> 00:26:15,339
porque ese cursor se ha quedado ahí atascado

555
00:26:15,339 --> 00:26:17,339
entonces se muestra el mensaje

556
00:26:17,339 --> 00:26:19,119
y luego ya si, esta se queda ahí atascada

557
00:26:19,119 --> 00:26:19,619
esperando

558
00:26:19,619 --> 00:26:23,339
esta aplicación ya es un poquito más amigable

559
00:26:23,339 --> 00:26:24,980
introduce tu edad y ahí estoy esperando

560
00:26:24,980 --> 00:26:26,799
y de ahí no me muevo hasta que no pongas

561
00:26:26,799 --> 00:26:28,440
tu edad y desalentes

562
00:26:28,440 --> 00:26:37,250
Y así podríamos meter tantos como quisiéramos

563
00:26:37,250 --> 00:26:40,509
Por ejemplo, ahora quiero que meta el peso

564
00:26:40,509 --> 00:26:44,410
Pues reutilizo ese objeto todas las veces que quiera

565
00:26:44,410 --> 00:26:47,190
Lo reutilizo todas las veces que quiera

566
00:26:47,190 --> 00:26:50,569
Introduce tu peso

567
00:26:50,569 --> 00:26:56,059
Pues lo vuelvo a reutilizar

568
00:26:56,059 --> 00:26:59,920
Ahora el peso, inPeso, declaro la variable

569
00:26:59,920 --> 00:27:01,920
int peso, pues

570
00:27:01,920 --> 00:27:04,019
scan.next

571
00:27:04,019 --> 00:27:04,740
int

572
00:27:04,740 --> 00:27:07,720
vale, pues ahora

573
00:27:07,720 --> 00:27:09,720
de nuevo, se quedará ahí atascado esperando

574
00:27:09,720 --> 00:27:10,700
se quedará atascado

575
00:27:10,700 --> 00:27:13,259
cuando yo le meta un número

576
00:27:13,259 --> 00:27:15,640
lo cogerá y

577
00:27:15,640 --> 00:27:17,819
le he dicho que lo lleve a algún sitio, menos mal

578
00:27:17,819 --> 00:27:19,460
porque si no ese número se va a la basura

579
00:27:19,460 --> 00:27:21,900
a la variable peso que declaro en ese

580
00:27:21,900 --> 00:27:23,059
momento, pero no la tengo de antes

581
00:27:23,059 --> 00:27:26,019
por ejemplo, y ahora ya

582
00:27:26,019 --> 00:27:26,920
pues

583
00:27:26,920 --> 00:27:37,900
Es decir, puedo reutilizar ese objeto para leer diferentes cosas

584
00:27:37,900 --> 00:27:40,180
Todas las veces que a mí me dé la gana

585
00:27:40,180 --> 00:27:41,480
¿Vale?

586
00:27:46,640 --> 00:27:48,759
Introduce tu edad, bla, bla, bla

587
00:27:48,759 --> 00:27:51,839
Introduce tu peso, bla, bla, bla

588
00:27:51,839 --> 00:27:53,980
¿Vale? Y así todas las veces que yo quiera

589
00:27:53,980 --> 00:28:02,279
Cuidado porque los objetos

590
00:28:02,279 --> 00:28:07,039
Lógicamente tienen todo un sistema de excepciones

591
00:28:07,039 --> 00:28:08,740
Que de nuevo no conocemos

592
00:28:08,740 --> 00:28:10,460
Pero ya conoceremos

593
00:28:10,460 --> 00:28:36,599
Entonces, si yo le he dicho next int, que es una de las cosas que puede hacer, que puede hacer muchas, int viene de entero. Le estoy diciendo, quédate esperando un número entero. Como se me ocurra meter algo que no sea un entero, se va a quejar y como forma de protesta, el programa se va a terminar. Se acabó, terminado.

594
00:28:36,599 --> 00:28:38,819
vale, vamos a probar

595
00:28:38,819 --> 00:28:40,799
introduce tu edad

596
00:28:40,799 --> 00:28:42,619
como yo le he dicho next int

597
00:28:42,619 --> 00:28:45,559
él está esperando un número entero

598
00:28:45,559 --> 00:28:48,680
porque int viene de entero

599
00:28:48,680 --> 00:28:50,960
que meto algo que no es un entero como esto

600
00:28:50,960 --> 00:28:54,359
se me queja y me dice

601
00:28:54,359 --> 00:28:56,700
esto no es un número entero

602
00:28:56,700 --> 00:28:59,339
y qué forma de quejar se tiene

603
00:28:59,339 --> 00:29:01,480
parando el programa

604
00:29:01,480 --> 00:29:03,759
se acabó, el programa se terminó

605
00:29:03,759 --> 00:29:04,480
terminado

606
00:29:04,480 --> 00:29:07,279
pasa y ya no ejecuta nada más de lo que hay

607
00:29:07,279 --> 00:29:09,619
después, programa terminado y ya no ejecuta

608
00:29:09,619 --> 00:29:10,799
más, vale

609
00:29:10,799 --> 00:29:13,279
si quisiéramos evitar esto, teníamos que

610
00:29:13,279 --> 00:29:15,059
hacer un tema de captura de excepciones, etcétera

611
00:29:15,059 --> 00:29:15,880
que todavía no sabemos

612
00:29:15,880 --> 00:29:19,119
ahora mismo quedémonos con que si yo pido

613
00:29:19,119 --> 00:29:21,119
un entero, mete un entero, porque si no el programa

614
00:29:21,119 --> 00:29:23,140
se te para, ya está, no hay otra

615
00:29:23,140 --> 00:29:24,460
vale

616
00:29:24,460 --> 00:29:29,549
que en lugar de un entero quiero meter

617
00:29:29,549 --> 00:29:30,009
un double

618
00:29:30,009 --> 00:29:33,769
pues con next int no puedo, es que next int

619
00:29:33,769 --> 00:29:35,650
me pide un entero, entonces yo no

620
00:29:35,650 --> 00:29:36,710
puedo decirle

621
00:29:36,710 --> 00:29:39,549
oye, introduce tu edad, pues

622
00:29:39,549 --> 00:29:41,789
mi edad es 45,8

623
00:29:41,789 --> 00:29:45,890
no, porque 45.8

624
00:29:45,890 --> 00:29:46,750
no es un entero

625
00:29:46,750 --> 00:29:48,650
se queja también y para

626
00:29:48,650 --> 00:29:51,849
pero jo, yo quiero hacer un programa que sea un entero

627
00:29:51,849 --> 00:29:53,589
por ejemplo, mi peso

628
00:29:53,589 --> 00:29:55,650
yo lo quiero dar con decimales

629
00:29:55,650 --> 00:29:57,549
no quiero el peso redondeado, el peso

630
00:29:57,549 --> 00:29:58,630
lo quiero con decimales

631
00:29:58,630 --> 00:30:00,970
pues entonces

632
00:30:00,970 --> 00:30:03,309
no uso el método nextInt

633
00:30:03,309 --> 00:30:06,029
uso el que se llama

634
00:30:06,029 --> 00:30:06,690
next double

635
00:30:06,690 --> 00:30:08,130
¿vale?

636
00:30:12,460 --> 00:30:15,559
next int cuando yo vaya a meter un número entero

637
00:30:15,559 --> 00:30:17,400
pero cuando yo vaya a meter un número

638
00:30:17,400 --> 00:30:19,460
con decimales, no uso next int

639
00:30:19,460 --> 00:30:20,900
uso next double

640
00:30:20,900 --> 00:30:23,160
y entonces el ya

641
00:30:23,160 --> 00:30:24,539
si le metes una coma

642
00:30:24,539 --> 00:30:27,160
ya no se vuelve loco

643
00:30:27,160 --> 00:30:28,200
dice, vale, me gusta

644
00:30:28,200 --> 00:30:30,720
es una coma, me gusta, es un decimal

645
00:30:30,720 --> 00:30:33,059
vamos a probarlo

646
00:30:33,059 --> 00:30:35,200
introduce tu edad

647
00:30:35,200 --> 00:30:36,299
la que sea

648
00:30:36,299 --> 00:30:37,980
introduce tu peso

649
00:30:37,980 --> 00:30:40,519
lo único es que para el next table

650
00:30:40,519 --> 00:30:42,279
te trata como muy humano

651
00:30:42,279 --> 00:30:45,079
él asume que tú no sabes que para Java

652
00:30:45,079 --> 00:30:46,579
las comas son puntos

653
00:30:46,579 --> 00:30:49,440
entonces él espera que se lo pongas con una comita

654
00:30:49,440 --> 00:30:51,180
que es como lo escribimos

655
00:30:51,180 --> 00:30:52,200
los humanos en un papel

656
00:30:52,200 --> 00:30:54,920
entonces yo quiero decirle que mi peso

657
00:30:54,920 --> 00:30:56,400
es 67,5

658
00:30:56,400 --> 00:30:58,099
se lo pongo con coma

659
00:30:58,099 --> 00:30:59,019
¿vale?

660
00:31:00,799 --> 00:31:02,559
luego él cuando me he hecho el system out

661
00:31:02,559 --> 00:31:04,940
me lo ha puesto lógicamente como él muestra

662
00:31:04,940 --> 00:31:05,619
los decimales

663
00:31:05,619 --> 00:31:07,740
entonces si yo no se lo pusiera con coma

664
00:31:07,740 --> 00:31:09,119
sino que se lo pusiera con punto

665
00:31:09,119 --> 00:31:11,420
se queja

666
00:31:11,420 --> 00:31:13,660
porque introduce tu peso

667
00:31:13,660 --> 00:31:15,980
punto 5

668
00:31:15,980 --> 00:31:17,759
no le gusta

669
00:31:17,759 --> 00:31:18,319
¿vale?

670
00:31:18,960 --> 00:31:20,160
ese único matiz

671
00:31:20,160 --> 00:31:23,660
que él asume que tú vas a usar la coma

672
00:31:23,660 --> 00:31:24,319
de los humanos

673
00:31:24,319 --> 00:31:29,759
y él ya luego lo traduce lógicamente

674
00:31:29,759 --> 00:31:30,519
a su

675
00:31:30,519 --> 00:31:33,579
notación, que siempre es con punto

676
00:31:33,579 --> 00:31:39,799
el dabel. Vale, pues entonces sabemos leer números enteros, números decimales, podemos

677
00:31:39,799 --> 00:31:43,359
leer todos los genos de la gana, uno tras otro, guardarlos en variables correspondientes,

678
00:31:43,480 --> 00:31:48,220
operar con ellos, lo que sea. Vale, y con esto, pues bueno, para que se nos haga un

679
00:31:48,220 --> 00:31:59,200
poco más llevadero, vamos a ver de la hoja de ejercicios que podáis hacer algunos. Vamos