1
00:00:01,389 --> 00:00:17,170
Vale, vamos a seguir. Bueno, pues entonces, estábamos diciendo que hay que hacer aparecer una variable que sea capaz de leer del teclado y se le hace aparecer igual que se hace aparecer una variable como las que hemos visto, declarándole y poniendo su tipo.

2
00:00:17,170 --> 00:00:19,750
y el tipo de dato hemos dicho que es este

3
00:00:19,750 --> 00:00:21,510
con el matiz de que como es muy largo

4
00:00:21,510 --> 00:00:22,410
me hago un truco

5
00:00:22,410 --> 00:00:25,929
bueno, pues he mentido un poco, como siempre

6
00:00:25,929 --> 00:00:26,989
y

7
00:00:26,989 --> 00:00:29,730
no se le hace aparecer

8
00:00:29,730 --> 00:00:31,730
solamente poniendo el nombre

9
00:00:31,730 --> 00:00:33,689
las variables primitivas sí

10
00:00:33,689 --> 00:00:35,850
las variables primitivas

11
00:00:35,850 --> 00:00:36,990
que son las que hemos visto

12
00:00:36,990 --> 00:00:39,770
funcionan así, yo pongo esto

13
00:00:39,770 --> 00:00:41,710
y ¡pam! apareció un espacio

14
00:00:41,710 --> 00:00:43,530
en memoria RAM para guardar

15
00:00:43,530 --> 00:00:44,750
un número entero, ya está

16
00:00:44,750 --> 00:00:48,530
Las variables objeto, como ya veremos en detalle

17
00:00:48,530 --> 00:00:53,350
Cuando ya hagamos pronunciación de entrada de objetos

18
00:00:53,350 --> 00:00:55,810
Para aparecer PAF en memoria

19
00:00:55,810 --> 00:00:59,130
No basta solamente con declararlas y ya

20
00:00:59,130 --> 00:01:00,969
Como las variables primitivas, no basta

21
00:01:00,969 --> 00:01:03,649
Hay que hacer además una cosita

22
00:01:03,649 --> 00:01:06,349
Que es el cuarto o quinto acto de fe que tenéis que hacer

23
00:01:06,349 --> 00:01:08,189
Que es escribir esto

24
00:01:08,189 --> 00:01:19,170
¿Vale? Esto hay que escribirlo sí o sí

25
00:01:19,170 --> 00:01:21,930
Porque las variables objeto

26
00:01:21,930 --> 00:01:23,890
para hacerlas aparecer

27
00:01:23,890 --> 00:01:25,549
además de declararlas

28
00:01:25,549 --> 00:01:27,870
hay que hacer una cosa

29
00:01:27,870 --> 00:01:29,909
se llama construirlas y eso se hace con new

30
00:01:29,909 --> 00:01:32,150
ya esto ya lo trabajaremos

31
00:01:32,150 --> 00:01:33,849
bastante, entonces ahora mismo

32
00:01:33,849 --> 00:01:35,930
con que sepamos como

33
00:01:35,930 --> 00:01:36,510
crear

34
00:01:36,510 --> 00:01:39,829
y declarar una variable scanner es suficiente

35
00:01:39,829 --> 00:01:41,730
porque estamos usando solo esta, variable objeto

36
00:01:41,730 --> 00:01:43,689
solo esta estamos usando, aler del teclado

37
00:01:43,689 --> 00:01:44,069
ya está

38
00:01:44,069 --> 00:01:50,849
vale, pues entonces

39
00:01:50,849 --> 00:01:53,349
esta variable

40
00:01:53,349 --> 00:01:55,530
ya está correctamente declarada

41
00:01:55,530 --> 00:02:01,430
Y además, dando inicializada de una manera que todavía no entendemos

42
00:02:01,430 --> 00:02:03,989
Pero bueno, nos da igual, inicializada como para a partir de ahora

43
00:02:03,989 --> 00:02:07,609
Poder hacer las cosas que ella es capaz de hacer

44
00:02:07,609 --> 00:02:08,889
Que es leer del teclado

45
00:02:08,889 --> 00:02:13,849
Las variables enteras, long, char, no pueden hacer nada

46
00:02:13,849 --> 00:02:14,930
Salvo recibir valor

47
00:02:14,930 --> 00:02:19,750
Las variables objeto como esta, aparte de recibir valor, pueden hacer cosas

48
00:02:19,750 --> 00:02:21,949
En este caso, ¿qué puede hacer?

49
00:02:22,449 --> 00:02:24,969
Leer un número entero del teclado, leer un número double

50
00:02:24,969 --> 00:02:26,689
leer un char

51
00:02:26,689 --> 00:02:28,750
que es lo que nosotros queremos

52
00:02:28,750 --> 00:02:31,349
bueno, pues vamos a hacerlo

53
00:02:31,349 --> 00:02:33,870
¿cómo la ordenamos?

54
00:02:33,990 --> 00:02:35,689
oye tú, lee el número entero del teclado

55
00:02:35,689 --> 00:02:43,400
vale, pues a ver

56
00:02:43,400 --> 00:02:45,520
para darle órdenes

57
00:02:45,520 --> 00:02:47,240
a esta variable objeto y que lea

58
00:02:47,240 --> 00:02:49,060
la llamo por su nombre

59
00:02:49,060 --> 00:02:51,539
por supuesto, para eso le he dado un nombre

60
00:02:51,539 --> 00:02:52,419
la llamo por su nombre

61
00:02:52,419 --> 00:02:55,199
y lo de darle la orden para que haga algo

62
00:02:55,199 --> 00:02:56,699
se hace poniendo un puntito

63
00:02:56,699 --> 00:02:58,340
que también entenderemos por qué

64
00:02:58,340 --> 00:03:00,500
poniendo un puntito se le da la orden

65
00:03:00,500 --> 00:03:16,039
Y ahora, ¿qué orden le quieres tú dar? ¿Qué le queremos ordenar? Queremos ordenarle que lea un número entero. Pues, ala, con esto le ordenamos que lea un número entero. Esa es la orden y es esa. Y es esa y hay que saberla.

66
00:03:16,039 --> 00:03:20,060
Y ahora la gran pregunta es

