1
00:00:01,710 --> 00:00:16,809
Pues con más o menos rapidez, siendo más o menos conscientes, porque a veces uno hace las cosas y ha seguido un hilo de pensamiento, aunque no sea consciente porque lo ha hecho de forma demasiado automatizada.

2
00:00:16,809 --> 00:00:19,969
entonces está bien que identifiquemos

3
00:00:19,969 --> 00:00:21,649
qué hilo de pensamiento

4
00:00:21,649 --> 00:00:23,589
tenemos que seguir cuando hacemos un programa

5
00:00:23,589 --> 00:00:25,750
porque cuando es sencillo

6
00:00:25,750 --> 00:00:27,690
pues lo hacemos de manera tan automática

7
00:00:27,690 --> 00:00:28,850
que no somos conscientes

8
00:00:28,850 --> 00:00:31,109
pero cuando ya una aplicación es más grande

9
00:00:31,109 --> 00:00:33,390
ya sí que tenemos que seguir

10
00:00:33,390 --> 00:00:35,109
esas fases de pensamientos

11
00:00:35,109 --> 00:00:37,030
de manera más organizada

12
00:00:37,030 --> 00:00:39,130
pues cuáles serían aquí entre comillas

13
00:00:39,130 --> 00:00:41,149
las fases de pensamiento que uno habría seguido

14
00:00:41,149 --> 00:00:45,390
primero leer el programa

15
00:00:45,390 --> 00:00:46,829
y entender lo que tiene que hacer

16
00:00:46,829 --> 00:00:49,109
Eso está claro porque son cuatro líneas, lo entendemos.

17
00:00:49,869 --> 00:00:51,409
Ahora ya empezamos a diseñarlo.

18
00:00:52,950 --> 00:00:54,850
A la hora de diseñarlo, lo primero que pensamos es,

19
00:00:54,929 --> 00:00:57,609
a ver, ¿mis datos de entrada los tengo claros?

20
00:00:58,170 --> 00:00:59,630
Sí, sí, los tienes claros.

21
00:00:59,630 --> 00:01:04,670
Tus datos de entrada son una variable string y una variable int.

22
00:01:05,049 --> 00:01:07,290
Esa parte la tengo clara, esos son mis datos de entrada.

23
00:01:07,810 --> 00:01:10,310
Ahí incluso podríamos empezar a escribir algo ya.

24
00:01:11,790 --> 00:01:14,890
Aunque normalmente uno empieza a escribir cuando lo tiene ya todo claro.

25
00:01:14,890 --> 00:01:44,609
Pero bueno, podríamos ya incluso empezar a escribir esa parte, que es la que tenemos clara. Vale, ahora, esta parte la tenemos clara, que es datos de entrada, un nombre, string, un número, int, una variable para cada dato de entrada.

26
00:01:44,609 --> 00:01:47,409
¿está claro? pues venga

27
00:01:47,409 --> 00:01:49,209
una variable nombre

28
00:01:49,209 --> 00:01:51,010
para mi dato de entrada nombre

29
00:01:51,010 --> 00:01:53,469
una variable int

30
00:01:53,469 --> 00:01:55,650
para mi dato de entrada número

31
00:01:55,650 --> 00:01:57,450
vale

32
00:01:57,450 --> 00:01:59,290
¿cómo reciben valor

33
00:01:59,290 --> 00:02:01,329
estas variables? lo van a

34
00:02:01,329 --> 00:02:03,170
recibir porque yo lo voy a

35
00:02:03,170 --> 00:02:05,109
solicitar por teclado y me voy a quedar

36
00:02:05,109 --> 00:02:06,250
ahí esperando que llegue

37
00:02:06,250 --> 00:02:12,759
venga, introduzca

38
00:02:12,759 --> 00:02:13,439
nombre

39
00:02:13,439 --> 00:02:15,840
lo podría hacer en la misma línea

40
00:02:15,840 --> 00:02:17,860
Lo de inicializar a través

41
00:02:17,860 --> 00:02:18,379
Pero bueno

42
00:02:18,379 --> 00:02:20,520
Lo estamos haciendo aquí

43
00:02:20,520 --> 00:02:20,840
Vale

44
00:02:20,840 --> 00:02:22,580
Ahora

45
00:02:22,580 --> 00:02:24,719
Mi variable nombre

46
00:02:24,719 --> 00:02:26,539
Le doy el resultado

47
00:02:26,539 --> 00:02:27,500
De

48
00:02:27,500 --> 00:02:31,340
Leer por aquí

49
00:02:31,340 --> 00:02:32,219
Muy bien

50
00:02:32,219 --> 00:02:33,759
Ahora

51
00:02:33,759 --> 00:02:38,819
Esto

52
00:02:38,819 --> 00:02:41,240
Introduzca número

53
00:02:41,240 --> 00:02:48,000
A la

54
00:02:48,000 --> 00:02:51,180
Número

55
00:02:51,180 --> 00:02:52,580
Igual a

56
00:02:52,580 --> 00:02:54,840
Scan.nextint

57
00:02:54,840 --> 00:02:59,060
Esto poco que pensar nos ha dado

58
00:02:59,060 --> 00:03:01,120
Hemos pensado

59
00:03:01,120 --> 00:03:02,159
Datos de entrada

60
00:03:02,159 --> 00:03:05,000
Un string porque es un nombre

61
00:03:05,000 --> 00:03:06,719
Un número entero

62
00:03:06,719 --> 00:03:09,900
Una variable para cada dato de entrada

63
00:03:09,900 --> 00:03:10,879
Vale

64
00:03:10,879 --> 00:03:12,740
Una variable para cada dato de entrada

65
00:03:12,740 --> 00:03:15,180
¿De dónde saco sus valores?

