1
00:00:00,000 --> 00:00:03,500
Venga, pues vamos a hacerlo

2
00:00:03,500 --> 00:00:07,019
Y ya nos quitamos esto de en medio

3
00:00:07,019 --> 00:00:07,759
Vale

4
00:00:07,759 --> 00:00:10,560
Venga, a ver si sacamos algo interesante

5
00:00:10,560 --> 00:00:13,060
Bueno, clase alumno

6
00:00:13,060 --> 00:00:15,599
Pues ala, alumno es con lo que vamos a trabajar

7
00:00:15,599 --> 00:00:17,660
Paquete nuestro

8
00:00:17,660 --> 00:00:18,640
Con el modelo

9
00:00:18,640 --> 00:00:19,559
Pues venga

10
00:00:19,559 --> 00:00:26,780
El modelo solamente tiene

11
00:00:26,780 --> 00:00:28,780
Una entidad, alumno, pues alumno

12
00:00:28,780 --> 00:00:39,219
Las propiedades serán

13
00:00:39,219 --> 00:00:40,979
Nombre y

14
00:00:40,979 --> 00:00:42,700
año de nacimiento, ¿verdad?

15
00:00:45,600 --> 00:00:46,340
pues ya está

16
00:00:46,340 --> 00:01:02,700
nacimiento, ala, ya está

17
00:01:02,700 --> 00:01:05,599
¿vale?

18
00:01:07,659 --> 00:01:09,859
ahora lo de siempre, get, set

19
00:01:09,859 --> 00:01:12,019
¿vale? nosotros hacemos de corrido

20
00:01:12,019 --> 00:01:14,040
siempre un montón de cosas, los get y los set

21
00:01:14,040 --> 00:01:16,280
porque realmente los get y los set

22
00:01:16,280 --> 00:01:17,200
son el estándar

23
00:01:17,200 --> 00:01:19,980
es la forma que nosotros

24
00:01:19,980 --> 00:01:21,299
publicamos

25
00:01:21,299 --> 00:01:23,920
dicho en palabras

26
00:01:23,920 --> 00:01:25,700
más técnicas, exponemos

27
00:01:25,700 --> 00:01:26,819
nuestra entidad

28
00:01:26,819 --> 00:01:29,760
vale, exponer en este contexto

29
00:01:29,760 --> 00:01:31,700
nuestro de desarrollo, significa

30
00:01:31,700 --> 00:01:33,780
que es lo que hacemos visible

31
00:01:33,780 --> 00:01:35,159
al exterior, pues estamos

32
00:01:35,159 --> 00:01:37,680
exponiendo nuestras propiedades con

33
00:01:37,680 --> 00:01:39,099
los getter y los setter, vale

34
00:01:39,099 --> 00:01:40,959
lo hacemos de corrido y ya está

35
00:01:40,959 --> 00:01:43,439
lo ponemos ahí y se acabó

36
00:01:43,439 --> 00:01:45,819
luego esto admite

37
00:01:45,819 --> 00:01:48,159
esto lo menciono

38
00:01:48,159 --> 00:01:49,859
simplemente pues para que se nos vaya

39
00:01:49,859 --> 00:01:52,120
quedando como ahí en el, yo que sé, como rondando

40
00:01:52,120 --> 00:01:53,980
vale, porque luego de repente

41
00:01:53,980 --> 00:01:55,579
van apareciendo las cosas

42
00:01:55,579 --> 00:01:58,299
en segundos sí que nos encontraremos ya

43
00:01:58,299 --> 00:02:00,340
al tener proyectos más complejos

44
00:02:00,340 --> 00:02:02,319
pues con la opción de hacer las cosas de otra manera

45
00:02:02,319 --> 00:02:04,340
entonces veis

46
00:02:04,340 --> 00:02:06,379
que generar los get y los setters

47
00:02:06,379 --> 00:02:07,719
desde el entorno

48
00:02:07,719 --> 00:02:10,080
afortunadamente fácil

49
00:02:10,080 --> 00:02:12,460
pero no deja de ser un chorizo de métodos

50
00:02:12,460 --> 00:02:14,020
que están ahí puestos, ¿vale?

51
00:02:14,080 --> 00:02:16,580
pues entonces hay cosas como

52
00:02:16,580 --> 00:02:18,719
long box, records

53
00:02:18,719 --> 00:02:19,180
cosas

54
00:02:19,180 --> 00:02:22,120
que te permiten trabajar con ellos

55
00:02:22,120 --> 00:02:24,020
como si estuvieran ahí aunque no estén

56
00:02:24,020 --> 00:02:26,120
¿Vale? Entonces vosotros

57
00:02:26,120 --> 00:02:28,680
A lo mejor le pedís cosas a CharGPT

58
00:02:28,680 --> 00:02:30,680
Y os saca clases que no tienen

59
00:02:30,680 --> 00:02:32,620
Getter y Setter, pero luego sí que se están llamando

60
00:02:32,620 --> 00:02:33,800
Desde fuera, ¿esto qué pasa?

61
00:02:34,120 --> 00:02:36,599
Bueno, pues que sepáis que existen Lombok, existen

62
00:02:36,599 --> 00:02:37,860
Record, existen cosas que

63
00:02:37,860 --> 00:02:40,419
Hacen que esos Getter y Setter estén

64
00:02:40,419 --> 00:02:41,500
Aunque no los veamos

65
00:02:41,500 --> 00:02:44,080
Bueno, solamente por

66
00:02:44,080 --> 00:02:45,319
Mencionarlo

67
00:02:45,319 --> 00:02:48,060
Vale, pero no estamos en ello

68
00:02:48,060 --> 00:02:52,370
Nosotros, ni es algo

69
00:02:52,370 --> 00:02:53,770
Tampoco especialmente común

70
00:02:53,770 --> 00:02:56,669
lo generamos

71
00:02:56,669 --> 00:02:58,150
y se acabó, este es mi alumno

72
00:02:58,150 --> 00:03:00,150
vale, pues este alumno

73
00:03:00,150 --> 00:03:02,550
en lugar de

74
00:03:02,550 --> 00:03:04,250
esta aplicación

75
00:03:04,250 --> 00:03:06,229
en lugar de

76
00:03:06,229 --> 00:03:08,409
ofrecer, crear los alumnos con

77
00:03:08,409 --> 00:03:08,969
constructor

78
00:03:08,969 --> 00:03:12,349
ofrece un método, crear alumno

79
00:03:12,349 --> 00:03:14,370
no ofrece un constructor para ello

80
00:03:14,370 --> 00:03:16,370
vale, entonces

81
00:03:16,370 --> 00:03:18,110
eso, que parece una tontería

82
00:03:18,110 --> 00:03:19,389
pero tiene mucho sentido

83
00:03:19,389 --> 00:03:22,229
normalmente los frameworks que hacen cosas

84
00:03:22,229 --> 00:03:24,610
ya está como bastante

85
00:03:24,610 --> 00:03:26,430
abandonado instanciar

86
00:03:26,430 --> 00:03:28,509
los objetos con el constructor directamente

87
00:03:28,509 --> 00:03:30,770
¿vale? es relativamente

88
00:03:30,770 --> 00:03:32,789
habitual, tú te haces tu clase

89
00:03:32,789 --> 00:03:34,629
y la forma en la

90
00:03:34,629 --> 00:03:36,689
que ofreces a los demás instanciar

91
00:03:36,689 --> 00:03:38,550
tus objetos no es directamente con

92
00:03:38,550 --> 00:03:40,430
new, con el constructor, sino

93
00:03:40,430 --> 00:03:41,569
ofreces tu método

94
00:03:41,569 --> 00:03:44,270
en este caso, crear alumno

95
00:03:44,270 --> 00:03:46,189
para crearlos, y en ese método pues

96
00:03:46,189 --> 00:03:48,389
a lo mejor lo aprovechas para hacer validaciones

97
00:03:48,389 --> 00:03:50,389
para hacer cosas, pues bueno

98
00:03:50,389 --> 00:03:51,849
Ya que ha surgido con este ejercicio

99
00:03:51,849 --> 00:03:52,590
Vamos a hacerlo así

100
00:03:52,590 --> 00:03:56,069
¿Vale? Vamos a hacer que el usuario que quiera