67
00:03:20,060 --> 00:03:21,180
Vale, muy bien

68
00:03:21,180 --> 00:03:23,979
Con esta orden que yo le he dado

69
00:03:23,979 --> 00:03:27,039
Se irá al teclado

70
00:03:27,039 --> 00:03:29,219
Cogerá el numerito que alguien haya tecleado

71
00:03:29,219 --> 00:03:30,139
Y que esté en el buffer

72
00:03:30,139 --> 00:03:31,939
Pero ese número tiene que ir a algún lado

73
00:03:31,939 --> 00:03:35,180
Claro, es que la idea es que ese número

74
00:03:35,180 --> 00:03:36,599
Se guarde, ¿dónde?

75
00:03:36,780 --> 00:03:39,180
En una variable para guardar números

76
00:03:39,180 --> 00:03:40,960
Porque para eso creamos las variables

77
00:03:40,960 --> 00:03:42,379
Nosotros, para guardar cosas

78
00:03:42,379 --> 00:03:44,199
Bueno, pues vamos a

79
00:03:44,199 --> 00:03:45,979
Por ejemplo

80
00:03:45,979 --> 00:03:48,020
Aquí vamos a declararnos

81
00:03:48,020 --> 00:03:50,360
Una variable para poder guardar el valor

82
00:03:50,360 --> 00:03:52,300
Porque es que si no, no hacemos nada con ese valor

83
00:03:52,300 --> 00:03:54,080
¿Vale?

84
00:03:54,180 --> 00:03:56,560
¿Y cómo le asignamos valor a una variable?

85
00:03:56,659 --> 00:03:57,439
Ya sabemos cómo

86
00:03:57,439 --> 00:03:59,780
Haciendo esto, ¿verdad?

87
00:04:00,699 --> 00:04:01,879
Esta es la asignación

88
00:04:01,879 --> 00:04:03,460
n igual

89
00:04:03,460 --> 00:04:06,520
En este caso a n, ¿qué le asignamos?

90
00:04:06,620 --> 00:04:08,580
No le asignamos 5, 7

91
00:04:08,580 --> 00:04:10,639
n1 por 12

92
00:04:10,639 --> 00:04:12,219
No, lo que le asignamos

93
00:04:12,219 --> 00:04:14,199
Es el resultado de esta orden

94
00:04:14,199 --> 00:04:17,759
le asignamos el resultado de ordenar

95
00:04:17,759 --> 00:04:20,240
a la variable lector del teclado

96
00:04:20,240 --> 00:04:22,980
que lea un número entero del teclado

97
00:04:22,980 --> 00:04:25,420
y el resultado de esa orden

98
00:04:25,420 --> 00:04:26,819
que será el número entero leído

99
00:04:26,819 --> 00:04:29,060
ese resultado se va a n

100
00:04:29,060 --> 00:04:32,540
luego esto es una asignación

101
00:04:32,540 --> 00:04:34,600
no es una asignación más

102
00:04:34,600 --> 00:04:35,980
es una asignación normal y corriente

103
00:04:35,980 --> 00:04:37,259
a n le asigno esto

104
00:04:37,259 --> 00:04:39,319
lo que pasa es que lo que le asigno

105
00:04:39,319 --> 00:04:42,259
es el resultado de la orden

106
00:04:42,259 --> 00:04:43,699
coger del teclado

107
00:04:43,699 --> 00:04:47,259
¿vale? entonces

108
00:04:47,259 --> 00:04:48,839
revisando

109
00:04:48,839 --> 00:04:51,899
la declaración y construcción del objeto este

110
00:04:51,899 --> 00:04:53,720
es así por narices

111
00:04:53,720 --> 00:04:55,300
le puedo cambiar el nombre, por supuesto

112
00:04:55,300 --> 00:04:57,339
los nombres de las variables, yo pongo el que me dé la gana

113
00:04:57,339 --> 00:04:58,040
se lo puedo cambiar

114
00:04:58,040 --> 00:05:01,060
pero es esta, y luego

115
00:05:01,060 --> 00:05:03,060
las órdenes que le tengo que dar

116
00:05:03,060 --> 00:05:05,060
las órdenes tienen

117
00:05:05,060 --> 00:05:07,759
un nombre, una llamada, y las tengo que saber

118
00:05:07,759 --> 00:05:08,920
las tengo que saber

119
00:05:08,920 --> 00:05:11,839
pues para leer un entero esta

120
00:05:11,839 --> 00:05:14,279
vamos de hecho a

121
00:05:14,279 --> 00:05:16,180
comprobarlo aquí

122
00:05:16,180 --> 00:05:17,819
a ver si ha leído correctamente

123
00:05:17,819 --> 00:05:19,959
bueno, no voy a poner las tildes

124
00:05:19,959 --> 00:05:20,420
porque

125
00:05:20,420 --> 00:05:26,819
el número leído es

126
00:05:26,819 --> 00:05:31,470
¿vale?

127
00:05:31,750 --> 00:05:33,449
recordad ya un uso

128
00:05:33,449 --> 00:05:34,610
del system.out.println

129
00:05:34,610 --> 00:05:36,750
que ya lo hemos hecho al principio de todo

130
00:05:36,750 --> 00:05:37,850
el primer programa que hicimos era

131
00:05:37,850 --> 00:05:40,670
yo le paso algo entrecomillado y me lo muestra tal cual

132
00:05:40,670 --> 00:05:42,889
vale, pues el número leído es

133
00:05:42,889 --> 00:05:44,930
y vamos a poner aquí abajo

134
00:05:44,930 --> 00:05:46,990
el numerito

135
00:05:46,990 --> 00:05:51,149
vale

136
00:05:51,149 --> 00:05:54,569
entonces va a ir incorporando

137
00:05:54,569 --> 00:05:56,389
pequeñas cosas, chorradas

138
00:05:56,389 --> 00:05:58,589
el system.out.println

139
00:05:58,589 --> 00:06:00,250
sabemos que muestra

140
00:06:00,250 --> 00:06:01,750
por consola

141
00:06:01,750 --> 00:06:03,529
lo que le pasemos aquí

142
00:06:03,529 --> 00:06:06,029
bien sea un texto entrecomillado