66
00:03:16,000 --> 00:03:17,800
Me han dicho que los tengo que recibir

67
00:03:17,800 --> 00:03:18,740
Desde la consola

68
00:03:18,740 --> 00:03:21,699
¿Se recibir datos desde la consola?

69
00:03:22,419 --> 00:03:22,979
Pues venga

70
00:03:22,979 --> 00:03:25,240
recibo el primero

71
00:03:25,240 --> 00:03:27,580
y recibo el segundo

72
00:03:27,580 --> 00:03:28,120
vale

73
00:03:28,120 --> 00:03:31,479
ahora que ya he recogido los datos, ahora ya viene la lógica

74
00:03:31,479 --> 00:03:33,020
la operativa del programa

75
00:03:33,020 --> 00:03:34,520
¿qué es?

76
00:03:36,969 --> 00:03:39,189
tiene que mostrar true, si patatín, falsis

77
00:03:39,189 --> 00:03:40,810
y no sé qué, bueno pues ahora

78
00:03:40,810 --> 00:03:42,849
es cuando yo pienso, ¿qué es lo que pienso?

79
00:03:43,650 --> 00:03:45,310
me voy al final del programa

80
00:03:45,310 --> 00:03:46,710
y digo, pero vamos a ver

81
00:03:46,710 --> 00:03:49,050
¿esto qué tiene que devolver?

82
00:03:49,150 --> 00:03:50,810
¿qué me tiene que mostrar a mí?

83
00:03:53,289 --> 00:03:54,409
tanto ruido de fondo

84
00:03:54,409 --> 00:03:56,789
que tiene que mostrar esto

85
00:03:56,789 --> 00:03:58,689
tiene que mostrar o true

86
00:03:58,689 --> 00:04:01,530
o false, en función de si algo

87
00:04:01,530 --> 00:04:03,189
pasa o no pasa, o true o false

88
00:04:03,189 --> 00:04:05,129
entonces yo lo primero que pienso ahora después

89
00:04:05,129 --> 00:04:06,550
me voy al final

90
00:04:06,550 --> 00:04:08,650
uno cuando piensa

91
00:04:08,650 --> 00:04:11,710
para programar, no piensa en secuencia

92
00:04:11,710 --> 00:04:12,629
¿vale?

93
00:04:13,830 --> 00:04:15,610
de lo primero que piensa es

94
00:04:15,610 --> 00:04:17,509
pero esto al final, ¿cuál va a ser su resultado?

95
00:04:17,730 --> 00:04:18,769
¿cuál va a ser su resultado?

96
00:04:19,329 --> 00:04:21,129
porque en función de eso, algunas cosas u otras

97
00:04:21,129 --> 00:04:23,329
pues su resultado va a ser

98
00:04:23,329 --> 00:04:25,949
yo vuelvo al enunciado y digo

99
00:04:25,949 --> 00:04:28,189
su resultado va a ser

100
00:04:28,189 --> 00:04:29,850
o true

101
00:04:29,850 --> 00:04:36,540
o false

102
00:04:36,540 --> 00:04:39,579
una de estas dos cosas va a ser

103
00:04:39,579 --> 00:04:41,759
vale, y eso de true o false

104
00:04:41,759 --> 00:04:43,620
¿qué es? pues true o false

105
00:04:43,620 --> 00:04:45,939
son los dos posibles valores

106
00:04:45,939 --> 00:04:47,100
de una variable boolean

107
00:04:47,100 --> 00:04:49,079
los dos posibles valores de una variable boolean

108
00:04:49,079 --> 00:04:51,060
¿no?

109
00:04:52,439 --> 00:04:52,920
entonces

110
00:04:52,920 --> 00:04:55,420
lo que me va a mostrar mi programa

111
00:04:55,420 --> 00:04:57,899
va a ser el contenido de una variable boolean

112
00:04:57,899 --> 00:04:58,860
eso es lo que me va a mostrar

113
00:04:58,860 --> 00:05:02,040
ah, vale, pues ya tengo una variable resultado

114
00:05:02,040 --> 00:05:03,360
que a saber cómo hago

115
00:05:03,360 --> 00:05:05,759
boolean, que va a ser

116
00:05:05,759 --> 00:05:06,699
mi resultado

117
00:05:06,699 --> 00:05:09,879
que no sé qué le vamos

118
00:05:09,879 --> 00:05:11,800
a dar, no tengo ni idea de qué le vamos

119
00:05:11,800 --> 00:05:13,920
a dar, pero lo que va a hacer

120
00:05:13,920 --> 00:05:14,579
mi programa

121
00:05:14,579 --> 00:05:16,600
va a ser mostrarla

122
00:05:16,600 --> 00:05:22,259
vale, entonces

123
00:05:22,259 --> 00:05:24,240
ya he hecho mucho y aquí

124
00:05:24,240 --> 00:05:26,639
voy por buen camino y estoy programando bien

125
00:05:26,639 --> 00:05:28,199
porque yo voy

126
00:05:28,199 --> 00:05:29,920
acotando mi programa

127
00:05:29,920 --> 00:05:32,519
he escrito la última línea

128
00:05:32,519 --> 00:05:34,819
que suele ser la primera que escribo

129
00:05:34,819 --> 00:05:36,660
siempre, vamos a ver, ya me he situado

130
00:05:36,660 --> 00:05:38,899
mi programa tiene que mostrar

131
00:05:38,899 --> 00:05:39,920
o true o false

132
00:05:39,920 --> 00:05:41,879
en función de lo que sea

133
00:05:41,879 --> 00:05:44,879
true o false son las dos posibilidades

134
00:05:44,879 --> 00:05:46,000
de una variable boolean

135
00:05:46,000 --> 00:05:48,759
pues entonces el resultado final