101
00:03:56,069 --> 00:03:58,210
Crear un alumno lo tenga que hacer obligatoriamente

102
00:03:58,210 --> 00:03:59,069
Con este método

103
00:03:59,069 --> 00:04:02,050
Dígame

104
00:04:02,050 --> 00:04:05,569
Sí

105
00:04:05,569 --> 00:04:08,150
Sí, sí, es un método más

106
00:04:08,150 --> 00:04:22,589
No lo sé, pero lo vamos a quitar

107
00:04:22,589 --> 00:04:23,990
¿Vale?

108
00:04:24,629 --> 00:04:26,189
Ahora miramos el enunciado

109
00:04:26,189 --> 00:04:27,829
Pero a ver si

110
00:04:27,829 --> 00:04:30,829
Incluir el constructor correspondiente

111
00:04:30,829 --> 00:04:39,829
Crear alumno

112
00:04:39,829 --> 00:04:41,329
Venga, pues entonces

113
00:04:41,329 --> 00:04:43,129
¿Qué haría este?

114
00:04:43,310 --> 00:04:44,250
Pues efectivamente

115
00:04:44,250 --> 00:04:51,639
Si el año pasado

116
00:04:51,639 --> 00:04:53,600
Fuera negativo, devuelve objeto nulo

117
00:04:53,600 --> 00:04:54,420
¿Vale?

118
00:04:57,399 --> 00:04:59,019
Si nacimiento

119
00:04:59,019 --> 00:05:03,480
Menor que cero

120
00:05:03,480 --> 00:05:06,459
Return nul

121
00:05:06,459 --> 00:05:08,680
Y en cualquier otro caso

122
00:05:08,680 --> 00:05:10,240
Incluso cero

123
00:05:10,240 --> 00:05:12,779
Pues devuelve al alumno

124
00:05:12,779 --> 00:05:15,000
Pues entonces aquí lo podemos hacer

125
00:05:15,000 --> 00:05:15,579
Aquí, ¿verdad?

126
00:05:16,160 --> 00:05:17,980
New alumno

127
00:05:17,980 --> 00:05:22,149
Y ahora, new alumno

128
00:05:22,149 --> 00:05:24,389
Si yo quiero hacerlo así, tengo que

129
00:05:24,389 --> 00:05:25,569
Efectivamente

130
00:05:25,569 --> 00:05:27,990
Incluir aquí un constructor

131
00:05:27,990 --> 00:05:30,209
Para poder llamarlo, o sea, si yo quiero

132
00:05:30,209 --> 00:05:31,269
Pasarle estos parámetros

133
00:05:31,269 --> 00:05:34,230
Yo por comodidad quiero hacer este crear alumno

134
00:05:34,230 --> 00:05:34,889
Así, ¿verdad?

135
00:05:39,290 --> 00:05:39,769
Nacimiento

136
00:05:39,769 --> 00:05:42,550
vale, entonces si yo quiero aquí

137
00:05:42,550 --> 00:05:47,529
devolver el objeto ya con estos parámetros

138
00:05:47,529 --> 00:05:51,689
pues entonces me voy a hacer aquí mi constructor

139
00:05:51,689 --> 00:05:57,439
vale, bueno, lo voy a generar directamente y ya está

140
00:05:57,439 --> 00:06:11,519
vale, entonces ahora pregunto yo por preguntar

141
00:06:11,519 --> 00:06:15,420
a ver, podría no haberme hecho este constructor

142
00:06:15,420 --> 00:06:19,519
y entonces aquí tendría, me hago con el new alumno por defecto

143
00:06:19,519 --> 00:06:22,420
le pongo las propiedades con el set

144
00:06:22,420 --> 00:06:24,319
y luego ya lo devuelvo

145
00:06:24,319 --> 00:06:25,279
pero

146
00:06:25,279 --> 00:06:27,819
esto si a primera vista es una tontería

147
00:06:27,819 --> 00:06:30,319
me he hecho crear alumno

148
00:06:30,319 --> 00:06:32,259
para, con la idea de que

149
00:06:32,259 --> 00:06:34,399
la gente que me use a mí y crea alumnos

150
00:06:34,399 --> 00:06:35,420
lo haga con este método

151
00:06:35,420 --> 00:06:37,759
pero para hacer este método

152
00:06:37,759 --> 00:06:40,199
me he creado el constructor para poder

153
00:06:40,199 --> 00:06:42,319
llamarlo desde aquí, pasándole los dos parámetros

154
00:06:42,319 --> 00:06:44,180
y que fuera más cómodo, con lo cual

155
00:06:44,180 --> 00:06:45,519
ya estoy aquí ofreciendo el constructor

156
00:06:45,519 --> 00:06:47,939
¿vale? ¿qué puedo hacer?

157
00:06:49,519 --> 00:06:51,120
¿Para ofrecer solo este método?

158
00:06:55,360 --> 00:06:56,939
No, no voy a eso.

159
00:06:57,019 --> 00:06:59,420
¿Qué puedo hacer para ofrecer solo este método

160
00:06:59,420 --> 00:07:00,660
y no el constructor?

161
00:07:05,410 --> 00:07:06,370
Hacerlo privado.

162
00:07:09,399 --> 00:07:10,220
A esto me refería.

163
00:07:10,300 --> 00:07:11,759
No sé si esta vez pensaba algo más retorcido.

164
00:07:12,540 --> 00:07:15,259
Los constructores privados no son nada del otro mundo.

165
00:07:16,139 --> 00:07:17,620
Los constructores privados

166
00:07:17,620 --> 00:07:19,899
solamente los puedo usar yo

167
00:07:19,899 --> 00:07:21,740
desde métodos propios de mi propia clase.

168
00:07:22,300 --> 00:07:23,160
Entonces, de esta manera,

169
00:07:23,860 --> 00:07:25,959
nadie me va a poder instanciar nunca con new.

170
00:07:26,160 --> 00:07:28,379
Nunca jamás nadie me va a poder instanciar nunca con new.

171
00:07:28,379 --> 00:07:29,879
porque el único constructor que hay

172
00:07:29,879 --> 00:07:31,160
es privado

173
00:07:31,160 --> 00:07:34,220
entonces desde fuera de esa clase

174
00:07:34,220 --> 00:07:35,860
nadie me va a poder instanciar con new

175
00:07:35,860 --> 00:07:37,660
que es algo que yo puedo querer

176
00:07:37,660 --> 00:07:38,779
y muchas veces lo querré

177
00:07:38,779 --> 00:07:40,939
que alguien quiere crear alumnos

178
00:07:40,939 --> 00:07:42,959
tendrá que hacerlo con este método

179
00:07:42,959 --> 00:07:44,300
crear alumno

180
00:07:44,300 --> 00:07:46,540
que este sí que es public

181
00:07:46,540 --> 00:07:49,019
y yo aquí ya hago lo que quiera

182
00:07:49,019 --> 00:07:50,480
pues valido los datos

183
00:07:50,480 --> 00:07:51,800
lo podría hacer el constructor

184
00:07:51,800 --> 00:07:55,759
pero una arquitectura

185
00:07:55,759 --> 00:07:57,360
relativamente habitual es esa

186
00:07:57,360 --> 00:07:59,639
los constructores son privados

187
00:07:59,639 --> 00:08:01,699
están de apoyo para métodos

188
00:08:01,699 --> 00:08:03,540
que ya con el nombre créame alumno

189
00:08:03,540 --> 00:08:05,759
son los que ya ofrezco yo

190
00:08:05,759 --> 00:08:07,319
para hacer las cosas

191
00:08:07,319 --> 00:08:11,230
esto en el fondo tiene un nombre

192
00:08:11,230 --> 00:08:13,310
que es el patrón

193
00:08:13,310 --> 00:08:14,370
factoría en realidad

194
00:08:14,370 --> 00:08:16,910
es decir, hay una cosa

195
00:08:16,910 --> 00:08:18,970
que se llaman patrones de diseño

196
00:08:18,970 --> 00:08:21,509
que son formas de diseñar aplicaciones

197
00:08:21,509 --> 00:08:22,829
formas de diseñar

198
00:08:22,829 --> 00:08:25,250
¿cuántas formas de diseñar una aplicación hay?

199
00:08:25,370 --> 00:08:26,610
200.000 millones

200
00:08:26,610 --> 00:08:28,930
vale, pero algunas