143
00:06:06,029 --> 00:06:08,269
o bien sea el contenido de una variable

144
00:06:08,269 --> 00:06:09,350
lo muestra por consola

145
00:06:09,350 --> 00:06:11,370
y además añade un salto de línea

146
00:06:11,370 --> 00:06:13,029
de ahí viene la ln

147
00:06:13,029 --> 00:06:16,370
pero hay otra versión del system.out

148
00:06:16,370 --> 00:06:19,810
que es sin el ln, también existe, sin el ln

149
00:06:19,810 --> 00:06:23,550
entonces sin el ln, muestra lo que yo le dé ahí

150
00:06:23,550 --> 00:06:28,329
pero luego no mete un salto de línea, depende del efecto que yo quiera

151
00:06:28,329 --> 00:06:32,009
pongo ln, no lo pongo, en este caso, sin ln

152
00:06:32,009 --> 00:06:36,230
me mostrará en la misma línea el número leído es, y me mostrará el número después

153
00:06:36,230 --> 00:06:38,730
porque no hay un salto de línea aquí, no lo hay

154
00:06:38,730 --> 00:06:43,730
si pongo un ln, me mostraría el número leído es

155
00:06:43,730 --> 00:06:45,350
Salta y abajo ya el número

156
00:06:45,350 --> 00:06:47,610
Depende del efecto que yo quiera lograr

157
00:06:47,610 --> 00:06:48,829
En la vista que me sale

158
00:06:48,829 --> 00:06:50,610
Aquí me es más cómodo

159
00:06:50,610 --> 00:06:51,490
Como lo he puesto en la misma línea

160
00:06:51,490 --> 00:06:53,810
Uso la versión de print

161
00:06:53,810 --> 00:06:59,699
Vale, pues entonces vamos a ver

162
00:06:59,699 --> 00:07:01,439
Si este programa funciona

163
00:07:01,439 --> 00:07:03,579
Vamos a ejecutarlo

164
00:07:03,579 --> 00:07:06,800
Lo ejecutamos

165
00:07:06,800 --> 00:07:10,459
Y ahí se ha quedado parado

166
00:07:10,459 --> 00:07:11,680
No ha terminado

167
00:07:11,680 --> 00:07:15,360
Para saber si un programa ha terminado

168
00:07:15,360 --> 00:07:17,100
Lo sabemos porque

169
00:07:17,100 --> 00:07:18,639
aquí viene, verdad

170
00:07:18,639 --> 00:07:21,379
aquí viene

171
00:07:21,379 --> 00:07:23,240
el término, aquí aparecería

172
00:07:23,240 --> 00:07:24,319
el término terminate

173
00:07:24,319 --> 00:07:27,279
este no ha terminado, de hecho

174
00:07:27,279 --> 00:07:29,279
me aparece este nombre porque

175
00:07:29,279 --> 00:07:31,040
dice, este está aquí parado en ejecución

176
00:07:31,040 --> 00:07:32,839
y tanto que está parado

177
00:07:32,839 --> 00:07:34,620
es que está ahí esperando

178
00:07:34,620 --> 00:07:36,040
ahí muerto de risa

179
00:07:36,040 --> 00:07:38,980
claro, porque esta orden

180
00:07:38,980 --> 00:07:40,300
la orden next in

181
00:07:40,300 --> 00:07:42,699
lo que hace es

182
00:07:42,699 --> 00:07:45,519
poner al programa cruzado de brazos

183
00:07:45,519 --> 00:07:47,420
A la espera de que alguien

184
00:07:47,420 --> 00:07:50,300
Se le ocurra meter un numerito y llenar el buffer

185
00:07:50,300 --> 00:07:51,639
Mientras en el buffer no haya nada

186
00:07:51,639 --> 00:07:54,819
Ese se va a quedar clavado hasta el infinito

187
00:07:54,819 --> 00:07:56,220
¿Vale?

188
00:07:56,259 --> 00:07:57,500
La orden next in

189
00:07:57,500 --> 00:07:59,420
Se va al buffer del teclado

190
00:07:59,420 --> 00:08:01,899
Que está vacío, ahí parado para siempre

191
00:08:01,899 --> 00:08:03,860
No hay forma de abortar eso

192
00:08:03,860 --> 00:08:04,959
Ahí parado para siempre

193
00:08:04,959 --> 00:08:08,379
Que alguien ya ha tecleado algo y ha llenado el buffer

194
00:08:08,379 --> 00:08:09,660
Lo coge del buffer

195
00:08:09,660 --> 00:08:11,660
Entonces ahí ya la orden sale

196
00:08:11,660 --> 00:08:14,060
Coge eso y va a la variable

197
00:08:14,060 --> 00:08:15,939
Pero mientras el buffer esté vacío

198
00:08:15,939 --> 00:08:16,899
Porque yo no he tecleado nada

199
00:08:16,899 --> 00:08:18,939
Ahí el programa se está parado

200
00:08:18,939 --> 00:08:21,259
Hasta el fin de los tiempos

201
00:08:21,259 --> 00:08:24,060
Bueno, pues para que no se esté parado

202
00:08:24,060 --> 00:08:24,800
Hasta el fin de los tiempos

203
00:08:24,800 --> 00:08:26,000
Vamos a meterle un numerito

204
00:08:26,000 --> 00:08:29,079
Y ya está, vale, el número he leído es 76

205
00:08:29,079 --> 00:08:30,360
Vale, estupendo

206
00:08:30,360 --> 00:08:33,460
Cuando yo le he metido 76

207
00:08:33,460 --> 00:08:35,120
Ha cogido del buffer el 76

208
00:08:35,120 --> 00:08:37,620
Perdón, ha llevado al buffer el 76

209
00:08:37,620 --> 00:08:39,759
Lo ha...

210
00:08:48,519 --> 00:08:49,620
Vale, cuidado

211
00:08:49,620 --> 00:08:51,500
Con lo que metéis

212
00:08:51,500 --> 00:08:52,399
Que nunca sabéis

213
00:08:52,399 --> 00:08:53,960
Lo que puede salir de ahí

214
00:08:53,960 --> 00:08:57,200
El next in

215
00:08:57,200 --> 00:08:58,179
Espera un número