136
00:05:48,759 --> 00:05:49,819
de mi programa será

137
00:05:49,819 --> 00:05:52,560
mostrar una variable boolean

138
00:05:52,560 --> 00:05:54,779
genial, ya estoy acotando

139
00:05:54,779 --> 00:05:56,660
mi programa, ahora

140
00:05:56,660 --> 00:05:57,680
me queda solo

141
00:05:57,680 --> 00:06:00,500
resolver esta

142
00:06:00,500 --> 00:06:02,500
cajita negra, ¿vale?

143
00:06:02,540 --> 00:06:04,500
Entonces yo he resuelto, he dado

144
00:06:04,500 --> 00:06:06,540
una plantilla de mi programa, ya tengo

145
00:06:06,540 --> 00:06:08,459
una plantilla, y ahora voy rellenando

146
00:06:08,459 --> 00:06:10,560
los huecos, solo me

147
00:06:10,560 --> 00:06:12,620
falta este hueco ahora mismo, ¿vale?

148
00:06:12,660 --> 00:06:13,519
Yo tengo mi

149
00:06:13,519 --> 00:06:16,240
esqueleto de programa, ya lo tengo,

150
00:06:17,240 --> 00:06:18,459
el primer boceto de por

151
00:06:18,459 --> 00:06:19,699
dónde van, que ese es el importante,

152
00:06:21,079 --> 00:06:22,620
lo que me va a tener que mostrar,

153
00:06:23,000 --> 00:06:24,339
los datos de entrada, tengo el primer

154
00:06:24,339 --> 00:06:26,600
boceto, pero tengo unas cajas negras

155
00:06:26,600 --> 00:06:28,560
ahí todavía por resolver, tengo

156
00:06:28,560 --> 00:06:30,339
esta caja negra que es, sí

157
00:06:30,339 --> 00:06:32,779
mi programa va a mostrar un resultado

158
00:06:32,779 --> 00:06:33,980
que es una variable boolean

159
00:06:33,980 --> 00:06:36,980
pero esta variable boolean, ¿cómo la relleno?

160
00:06:37,459 --> 00:06:38,860
¿vale? ahí dejo esa caja negra

161
00:06:38,860 --> 00:06:40,620
y podría este

162
00:06:40,620 --> 00:06:42,839
esqueleto, dárselo a otro programador

163
00:06:42,839 --> 00:06:44,519
y decir, mira, ya tienes el esqueleto del programa

164
00:06:44,519 --> 00:06:46,480
encárgate tú de esa caja negra

165
00:06:46,480 --> 00:06:48,500
¿vale? ahora en este caso

166
00:06:48,500 --> 00:06:50,360
que es un programa sencillo, pues no, pero

167
00:06:50,360 --> 00:06:52,199
normalmente en un

168
00:06:52,199 --> 00:06:54,139
proyecto se trabaja así

169
00:06:54,139 --> 00:06:56,680
se van haciendo los diferentes esqueletos

170
00:06:56,680 --> 00:06:58,779
y luego ya van quedando

171
00:06:58,779 --> 00:07:00,860
las cajas negras y cada programador

172
00:07:00,860 --> 00:07:02,420
se puede dedicar a una caja negra

173
00:07:02,420 --> 00:07:04,160
pues aquí nos quedaría esta

174
00:07:04,160 --> 00:07:06,379
vale, ahora refinamos

175
00:07:06,379 --> 00:07:07,699
entramos en una

176
00:07:07,699 --> 00:07:11,100
siguiente iteración en la que seguimos refinando

177
00:07:11,100 --> 00:07:12,879
y es, vale, ahora ya

178
00:07:12,879 --> 00:07:14,339
me voy a centrar en resultado

179
00:07:14,339 --> 00:07:16,459
resultado que tiene que tener

180
00:07:16,459 --> 00:07:17,839
true

181
00:07:17,839 --> 00:07:21,240
si el número de caracteres

182
00:07:21,240 --> 00:07:22,500
de nombre es mayor que número

183
00:07:22,500 --> 00:07:24,639
o al revés, no lo sé, como lo hubiera enunciado a lo mismo

184
00:07:24,639 --> 00:07:26,579
pues tiene que tener

185
00:07:26,579 --> 00:07:27,759
true

186
00:07:27,759 --> 00:07:30,899
si pasa que la cantidad

187
00:07:30,899 --> 00:07:32,160
de caracteres de nombre

188
00:07:32,160 --> 00:07:34,040
si el tamaño de nombre

189
00:07:34,040 --> 00:07:36,100
es mayor que número

190
00:07:36,100 --> 00:07:38,120
y false

191
00:07:38,120 --> 00:07:39,980
si pasa otra cosa

192
00:07:39,980 --> 00:07:42,420
que el tamaño de nombre

193
00:07:42,420 --> 00:07:43,720
es menor que número

194
00:07:43,720 --> 00:07:46,920
yo lo escribo ahí con mis palabras para situarme

195
00:07:46,920 --> 00:07:49,300
vale, esto ya se parece

196
00:07:49,300 --> 00:07:49,800
a código

197
00:07:49,800 --> 00:07:52,100
es decir, tendrá true

198
00:07:52,100 --> 00:07:55,220
si una condición de tipo mayor que

199
00:07:55,220 --> 00:07:55,819
se cumple

200
00:07:55,819 --> 00:07:58,540
y falsa en caso contrario

201
00:07:58,540 --> 00:08:00,980
ya se empieza a parecer a código

202
00:08:00,980 --> 00:08:03,120
ah, vale, entonces la condición que tengo

203
00:08:03,120 --> 00:08:05,019
que poner aquí será una condición

204
00:08:05,019 --> 00:08:06,199
de tipo mayor que

205
00:08:06,199 --> 00:08:09,160
si se cumple esa condición