201
00:08:28,930 --> 00:08:31,810
siguen ciertas pautas, están estandarizadas

202
00:08:31,810 --> 00:08:33,450
entonces esas formas

203
00:08:33,450 --> 00:08:35,350
relativamente estandarizadas

204
00:08:35,350 --> 00:08:36,509
de diseñar aplicaciones

205
00:08:36,509 --> 00:08:38,669
son los patrones de diseño

206
00:08:38,669 --> 00:08:42,049
hay un montón de patrones de diseño

207
00:08:42,049 --> 00:08:43,710
patrón DAO, patrón Singleton

208
00:08:43,710 --> 00:08:44,629
patrón no sé qué

209
00:08:44,629 --> 00:08:46,049
cada uno se ocupa

210
00:08:46,049 --> 00:08:48,610
de consejos

211
00:08:48,610 --> 00:08:51,350
sobre cómo diseñar

212
00:08:51,350 --> 00:08:52,350
partes concretas

213
00:08:52,350 --> 00:08:53,389
la parte de la pesadilla

214
00:08:53,389 --> 00:08:56,990
bueno, todo esto lo digo un poco

215
00:08:56,990 --> 00:08:59,009
por cultura general

216
00:08:59,009 --> 00:09:00,149
por ahora, ¿vale?

217
00:09:00,370 --> 00:09:02,789
Bueno, pues aquí he diseñado siguiendo

218
00:09:02,789 --> 00:09:04,090
sin saberlo en realidad

219
00:09:04,090 --> 00:09:06,549
siguiendo un patrón de diseño muy común

220
00:09:06,549 --> 00:09:08,450
¿vale?

221
00:09:08,490 --> 00:09:10,789
que es un patrón que se ocupa de cómo

222
00:09:10,789 --> 00:09:13,049
crear objetos, pues un patrón

223
00:09:13,049 --> 00:09:14,470
de diseño te dice, oye

224
00:09:14,470 --> 00:09:16,710
ofrece métodos propios

225
00:09:16,710 --> 00:09:18,629
para crearlo, oculta

226
00:09:18,629 --> 00:09:20,710
los constructores y usa los de apoyo

227
00:09:20,710 --> 00:09:22,049
para dentro de esos métodos, claro

228
00:09:22,049 --> 00:09:24,629
esto en realidad, esta tontería es un

229
00:09:24,629 --> 00:09:26,029
patrón de diseño de los

230
00:09:26,029 --> 00:09:28,870
Bueno, pues entonces

231
00:09:28,870 --> 00:09:36,730
Son clases más antiguas

232
00:09:36,730 --> 00:09:38,889
Bueno, y no siempre

233
00:09:38,889 --> 00:09:40,850
Se siguen ciertos patrones de diseño

234
00:09:40,850 --> 00:09:42,830
Según si conviene o no conviene

235
00:09:42,830 --> 00:09:54,100
Bueno, a ver

236
00:09:54,100 --> 00:09:56,919
El parámetro le llama al alumno en vez de nombre

237
00:09:56,919 --> 00:09:57,559
Pero da igual

238
00:09:57,559 --> 00:10:00,120
¿Qué más da? Mientras sea un estil

239
00:10:00,120 --> 00:10:02,279
Y lo pases correctamente, a ver si te aclaras mejor

240
00:10:02,279 --> 00:10:04,740
Llamándolo nombre, pero vamos que eso es lo de menos

241
00:10:04,740 --> 00:10:06,720
No, es que arriba lo llamaste

242
00:10:06,720 --> 00:10:07,580
No me lo estaba por eso

243
00:10:07,580 --> 00:10:10,159
Claro, pero que da igual como lo llame yo, da lo mismo

244
00:10:10,159 --> 00:10:12,080
Lo puedo llamar como quiera

245
00:10:12,080 --> 00:10:15,399
Vale

246
00:10:15,399 --> 00:10:18,059
Vale, pues entonces ya tenemos nuestro

247
00:10:18,059 --> 00:10:20,379
Entidad alumno que no le queda

248
00:10:20,379 --> 00:10:21,899
Más remedio que crearse así

249
00:10:21,899 --> 00:10:24,059
Vale

250
00:10:24,059 --> 00:10:25,860
Y ahora la clase principal

251
00:10:25,860 --> 00:10:27,419
Pues crea alumnos

252
00:10:27,419 --> 00:10:30,240
Venga

253
00:10:30,240 --> 00:10:35,330
Pues vamos a hacer la clase main

254
00:10:35,330 --> 00:10:36,730
En un paquete main

255
00:10:36,730 --> 00:10:45,559
Aquí tenemos nuestra

256
00:10:45,559 --> 00:10:46,539
Aplicación

257
00:10:46,539 --> 00:10:51,519
De alumnos, vale

258
00:10:51,519 --> 00:10:55,480
¿Qué va a hacer esta aplicación?

259
00:10:57,779 --> 00:10:58,259
Rellenar

260
00:10:58,259 --> 00:10:59,399
Un array, bueno

261
00:10:59,399 --> 00:11:00,259
Más que un array

262
00:11:00,259 --> 00:11:02,460
Vamos a hacer un mapa

263
00:11:02,460 --> 00:11:04,500
Vamos a hacer un map, ¿no?

264
00:11:04,639 --> 00:11:05,720
En lugar de meterlo en un array

265
00:11:05,720 --> 00:11:09,539
Lo vamos a meter en un map y así tiene un poquito más de interés

266
00:11:09,539 --> 00:11:11,019
Entonces

267
00:11:11,019 --> 00:11:14,120
¿Cuántos alumnos? Pues unos cuantos

268
00:11:14,120 --> 00:11:17,279
Vamos a pedirlo primero

269
00:11:17,279 --> 00:11:19,679
Uy, no he puesto

270
00:11:19,679 --> 00:11:20,539
Todo

271
00:11:20,539 --> 00:11:23,919
¿Cómo?

272
00:11:29,460 --> 00:11:30,860
Bueno, ¿cuántos va a haber en el mapa?

273
00:11:31,039 --> 00:11:32,580
El mapa es una caja de alumnos

274
00:11:32,580 --> 00:11:34,659
Tendría que decir cuántos quiero

275
00:11:34,659 --> 00:11:36,960
Igual que si con una lista, una RAI

276
00:11:36,960 --> 00:11:38,580
No entiendo la pregunta

277
00:11:38,580 --> 00:11:40,980
O sea, map es la forma de guardarlos

278
00:11:40,980 --> 00:11:42,980
¿Pero cuántos guarde?

279
00:11:43,039 --> 00:11:44,360
Pues puedo guardar 20, 30

280
00:11:44,360 --> 00:11:45,139
No sé

281
00:11:45,139 --> 00:11:47,340
Claro, pero no tiene un límite, ¿no?

282
00:11:47,460 --> 00:11:48,580
O sea, puede para lo que quiera.

283
00:11:49,019 --> 00:11:49,399
Claro.

284
00:11:50,500 --> 00:11:52,659
Ah, bueno, lo dices por el espacio a reservar.

285
00:11:52,860 --> 00:11:57,580
Ah, no, por el for, por luego en el for, vale.

286
00:11:59,100 --> 00:12:00,980
Para no hacerlo por condición de finalización,

287
00:12:01,080 --> 00:12:02,299
cuando meta fin, que es más pesado.

288
00:12:02,840 --> 00:12:02,960
Sí.

289
00:12:03,179 --> 00:12:04,960
¿Cómo haces a crear alumnos

290
00:12:04,960 --> 00:12:06,259
si no tienes un objeto para crear?

291
00:12:07,139 --> 00:12:08,919
¿Cómo que no tienes un objeto para crear, no?

292
00:12:08,980 --> 00:12:10,100
O sea, porque ahora has hecho stand-in,

293
00:12:10,120 --> 00:12:12,360
necesitas un objeto para crear a ese método, ¿no?

294
00:12:13,100 --> 00:12:14,279
Sí, tienes razón.

295
00:12:14,279 --> 00:12:16,019
A ver, no sería un problema

296
00:12:16,019 --> 00:12:17,159
Puedo yo crear un

297
00:12:17,159 --> 00:12:20,080
Efectivamente, tienes toda la razón

298
00:12:20,080 --> 00:12:22,059
Muy bien, muy bien visto, claro