216
00:08:58,179 --> 00:09:00,899
Como no metáis un número

217
00:09:00,899 --> 00:09:03,399
¿Vale? Vamos a ver a ejecutar el programa

218
00:09:03,399 --> 00:09:08,350
El next in

219
00:09:08,350 --> 00:09:09,190
Se queda esperando

220
00:09:09,190 --> 00:09:10,929
Y a mí se me va la mano

221
00:09:10,929 --> 00:09:13,309
76 y una i que se me ha ido la mano

222
00:09:13,309 --> 00:09:16,750
Ya la hemos roto

223
00:09:16,750 --> 00:09:17,809
Ya la hemos roto

224
00:09:17,809 --> 00:09:19,330
Porque next in dice 76

225
00:09:19,330 --> 00:09:20,669
Sí, pero ¿qué número es ese?

226
00:09:21,169 --> 00:09:22,450
Como no sea un número

227
00:09:22,450 --> 00:09:25,330
con parte imaginaria pura

228
00:09:25,330 --> 00:09:26,929
¿no? recordáis números complejos, ¿verdad?

229
00:09:27,830 --> 00:09:28,970
68 hoy es un número

230
00:09:28,970 --> 00:09:30,629
pero es un número complejo, no es real

231
00:09:30,629 --> 00:09:32,929
los números complejos para Java

232
00:09:32,929 --> 00:09:34,669
no ha llevado hasta ahí, no existen

233
00:09:34,669 --> 00:09:37,309
conclusión

234
00:09:37,309 --> 00:09:39,250
si metéis algo

235
00:09:39,250 --> 00:09:40,549
que no es un número entero

236
00:09:40,549 --> 00:09:42,169
next in

237
00:09:42,169 --> 00:09:45,649
va a parar el programa automáticamente

238
00:09:45,649 --> 00:09:47,330
fuera, parado, ya no pasa nada más

239
00:09:47,330 --> 00:09:48,269
el programa se paró

240
00:09:48,269 --> 00:09:50,350
y de hecho aparece el terminator

241
00:09:50,350 --> 00:09:51,710
es el terminator

242
00:09:51,710 --> 00:09:54,750
aparece ahí, ¿verdad? porque el programa ha terminado

243
00:09:54,750 --> 00:09:57,970
o sea, el programa termina

244
00:09:57,970 --> 00:10:00,590
y no pasa

245
00:10:00,590 --> 00:10:02,169
del resto, lo que hay después pasa

246
00:10:02,169 --> 00:10:03,190
fuera, pasa

247
00:10:03,190 --> 00:10:06,710
esto es lo que se llama, se ha generado una excepción

248
00:10:06,710 --> 00:10:10,470
¿vale? para que vayamos incorporando

249
00:10:10,470 --> 00:10:12,830
conceptos

250
00:10:12,830 --> 00:10:14,750
una excepción es

251
00:10:14,750 --> 00:10:18,750
algo que a la máquina virtual no le cuadro

252
00:10:18,750 --> 00:10:21,809
No le cuadro, ya veremos cómo se genera en su momento

253
00:10:21,809 --> 00:10:23,610
Por qué, cómo evitarlas

254
00:10:23,610 --> 00:10:25,149
Cómo capturarlas nuestras

255
00:10:25,149 --> 00:10:28,149
Eso ya es el tema de excepciones

256
00:10:28,149 --> 00:10:29,070
Que está más adelante

257
00:10:29,070 --> 00:10:32,049
Una excepción basta con que ahora sepamos qué es

258
00:10:32,049 --> 00:10:34,210
La máquina virtual

259
00:10:34,210 --> 00:10:36,169
Ha intentado hacer una sentencia

260
00:10:36,169 --> 00:10:38,090
Esa sentencia

261
00:10:38,090 --> 00:10:39,509
Por lo que sea le ha salido rana

262
00:10:39,509 --> 00:10:41,889
Pues entonces

263
00:10:41,889 --> 00:10:44,029
Te avisa con unas letras rojas muy feas

264
00:10:44,029 --> 00:10:46,450
Y para automáticamente el programa

265
00:10:46,450 --> 00:10:47,110
Ya no sigue

266
00:10:47,110 --> 00:10:51,389
bueno, pues nos van a pasar tropecientas mil excepciones

267
00:10:51,389 --> 00:10:53,710
porque habrá mil veces que a la máquina virtual le pase eso

268
00:10:53,710 --> 00:10:56,370
que intente ejecutar una sentencia y diga

269
00:10:56,370 --> 00:10:58,070
uuuh, esto es imposible

270
00:10:58,070 --> 00:11:00,889
me pare el programa y me saque unas letras rojas feas

271
00:11:00,889 --> 00:11:02,789
bueno, habrá muchas veces que nos pase

272
00:11:02,789 --> 00:11:04,090
pues este es el primero que nos va a pasar

273
00:11:04,090 --> 00:11:06,169
como demos una orden de next in

274
00:11:06,169 --> 00:11:07,850
y le metamos algo que no sea un entero

275
00:11:07,850 --> 00:11:09,210
pues lo hemos liado

276
00:11:09,210 --> 00:11:12,070
que yo le meto un menos esto

277
00:11:12,070 --> 00:11:14,210
aquí el encanta de la vida

278
00:11:14,210 --> 00:11:16,509
porque menos 98 es un número entero

279
00:11:16,509 --> 00:11:19,230
A NextIn le gusta el menos 98

280
00:11:19,230 --> 00:11:24,070
Aquí en la consola

281
00:11:24,070 --> 00:11:25,269
¿No tienes consola abierta?

282
00:11:28,539 --> 00:11:30,100
Si hay un NextIn lanzado

283
00:11:30,100 --> 00:11:31,580
Y un programa lanzado esperando, sí

284
00:11:31,580 --> 00:11:34,039
Tienes que tener el programa lanzado

285
00:11:34,039 --> 00:11:35,639
Y un NextIn que está ahí esperando

286
00:11:35,639 --> 00:11:41,179
¿Vale?

287
00:11:42,840 --> 00:11:44,220
Bueno, pues en cuanto a enteros

288
00:11:44,220 --> 00:11:44,559
Esto