206
00:08:09,160 --> 00:08:11,139
entonces será true y si se cumple será falsa

207
00:08:11,139 --> 00:08:13,399
ah, vale, vale, entonces esto

208
00:08:13,399 --> 00:08:16,819
pues esta condición de aquí

209
00:08:16,819 --> 00:08:19,139
va a ser algo de este estilo

210
00:08:19,139 --> 00:08:20,819
si algo

211
00:08:20,819 --> 00:08:23,180
es mayor que algo

212
00:08:23,180 --> 00:08:28,129
si algo es mayor que algo

213
00:08:28,129 --> 00:08:30,910
me volverá true

214
00:08:30,910 --> 00:08:32,830
si no, false, entonces ya voy acotando

215
00:08:32,830 --> 00:08:35,070
ya tengo dos cajitas negras

216
00:08:35,070 --> 00:08:36,009
más pequeñitas

217
00:08:36,009 --> 00:08:38,970
dos cajitas negras más pequeñas

218
00:08:38,970 --> 00:08:39,889
por resolver

219
00:08:39,889 --> 00:08:41,889
esta y esta

220
00:08:41,889 --> 00:08:44,929
vale, pues entonces

221
00:08:44,929 --> 00:08:46,610
uno de los dos lados está claro

222
00:08:46,610 --> 00:08:47,750
¿qué me decía el enunciado?

223
00:08:48,470 --> 00:08:50,970
si el... a ver, voy a leerlo

224
00:08:50,970 --> 00:08:55,009
si el nombre tiene más caracteres

225
00:08:55,009 --> 00:08:57,169
que el número, vale, pues entonces

226
00:08:57,169 --> 00:09:00,529
esta cajita negra está clara, esta será número

227
00:09:00,529 --> 00:09:04,860
número, aquí será

228
00:09:04,860 --> 00:09:08,179
la cantidad de caracteres del nombre

229
00:09:08,179 --> 00:09:09,899
y aquí será el número

230
00:09:09,899 --> 00:09:12,559
esta está clara, será número, ¿verdad?

231
00:09:13,480 --> 00:09:16,279
a ver, me distraigo

232
00:09:16,279 --> 00:09:20,240
os escribís por señas por ahí, pero que no haga ruido

233
00:09:20,240 --> 00:09:22,220
porque es que yo no puedo hablar y oír ruido a la vez

234
00:09:22,220 --> 00:09:23,600
se me va el hilo

235
00:09:23,600 --> 00:09:28,799
vale, este ya lo hemos resuelto

236
00:09:28,799 --> 00:09:30,940
aquí será número, genial

237
00:09:30,940 --> 00:09:32,940
nos falta solo esta caja negra

238
00:09:32,940 --> 00:09:35,220
esta caja negra que tiene que ser

239
00:09:35,220 --> 00:09:37,320
el número de caracteres

240
00:09:37,320 --> 00:09:37,759
del nombre

241
00:09:37,759 --> 00:09:40,019
el número de caracteres del nombre

242
00:09:40,019 --> 00:09:43,139
uy, como averiguo yo el número de caracteres

243
00:09:43,139 --> 00:09:44,919
del nombre, anda, teníamos

244
00:09:44,919 --> 00:09:47,440
esa función len que hemos visto antes

245
00:09:47,440 --> 00:09:48,799
la teníamos

246
00:09:48,799 --> 00:09:50,580
ah, vale, que bien, pues la voy a usar

247
00:09:50,580 --> 00:09:52,440
la voy a usar

248
00:09:52,440 --> 00:09:54,639
y me digo

249
00:09:54,639 --> 00:09:56,840
venga, número de caracteres

250
00:09:56,840 --> 00:10:00,340
sabía que haciendo esto

251
00:10:00,340 --> 00:10:04,289
sé que una variable string

252
00:10:04,289 --> 00:10:06,629
puede llamar

253
00:10:06,629 --> 00:10:08,149
a esta funcionalidad

254
00:10:08,149 --> 00:10:09,850
me devuelve el número de caracteres

255
00:10:09,850 --> 00:10:10,669
que lo guardo en int

256
00:10:10,669 --> 00:10:12,730
justo lo que necesitaba

257
00:10:12,730 --> 00:10:15,429
pues ahora ya puedo poner aquí

258
00:10:15,429 --> 00:10:17,769
lo que me faltaba

259
00:10:17,769 --> 00:10:20,090
para completar mi cajita negra última

260
00:10:20,090 --> 00:10:23,259
no, no, no

261
00:10:23,259 --> 00:10:26,299
estoy estructurando el pensamiento paso por paso

262
00:10:26,299 --> 00:10:29,620
a ver

263
00:10:29,620 --> 00:10:31,159
un segundo

264
00:10:31,159 --> 00:10:32,460
esto está claro, ¿no?

265
00:10:32,919 --> 00:10:34,840
sobre todo lo que me interesa

266
00:10:34,840 --> 00:10:37,559
es que os deis cuenta

267
00:10:37,559 --> 00:10:40,240
del hilo de pensamiento que hemos seguido

268
00:10:40,240 --> 00:10:41,820
primero uno

269
00:10:41,820 --> 00:10:42,980
entiende el ejercicio

270
00:10:42,980 --> 00:10:44,580
datos de entrada, ¿cuáles son?

271
00:10:44,580 --> 00:10:46,279
tiene que tener un método de datos de entrada

272
00:10:46,279 --> 00:10:48,419
tipo de datos de cada uno

273
00:10:48,419 --> 00:10:49,399
y cómo leerlos

274
00:10:49,399 --> 00:10:51,720
y luego automáticamente se va al final

275
00:10:51,720 --> 00:10:54,019
y dice, pero, ¿y qué tiene que pasar aquí?