299
00:12:22,059 --> 00:12:23,820
Si no lo hago estático

300
00:12:23,820 --> 00:12:25,659
Lógicamente es una tontería esto

301
00:12:25,659 --> 00:12:28,220
Si no lo hago estático, solamente puedo llamarlo

302
00:12:28,220 --> 00:12:29,480
Con un objeto alumno

303
00:12:29,480 --> 00:12:31,519
Y es que no voy a poder crearlo

304
00:12:31,519 --> 00:12:33,639
Porque no tengo ningún constructor visible

305
00:12:33,639 --> 00:12:36,080
Entonces efectivamente es que este método

306
00:12:36,080 --> 00:12:37,779
Su objetivo es ser estático

307
00:12:37,779 --> 00:12:40,299
Claro, tienes razón, sí, sí, sí

308
00:12:40,299 --> 00:12:41,940
Se me ha escapado el estático

309
00:12:41,940 --> 00:12:44,539
hoy no estás dormido

310
00:12:44,539 --> 00:12:48,759
mira que raro

311
00:12:48,759 --> 00:12:50,340
pero vamos

312
00:12:50,340 --> 00:13:14,789
venga, nuestros alumnos van a estar aquí

313
00:13:14,789 --> 00:13:15,429
metidos

314
00:13:15,429 --> 00:13:18,350
en este map

315
00:13:18,350 --> 00:13:28,580
venga, vamos a

316
00:13:28,580 --> 00:13:31,059
meterlo en new hash map

317
00:13:31,059 --> 00:13:38,710
A ver, repito

318
00:13:38,710 --> 00:13:41,389
Vamos a cambiar, en lugar de meterlos en un array

319
00:13:41,389 --> 00:13:43,149
Vamos a meterlos en un map

320
00:13:43,149 --> 00:13:44,710
Entonces para meterlos en un map

321
00:13:44,710 --> 00:13:46,789
Cada alumno

322
00:13:46,789 --> 00:13:49,850
Se corresponde con un par

323
00:13:49,850 --> 00:13:52,049
La clave, lo que lo identifica de forma única

324
00:13:52,049 --> 00:13:52,549
Y el valor

325
00:13:52,549 --> 00:13:53,929
El valor está claro cuál va a ser

326
00:13:53,929 --> 00:13:55,210
El propio objeto alumno

327
00:13:55,210 --> 00:13:57,509
La clave cuál va a ser

328
00:13:57,509 --> 00:13:59,669
Lo que lo identifique de forma única

329
00:13:59,669 --> 00:14:01,909
El alumno sólo se caracteriza

330
00:14:01,909 --> 00:14:03,929
según mi aplicación, que es una aplicación muy cutre

331
00:14:03,929 --> 00:14:04,909
solo para ver excepciones

332
00:14:04,909 --> 00:14:07,889
el alumno de él solamente tengo como datos

333
00:14:07,889 --> 00:14:08,769
nombre y nacimiento

334
00:14:08,769 --> 00:14:12,350
uno de los dos tendrá que funcionar de clave primaria

335
00:14:12,350 --> 00:14:14,230
no tiene sentido que sea el nacimiento

336
00:14:14,230 --> 00:14:15,570
lógicamente, pues el nombre

337
00:14:15,570 --> 00:14:18,269
pues entonces la clave primaria de mi map

338
00:14:18,269 --> 00:14:19,509
va a ser un stream

339
00:14:19,509 --> 00:14:22,450
el nombre del alumno

340
00:14:22,450 --> 00:14:24,289
y el valor es el alumno enterito

341
00:14:24,289 --> 00:14:28,840
estos son

342
00:14:28,840 --> 00:14:31,220
es imposible de coger ese stream

343
00:14:31,220 --> 00:14:32,240
el nombre

344
00:14:32,240 --> 00:14:36,960
Sí, pero tengo que tener ese dato

345
00:14:36,960 --> 00:14:38,940
y como mi aplicación

346
00:14:38,940 --> 00:14:39,980
dice el enunciado

347
00:14:39,980 --> 00:14:42,419
alumnos con nombre y entonces

348
00:14:42,419 --> 00:14:44,259
claro, se supone que este enunciado

349
00:14:44,259 --> 00:14:46,240
me lo ha dado alguien que me ha dicho que haga eso

350
00:14:46,240 --> 00:14:48,559
y él me ha dicho que tengo el nombre y el año de nacimiento

351
00:14:48,559 --> 00:14:50,440
entonces yo son los datos que tengo

352
00:14:50,440 --> 00:14:52,399
otra cosa es que yo vaya a hablar con él

353
00:14:52,399 --> 00:14:54,600
y le diga, ¿es posible que esta aplicación

354
00:14:54,600 --> 00:14:55,840
trabaje también con los NIF?

355
00:14:55,940 --> 00:14:58,220
Ah, sí, sí, el alumno te va a meter el NIF, vale, pues yo ya cambio

356
00:14:58,220 --> 00:15:00,019
mi diseño, luego la clave NIF

357
00:15:00,019 --> 00:15:04,320
pero en este caso, pues lo tenemos

358
00:15:04,320 --> 00:15:05,480
pues vamos a respetarlo

359
00:15:05,480 --> 00:15:08,860
Venga, ¿cuántos alumnos tiene usted, señor?

360
00:15:27,470 --> 00:15:28,750
Vale, ya que estamos

361
00:15:28,750 --> 00:15:30,909
Vamos a validar la entrada

362
00:15:30,909 --> 00:15:32,830
Vamos a validarla ya que estamos

363
00:15:32,830 --> 00:15:35,450
Para

364
00:15:35,450 --> 00:15:39,009
Que se nos quede en la cabeza lo del bloque try-catch

365
00:15:39,009 --> 00:15:42,389
Nosotros ya sabemos que si él dijera

366
00:15:42,389 --> 00:15:43,470
¿Cuántos alumnos tiene usted?

367
00:15:43,750 --> 00:15:46,549
Tengo HJ, pues la aplicación se para ahí

368
00:15:46,549 --> 00:15:48,230
Entonces vamos a validarlo

369
00:15:48,230 --> 00:15:50,110
Para que meta un número seguro

370
00:15:50,110 --> 00:16:07,950
Entonces vamos a

371
00:16:07,950 --> 00:16:09,950
Intentar leer

372
00:16:09,950 --> 00:16:12,950
Y vamos a capturar

373
00:16:12,950 --> 00:16:13,990
La excepción

374
00:16:13,990 --> 00:16:16,269
Input

375
00:16:16,269 --> 00:16:18,110
Mismatch

376
00:16:18,110 --> 00:16:20,090
Exception

377
00:16:20,090 --> 00:16:22,429
Vale

378
00:16:22,429 --> 00:16:24,950
Si entramos en la excepción

379
00:16:24,950 --> 00:16:26,570
Vamos a avisar

380
00:16:26,570 --> 00:16:27,529
De alguna manera

381
00:16:27,529 --> 00:16:34,090
Con un boolean por ejemplo

382
00:16:34,090 --> 00:16:37,600
Boolean

383
00:16:37,600 --> 00:16:38,559
Valid

384
00:16:38,559 --> 00:16:40,940
Igual a false

385
00:16:40,940 --> 00:16:47,360
Y aquí válido igual a true

386
00:16:47,360 --> 00:16:51,179
Eh, perdón

387
00:16:51,179 --> 00:16:52,759
Válido while

388
00:16:52,759 --> 00:16:55,259
Lo hago yo aquí

389
00:16:55,259 --> 00:17:01,840
Para decidir cuando se sale del bucle

390
00:17:01,840 --> 00:17:04,640
Válido igual a true

391
00:17:04,640 --> 00:17:08,859
Mientras no válido

392
00:17:08,859 --> 00:17:19,589
Entonces si salta excepción

393
00:17:19,589 --> 00:17:28,430
Entonces le decimos que introduzca otro número

394
00:17:28,430 --> 00:17:35,640
introduzca entero

395
00:17:35,640 --> 00:17:44,099
sí, eso estaba revisando

396
00:17:44,099 --> 00:17:45,500
porque si no nos va a pasar lo de siempre

397
00:17:45,500 --> 00:17:48,039
si va aquí

398
00:17:48,039 --> 00:17:50,660
y volvemos a pedir el next in