289
00:11:44,559 --> 00:11:48,620
Que yo quiero, claro, que yo quiero meter un número muy grandote

290
00:11:48,620 --> 00:11:50,220
Pues

291
00:11:50,220 --> 00:11:52,179
Y no me cabe en un int

292
00:11:52,179 --> 00:11:53,860
No lo leería con NextIn

293
00:11:53,860 --> 00:11:55,580
pero puedo leerlo con NextLong

294
00:11:55,580 --> 00:11:56,740
¿verdad?

295
00:12:03,419 --> 00:12:04,220
a ver, ¿cómo?

296
00:12:05,659 --> 00:12:06,059
vale

297
00:12:06,059 --> 00:12:14,909
vale, a ver, lo de que se puede

298
00:12:14,909 --> 00:12:17,210
aquí en la consola o no se pueda, no es que se pueda o no se pueda

299
00:12:17,210 --> 00:12:18,669
o sea, la consola

300
00:12:18,669 --> 00:12:20,990
es esto de aquí abajo, esto blanco

301
00:12:20,990 --> 00:12:22,970
esto blanco está ahí

302
00:12:22,970 --> 00:12:24,809
para lo que el programa mande

303
00:12:24,809 --> 00:12:27,090
¿vale? silencio

304
00:12:27,090 --> 00:12:27,750
escuchadme

305
00:12:27,750 --> 00:12:30,789
la consola, que es eso bajito

306
00:12:30,789 --> 00:12:32,730
que está ahí abajo, está ahí

307
00:12:32,730 --> 00:12:33,809
para lo que el programa decida

308
00:12:33,809 --> 00:12:37,450
Entonces el programa, ¿para qué puede decidir usar la consola?

309
00:12:37,990 --> 00:12:43,850
Puede decidir usarlo para mostrar datos o para recogerlos

310
00:12:43,850 --> 00:12:50,190
Y en cada momento, o me sirve para mostrar o me sirve para recoger según lo que el programa diga

311
00:12:50,190 --> 00:12:54,509
El programa es el que tiene las órdenes, el que va ordenando sentencia por sentencia

312
00:12:54,509 --> 00:13:01,269
Y en función de las órdenes, la consola me sirve como mostradora de datos o me sirve como receptora

313
00:13:01,269 --> 00:13:21,190
Por ejemplo, la máquina virtual arranca, el programa arranca, lo primero que hemos hecho, o sea, lo primero no, si se encuentra esto, en este momento la consola solo me vale para mostrar, está claro, porque System.out.print es una orden que es para que la consola muestre, entonces en ese caso la consola me vale para mostrar.

314
00:13:21,190 --> 00:13:23,730
pero si yo hago una sentencia

315
00:13:23,730 --> 00:13:24,470
como esta

316
00:13:24,470 --> 00:13:27,570
como esa, entonces ahí

317
00:13:27,570 --> 00:13:29,950
la consola se convierte automáticamente

318
00:13:29,950 --> 00:13:31,509
en esperadora

319
00:13:31,509 --> 00:13:32,669
receptora de datos

320
00:13:32,669 --> 00:13:35,509
entonces la consola o puede recibir datos

321
00:13:35,509 --> 00:13:37,809
o no, en función de si el programa

322
00:13:37,809 --> 00:13:39,090
se lo ordena o no se lo ordena

323
00:13:39,090 --> 00:13:41,649
la consola no es que sea un ente aparte

324
00:13:41,649 --> 00:13:43,870
que haga cosas o no las haga

325
00:13:43,870 --> 00:13:45,789
la consola está al servicio

326
00:13:45,789 --> 00:13:48,049
de lo que las instrucciones le manden

327
00:13:48,049 --> 00:13:49,909
bueno, pues hasta ahora

328
00:13:49,909 --> 00:13:51,629
solamente ha estado al servicio

329
00:13:51,629 --> 00:13:53,350
de instrucciones de mostrar

330
00:13:53,350 --> 00:13:55,350
porque solo lo hemos usado para eso

331
00:13:55,350 --> 00:13:57,389
con system out para mostrar una variable

332
00:13:57,389 --> 00:13:58,950
mostrar una cadena, solo hemos usado para eso

333
00:13:58,950 --> 00:14:01,110
entonces hasta ahora la consola solamente ha estado

334
00:14:01,110 --> 00:14:02,289
al servicio de mostrar

335
00:14:02,289 --> 00:14:04,669
pero ahora hemos incorporado ya una sentencia

336
00:14:04,669 --> 00:14:06,789
solo una hasta ahora, que es esta

337
00:14:06,789 --> 00:14:09,049
que pone la consola

338
00:14:09,049 --> 00:14:11,470
en modo escucha

339
00:14:11,470 --> 00:14:13,269
entonces la consola

340
00:14:13,269 --> 00:14:15,710
solo puede recibir datos

341
00:14:15,710 --> 00:14:17,570
cuando se ejecute

342
00:14:17,570 --> 00:14:18,309
esta sentencia

343
00:14:18,309 --> 00:14:20,990
entonces cuando esta sentencia se ejecuta

344
00:14:20,990 --> 00:14:22,289
solo en ese momento

345
00:14:22,289 --> 00:14:24,350
que es en el que estoy ahora mismo yo en mi programa

346
00:14:24,350 --> 00:14:27,289
eso está en modo recibir datos

347
00:14:27,289 --> 00:14:28,009
y ahí está parado

348
00:14:28,009 --> 00:14:29,789
y el programa está aquí parado

349
00:14:29,789 --> 00:14:31,769
y de aquí no va a salir nunca jamás

350
00:14:31,769 --> 00:14:33,690
ahí está paradísimo, nunca jamás

351
00:14:33,690 --> 00:14:35,250
porque está atascado en esta sentencia

352
00:14:35,250 --> 00:14:37,830
y la consola está ahí esperando

353
00:14:37,830 --> 00:14:40,450
y ahí atascado en mesin

354
00:14:40,450 --> 00:14:41,370
atascado

355
00:14:41,370 --> 00:14:43,789
y no se va a desatascar jamás

356
00:14:43,789 --> 00:14:45,269
cuando se va a desatascar

357
00:14:45,269 --> 00:14:47,090
cuando yo le meta un número