276
00:10:54,100 --> 00:10:54,899
¿Cuál tiene que ser el quinto?

277
00:10:55,759 --> 00:10:58,120
Pues en este caso era que en nuestro resultado

278
00:10:58,120 --> 00:11:00,320
y a partir de ahí hemos ido construyendo,

279
00:11:00,399 --> 00:11:01,960
hemos ido rellenando, ¿vale?

280
00:11:02,320 --> 00:11:03,480
Y hemos llegado a esto.

281
00:11:04,139 --> 00:11:06,039
Ahora ya nos podemos plantear

282
00:11:06,039 --> 00:11:08,340
reescribir este código en menos líneas.

283
00:11:09,200 --> 00:11:09,679
Pero da igual,

284
00:11:09,779 --> 00:11:11,200
ese efecto es de mirarlo con los ojos.

285
00:11:11,340 --> 00:11:12,679
A la máquina virtual le da lo mismo.

286
00:11:14,860 --> 00:11:16,379
Este código ya está bien.

287
00:11:19,100 --> 00:11:20,519
Entonces, lo que decía él,

288
00:11:21,559 --> 00:11:22,279
decía, a ver,

289
00:11:22,279 --> 00:11:25,279
yo sé que nombre.length

290
00:11:25,279 --> 00:11:27,279
es el número

291
00:11:27,279 --> 00:11:29,440
de caracteres, pues en lugar

292
00:11:29,440 --> 00:11:31,299
de guardar una variable, poner la variable aquí

293
00:11:31,299 --> 00:11:32,059
él dice

294
00:11:32,059 --> 00:11:35,080
voy a poner esto directamente

295
00:11:35,080 --> 00:11:35,659
aquí

296
00:11:35,659 --> 00:11:39,340
sí, pero vamos a

297
00:11:39,340 --> 00:11:41,200
dejarlo por ahora, vale

298
00:11:41,200 --> 00:11:43,399
lo ponéis ahí

299
00:11:43,399 --> 00:11:45,299
directamente y ya está

300
00:11:45,299 --> 00:11:45,740
pero

301
00:11:45,740 --> 00:11:50,460
sí, claro, es una sentencia

302
00:11:50,460 --> 00:11:57,539
Pero, ahora mismo vamos a olvidarnos de esto.

303
00:11:59,879 --> 00:12:02,059
Ahora mismo no lo vamos a olvidar, ¿vale?

304
00:12:03,080 --> 00:12:08,820
Estamos practicando desde el principio, desde lo muy básico y no vamos a liarnos, ¿vale?

305
00:12:12,730 --> 00:12:15,210
Bueno, pues ya está, ya tenemos nuestro programa hecho.

306
00:12:15,990 --> 00:12:19,529
Ahora que no tiene errores de compilación, uno le parece que está bien,

307
00:12:19,529 --> 00:12:22,230
Pues lo intenta ejecutar

308
00:12:22,230 --> 00:12:23,970
A ver si realmente hace lo que tiene que hacer

309
00:12:23,970 --> 00:12:30,450
Venga, le voy a dar un nombre

310
00:12:30,450 --> 00:12:31,470
Dos

311
00:12:31,470 --> 00:12:35,190
Pues true, efectivamente tiene más caracteres

312
00:12:35,190 --> 00:12:36,190
Que el número

313
00:12:36,190 --> 00:12:38,470
Lo vuelvo a ejecutar

314
00:12:38,470 --> 00:12:40,330
Introduzca un nombre

315
00:12:40,330 --> 00:12:42,029
Este

316
00:12:42,029 --> 00:12:44,350
Dieciséis

317
00:12:44,350 --> 00:12:47,230
Pues false, no tiene más caracteres

318
00:12:47,230 --> 00:12:49,009
Que el número

319
00:12:49,009 --> 00:12:50,289
Vale

320
00:12:50,289 --> 00:12:52,090
Muy bien

321
00:12:52,090 --> 00:12:56,620
¿Vale? ¿Esto entendido?

322
00:13:04,059 --> 00:13:05,360
Puede que a alguien

323
00:13:05,360 --> 00:13:07,220
Le haya salido

324
00:13:07,220 --> 00:13:08,820
En la ejecución

325
00:13:08,820 --> 00:13:10,440
Una cosa rara

326
00:13:10,440 --> 00:13:13,139
Porque ha leído las variables

327
00:13:13,139 --> 00:13:14,019
En otro orden

328
00:13:14,019 --> 00:13:17,159
¿Nadie ha leído las variables en otro orden?

329
00:13:19,200 --> 00:13:20,179
Vamos a probar

330
00:13:20,179 --> 00:13:21,460
Leerlas en otro orden

331
00:13:21,460 --> 00:13:22,419
Que en principio me da igual

332
00:13:22,419 --> 00:13:25,139
¿Qué más me da leer primero el nombre y luego el número?

333
00:13:25,299 --> 00:13:28,000
¿Qué más me da?

334
00:13:28,000 --> 00:13:30,200
vamos a hacer una versión

335
00:13:30,200 --> 00:13:31,700
en la que las leamos en otro orden

336
00:13:31,700 --> 00:13:38,289
es decir

337
00:13:38,289 --> 00:13:40,509
voy a comentar esto

338
00:13:40,509 --> 00:13:42,590
un momentito, voy a dejarlo

339
00:13:42,590 --> 00:13:43,909
ahí comentado un momentito

340
00:13:43,909 --> 00:13:45,889
y voy a hacer este código

341
00:13:45,889 --> 00:13:48,529
en otro orden

342
00:13:48,529 --> 00:13:51,210
a ver

343
00:13:51,210 --> 00:13:56,759
primero vamos a leer

344
00:13:56,759 --> 00:14:00,259
control x