399
00:17:50,660 --> 00:17:52,440
pues pasa otra vez lo de siempre

400
00:17:52,440 --> 00:17:53,700
entonces eso

401
00:17:53,700 --> 00:17:56,279
que ya vimos ayer el problema

402
00:17:56,279 --> 00:18:00,150
lo habíamos arreglado así

403
00:18:00,150 --> 00:18:00,450
¿verdad?

404
00:18:11,269 --> 00:18:12,569
vale, a ver

405
00:18:12,569 --> 00:18:19,430
este bucle me está validando

406
00:18:19,430 --> 00:18:21,130
que lo que introduzca el tío

407
00:18:21,130 --> 00:18:23,210
sea un número entero, ¿verdad?

408
00:18:23,670 --> 00:18:25,190
Si lo hemos hecho bien, luego si no lo has probado,

409
00:18:25,230 --> 00:18:27,509
lo comprobaremos. En principio, de ese bucle

410
00:18:27,509 --> 00:18:29,670
no sale hasta que no llegue

411
00:18:29,670 --> 00:18:31,670
aquí. Y solamente

412
00:18:31,670 --> 00:18:33,490
va a llegar aquí si esta sentencia

413
00:18:33,490 --> 00:18:35,430
se termina correctamente.

414
00:18:36,230 --> 00:18:37,390
Luego, en principio, este bucle

415
00:18:37,390 --> 00:18:39,490
solamente termina, este do while,

416
00:18:40,029 --> 00:18:41,369
si se mete un número entero.

417
00:18:42,210 --> 00:18:43,569
¿Vale? Si no se mete

418
00:18:43,569 --> 00:18:45,609
un número entero, esto no se ejecuta.

419
00:18:46,210 --> 00:18:46,789
Luego de aquí

420
00:18:46,789 --> 00:18:49,089
entramos aquí, nos pide

421
00:18:49,089 --> 00:18:50,470
otra vez para arriba

422
00:18:50,470 --> 00:18:51,789
vale

423
00:18:51,789 --> 00:18:54,990
pero vamos, si quisiéramos validar

424
00:18:54,990 --> 00:18:56,569
no solo entero, sino entero positivo

425
00:18:56,569 --> 00:18:58,289
¿cuántos alumnos quiere usted?

426
00:18:59,109 --> 00:19:01,210
y me dice menos 12, el menos 2 tampoco me gusta

427
00:19:01,210 --> 00:19:02,390
quiero que sea

428
00:19:02,390 --> 00:19:03,730
mayor que 1

429
00:19:03,730 --> 00:19:06,210
esto estoy improvisando sobre la marcha

430
00:19:06,210 --> 00:19:08,589
¿cómo podríamos incorporar aquí

431
00:19:08,589 --> 00:19:10,809
que la validación fuera entero

432
00:19:10,809 --> 00:19:13,089
y además positivo? hay que incluir algo más

433
00:19:13,089 --> 00:19:15,130
porque la excepción solo valida que sea

434
00:19:15,130 --> 00:19:16,289
entero

435
00:19:16,289 --> 00:19:25,809
a ver, el tema es que

436
00:19:25,809 --> 00:19:27,109
si me mete un negativo

437
00:19:27,109 --> 00:19:39,029
bueno, o que este

438
00:19:39,029 --> 00:19:40,589
válido solo se ponga true

439
00:19:40,589 --> 00:19:42,509
ya está un if y se acabó

440
00:19:42,509 --> 00:19:46,430
bueno, no hace falta un bucle

441
00:19:46,430 --> 00:19:47,869
sino simplemente

442
00:19:47,869 --> 00:19:51,130
que solamente lo ponga

443
00:19:51,130 --> 00:19:52,069
true si es positivo

444
00:19:52,069 --> 00:19:55,029
porque si no, va a volver arriba

445
00:19:55,029 --> 00:19:56,630
otra vez, no hace falta meter otro bucle ahí

446
00:19:56,630 --> 00:20:02,799
pero de un if

447
00:20:02,799 --> 00:20:03,279
sin más

448
00:20:03,279 --> 00:20:05,500
eso, eso, sí, sí, vale

449
00:20:05,500 --> 00:20:08,400
te he entendido hacer aquí otro bucle dentro

450
00:20:08,400 --> 00:20:09,859
vale, vale

451
00:20:09,859 --> 00:20:11,680
exacto

452
00:20:11,680 --> 00:20:19,920
también, ¿no?

453
00:20:20,180 --> 00:20:21,480
mientras no válido

454
00:20:21,480 --> 00:20:23,960
ya, pero no, pero no, pero es que

455
00:20:23,960 --> 00:20:25,980
si no cambias eso, el válido ya se ha puesto

456
00:20:25,980 --> 00:20:27,539
Bueno, no, claro

457
00:20:27,539 --> 00:20:29,839
Si ponemos no válido

458
00:20:29,839 --> 00:20:31,839
Mientras IN

459
00:20:31,839 --> 00:20:33,819
Diferente de IN menor

460
00:20:33,819 --> 00:20:36,200
Entonces, aunque válido

461
00:20:36,200 --> 00:20:37,299
Lo hayas puesto ya true

462
00:20:37,299 --> 00:20:38,799
Va a volver arriba otra vez, ¿verdad?

463
00:20:43,799 --> 00:20:44,200
También

464
00:20:44,200 --> 00:20:48,119
Podríamos hacer otra y capturar las dos

465
00:20:48,119 --> 00:20:50,539
Esta y número negativo

466
00:20:50,539 --> 00:20:52,259
Número de alumnos negativo

467
00:20:52,259 --> 00:20:53,740
También, sería otra posibilidad

468
00:20:53,740 --> 00:20:56,319
hacer una excepción, número de alumnos negativo

469
00:20:56,319 --> 00:20:57,599
entonces

470
00:20:57,599 --> 00:21:00,599
si hiciéramos

471
00:21:00,599 --> 00:21:01,599
a ver, cualquiera de las

472
00:21:01,599 --> 00:21:03,819
vamos a recopilar las dos primeras

473
00:21:03,819 --> 00:21:05,319
y luego la de la excepción

474
00:21:05,319 --> 00:21:08,619
entonces una, la primera que habéis dicho

475
00:21:08,619 --> 00:21:10,000
sería

476
00:21:10,000 --> 00:21:12,579
que solo ponga el válido a true

477
00:21:12,579 --> 00:21:14,079
si

478
00:21:14,079 --> 00:21:16,779
n es mayor que 0

479
00:21:16,779 --> 00:21:17,819
¿verdad?

480
00:21:25,250 --> 00:21:26,910
También, efectivamente

481
00:21:26,910 --> 00:21:28,569
Else, pones aquí

482
00:21:28,569 --> 00:21:31,130
Otra vez, introduzca entero

483
00:21:31,130 --> 00:21:36,819
Entonces

484
00:21:36,819 --> 00:21:38,539
Y dentro del

485
00:21:38,539 --> 00:21:39,859
Y luego además

486
00:21:39,859 --> 00:21:43,779
Y luego además habría que hacer el scan next line

487
00:21:43,779 --> 00:21:45,039
También aquí en el else, ¿verdad?

488
00:21:51,859 --> 00:21:53,819
Es decir, como va a volver arriba otra vez

489
00:21:53,819 --> 00:21:55,579
Aquí habría que hacer

490
00:21:55,579 --> 00:21:57,059
También el scan next line

491
00:21:57,059 --> 00:21:58,160
¿Verdad?

492
00:22:01,660 --> 00:22:02,960
Vale, esta creemos que

493
00:22:02,960 --> 00:22:03,619
Funcionaría

494
00:22:03,619 --> 00:22:07,339
creemos que sí

495
00:22:07,339 --> 00:22:09,579
que validaría si el número es

496
00:22:09,579 --> 00:22:11,380
entero positivo

497
00:22:11,380 --> 00:22:16,039
perdón, no te oigo

498
00:22:16,039 --> 00:22:19,380
bueno, por lo mismo que lo hemos metido

499
00:22:19,380 --> 00:22:21,279
aquí, porque al volver a hacer

500
00:22:21,279 --> 00:22:22,940
el next y se nos quedaba encajado

501
00:22:22,940 --> 00:22:25,319
y aquí va a pasar lo mismo