358
00:14:47,090 --> 00:14:49,090
Cuando yo le meta un número, ya

359
00:14:49,090 --> 00:14:52,250
Coge el valor, esta sentencia ha terminado

360
00:14:52,250 --> 00:14:53,649
Con lo cual la consola

361
00:14:53,649 --> 00:14:55,750
Deja de ser ya automáticamente receptora de datos

362
00:14:55,750 --> 00:14:57,110
Porque ya la sentencia terminó

363
00:14:57,110 --> 00:14:59,230
No volverá a ser receptora de datos

364
00:14:59,230 --> 00:15:01,129
Hasta que nos llegue un next in más adelante

365
00:15:01,129 --> 00:15:02,169
¿Vale?

366
00:15:03,169 --> 00:15:04,750
Cuando yo le meta un numerito

367
00:15:04,750 --> 00:15:07,789
Y de al enter, porque el enter significa

368
00:15:07,789 --> 00:15:08,870
Ya he acabado de meter

369
00:15:08,870 --> 00:15:10,990
Cuando yo le de al enter

370
00:15:10,990 --> 00:15:12,950
Ahora ya esta sentencia acabó

371
00:15:12,950 --> 00:15:15,769
La consola dejó de ser receptora de datos

372
00:15:15,769 --> 00:15:16,789
Pero la sentencia acabó

373
00:15:16,789 --> 00:15:19,389
Y ahora ya se ha convertido en mostradora

374
00:15:19,389 --> 00:15:20,929
Porque se le ordena esta sentencia

375
00:15:20,929 --> 00:15:22,190
¿Vale? Se le ordena

376
00:15:22,190 --> 00:15:24,629
Y se ha convertido en mostradora

377
00:15:24,629 --> 00:15:25,789
El número leído es

378
00:15:25,789 --> 00:15:27,190
Y otra vez vuelve a mostrar

379
00:15:27,190 --> 00:15:30,350
¿Vale? Así funciona

380
00:15:30,350 --> 00:15:33,389
La consola y estas sentencias

381
00:15:33,389 --> 00:15:35,250
Bueno, pues estábamos

382
00:15:35,250 --> 00:15:37,429
Para leer un número entero

383
00:15:37,429 --> 00:15:38,950
Que es una tarea habitual en nuestros códigos

384
00:15:38,950 --> 00:15:40,330
Ya sabemos perfectamente cómo hacerlo

385
00:15:40,330 --> 00:15:41,090
Y sin ningún problema

386
00:15:41,090 --> 00:15:42,629
Lo podemos leer así

387
00:15:42,629 --> 00:15:44,429
Que yo quiero leer un número

388
00:15:44,429 --> 00:15:45,950
Que es muy grandote

389
00:15:45,950 --> 00:15:47,809
y que va una variable log muy grandote

390
00:15:47,809 --> 00:15:49,490
pues tengo otra orden

391
00:15:49,490 --> 00:15:51,470
que es next long, esto es fácil de memorizar

392
00:15:51,470 --> 00:15:54,169
pues next in, next long, es fácil de memorizar

393
00:15:54,169 --> 00:15:55,509
esta orden

394
00:15:55,509 --> 00:15:57,529
la usaré cuando

395
00:15:57,529 --> 00:15:59,629
yo prevea que el usuario

396
00:15:59,629 --> 00:16:01,110
me puede meter una cosa muy grandota

397
00:16:01,110 --> 00:16:03,509
¿vale? entonces sí

398
00:16:03,509 --> 00:16:15,129
el número por ejemplo

399
00:16:15,129 --> 00:16:18,529
¿vale? y ambas me funcionan, por ejemplo

400
00:16:18,529 --> 00:16:19,750
aquí voy a leer dos números

401
00:16:19,750 --> 00:16:21,750
este y este

402
00:16:21,750 --> 00:16:24,269
vamos a leerlos, entonces

403
00:16:24,269 --> 00:16:25,529
Ejecutamos el programa

404
00:16:25,529 --> 00:16:27,850
¡Hala! Primero

405
00:16:27,850 --> 00:16:29,870
Ahí se ha quedado, esperando el primero

406
00:16:29,870 --> 00:16:32,289
Venga, esperando el primero

407
00:16:32,289 --> 00:16:34,450
Ahora, ya ha hecho

408
00:16:34,450 --> 00:16:36,370
Esto System.out y otra vez

409
00:16:36,370 --> 00:16:38,090
Se vuelve a quedar esperando el segundo

410
00:16:38,090 --> 00:16:40,370
Otra vez se ha parado, otra vez está aquí parada

411
00:16:40,370 --> 00:16:41,870
Otra vez parada

412
00:16:41,870 --> 00:16:44,149
Atascada ahí en este Next.log, otra vez parada

413
00:16:44,149 --> 00:16:46,269
¿Vale? Pues le doy un numeraco

414
00:16:46,269 --> 00:16:47,929
No sé si...

415
00:16:47,929 --> 00:16:52,440
Yo creo que así ya me he salido del entero

416
00:16:52,440 --> 00:16:54,779
¿Vale? Este...

417
00:16:54,779 --> 00:16:57,440
Porque el entero creo que tenía menos cifras decimales que esto.

418
00:17:00,740 --> 00:17:02,600
Vale, pues ya está.

419
00:17:02,879 --> 00:17:04,700
He leído este numerito y aquí se ha quedado.

420
00:17:09,799 --> 00:17:12,240
Bueno, pues aquí dos veces la consola se ha parado.

421
00:17:12,339 --> 00:17:13,079
Se ha parado aquí.

422
00:17:13,660 --> 00:17:15,539
Cuando le dio el número ha hecho esto.

423
00:17:15,660 --> 00:17:17,000
Se ha vuelto a quedar parada aquí.

424
00:17:17,240 --> 00:17:18,799
Cuando le he leído el número ha hecho esto.

425
00:17:19,000 --> 00:17:19,420
Y ya está.

426
00:17:20,160 --> 00:17:21,440
Bueno, pues leer números.

427
00:17:22,759 --> 00:17:24,259
Indabel, que son los que manejamos.

428
00:17:27,470 --> 00:17:29,349
Claro, porque no has cambiado este n por n2.