345
00:14:00,259 --> 00:14:05,409
vale, vamos a leer primero el número

346
00:14:05,409 --> 00:14:06,889
y luego el nombre

347
00:14:06,889 --> 00:14:10,580
debería ser lo mismo, ¿no?

348
00:14:10,580 --> 00:14:11,220
¿Qué más nos da?

349
00:14:11,320 --> 00:14:13,240
Haber pedido primero el número y luego el nombre,

350
00:14:13,360 --> 00:14:14,860
que haber pedido primero el nombre y luego el número.

351
00:14:14,940 --> 00:14:15,480
¿Qué más nos da?

352
00:14:15,519 --> 00:14:16,299
Debería ser lo mismo.

353
00:14:17,120 --> 00:14:18,759
Una vez que ya hemos hecho la lectura,

354
00:14:20,159 --> 00:14:22,440
averiguamos de esta manera el número de caracteres,

355
00:14:22,480 --> 00:14:23,340
lo guardamos aquí.

356
00:14:24,179 --> 00:14:28,379
Ahora ya hacemos esta condición con el operador sencillo.

357
00:14:29,080 --> 00:14:32,320
El número es mayor que esto, pues me dará true o false,

358
00:14:32,460 --> 00:14:33,860
que se guarda en una variable booleana,

359
00:14:34,539 --> 00:14:35,460
que es una condición.

360
00:14:35,460 --> 00:14:37,159
Y ahora ya hemos dado la variable booleana y ya está.

361
00:14:38,600 --> 00:14:40,200
Vamos a ejecutar esta versión,

362
00:14:40,200 --> 00:14:43,059
que lo único que ha cambiado es el orden en el cual yo meto los datos.

363
00:14:48,139 --> 00:14:50,440
Introduzca número 87.

364
00:14:52,809 --> 00:14:56,710
Y no me ha dado opción a meter el nombre.

365
00:14:59,220 --> 00:15:00,539
Qué cosa más rara ha hecho, ¿verdad?

366
00:15:00,559 --> 00:15:02,679
Vamos a ejecutarlo otra vez, a ver si es que se me ha ido el dedo.

367
00:15:03,759 --> 00:15:05,100
Introduzca número 5.

368
00:15:06,320 --> 00:15:07,000
Introduzca nombre.

369
00:15:07,720 --> 00:15:10,799
No se queda esperando que introduzca el nombre y ya sale falso.

370
00:15:12,799 --> 00:15:13,159
¿Por?

371
00:15:14,460 --> 00:15:16,879
Es que no puedo, porque no se queda esperando

372
00:15:16,879 --> 00:15:17,759
a que ponga el carácter

373
00:15:17,759 --> 00:15:21,059
no puedo, yo cada vez que lo ejecuto

374
00:15:21,059 --> 00:15:22,639
aquí se queda esperando

375
00:15:22,639 --> 00:15:24,120
muy bien, yo le meto el número

376
00:15:24,120 --> 00:15:26,919
luego debería quedarse esperando al nombre

377
00:15:26,919 --> 00:15:28,480
y es que no se queda

378
00:15:28,480 --> 00:15:30,059
ya directamente pone falsa y cierra

379
00:15:30,059 --> 00:15:32,879
vale, ¿por qué es esto?

380
00:15:32,940 --> 00:15:33,539
os lo aviso

381
00:15:33,539 --> 00:15:37,179
esto es por una particularidad del funcionamiento

382
00:15:37,179 --> 00:15:37,899
del escáner

383
00:15:37,899 --> 00:15:40,399
que cuanto antes la conozcamos mejor

384
00:15:40,399 --> 00:15:41,519
para que no pase esto

385
00:15:41,519 --> 00:15:44,120
pues esta particularidad se da

386
00:15:44,120 --> 00:15:46,519
cuando usáis el escáner en un programa

387
00:15:46,519 --> 00:15:48,679
y leéis primero un número

388
00:15:48,679 --> 00:15:51,100
y luego una cadena

389
00:15:51,100 --> 00:15:53,240
solo en esa situación

390
00:15:53,240 --> 00:15:55,019
cuando leéis primero un número

391
00:15:55,019 --> 00:15:55,720
y luego una cadena

392
00:15:55,720 --> 00:15:57,500
¿qué es lo que está pasando?

393
00:15:58,220 --> 00:15:59,980
cuando el escáner lee un número

394
00:15:59,980 --> 00:16:01,679
nosotros metemos

395
00:16:01,679 --> 00:16:03,419
58, vale

396
00:16:03,419 --> 00:16:05,860
pero no solo estamos metiendo 58

397
00:16:05,860 --> 00:16:08,679
metemos 58 y hemos dado a enter después

398
00:16:08,679 --> 00:16:09,980
¿verdad? hemos dado a enter

399
00:16:09,980 --> 00:16:11,259
para que se coja el 58

400
00:16:11,259 --> 00:16:13,899
pero como este solo quiere un número

401
00:16:13,899 --> 00:16:15,919
se ha quedado con el número

402
00:16:15,919 --> 00:16:18,379
y el enter no lo ha recogido

403
00:16:18,379 --> 00:16:20,340
del buffer, se ha quedado en el buffer

404
00:16:20,340 --> 00:16:22,379
entonces cuando luego llega

405
00:16:22,379 --> 00:16:24,279
el next line, el next line

406
00:16:24,279 --> 00:16:26,340
va al buffer y el buffer ya tiene

407
00:16:26,340 --> 00:16:27,919
algo, que es el salto de línea

408
00:16:27,919 --> 00:16:29,919
anterior, entonces

409
00:16:29,919 --> 00:16:32,460
entiende que estamos metiendo la cadena vacía

410
00:16:32,460 --> 00:16:33,460
con un salto de línea