502
00:22:25,319 --> 00:22:27,240
yo entiendo que

503
00:22:27,240 --> 00:22:27,859
si no lo haces

504
00:22:27,859 --> 00:22:34,869
es que yo tampoco me lo esperaba

505
00:22:34,869 --> 00:22:36,650
leer varios números seguidos

506
00:22:36,650 --> 00:22:39,390
la situación conflictiva es cuando

507
00:22:39,390 --> 00:22:41,089
lees una cadena

508
00:22:41,089 --> 00:22:42,130
después del número

509
00:22:42,130 --> 00:22:45,150
esa es la que hemos identificado

510
00:22:45,150 --> 00:22:46,910
y aquí estás leyendo dos nextkin

511
00:22:46,910 --> 00:22:49,269
entonces yo no sé por qué antes se nos

512
00:22:49,269 --> 00:22:51,009
ha quedado, vamos a probar esto

513
00:22:51,009 --> 00:23:01,420
a ver, el tema es que

514
00:23:01,420 --> 00:23:04,599
cuando sale

515
00:23:04,599 --> 00:23:07,960
claro, pero aquí la diferencia es que puede que

516
00:23:07,960 --> 00:23:09,920
aquí no haga falta, la diferencia

517
00:23:09,920 --> 00:23:12,119
es que cuando llegamos

518
00:23:12,119 --> 00:23:14,119
aquí, este no se ha llegado

519
00:23:14,119 --> 00:23:15,799
a completar y no sabemos

520
00:23:15,799 --> 00:23:17,680
en qué estado ha dejado el buffer

521
00:23:17,680 --> 00:23:20,059
y cuando llegamos aquí

522
00:23:20,059 --> 00:23:22,019
por este lado, este sí se ha llegado

523
00:23:22,019 --> 00:23:24,119
a completar, con lo cual sí que tenemos la seguridad

524
00:23:24,119 --> 00:23:25,460
de que el buffer lo habrá dejado limpio

525
00:23:25,460 --> 00:23:27,980
entonces yo creo que no va a hacer

526
00:23:27,980 --> 00:23:30,000
falta este, pero este

527
00:23:30,000 --> 00:23:31,880
sí hace falta porque llegamos

528
00:23:31,880 --> 00:23:33,839
a este punto no habiendo completado

529
00:23:33,839 --> 00:23:36,000
el next in, sino habiendo salido

530
00:23:36,000 --> 00:23:37,680
por la mitad y no sabemos

531
00:23:37,680 --> 00:23:39,779
en qué estado se ha quedado el buffer en ese momento

532
00:23:39,779 --> 00:23:42,140
¿vale? entonces vamos a

533
00:23:42,140 --> 00:23:43,819
probarlo así sin el

534
00:23:43,819 --> 00:23:45,700
next line, que yo creo que vamos a ver

535
00:23:45,700 --> 00:23:47,380
si así validaría esto

536
00:23:47,380 --> 00:23:49,259
sí que funciona, ¿verdad?

537
00:23:49,380 --> 00:23:50,619
¿no hace falta ni probarlo? ¿ya está?

538
00:23:51,480 --> 00:23:53,640
uy, qué rapidez, ¿este mismo idéntico clavado?

539
00:23:54,279 --> 00:23:55,519
vale, pues entonces nuestra intuición

540
00:23:55,519 --> 00:23:57,519
es correcta, aquí realmente no hace falta

541
00:23:57,519 --> 00:23:59,559
hacer varias lecturas de números seguidos

542
00:23:59,559 --> 00:24:01,180
no deja nada en el buffer

543
00:24:01,180 --> 00:24:03,480
pero claro, cuando tú vas

544
00:24:03,480 --> 00:24:05,220
por el catch, no has

545
00:24:05,220 --> 00:24:06,920
completado la lectura del número

546
00:24:06,920 --> 00:24:08,740
te has ido a medias

547
00:24:08,740 --> 00:24:11,000
entonces hemos comprobado

548
00:24:11,000 --> 00:24:12,480
empíricamente que hace falta

549
00:24:12,480 --> 00:24:15,599
¿por qué? es que no tenemos los detalles

550
00:24:15,599 --> 00:24:17,380
de en qué momento ha saltado la excepción realmente

551
00:24:17,380 --> 00:24:20,339
claro

552
00:24:20,339 --> 00:24:22,839
pues es que habría que ver

553
00:24:22,839 --> 00:24:24,400
habría que buscar aquí en el throw

554
00:24:24,400 --> 00:24:26,380
efectivamente cuando hace el throw

555
00:24:26,380 --> 00:24:27,900
en qué estado se ha quedado aquí el buffer

556
00:24:27,900 --> 00:24:31,059
pero bueno, es más fácil funcionar

557
00:24:31,059 --> 00:24:33,039
por prueba y error y ya está

558
00:24:33,039 --> 00:24:35,579
Vale, bueno pues entonces

559
00:24:35,579 --> 00:24:38,299
Este ya efectivamente no hace falta

560
00:24:38,299 --> 00:24:39,380
Como podemos intuir

561
00:24:39,380 --> 00:24:41,160
Esta validación funciona

562
00:24:41,160 --> 00:24:44,339
¿Qué otro método de validación

563
00:24:44,339 --> 00:24:46,099
Habíais planteado?

564
00:24:46,720 --> 00:24:48,359
El de cambiar la condición

565
00:24:48,359 --> 00:24:58,940
Es que sí, que sí

566
00:24:58,940 --> 00:24:59,819
Que estamos, a ver

567
00:24:59,819 --> 00:25:02,140
Espera un momento

568
00:25:02,140 --> 00:25:05,539
Ya, pero es que

569
00:25:05,539 --> 00:25:07,279
Me estreso

570
00:25:07,279 --> 00:25:12,289
paz, por favor

571
00:25:12,289 --> 00:25:13,509
vamos por partes

572
00:25:13,509 --> 00:25:15,910
vale, entonces

573
00:25:15,910 --> 00:25:17,589
siguiente opción

574
00:25:17,589 --> 00:25:20,349
que habíais planteado

575
00:25:20,349 --> 00:25:21,450
vamos ahora a ella

576
00:25:21,450 --> 00:25:24,309
esta era la opción original, verdad

577
00:25:24,309 --> 00:25:26,150
la de que solo valida

578
00:25:26,150 --> 00:25:27,109
que sea un número entero

579
00:25:27,109 --> 00:25:29,710
vale, pues tú sigue aquí en el bucle

580
00:25:29,710 --> 00:25:31,009
mientras no válido

581
00:25:31,009 --> 00:25:32,109
y

582
00:25:32,109 --> 00:25:34,029
mientras no válido

583
00:25:34,029 --> 00:25:34,750
y o

584
00:25:34,750 --> 00:25:53,579
mientras no sea válido

585
00:25:53,579 --> 00:25:56,180
o sea negativo

586
00:25:56,180 --> 00:25:58,200
el número sea

587
00:25:58,200 --> 00:25:59,539
menor que cero

588
00:25:59,539 --> 00:26:01,059
vale, entonces

589
00:26:01,059 --> 00:26:02,480
esto

590
00:26:02,480 --> 00:26:06,000
lo primero que implica es que

591
00:26:06,000 --> 00:26:07,960
n se quede inicializado a algo, a cualquier

592
00:26:07,960 --> 00:26:09,579
número, vale

593
00:26:09,579 --> 00:26:11,019
entonces

594
00:26:11,019 --> 00:26:13,940
pues a cualquiera

595
00:26:13,940 --> 00:26:15,079
a menos uno, no os da igual

596
00:26:15,079 --> 00:26:17,839
vale, entonces ahora, esto funcionaría

597
00:26:17,839 --> 00:26:19,799
pregunto, vamos a ver

598
00:26:19,799 --> 00:26:21,480
la secretaria que lo prueba todo rápido

599
00:26:21,480 --> 00:26:23,960
eso funcionaría, la secretaria por favor

600
00:26:23,960 --> 00:26:25,099
vale

601
00:26:25,099 --> 00:26:28,039
vamos a verlo

602
00:26:28,039 --> 00:26:30,140
vamos a suponer

603
00:26:30,140 --> 00:26:31,599
que si mete uno

604
00:26:31,599 --> 00:26:33,240
no válido, está claro