429
00:17:29,349 --> 00:17:30,470
¿Has hecho el copia y pega como yo?

430
00:17:30,910 --> 00:17:31,950
Y has dejado aquí n, ¿verdad?

431
00:17:33,769 --> 00:17:35,809
Claro, con los copias y pegas hay que tener cuidado

432
00:17:35,809 --> 00:17:38,250
porque luego hay que revisar a ver si tengo que tocar algo

433
00:17:38,250 --> 00:17:39,210
en el pega que he hecho.

434
00:17:40,529 --> 00:17:40,769
Vale.

435
00:17:44,769 --> 00:17:46,490
Para leer números en todo esto es lo que haremos.

436
00:17:47,529 --> 00:17:48,690
Leer boolean no tiene sentido.

437
00:17:48,789 --> 00:17:49,869
Uno no lee los boolean.

438
00:17:50,190 --> 00:17:52,630
Los boolean son para almacenar condiciones,

439
00:17:52,630 --> 00:17:53,309
pero se podría.

440
00:17:53,450 --> 00:17:55,630
Hay un boolean, pero no nos...

441
00:17:55,630 --> 00:17:56,009
¿Vale?

442
00:17:56,170 --> 00:17:57,049
Y leer char.

443
00:17:57,049 --> 00:18:00,170
leer char, uno no lee un char en realidad

444
00:18:00,170 --> 00:18:02,009
uno cuando lee de la consola

445
00:18:02,009 --> 00:18:03,269
lo que quiere leer es un texto

446
00:18:03,269 --> 00:18:05,750
y ya veremos como

447
00:18:05,750 --> 00:18:07,710
lo almacenamos, porque un texto no vale

448
00:18:07,710 --> 00:18:09,910
en una cadena

449
00:18:09,910 --> 00:18:11,950
no vale en una variable char

450
00:18:11,950 --> 00:18:14,009
vale, pero es que no quiero

451
00:18:14,009 --> 00:18:18,170
incorporar más cosas ahora

452
00:18:18,170 --> 00:18:19,930
quiero que hagáis una

453
00:18:19,930 --> 00:18:22,470
primera chorradilla

454
00:18:22,470 --> 00:18:23,910
ya, por fin

455
00:18:23,910 --> 00:18:24,769
para que yo me calle

456
00:18:24,769 --> 00:18:27,569
vale, pues entonces

457
00:18:27,569 --> 00:18:32,519
venga, pues

458
00:18:32,519 --> 00:18:36,700
antes de poner ya ejercicios

459
00:18:36,700 --> 00:18:37,319
un poco más

460
00:18:37,319 --> 00:18:40,059
que tenemos que ver más cosas

461
00:18:40,059 --> 00:18:47,220
pues venga, haced simplemente esto

462
00:18:47,220 --> 00:18:49,079
simplemente esto para aseguraros de que todo

463
00:18:49,079 --> 00:18:50,140
está claro, vale

464
00:18:50,140 --> 00:18:55,279
sí, pero una clase nueva en la que voy a poner solo

465
00:18:55,279 --> 00:18:57,680
en modo de comentario lo que tenéis que hacer, luego ya lo hacéis vosotros

466
00:18:57,680 --> 00:19:00,759
he abierto una clase nueva para

467
00:19:00,759 --> 00:19:03,500
poner en modo comentario

468
00:19:03,500 --> 00:19:06,079
lo que os mando a hacer, luego ya lo hacéis vosotros

469
00:19:06,079 --> 00:19:07,779
¿vale? bueno, pero antes de nada

470
00:19:07,779 --> 00:19:09,400
para que el programa quede

471
00:19:09,400 --> 00:19:11,319
usable, amable

472
00:19:11,319 --> 00:19:13,140
que no sea un programa que no se entiende nada

473
00:19:13,140 --> 00:19:14,519
porque con este, ¿qué ha pasado?

474
00:19:15,140 --> 00:19:16,920
que cuando lo hemos ejecutado este programa

475
00:19:16,920 --> 00:19:19,940
es que, porque lo hemos hecho nosotros

476
00:19:19,940 --> 00:19:21,640
y como lo hemos hecho nosotros, sabemos que eso

477
00:19:21,640 --> 00:19:22,759
se ha quedado aquí esperando un número

478
00:19:22,759 --> 00:19:25,940
pero que lo hemos hecho nosotros, si este programa lo ejecuta el otro tío

479
00:19:25,940 --> 00:19:27,940
ve eso en blanco

480
00:19:27,940 --> 00:19:29,920
con el cursor esperando y dice, ¿y tú qué estás esperando?

481
00:19:31,019 --> 00:19:31,599
entonces, hombre

482
00:19:31,599 --> 00:19:33,460
eso es un poco feo, hay que hacer programas

483
00:19:33,460 --> 00:19:34,819
con interfaces lo más

484
00:19:34,819 --> 00:19:37,180
usables y amables posibles

485
00:19:37,180 --> 00:19:39,660
entonces, aquí en este

486
00:19:39,660 --> 00:19:41,539
programa, por ejemplo, que lo que queremos es leer

487
00:19:41,539 --> 00:19:43,579
un numerito, pues tendría sentido

488
00:19:43,579 --> 00:19:45,019
poner un mensaje antes

489
00:19:45,019 --> 00:19:47,319
ponerle un mensajito antes y decir

490
00:19:47,319 --> 00:19:49,519
introduzca número

491
00:19:49,519 --> 00:19:50,119
entero

492
00:19:50,119 --> 00:19:53,779
entonces ahora el programa

493
00:19:53,779 --> 00:19:55,740
es un poquito más majo

494
00:19:55,740 --> 00:19:57,619
porque primero

495
00:19:57,619 --> 00:19:59,779
mostrará el mensaje, y ahora ya si se quedará

496
00:19:59,779 --> 00:20:01,579
esperando, pero al menos tú ya sabrás que tienes que

497
00:20:01,579 --> 00:20:01,859
meter

498
00:20:01,859 --> 00:20:04,359
y con el otro long

499
00:20:04,359 --> 00:20:05,259
igual

500
00:20:05,259 --> 00:20:07,680
podríamos ponerle aquí