411
00:16:33,460 --> 00:16:35,960
y dice, ah, cadena vacía, y se queda con eso

412
00:16:35,960 --> 00:16:38,019
y mete en nombre la cadena vacía

413
00:16:38,019 --> 00:16:40,000
por eso nos da false todo el rato

414
00:16:40,000 --> 00:16:42,120
nos da false todo el rato porque

415
00:16:42,120 --> 00:16:43,559
el número siempre es mayor

416
00:16:43,559 --> 00:16:45,620
que el tamaño de la cadena vacía

417
00:16:45,620 --> 00:16:48,779
Entonces por eso nos da false todo el rato

418
00:16:48,779 --> 00:16:49,820
Entonces

419
00:16:49,820 --> 00:16:51,379
Esto que os digo

420
00:16:51,379 --> 00:16:52,940
Lo vamos a

421
00:16:52,940 --> 00:16:55,100
Vale

422
00:16:55,100 --> 00:16:59,240
Ojo si leemos

423
00:16:59,240 --> 00:17:01,820
Con escáner

424
00:17:01,820 --> 00:17:07,109
Una cadena

425
00:17:07,109 --> 00:17:09,329
Después de un número

426
00:17:09,329 --> 00:17:15,500
Porque que, que va a pasar

427
00:17:15,500 --> 00:17:20,650
El programa

428
00:17:20,650 --> 00:17:23,549
Va a coger

429
00:17:23,549 --> 00:17:25,529
Como cadena

430
00:17:25,529 --> 00:17:29,589
Una cadena vacía

431
00:17:29,589 --> 00:17:31,869
y va a seguir

432
00:17:31,869 --> 00:17:34,430
vale, metemos el número

433
00:17:34,430 --> 00:17:35,730
enter, el número llega

434
00:17:35,730 --> 00:17:38,150
pero luego ya el programa

435
00:17:38,150 --> 00:17:39,549
no se queda esperando una cadena

436
00:17:39,549 --> 00:17:40,990
porque ve que hay un enter en el buffer

437
00:17:40,990 --> 00:17:42,470
y dice, ah, pues va a ser esta la cadena

438
00:17:42,470 --> 00:17:45,289
y coge una cadena vacía, no se queda esperando

439
00:17:45,289 --> 00:17:47,960
entonces

440
00:17:47,960 --> 00:17:49,940
un segundo

441
00:17:49,940 --> 00:17:52,240
siempre podemos

442
00:17:52,240 --> 00:17:54,539
si yo puedo leer antes el nombre

443
00:17:54,539 --> 00:17:57,900
lo leo antes

444
00:17:57,900 --> 00:18:00,480
pero puedo tener un programa en el cual

445
00:18:00,480 --> 00:18:02,000
tenga que leer primero un número

446
00:18:02,000 --> 00:18:03,720
luego hacer cosas con el número

447
00:18:03,720 --> 00:18:04,880
luego leer la cadena

448
00:18:04,880 --> 00:18:06,859
y ahí es cuando le he fastidiado

449
00:18:06,859 --> 00:18:10,259
bueno, pues si detecto un programa en el que me está pasando eso

450
00:18:10,259 --> 00:18:12,119
que leo primero un número, luego hago lo que sea

451
00:18:12,119 --> 00:18:12,960
luego una cadena

452
00:18:12,960 --> 00:18:16,480
pues, ¿cómo arreglamos esto?

453
00:18:18,240 --> 00:18:20,000
como yo sé que después del número

454
00:18:20,000 --> 00:18:22,359
y antes de la cadena se ha quedado

455
00:18:22,359 --> 00:18:23,960
la cadena vacía

456
00:18:23,960 --> 00:18:26,460
hago una lectura así

457
00:18:26,460 --> 00:18:29,740
voy a ponerlo así, aunque luego lo tira a la basura

458
00:18:29,740 --> 00:18:39,799
next line

459
00:18:39,799 --> 00:18:41,400
vale

460
00:18:41,400 --> 00:18:44,640
agregando esto lo arreglo

461
00:18:44,640 --> 00:18:46,240
porque ahora que pasa

462
00:18:46,240 --> 00:18:48,759
leo el numerito, muy bien el numero va aquí

463
00:18:48,759 --> 00:18:50,500
y el enter se ha quedado ahí

464
00:18:50,500 --> 00:18:52,660
hago una lectura de una cadena

465
00:18:52,660 --> 00:18:54,799
esa ya no se va a quedar

466
00:18:54,799 --> 00:18:57,000
esperando y va a coger ese enter que se ha quedado ahí

467
00:18:57,000 --> 00:18:58,359
que lo he dejado yo de antes

468
00:18:58,359 --> 00:19:00,940
y lo recoge

469
00:19:00,940 --> 00:19:02,660
y me lo guarda aquí que no lo uso

470
00:19:02,660 --> 00:19:04,759
para nada y ahora ya si

471
00:19:04,759 --> 00:19:06,000
que el buffer está limpio

472
00:19:06,000 --> 00:19:08,539
entonces al estar limpio el buffer cuando llegue aquí

473
00:19:08,539 --> 00:19:10,140
ahora ya sí que se va a quedar esperando

474
00:19:10,140 --> 00:19:12,339
¿vale? porque esta

475
00:19:12,339 --> 00:19:14,680
ha limpiado el buffer de ese salto de línea

476
00:19:14,680 --> 00:19:16,619
que dejó la lectura de números

477
00:19:16,619 --> 00:19:18,140
¿vale?

478
00:19:18,559 --> 00:19:20,400
los next line no dejan

479
00:19:20,400 --> 00:19:22,299
en el buffer el salto de línea, no lo dejan

480
00:19:22,299 --> 00:19:24,539
luego uno puede leer tantos next line seguidos