605
00:26:33,240 --> 00:26:36,019
que el válido no cambia, con lo cual

606
00:26:36,019 --> 00:26:38,180
esta condición ya directamente

607
00:26:38,180 --> 00:26:40,000
sería true

608
00:26:40,000 --> 00:26:42,440
con lo cual sigue, eso está claro

609
00:26:42,440 --> 00:26:43,119
vale

610
00:26:43,119 --> 00:26:46,119
ahora, ha metido uno válido

611
00:26:46,119 --> 00:26:48,380
con lo cual válido ha cambiado, entonces esta ya sería

612
00:26:48,380 --> 00:26:50,140
falso, miraría la siguiente

613
00:26:50,140 --> 00:26:52,200
como n es negativo

614
00:26:52,200 --> 00:26:54,119
esta se convierte en true

615
00:26:54,119 --> 00:26:55,559
con lo cual vuelve arriba

616
00:26:55,559 --> 00:26:58,200
que es lo único que le haría salir, las dos

617
00:26:58,200 --> 00:26:59,920
falsas, que es

618
00:26:59,920 --> 00:27:00,960
que

619
00:27:00,960 --> 00:27:04,259
el número haya sido entero, es decir

620
00:27:04,259 --> 00:27:06,259
que válido es igual a true, que eso se ha completado

621
00:27:06,259 --> 00:27:08,059
y que además

622
00:27:08,059 --> 00:27:09,799
el número sea mayor o igual que 0

623
00:27:09,799 --> 00:27:12,019
esto es lo único que le haría salir, las dos falsas

624
00:27:12,019 --> 00:27:13,880
¿verdad? con lo cual esto

625
00:27:13,880 --> 00:27:16,259
en principio funcionaría

626
00:27:16,259 --> 00:27:17,460
¿verdad?

627
00:27:18,279 --> 00:27:18,799
¿lo has probado?

628
00:27:19,940 --> 00:27:21,799
vamos a probarlo porque hay veces que las

629
00:27:21,799 --> 00:27:23,980
intuiciones de uno, uno ve los códigos

630
00:27:23,980 --> 00:27:25,660
y dice uy que bien y luego de repente

631
00:27:25,660 --> 00:27:27,799
lo prueba y dice uy no me he dado cuenta de esta

632
00:27:27,799 --> 00:27:28,279
tontería

633
00:27:28,279 --> 00:27:35,900
bueno a ver, salta si lo pongo

634
00:27:35,900 --> 00:27:37,519
aquí, claro

635
00:27:37,519 --> 00:27:39,400
Si n menor que 0

636
00:27:39,400 --> 00:27:40,680
Entonces

637
00:27:40,680 --> 00:27:45,259
Introduzca entero

638
00:27:45,259 --> 00:27:46,299
Si lo pongo aquí, sí

639
00:27:46,299 --> 00:27:52,259
No, ahorrar

640
00:27:52,259 --> 00:27:54,839
No, no, es que el try catch no lo puedes ahorrar

641
00:27:54,839 --> 00:27:55,519
Porque es que

642
00:27:55,519 --> 00:28:00,039
A ver

643
00:28:00,039 --> 00:28:02,900
O sea, el try catch no lo puedes quitar

644
00:28:02,900 --> 00:28:04,500
Porque si el tío te mete jj

645
00:28:04,500 --> 00:28:05,420
Va a parar el programa

646
00:28:05,420 --> 00:28:07,440
El try catch no lo puedes quitar

647
00:28:07,440 --> 00:28:11,839
El tema es añadir alguna validación extra

648
00:28:11,839 --> 00:28:13,960
Entonces, a ver un momentito

649
00:28:13,960 --> 00:28:14,920
Vamos a ver si funciona

650
00:28:14,920 --> 00:28:16,180
Y si está ahí

651
00:28:16,180 --> 00:28:19,720
Me pongo a un fin

652
00:28:19,720 --> 00:28:21,440
Para que me entere yo de bien

653
00:28:21,440 --> 00:28:22,259
De cuando ha salido

654
00:28:22,259 --> 00:28:24,839
Vamos a probar

655
00:28:24,839 --> 00:28:32,680
¿Cuántos alumnos queremos?

656
00:28:34,119 --> 00:28:35,000
Le pongo esto

657
00:28:35,000 --> 00:28:36,400
Introduzca entero

658
00:28:36,400 --> 00:28:37,680
Vale, esta está clara

659
00:28:37,680 --> 00:28:39,940
Le pongo menos cuatro

660
00:28:39,940 --> 00:28:41,880
Introduzca entero

661
00:28:41,880 --> 00:28:45,180
Vale, parece que sí, ¿no?

662
00:28:46,599 --> 00:28:49,339
Y ahora ya le pongo 98 alumnos, fin

663
00:28:49,339 --> 00:28:50,380
Vale

664
00:28:50,380 --> 00:28:52,900
Bueno, pues eso también nos gusta

665
00:28:52,900 --> 00:28:55,400
Y ahora

666
00:28:55,400 --> 00:29:01,519
Vamos a hacer una excepción

667
00:29:01,519 --> 00:29:02,480
¿Vale?

668
00:29:03,900 --> 00:29:05,660
Se quedan las dos comentadas

669
00:29:05,660 --> 00:29:08,339
Nuestro bucle original era este

670
00:29:08,339 --> 00:29:12,640
Que vamos a darle la otra opción

671
00:29:12,640 --> 00:29:41,539
Vale, pues volvemos al bucle original

672
00:29:41,539 --> 00:29:43,660
que era este, que este es el que valida

673
00:29:43,660 --> 00:29:45,740
solo que el número

674
00:29:45,740 --> 00:29:46,920
no sea entero, ¿verdad?

675
00:29:47,319 --> 00:29:49,180
si no es entero te vienes por aquí

676
00:29:49,180 --> 00:29:51,259
y ya hemos visto que hay que poner el netline

677
00:29:51,259 --> 00:29:53,720
porque como te vas a medias pues ha quedado roto

678
00:29:53,720 --> 00:29:54,539
vale, bueno

679
00:29:54,539 --> 00:29:58,259
ahora

680
00:29:58,259 --> 00:30:01,539
vamos a validar también que el número no sea negativo

681
00:30:01,539 --> 00:30:03,559
haciendo que lance

682
00:30:03,559 --> 00:30:05,980
una excepción

683
00:30:05,980 --> 00:30:07,420
pero

684
00:30:07,420 --> 00:30:09,099
a ver

685
00:30:09,099 --> 00:30:11,160
eso no sería tan sencillo porque

686
00:30:11,160 --> 00:30:15,109
es que quedaría muy

687
00:30:15,109 --> 00:30:22,109
tendríamos que meter esto

688
00:30:22,109 --> 00:30:24,369
en un método aparte y que ese método

689
00:30:24,369 --> 00:30:27,410
lance la excepción

690
00:30:27,410 --> 00:30:29,910
si el número es negativo

691
00:30:29,910 --> 00:30:30,809
entonces

692
00:30:30,809 --> 00:30:32,809
vamos a ponerlo aquí

693
00:30:32,809 --> 00:30:44,190
opción lanzando dos excepciones

694
00:30:44,190 --> 00:30:46,069
vale

695
00:30:46,069 --> 00:30:48,309
pues entonces

696
00:30:48,309 --> 00:30:49,690
vamos a hacer un método auxiliar

697
00:30:49,690 --> 00:30:51,990
que lea el número y ahora ese método

698
00:30:51,990 --> 00:30:54,569
que lance las dos posibilidades

699
00:30:54,569 --> 00:30:56,710
No eres número o eres número negativo

700
00:30:56,710 --> 00:30:58,890
¿Vale? No nos queda más remedio

701
00:30:58,890 --> 00:30:59,690
Tenemos que hacerlo así

702
00:30:59,690 --> 00:31:01,890
Pues venga, vamos a hacernos aquí

703
00:31:01,890 --> 00:31:04,450
Un método

704
00:31:04,450 --> 00:31:14,099
Sí, sí, sí, claro

705
00:31:14,099 --> 00:31:15,640
Porque es otro método aparte

706
00:31:15,640 --> 00:31:17,099
Leer número

707
00:31:17,099 --> 00:31:21,549
Vale, entonces este leer número

708
00:31:21,549 --> 00:31:23,569
Me hace esto de aquí