501
00:20:07,680 --> 00:20:10,140
introduzca número entero

502
00:20:10,140 --> 00:20:12,700
y ponerle entre paréntesis para que se aclare

503
00:20:12,700 --> 00:20:14,059
puede ser long

504
00:20:14,059 --> 00:20:16,200
para que sepa que puede ser muy largote

505
00:20:16,200 --> 00:20:18,680
entonces ahora ya el programa

506
00:20:18,680 --> 00:20:19,680
queda un poquito más majo

507
00:20:19,680 --> 00:20:21,279
si lo ejecutamos

508
00:20:21,279 --> 00:20:25,829
ahora ya, introduzca número entero

509
00:20:25,829 --> 00:20:27,990
y se queda esperando efectivamente

510
00:20:27,990 --> 00:20:29,589
con el next in se queda esperando

511
00:20:29,589 --> 00:20:31,950
pero al menos ya el usuario

512
00:20:31,950 --> 00:20:33,190
Que no es el que ha hecho el programa

513
00:20:33,190 --> 00:20:34,890
Normalmente el usuario sabe lo que tiene que hacer

514
00:20:34,890 --> 00:20:36,230
Ah, vale, un número entero

515
00:20:36,230 --> 00:20:37,109
Pues venga, ya está

516
00:20:37,109 --> 00:20:39,470
Ahora me lo vuelve a decir

517
00:20:39,470 --> 00:20:40,630
Introduzca número entero

518
00:20:40,630 --> 00:20:41,529
Este puede ser largo

519
00:20:41,529 --> 00:20:42,529
¡Paaaaa!

520
00:20:44,390 --> 00:20:44,789
¡Hala!

521
00:20:45,650 --> 00:20:46,410
Vale, entonces, bueno

522
00:20:46,410 --> 00:20:48,230
Incorporad siempre

523
00:20:48,230 --> 00:20:50,130
Toda la ayuda

524
00:20:50,130 --> 00:20:52,369
Para el usuario que va a ejecutar el programa

525
00:20:52,369 --> 00:20:54,150
Como

526
00:20:54,150 --> 00:20:56,369
En nuestro caso somos nosotros

527
00:20:56,369 --> 00:20:58,089
No nos es imprescindible esa ayuda

528
00:20:58,089 --> 00:20:59,210
Pero hay que acostumbrarse

529
00:20:59,210 --> 00:21:00,130
¿Vale?

530
00:21:00,130 --> 00:21:06,650
claro, es añadir mensaje

531
00:21:06,650 --> 00:21:07,910
no comentario, esto no es un comentario

532
00:21:07,910 --> 00:21:10,650
es añadir una sentencia que muestra por pantalla

533
00:21:10,650 --> 00:21:12,650
solamente con la idea

534
00:21:12,650 --> 00:21:14,470
de facilitar el trabajo al que lo va a usar

535
00:21:14,470 --> 00:21:16,650
de facilitar, o sea, de darle información

536
00:21:16,650 --> 00:21:44,700
este es todo el código

537
00:21:44,700 --> 00:21:51,960
este es todo el código que hay

538
00:21:51,960 --> 00:21:54,259
leemos número entero, dejamos aquí el programa

539
00:21:54,259 --> 00:21:56,500
esperando, lo mostramos

540
00:21:56,500 --> 00:21:58,579
ponemos el mensaje

541
00:21:58,579 --> 00:21:59,259
de aviso

542
00:21:59,259 --> 00:22:01,460
Nos quedamos esperando al siguiente

543
00:22:01,460 --> 00:22:02,259
Y lo mostramos

544
00:22:02,259 --> 00:22:30,220
Venga, pues os voy a complicar la vida un pelín

545
00:22:30,220 --> 00:22:32,240
Pero un pelín solo de cara a pensar

546
00:22:32,240 --> 00:22:33,440
No de cara a hacer nada

547
00:22:33,440 --> 00:22:34,440
Diciendo lo que hemos hecho

548
00:22:34,440 --> 00:22:35,960
Vale

549
00:22:35,960 --> 00:22:40,359
Se lo tenéis que hacer solo con lo que hemos visto

550
00:22:40,359 --> 00:22:42,380
No con nada que sepáis del pasado

551
00:22:42,380 --> 00:22:43,440
Ni del futuro

552
00:22:43,440 --> 00:22:48,650
Vale, programa que

553
00:22:48,650 --> 00:22:49,970
Solicite

554
00:22:49,970 --> 00:22:53,410
Y lea dos números enteros

555
00:22:53,410 --> 00:22:54,369
Uno detrás de otro, claro

556
00:22:54,369 --> 00:22:56,230
Los programas siempre actúan en secuencia

557
00:22:56,230 --> 00:22:59,329
Dos números enteros

558
00:22:59,329 --> 00:23:01,849
Int log, elegís el que sea

559
00:23:01,849 --> 00:23:04,410
Por defecto, siempre se suele usar el tipo int

560
00:23:04,410 --> 00:23:07,289
A menos que sean aplicaciones que no sepa que va a usar esos pedazos de números

561
00:23:07,289 --> 00:23:09,069
Números enteros

562
00:23:09,069 --> 00:23:14,329
Y a continuación

563
00:23:14,329 --> 00:23:18,789
Muestre el mayor de los dos

564
00:23:18,789 --> 00:23:21,509
A ver si se os ocurre como hacerlo

565
00:23:21,509 --> 00:23:25,769
Quizá lo he puesto un poco retorcido, de buenas a primeras

566
00:23:25,769 --> 00:23:27,089
Pero como soy muy listos

567
00:23:27,089 --> 00:23:30,549
a ver si os ocurre como hacerlo

568
00:23:30,549 --> 00:23:32,789
recurriendo

569
00:23:32,789 --> 00:23:34,569
solo a lo que hemos visto aquí

570
00:23:34,569 --> 00:23:36,569
no a cosas que

571
00:23:36,569 --> 00:23:38,829
busquéis, ni a sentencias

572
00:23:38,829 --> 00:23:40,930
y ni a nada, solo lo que hemos visto

573
00:23:40,930 --> 00:23:41,710
aquí

574
00:23:41,710 --> 00:23:49,319
venga, pues paro la grabación