481
00:19:24,539 --> 00:19:25,640
como quiera, no los deja

482
00:19:25,640 --> 00:19:28,380
pero este sí que deja

483
00:19:28,380 --> 00:19:29,819
un salto de línea en el buffer

484
00:19:29,819 --> 00:19:34,299
entonces si nosotros ejecutamos esta versión del programa

485
00:19:34,299 --> 00:19:37,859
esta sí que nos va a funcionar bien

486
00:19:37,859 --> 00:19:39,359
introduzca números

487
00:19:39,359 --> 00:19:41,299
76, ¿veis? Introduzca nombre

488
00:19:41,299 --> 00:19:42,859
patatín, ¿vale?

489
00:19:44,480 --> 00:19:45,539
Pero hemos tenido que poner

490
00:19:45,539 --> 00:19:46,599
esta sentencia tan tonta

491
00:19:46,599 --> 00:19:51,299
de hecho es tan tonta que estoy usando una variable

492
00:19:51,299 --> 00:19:53,059
que luego no me sirve

493
00:19:53,059 --> 00:19:54,880
para nada, pues lo normal

494
00:19:54,880 --> 00:19:56,259
es que ni la use

495
00:19:56,259 --> 00:19:58,099
porque yo puedo

496
00:19:58,099 --> 00:19:59,680
llamar a este método

497
00:19:59,680 --> 00:20:02,880
y decidir que el valor de retorno

498
00:20:02,880 --> 00:20:04,920
la máquina virtual lo tire

499
00:20:04,920 --> 00:20:05,579
a la basura

500
00:20:05,579 --> 00:20:07,920
y eso lo puedo hacer así

501
00:20:07,920 --> 00:20:14,380
¿esto qué hace?

502
00:20:14,859 --> 00:20:17,059
hace este método, lee el valor

503
00:20:17,059 --> 00:20:19,559
y cuando la máquina virtual va a asignarlo

504
00:20:19,559 --> 00:20:21,140
a algún sitio, dice

505
00:20:21,140 --> 00:20:23,500
uy, no me has dicho dónde, pues a la basura

506
00:20:23,500 --> 00:20:25,880
y ya está, no pasa nada, lo tira a la basura

507
00:20:25,880 --> 00:20:27,380
como no le hemos dicho

508
00:20:27,380 --> 00:20:29,299
nombre, ¿dónde? a la basura

509
00:20:29,299 --> 00:20:31,480
y realmente es lo que queremos

510
00:20:31,480 --> 00:20:33,440
que lo tire a la basura, porque ese salto de línea

511
00:20:33,440 --> 00:20:35,079
de cadena vacía no lo queremos para nada

512
00:20:35,079 --> 00:20:36,940
luego ahora mismo

513
00:20:36,940 --> 00:20:39,799
aparte de entender lo que hay por dentro

514
00:20:39,799 --> 00:20:41,859
que más o menos yo creo que más o menos lo entendemos

515
00:20:41,859 --> 00:20:43,819
lo único que quiero es

516
00:20:43,819 --> 00:20:46,380
que quede claro que si en algún momento

517
00:20:46,380 --> 00:20:48,140
os comunicáis con un programa leyendo

518
00:20:48,140 --> 00:20:49,920
números y cadenas, pues

519
00:20:49,920 --> 00:20:52,299
identificáis una secuencia de lecturas

520
00:20:52,299 --> 00:20:54,079
en la que primero leáis un

521
00:20:54,079 --> 00:20:55,500
número y luego una cadena

522
00:20:55,500 --> 00:20:57,619
acordaos de meter esto en medio

523
00:20:57,619 --> 00:20:59,980
porque si no va a pasar ese efecto que

524
00:20:59,980 --> 00:21:01,819
hemos dicho antes. ¿Vale?

525
00:21:08,789 --> 00:21:08,990
¿Eh?

526
00:21:10,650 --> 00:21:13,890
No, no, no, porque es que no puedes poner

527
00:21:13,890 --> 00:21:15,950
dos flujos a un mismo recurso porque uno

528
00:21:15,950 --> 00:21:17,130
te lo bloquea. No, no.

529
00:21:17,849 --> 00:21:18,710
Un único escáner.

530
00:21:19,930 --> 00:21:23,069
Dos escáneres asociados al mismo recurso

531
00:21:23,069 --> 00:21:25,250
No, o sea, asociados a otros recursos

532
00:21:25,250 --> 00:21:26,210
Sí, pero al teclado no

533
00:21:26,210 --> 00:21:28,130
Porque tendrían una

534
00:21:28,130 --> 00:21:29,750
Una colisión

535
00:21:29,750 --> 00:21:34,869
Claro, system.in es el nombre que Java

536
00:21:34,869 --> 00:21:36,710
Le da a la entrada por defecto

537
00:21:36,710 --> 00:21:38,069
Que es la consola

538
00:21:38,069 --> 00:21:41,069
Pero tú un escáner podrías asociarlo a otra cosa

539
00:21:41,069 --> 00:21:44,609
A ficheros

540
00:21:44,609 --> 00:21:47,250
A builders de string

541
00:21:47,250 --> 00:21:50,930
A cualquier cosa que sea un flujo de datos

542
00:21:50,930 --> 00:21:51,470
Para Java

543
00:21:51,470 --> 00:21:58,519
No, aún a fondo

544
00:21:58,519 --> 00:22:00,680
Porque para leer una base de datos lo tienes que hacer

545
00:22:00,680 --> 00:22:02,819
Con un conector JDBC que es otra cosa

546
00:22:02,819 --> 00:22:05,400
A una base de datos no

547
00:22:05,400 --> 00:22:07,539
A un fichero podrías asociarlo

548
00:22:07,539 --> 00:22:11,440
Venga, bueno, hemos asumido que nos vamos