709
00:31:23,569 --> 00:31:26,029
Int n igual a

710
00:31:26,029 --> 00:31:27,470
Esto

711
00:31:27,470 --> 00:31:38,960
Y aquí me pongo yo un escáner local

712
00:31:38,960 --> 00:31:40,119
Para no

713
00:31:40,119 --> 00:31:42,839
guiar las cosas

714
00:31:42,839 --> 00:31:53,240
vale, y ahora ya sí

715
00:31:53,240 --> 00:31:55,420
si n

716
00:31:55,420 --> 00:31:56,880
es menor que 0

717
00:31:56,880 --> 00:31:59,619
entonces lanza

718
00:31:59,619 --> 00:32:00,500
una excepción

719
00:32:00,500 --> 00:32:02,799
vale

720
00:32:02,799 --> 00:32:05,579
si n es menor que 0, lanza una excepción

721
00:32:05,579 --> 00:32:09,299
que esa excepción

722
00:32:09,299 --> 00:32:10,619
pues puede ser new

723
00:32:10,619 --> 00:32:13,779
número

724
00:32:13,779 --> 00:32:14,680
alumnos

725
00:32:14,680 --> 00:32:19,619
negativo

726
00:32:19,619 --> 00:32:22,579
excepción

727
00:32:22,579 --> 00:32:29,160
y si no, return n.

728
00:32:34,210 --> 00:32:35,650
Vale, pues este método

729
00:32:35,650 --> 00:32:37,829
nuestro puede lanzar

730
00:32:37,829 --> 00:32:38,750
dos excepciones.

731
00:32:39,609 --> 00:32:41,890
La de input mismatch,

732
00:32:42,289 --> 00:32:44,069
si el número es cadena.

733
00:32:44,990 --> 00:32:45,890
O la de número

734
00:32:45,890 --> 00:32:47,789
alumnos negativo excepción. Puede lanzar

735
00:32:47,789 --> 00:32:49,869
dos. Entonces, cuando lo llamemos

736
00:32:49,869 --> 00:32:51,250
arriba, haremos los dos catch.

737
00:32:52,589 --> 00:32:53,069
¿Vale?

738
00:32:53,730 --> 00:32:55,349
Pero claro, tenemos que completarlo.

739
00:32:56,430 --> 00:32:57,450
Esta clase hay que

740
00:32:57,450 --> 00:32:57,970
crearla.

741
00:32:57,970 --> 00:33:00,849
entonces para no emborronar

742
00:33:00,849 --> 00:33:02,089
y seguir aprendiendo cosas

743
00:33:02,089 --> 00:33:04,430
nosotros hasta ahora todas las clases

744
00:33:04,430 --> 00:33:05,390
las hemos declarado

745
00:33:05,390 --> 00:33:08,769
cada una un código aparte

746
00:33:08,769 --> 00:33:09,930
un fichero aparte

747
00:33:09,930 --> 00:33:12,130
cada clase va por separado

748
00:33:12,130 --> 00:33:13,470
y está fuera de las otras

749
00:33:13,470 --> 00:33:16,890
no hace falta en realidad que estén en ficheros aparte

750
00:33:16,890 --> 00:33:17,470
eso es lo de menos

751
00:33:17,470 --> 00:33:19,730
yo en un fichero puedo tener clase, una clase entera

752
00:33:19,730 --> 00:33:21,930
debajo de ella clase, otra clase entera

753
00:33:21,930 --> 00:33:23,349
eso siempre lo podemos hacer

754
00:33:23,349 --> 00:33:25,450
pero luego cuando se precompilan

755
00:33:25,450 --> 00:33:27,029
ya son punto clase distinto

756
00:33:27,029 --> 00:33:29,529
pero

757
00:33:29,529 --> 00:33:31,710
por comodidad

758
00:33:31,710 --> 00:33:34,109
se puede hacer una cosa que es

759
00:33:34,109 --> 00:33:36,269
declarar una clase dentro de la otra

760
00:33:36,269 --> 00:33:38,190
¿vale?

761
00:33:38,230 --> 00:33:40,309
por ejemplo, en esta situación

762
00:33:40,309 --> 00:33:42,029
me gusta y me interesa

763
00:33:42,029 --> 00:33:44,109
esa idea, es decir

764
00:33:44,109 --> 00:33:46,509
esta excepción yo me la he inventado

765
00:33:46,509 --> 00:33:48,349
aquí solamente para poder

766
00:33:48,349 --> 00:33:50,210
hacer la validación de forma bonita

767
00:33:50,210 --> 00:33:52,470
con dos try-catch, con dos catch

768
00:33:52,470 --> 00:33:53,609
¿vale? me la he inventado

769
00:33:53,609 --> 00:33:55,549
para poder hacer una validación

770
00:33:55,549 --> 00:33:57,690
Más bonita que estas de arriba

771
00:33:57,690 --> 00:33:59,190
Que me he ofrecido aquí

772
00:33:59,190 --> 00:34:01,329
Para hacer un try con dos cats

773
00:34:01,329 --> 00:34:04,210
¿Vale? Para esto me he inventado esa excepción

774
00:34:04,210 --> 00:34:05,829
Para poder hacer un try con dos cats

775
00:34:05,829 --> 00:34:06,490
En este fichero

776
00:34:06,490 --> 00:34:09,130
Pero esta excepción no va más allá de eso

777
00:34:09,130 --> 00:34:11,429
No la van a usar otras clases por ahí

778
00:34:11,429 --> 00:34:12,289
Ni la va a usar nadie

779
00:34:12,289 --> 00:34:15,510
Entonces, meter otra clase más

780
00:34:15,510 --> 00:34:16,449
En mi aplicación

781
00:34:16,449 --> 00:34:18,369
Pequeñita

782
00:34:18,369 --> 00:34:21,309
Que solamente va a ser usada desde aquí

783
00:34:21,309 --> 00:34:22,590
Y solo desde aquí

784
00:34:22,590 --> 00:34:25,309
Pues hombre, quizás emboronar un poco la aplicación

785
00:34:25,309 --> 00:34:27,550
entonces yo siempre puedo hacer una cosa

786
00:34:27,550 --> 00:34:30,130
que es declarar una clase dentro de la otra

787
00:34:30,130 --> 00:34:32,349
eso es una clase interna

788
00:34:32,349 --> 00:34:35,789
clase anónima es su siguiente paso

789
00:34:35,789 --> 00:34:37,989
es una clase interna

790
00:34:37,989 --> 00:34:39,050
que ni siquiera tiene nombre

791
00:34:39,050 --> 00:34:39,989
es todavía más

792
00:34:39,989 --> 00:34:42,570
más

793
00:34:42,570 --> 00:34:44,869
como se dice cuando vas

794
00:34:44,869 --> 00:34:47,769
se me van las palabras

795
00:34:47,769 --> 00:34:49,869
no, no, no

796
00:34:49,869 --> 00:34:51,750
no tiene que ver con programación

797
00:34:51,750 --> 00:34:53,690
como es la palabra cuando vas quitándole a alguien

798
00:34:53,690 --> 00:34:56,230
destitulado, no es destituida

799
00:34:56,230 --> 00:34:57,969
más todavía destituida que la otra

800
00:34:57,969 --> 00:34:59,010
no me gusta esa palabra

801
00:34:59,010 --> 00:35:02,170
vale, de la clase anónima

802
00:35:02,170 --> 00:35:03,789
por ahora, olvídate, si es

803
00:35:03,789 --> 00:35:05,989
una clase anónima, es una interna

804
00:35:05,989 --> 00:35:07,789
pero además sin nombre, está todavía, es que me sale

805
00:35:07,789 --> 00:35:10,070
descatalogada, no, bueno, da igual

806
00:35:10,070 --> 00:35:11,570
vale, pues a ver

807
00:35:11,570 --> 00:35:14,070
uno puede declarar una clase dentro de la otra

808
00:35:14,070 --> 00:35:15,849
si quiere, entonces

809
00:35:15,849 --> 00:35:17,230
esta es mi clase

810
00:35:17,230 --> 00:35:19,989
bueno, vamos a parar y lo hacemos

811
00:35:19,989 --> 00:35:20,610
luego, vale

812
00:35:20,610 --> 00:35:23,829
que esto no es corto