1
00:00:00,000 --> 00:00:06,240
Bueno, vamos a continuar con esto que es muy sencillo, ¿vale?

2
00:00:07,620 --> 00:00:11,839
Recordad que lo que estamos viendo ahora es la programación estructurada,

3
00:00:11,839 --> 00:00:19,839
que es elaborar algoritmos, lo que pasa es que esos algoritmos los escribimos directamente en un lenguaje de programación,

4
00:00:20,800 --> 00:00:28,219
pero podríamos escribirlo con nuestro propio lenguaje, lee número, suma al número un 7,

5
00:00:28,219 --> 00:00:30,260
podríamos escribirlo con nuestro propio lenguaje

6
00:00:30,260 --> 00:00:32,320
pero bueno, los estamos escribiendo con Java

7
00:00:32,320 --> 00:00:34,179
bueno, lo que estamos haciendo es

8
00:00:34,179 --> 00:00:35,259
elaborar algoritmos

9
00:00:35,259 --> 00:00:38,560
según los principios de programación estructurada

10
00:00:38,560 --> 00:00:39,119
que son

11
00:00:39,119 --> 00:00:42,219
el algoritmo, en nuestro caso

12
00:00:42,219 --> 00:00:44,159
programa, porque está escrito en Java

13
00:00:44,159 --> 00:00:46,219
pero es lo mismo, el algoritmo

14
00:00:46,219 --> 00:00:47,500
barra programa

15
00:00:47,500 --> 00:00:50,259
es una secuencia ordenada

16
00:00:50,259 --> 00:00:52,479
es decir, una tras otra, pin, pin, pin

17
00:00:52,479 --> 00:00:53,979
de sentencias

18
00:00:53,979 --> 00:00:56,219
o instrucciones, una secuencia ordenada

19
00:00:56,219 --> 00:00:57,979
infinita, por supuesto

20
00:00:57,979 --> 00:00:59,880
tiene que acabar y

21
00:00:59,880 --> 00:01:02,219
entre esas sentencias encontramos

22
00:01:02,219 --> 00:01:04,159
muy poca variedad de tipos

23
00:01:04,159 --> 00:01:06,219
una variedad de tipos muy pequeña

24
00:01:06,219 --> 00:01:07,760
porque no hace falta más variedad

25
00:01:07,760 --> 00:01:08,980
que es lo que estamos haciendo

26
00:01:08,980 --> 00:01:11,180
asignar valores a variables

27
00:01:11,180 --> 00:01:14,060
esos valores pueden venir de valores de una expresión

28
00:01:14,060 --> 00:01:15,920
muy gordota o de muchas cosas raras

29
00:01:15,920 --> 00:01:17,900
pero no deja de ser una

30
00:01:17,900 --> 00:01:20,099
asignación, incluso cuando

31
00:01:20,099 --> 00:01:22,239
leemos del teclado con el scan next in

32
00:01:22,239 --> 00:01:24,000
es una asignación, es decir

33
00:01:24,000 --> 00:01:24,939
dar valores a variables

34
00:01:24,939 --> 00:01:27,620
ese es un tipo de sentencia

35
00:01:27,620 --> 00:01:29,140
que es la que hemos hecho ahora

36
00:01:29,140 --> 00:01:31,659
y ¿qué más tipos de sentencias

37
00:01:31,659 --> 00:01:33,319
podemos manejar en la posición estructurada?

38
00:01:33,400 --> 00:01:36,079
las decisiones y los bucles

39
00:01:36,079 --> 00:01:37,579
y ya está, no hace falta

40
00:01:37,579 --> 00:01:40,099
manejar más tipos de sentencias distintas

41
00:01:40,099 --> 00:01:40,719
solo esas

42
00:01:40,719 --> 00:01:42,599
las asignaciones

43
00:01:42,599 --> 00:01:44,879
las decisiones y los bucles

44
00:01:44,879 --> 00:01:46,140
combinando

45
00:01:46,140 --> 00:01:49,900
en una secuencia ordenada y finita

46
00:01:49,900 --> 00:01:51,459
de pasos

47
00:01:51,459 --> 00:01:53,040
esas sentencias podemos

48
00:01:53,040 --> 00:01:55,260
ejecutar, podemos

49
00:01:55,260 --> 00:01:57,540
elaborar cualquier programa

50
00:01:57,540 --> 00:01:59,459
para cualquier problema

51
00:01:59,459 --> 00:02:01,140
que se nos presente, que

52
00:02:01,140 --> 00:02:02,920
queramos que nos resuelva un ordenador.

53
00:02:03,980 --> 00:02:04,579
¿Vale? Cualquiera.

54
00:02:05,239 --> 00:02:07,439
Bueno, pues de las asignaciones tenemos todo lo que

55
00:02:07,439 --> 00:02:08,840
tenemos que saber. Está más que

56
00:02:08,840 --> 00:02:10,400
hiper mega sabido.

57
00:02:11,159 --> 00:02:13,039
Entonces, vamos a incorporar la siguiente sentencia

58
00:02:13,039 --> 00:02:15,219
dentro de los únicos tres tipos que tenemos

59
00:02:15,219 --> 00:02:17,159
de actuación estructurada, que es la de

60
00:02:17,159 --> 00:02:19,259
decisión, pues que ya sabes

61
00:02:19,259 --> 00:02:21,159
lo que nos permite la sentencia de decisión

62
00:02:21,159 --> 00:02:33,639
por su nombre, que es nuestro programa, en lugar de seguir siempre una única línea de ejecución,

63
00:02:34,000 --> 00:02:38,659
ahora esto, ahora esto, ahora esto, ahora esto, pues vamos a en un punto determinado decir,

64
00:02:38,800 --> 00:02:46,960
oye, perdona, en este punto de aquí yo a veces querré hacer esto o a veces querré hacer esto otro.

65
00:02:46,960 --> 00:02:49,319
Vale, entonces la sentencia de decisión

66
00:02:49,319 --> 00:02:50,860
Nos permite en algún momento

67
00:02:50,860 --> 00:02:52,139
Vamos ejecutando

68
00:02:52,139 --> 00:02:54,599
Uy, quiero abrir dos posibilidades

69
00:02:54,599 --> 00:02:56,599
A veces querré hacer esto

70
00:02:56,599 --> 00:02:58,120
O a veces querré hacer esto otro

71
00:02:58,120 --> 00:03:00,819
Esas dos posibilidades

72
00:03:00,819 --> 00:03:03,419
Luego cuando ya terminan

73
00:03:03,419 --> 00:03:04,599
Continúan

74
00:03:04,599 --> 00:03:07,259
Entonces la sentencia de decisión nos permite esto

75
00:03:07,259 --> 00:03:09,719
Pasar de esto de aquí

76
00:03:09,719 --> 00:03:11,979
A poder ya abrir

77
00:03:11,979 --> 00:03:12,919
Dos posibilidades

78
00:03:12,919 --> 00:03:14,460
Que mi programa haga esto

79
00:03:14,460 --> 00:03:18,039
o que mi programa haga esto otro

80
00:03:18,039 --> 00:03:22,180
ya le doy un poquito más de flexibilidad

81
00:03:22,180 --> 00:03:23,819
entonces

82
00:03:23,819 --> 00:03:27,080
esto lo tenemos que poder hacer efectivamente

83
00:03:27,080 --> 00:03:29,259
porque hay veces que un programa

84
00:03:29,259 --> 00:03:31,219
en función de los datos de entrada

85
00:03:31,219 --> 00:03:34,020
nos interesa que haga una cosa o que haga otra

86
00:03:34,020 --> 00:03:37,379
una calculadora en función del dato de entrada

87
00:03:37,379 --> 00:03:39,819
operador o bien hace una suma

88
00:03:39,819 --> 00:03:41,020
o bien hace una resta

89
00:03:41,020 --> 00:03:47,939
un programa en función de si una contraseña que hemos introducido es correcta o no,

90
00:03:48,439 --> 00:03:53,280
o bien te autentica y hace una cosa, o bien no te autentica y te reenvía a otro sitio.

91
00:03:54,139 --> 00:04:01,719
Entonces, todos los programas admiten, lógicamente, varias posibilidades en función de datos de entrada.

92
00:04:02,719 --> 00:04:05,240
Entonces, estas ramas no es que se abran de la nada.

93
00:04:06,300 --> 00:04:09,919
Estas ramas dependerán de una condición.

94
00:04:11,020 --> 00:04:14,099
estas ramas dependerán de una condición

95
00:04:14,099 --> 00:04:15,599
que lógicamente

96
00:04:15,599 --> 00:04:17,800
como consecuencia de haber

97
00:04:17,800 --> 00:04:19,519
analizado bien el programa

98
00:04:19,519 --> 00:04:21,620
de denunciado, haberlo entendido

99
00:04:21,620 --> 00:04:23,300
pues iremos definiendo

100
00:04:23,300 --> 00:04:24,220
¿vale?

101
00:04:25,120 --> 00:04:28,160
entonces, esta es una situación

102
00:04:28,160 --> 00:04:28,740
estándar

103
00:04:28,740 --> 00:04:31,839
un enunciado, una aplicación

104
00:04:31,839 --> 00:04:33,379
algo que tenemos que hacer

105
00:04:33,379 --> 00:04:35,620
que después de analizarlo y estudiarlo

106
00:04:35,620 --> 00:04:37,839
identificamos que a veces nos

107
00:04:37,839 --> 00:04:39,279
interesará que haga una cosa

108
00:04:39,279 --> 00:04:41,740
Y a veces nos interesará que haga otra

109
00:04:41,740 --> 00:04:44,319
Entonces rápidamente nos damos cuenta

110
00:04:44,319 --> 00:04:45,860
De que el programa no es una secuencia

111
00:04:45,860 --> 00:04:47,339
Que siempre vaya a hacer lo mismo

112
00:04:47,339 --> 00:04:49,860
A veces nos interesará que haga una cosa

113
00:04:49,860 --> 00:04:51,860
Y a veces nos interesará que haga otra

114
00:04:51,860 --> 00:04:53,920
Entonces si identificamos

115
00:04:53,920 --> 00:04:56,379
Que ese programa está en esa situación

116
00:04:56,379 --> 00:04:58,100
Que a veces nos interesará que haga una cosa

117
00:04:58,100 --> 00:04:59,139
Y a veces nos interesará que haga otra

118
00:04:59,139 --> 00:05:02,180
Automáticamente nos tiene que venir a la cabeza

119
00:05:02,180 --> 00:05:03,879
La pregunta de ¿y de qué depende?

120
00:05:04,620 --> 00:05:06,680
¿De qué depende que haga esta cosa

121
00:05:06,680 --> 00:05:07,920
O que haga esta otra?

122
00:05:08,180 --> 00:05:08,839
¿De qué depende?

123
00:05:09,279 --> 00:05:11,959
Pues va a depender siempre de una condición.

124
00:05:12,399 --> 00:05:16,899
De una condición que tendremos que elaborar, lógicamente, como parte del programa.

125
00:05:18,240 --> 00:05:20,560
Luego la sentencia if me abre esta posibilidad.

126
00:05:21,980 --> 00:05:22,160
¿Vale?

127
00:05:24,439 --> 00:05:29,540
Entonces, el programa, no es que el programa empiece a hacer computación paralela, no.

128
00:05:29,699 --> 00:05:32,040
Lo que pasa es que en una ejecución vendrá por aquí.

129
00:05:32,939 --> 00:05:34,899
Sigue siendo una secuencia ordenada.

130
00:05:35,060 --> 00:05:36,759
Pam, pam, pam, pam, pam, pam, pam, pam.

131
00:05:36,759 --> 00:05:39,019
Pero a lo mejor en la ejecución de mañana

132
00:05:39,019 --> 00:05:41,399
Como los datos de entrada han cambiado

133
00:05:41,399 --> 00:05:43,800
Y la condición deja de cumplirse

134
00:05:43,800 --> 00:05:45,040
Pues en la ejecución de mañana

135
00:05:45,040 --> 00:05:46,279
Pues va por aquí

136
00:05:46,279 --> 00:05:50,379
Siempre para cada ejecución

137
00:05:50,379 --> 00:05:52,639
El programa hace una única cosa

138
00:05:52,639 --> 00:05:54,139
O hace esto

139
00:05:54,139 --> 00:05:55,579
O hace esto

140
00:05:55,579 --> 00:05:58,220
Para cada ejecución hace una única cosa

141
00:05:58,220 --> 00:06:00,560
Es decir, el programa sigue siendo

142
00:06:00,560 --> 00:06:02,500
Una secuencia ordenada y finita de pasos

143
00:06:02,500 --> 00:06:04,699
Esta, esta, esta, esta, esta, esta, esta

144
00:06:04,699 --> 00:06:08,120
o esta, esta, esta, esta, esta, esta, esta, esta.

145
00:06:08,439 --> 00:06:09,860
Una de las dos va a ser.

146
00:06:10,920 --> 00:06:13,040
¿De qué va a depender en cada momento,

147
00:06:13,240 --> 00:06:16,259
en cada ejecución que sea esta secuencia o que sea esta?

148
00:06:17,019 --> 00:06:19,939
Pues repito, de una condición que tenemos que elaborar,

149
00:06:20,000 --> 00:06:21,319
lógicamente, y definir cuál es.

150
00:06:22,540 --> 00:06:22,800
¿Vale?

151
00:06:24,540 --> 00:06:26,040
Bueno, pues cuando se abre,

152
00:06:26,439 --> 00:06:28,579
se abren dos ramas.

153
00:06:29,000 --> 00:06:30,759
Porque hemos puesto aquí una condición,

154
00:06:30,759 --> 00:06:32,319
cuando se abren dos ramas,

155
00:06:32,899 --> 00:06:34,300
no significa que ya el programa

156
00:06:34,300 --> 00:06:38,199
automáticamente progresa en dos ramas independientes

157
00:06:38,199 --> 00:06:39,800
el resto de su vida hasta que termine.

158
00:06:40,519 --> 00:06:40,959
No, no, no.

159
00:06:41,699 --> 00:06:45,720
Esas dos ramas que están asociadas a si la condición se cumple o no

160
00:06:45,720 --> 00:06:49,819
serán hace esta cosa, que pueden ser una, dos, siete sentencias.

161
00:06:50,040 --> 00:06:52,560
Hace esta cosa si la condición se cumple.

162
00:06:53,720 --> 00:06:55,360
Si no se cumple, hace esta otra,

163
00:06:55,560 --> 00:06:57,759
que pueden ser una, dos, tres, cuatro sentencias.

164
00:06:58,420 --> 00:07:00,779
Pero cuando eso ha terminado,

165
00:07:00,779 --> 00:07:02,579
el programa ya continúa

166
00:07:02,579 --> 00:07:04,620
con su camino

167
00:07:04,620 --> 00:07:06,779
¿vale?

168
00:07:06,839 --> 00:07:08,920
no es que esto lo abra y cada programa ya

169
00:07:08,920 --> 00:07:10,860
no, no, el programa una vez que se ha

170
00:07:10,860 --> 00:07:12,100
hecho eso asociado a

171
00:07:12,100 --> 00:07:14,540
¿qué ha pasado?

172
00:07:16,040 --> 00:07:16,240
¿eh?

173
00:07:16,899 --> 00:07:18,040
el que está cargando

174
00:07:18,040 --> 00:07:21,000
bueno, da igual

175
00:07:21,000 --> 00:07:22,180
esta pantalla es muy rara

176
00:07:22,180 --> 00:07:25,060
una vez que se ha terminado de hacer esto

177
00:07:25,060 --> 00:07:26,360
el programa continúa por aquí

178
00:07:26,360 --> 00:07:28,660
luego, las dos ramas que se abren

179
00:07:28,660 --> 00:07:30,959
Siempre confluyen en un punto

180
00:07:30,959 --> 00:07:36,230
Esta es la peor pantalla de todo el instituto

181
00:07:36,230 --> 00:07:37,889
Ni consigo que

182
00:07:37,889 --> 00:07:39,589
Ah, ya está

183
00:07:39,589 --> 00:07:40,850
Que responda el táctil

184
00:07:40,850 --> 00:07:43,509
El resto de profesores no tienen problemas con ella

185
00:07:43,509 --> 00:07:44,189
Solo yo

186
00:07:44,189 --> 00:07:47,009
Bueno

187
00:07:47,009 --> 00:07:49,370
Vale, entonces

188
00:07:49,370 --> 00:07:50,829
Las dos ramas que se abren

189
00:07:50,829 --> 00:07:52,870
Es importante que entendamos

190
00:07:52,870 --> 00:07:56,089
Que confluyen a un punto

191
00:07:56,089 --> 00:07:58,750
Si yo voy por esta rama

192
00:07:58,750 --> 00:08:01,050
porque la condición es cierta, haré lo que sea

193
00:08:01,050 --> 00:08:02,490
pero llego a este punto

194
00:08:02,490 --> 00:08:04,470
y si voy por esta rama

195
00:08:04,470 --> 00:08:06,410
porque la condición es falsa

196
00:08:06,410 --> 00:08:08,290
haré lo que sea pero llego a este punto

197
00:08:08,290 --> 00:08:10,730
luego puede ocurrir

198
00:08:10,730 --> 00:08:12,850
que ese punto es el punto final

199
00:08:12,850 --> 00:08:14,209
que ahí la aplicación termina

200
00:08:14,209 --> 00:08:16,149
yo no quiero que pase nada más, bueno pues no pasa

201
00:08:16,149 --> 00:08:17,829
pues entonces han concluido

202
00:08:17,829 --> 00:08:19,209
en el fin

203
00:08:19,209 --> 00:08:22,110
pero podría ser que no

204
00:08:22,110 --> 00:08:24,910
que una vez que ya hemos hecho la alternativa

205
00:08:24,910 --> 00:08:26,370
que toque, el programa siga

206
00:08:26,370 --> 00:08:27,889
por su único camino

207
00:08:27,889 --> 00:08:29,750
y a lo mejor luego más adelante

208
00:08:29,750 --> 00:08:30,990
pues vuelve a abrirse otra vez

209
00:08:30,990 --> 00:08:33,149
en buena condición, vuelve a abrirse

210
00:08:33,149 --> 00:08:34,529
y luego vuelve a confluir

211
00:08:34,529 --> 00:08:35,590
¿vale?

212
00:08:40,539 --> 00:08:41,820
esto en el

213
00:08:41,820 --> 00:08:44,019
los diagramas de flujo

214
00:08:44,700 --> 00:08:46,019
porque el término de diagramas

215
00:08:46,019 --> 00:08:47,919
de flujo que en entornos de desarrollo

216
00:08:47,919 --> 00:08:48,440
a lo mejor

217
00:08:48,440 --> 00:08:52,320
¿habéis visto algún tema ya en entornos de desarrollo?

218
00:08:52,320 --> 00:08:53,120
que es el ciclo

219
00:08:53,120 --> 00:08:55,480
de vida del software

220
00:08:55,480 --> 00:08:57,519
análisis, diseño

221
00:08:57,519 --> 00:09:04,100
que habéis tenido una clase

222
00:09:04,100 --> 00:09:04,919
en tonos de desarrollo

223
00:09:04,919 --> 00:09:09,179
bueno

224
00:09:09,179 --> 00:09:11,240
pues en general

225
00:09:11,240 --> 00:09:13,419
los diagramas de flujo

226
00:09:13,419 --> 00:09:15,000
son dibujitos

227
00:09:15,000 --> 00:09:16,679
que vienen muy bien

228
00:09:16,679 --> 00:09:18,919
para ayudar

229
00:09:18,919 --> 00:09:20,519
a entender programas

230
00:09:20,519 --> 00:09:22,179
para documentar programas

231
00:09:22,179 --> 00:09:24,820
son dibujitos, un diagrama de flujo

232
00:09:24,820 --> 00:09:26,820
entonces, en general

233
00:09:26,820 --> 00:09:28,820
aunque eso ya lo veréis en entornos de desarrollo

234
00:09:28,820 --> 00:09:30,659
pues cuando se desarrolla

235
00:09:30,659 --> 00:09:32,940
un software, una aplicación

236
00:09:32,940 --> 00:09:34,159
un programa grandote

237
00:09:34,159 --> 00:09:36,820
pues para que eso no sea un caos

238
00:09:36,820 --> 00:09:38,940
y seguir más o menos

239
00:09:38,940 --> 00:09:40,500
pautas de trabajo similares

240
00:09:40,500 --> 00:09:42,639
en todos los contextos o en otras empresas

241
00:09:42,639 --> 00:09:45,259
pues hay un procedimiento

242
00:09:45,259 --> 00:09:47,039
que se concreta

243
00:09:47,039 --> 00:09:48,860
en una cosa que se llama el ciclo de desarrollo

244
00:09:48,860 --> 00:09:50,860
del software, que es los pasos que das tú

245
00:09:50,860 --> 00:09:52,980
cuando vas a hacer un programa

246
00:09:52,980 --> 00:09:55,000
¿qué pasos das tú cuando vas a hacer un programa?

247
00:09:55,000 --> 00:09:57,240
o un software, hablando en términos más amplios.

248
00:09:58,139 --> 00:09:59,980
Paso uno, análisis.

249
00:10:00,620 --> 00:10:03,440
Todavía no habéis mencionado términos de análisis, diseño,

250
00:10:03,539 --> 00:10:05,460
no os ha dado tiempo nada de eso en torno.

251
00:10:05,700 --> 00:10:06,179
No, no, no.

252
00:10:06,320 --> 00:10:06,539
Vale.

253
00:10:07,159 --> 00:10:10,200
Pues pasos que sigue uno cuando va a hacer uno

254
00:10:10,200 --> 00:10:11,539
o un equipo de proyecto,

255
00:10:11,659 --> 00:10:13,779
cuando va a hacer un software o un programa.

256
00:10:14,639 --> 00:10:19,240
Paso uno, análisis.

257
00:10:21,639 --> 00:10:24,919
El análisis no tiene nada que ver con programar,

258
00:10:24,919 --> 00:10:27,399
pero es la fase más importante

259
00:10:27,399 --> 00:10:28,860
para que luego ese producto

260
00:10:28,860 --> 00:10:30,580
que se desarrolla

261
00:10:30,580 --> 00:10:32,600
realmente no nos lo tiren a la basura

262
00:10:32,600 --> 00:10:34,100
y no hayamos perdido el tiempo

263
00:10:34,100 --> 00:10:35,240
que el análisis es

264
00:10:35,240 --> 00:10:37,440
¿qué quiero hacer?

265
00:10:38,100 --> 00:10:39,200
¿qué tiene que hacer?

266
00:10:40,720 --> 00:10:42,480
¿qué hago? ¿qué es lo que tengo que hacer?

267
00:10:43,519 --> 00:10:45,179
y esto es lo que hacen los analistas

268
00:10:45,179 --> 00:10:47,279
tratar de entender la situación

269
00:10:47,279 --> 00:10:50,019
que les ha planteado el que ha pedido ese software

270
00:10:50,019 --> 00:10:52,159
para entender exactamente

271
00:10:52,159 --> 00:10:53,019
¿qué quiere?

272
00:10:53,019 --> 00:10:55,419
que no es trivial porque la gente

273
00:10:55,419 --> 00:10:57,320
o no se explica bien o tiene las ideas muy claras

274
00:10:57,320 --> 00:10:59,279
entonces si tú no haces una buena fase

275
00:10:59,279 --> 00:11:01,440
de análisis, te metes a desarrollar

276
00:11:01,440 --> 00:11:03,620
un software y luego ese software no responde

277
00:11:03,620 --> 00:11:04,600
a las expectativas

278
00:11:04,600 --> 00:11:07,440
del cliente que te lo pidió, luego todo ese tiempo

279
00:11:07,440 --> 00:11:08,799
que has dedicado no vale para nada

280
00:11:08,799 --> 00:11:10,740
por eso esta fase es importante

281
00:11:10,740 --> 00:11:13,299
toda esa serie

282
00:11:13,299 --> 00:11:14,259
de entrevistas

283
00:11:14,259 --> 00:11:17,379
de formas de proceder

284
00:11:17,379 --> 00:11:18,659
que hay para

285
00:11:18,659 --> 00:11:20,960
hacer un buen análisis, etc.

286
00:11:22,139 --> 00:11:22,580
entonces

287
00:11:22,580 --> 00:11:25,340
una vez que uno tiene muy claro que es lo que

288
00:11:25,340 --> 00:11:27,279
hace, entra en la

289
00:11:27,279 --> 00:11:28,240
fase de diseño

290
00:11:28,240 --> 00:11:30,720
que ahora ya es, vale

291
00:11:30,720 --> 00:11:36,980
¿cómo lo hago? y aquí era

292
00:11:36,980 --> 00:11:38,399
a donde iba yo cuando

293
00:11:38,399 --> 00:11:40,059
decía de los diagramas de Facebook

294
00:11:40,059 --> 00:11:41,779
ahora ya sí

295
00:11:41,779 --> 00:11:44,320
nos empezamos a plantear cosas de

296
00:11:44,320 --> 00:11:46,659
como todavía no sabemos objetos

297
00:11:46,659 --> 00:11:48,759
pues a eso igual nos puede sonar

298
00:11:48,759 --> 00:11:50,820
un poco más raro, pero nos empezamos a plantear cosas

299
00:11:50,820 --> 00:11:52,820
del estilo de

300
00:11:52,820 --> 00:11:54,960
vale, ¿cuántas

301
00:11:54,960 --> 00:11:57,220
entidades, cuántas

302
00:11:57,220 --> 00:11:58,860
clases necesito para mi aplicación

303
00:11:58,860 --> 00:12:01,059
pues una clase alumno, una clase

304
00:12:01,059 --> 00:12:02,659
factura, bueno, eso ya lo entenderemos

305
00:12:02,659 --> 00:12:04,860
pero sobre todo

306
00:12:04,860 --> 00:12:07,000
entramos en, vale, ¿cómo voy a hacer las

307
00:12:07,000 --> 00:12:08,940
cosas? si mi aplicación es

308
00:12:08,940 --> 00:12:10,919
yo te voy a dar un número

309
00:12:10,919 --> 00:12:12,279
y sácame el factorial

310
00:12:12,279 --> 00:12:15,159
bueno, pues el analista

311
00:12:15,159 --> 00:12:16,980
ha dicho, lo que tienes

312
00:12:16,980 --> 00:12:19,039
que hacer es el factorial, que el factorial

313
00:12:19,039 --> 00:12:20,899
de un número es, dado

314
00:12:20,899 --> 00:12:22,600
el número n, multiplicarlo por

315
00:12:22,600 --> 00:12:24,919
n-1 por n-2, así hasta 1

316
00:12:24,919 --> 00:12:27,120
eso es, eso es lo que tienes que hacer

317
00:12:27,120 --> 00:12:29,220
¿te has enterado que eso es lo que tienes que hacer?

318
00:12:29,559 --> 00:12:31,740
sí, vale, esa sería la fase de análisis

319
00:12:31,740 --> 00:12:33,659
de ese programita, entender exactamente

320
00:12:33,659 --> 00:12:34,740
qué tengo que hacer

321
00:12:34,740 --> 00:12:37,720
vale, ya he entendido lo que tengo que hacer

322
00:12:37,720 --> 00:12:39,700
me dan un número n y tengo que

323
00:12:39,700 --> 00:12:42,139
conseguir la multiplicación de n por n-1

324
00:12:42,139 --> 00:12:43,600
por n-2, por n-3

325
00:12:43,600 --> 00:12:44,620
porque ese es el factoría

326
00:12:44,620 --> 00:12:47,059
vale, ahora ya me iría a cómo lo hago

327
00:12:47,059 --> 00:12:49,379
cómo lo hago, ya entra

328
00:12:49,379 --> 00:12:51,480
donde estamos nosotros, que es

329
00:12:51,480 --> 00:12:53,279
¿qué sentencias necesito?

330
00:12:53,279 --> 00:12:55,580
pues tendrás que leer datos

331
00:12:55,580 --> 00:12:56,720
¿de dónde los lees? ¿cómo?

332
00:12:57,080 --> 00:12:58,980
en este caso un dato, cuando tengas ese dato

333
00:12:58,980 --> 00:13:01,379
¿qué haces para obtener ese resultado?

334
00:13:01,519 --> 00:13:03,460
¿cómo lo haces? tendré que hacer un bucle porque son muchas

335
00:13:03,460 --> 00:13:05,539
multiplicaciones, luego voy a tener que multiplicar mucho

336
00:13:05,539 --> 00:13:07,639
pues hago un bucle, pues ahí ya entra

337
00:13:07,639 --> 00:13:09,519
el diseño, que ahí ya sí que estamos

338
00:13:09,519 --> 00:13:11,519
nosotros, y una vez

339
00:13:11,519 --> 00:13:12,340
que uno tiene claro

340
00:13:12,340 --> 00:13:15,360
cómo lo va a hacer, ya

341
00:13:15,360 --> 00:13:18,039
lo programa en un lenguaje de programación

342
00:13:18,039 --> 00:13:21,379
que sería la fase de

343
00:13:21,379 --> 00:13:23,039
escritura de código, de codificación

344
00:13:23,039 --> 00:13:25,159
entonces aquí ya entra

345
00:13:25,159 --> 00:13:27,019
elegir un lenguaje de programación

346
00:13:27,019 --> 00:13:28,879
claro, pero

347
00:13:28,879 --> 00:13:31,159
la fase de diseño que es la crítica

348
00:13:31,159 --> 00:13:33,460
después del análisis

349
00:13:33,460 --> 00:13:35,039
claro, no necesita ningún lenguaje

350
00:13:35,039 --> 00:13:35,600
de programación

351
00:13:35,600 --> 00:13:39,259
y luego ya para completar y no quedarnos a medias

352
00:13:39,259 --> 00:13:41,080
pues tendríamos la fase

353
00:13:41,080 --> 00:13:41,960
de pruebas

354
00:13:41,960 --> 00:13:45,019
en la que el código ya está

355
00:13:45,019 --> 00:13:47,240
hecho, ya se puede ejecutar

356
00:13:47,240 --> 00:13:49,200
y se le empiezan a meter

357
00:13:49,200 --> 00:13:50,600
casos de pruebas

358
00:13:50,600 --> 00:13:52,419
pruebas. Por ejemplo, si mi programa

359
00:13:52,419 --> 00:13:54,440
hacía el factorial, pruebo con negativos,

360
00:13:54,639 --> 00:13:56,799
pruebo con cero, pruebo con números enormes,

361
00:13:56,940 --> 00:13:57,980
pruebo con números pequeñitos,

362
00:13:58,360 --> 00:14:00,580
hago muchas pruebas a ver si en alguna

363
00:14:00,580 --> 00:14:01,639
consigo que falle.

364
00:14:03,220 --> 00:14:04,600
¿Vale? Entonces la fase de pruebas es

365
00:14:04,600 --> 00:14:06,600
importantísima. Por eso está

366
00:14:06,600 --> 00:14:08,980
también establecido una serie de procedimientos

367
00:14:08,980 --> 00:14:10,320
para que se haga organizada

368
00:14:10,320 --> 00:14:12,799
con un conjunto de casos de prueba que cubran

369
00:14:12,799 --> 00:14:13,980
todas las posibilidades posibles, etc.

370
00:14:14,580 --> 00:14:16,179
Que también lo veréis en entornos de desarrollo.

371
00:14:17,519 --> 00:14:19,059
Y si ya el software ha pasado a la fase

372
00:14:19,059 --> 00:14:21,039
de pruebas, se supone que ya

373
00:14:21,039 --> 00:14:22,980
se sube a los servidores de

374
00:14:22,980 --> 00:14:24,940
producción, ya se pone ahí a disposición

375
00:14:24,940 --> 00:14:25,139
de

376
00:14:25,139 --> 00:14:29,159
a los usuarios y entraría

377
00:14:29,159 --> 00:14:30,559
en una fase que no acaba nunca

378
00:14:30,559 --> 00:14:33,240
que es la fase de mantenimiento.

379
00:14:34,340 --> 00:14:35,340
¿Vale? Porque esa aplicación

380
00:14:35,340 --> 00:14:37,120
aunque la fase de pruebas haya sido

381
00:14:37,120 --> 00:14:39,000
la más completa y la mejor del universo

382
00:14:39,000 --> 00:14:40,279
seguro

383
00:14:40,279 --> 00:14:42,600
que algún bug se ha colado.

384
00:14:43,179 --> 00:14:44,940
Y lo más probable es que en algún momento

385
00:14:44,940 --> 00:14:47,080
un usuario dentro de seis

386
00:14:47,080 --> 00:14:48,720
meses te diga

387
00:14:48,720 --> 00:14:51,360
uy, intenté hacer esto

388
00:14:51,360 --> 00:14:52,659
y me cascó, no pude

389
00:14:52,659 --> 00:14:55,539
¿vale? pues esa fase de mantenimiento infinita

390
00:14:55,539 --> 00:14:57,320
es en la que

391
00:14:57,320 --> 00:14:59,299
se mantiene la aplicación

392
00:14:59,299 --> 00:15:01,039
según se van reportando bugs

393
00:15:01,039 --> 00:15:02,100
o problemas que ha tenido

394
00:15:02,100 --> 00:15:05,080
se la amplían porque el cliente que te pidió

395
00:15:05,080 --> 00:15:06,759
el software a lo mejor dentro de un año te dice

396
00:15:06,759 --> 00:15:08,820
jo, vale, está muy bien

397
00:15:08,820 --> 00:15:11,179
pero por favor he incorporado un departamento nuevo

398
00:15:11,179 --> 00:15:12,919
incorpórame estas funcionalidades

399
00:15:12,919 --> 00:15:14,740
al software, porque quiero que haga

400
00:15:14,740 --> 00:15:16,980
además esta cosita, bueno, pues todo esto

401
00:15:16,980 --> 00:15:18,259
es esta fase infinita

402
00:15:18,259 --> 00:15:20,360
hasta que ya el software desaparece

403
00:15:20,360 --> 00:15:21,559
pues ya no se usa jamás

404
00:15:21,559 --> 00:15:22,860
si, dime

405
00:15:22,860 --> 00:15:23,980
bueno, si te piden una

406
00:15:23,980 --> 00:15:26,539
o sea, en una aplicación que ya has hecho

407
00:15:26,539 --> 00:15:28,700
y te piden algo nuevo, sería otra vez

408
00:15:28,700 --> 00:15:30,580
hacer una análisis, diseño y tal

409
00:15:30,580 --> 00:15:32,639
en el campo de mantenimiento, habría que hacerlo por eso

410
00:15:32,639 --> 00:15:34,539
sí, claro, porque esto

411
00:15:34,539 --> 00:15:35,940
que yo he dicho aquí es

412
00:15:35,940 --> 00:15:38,799
el modelo más claro del ciclo

413
00:15:38,799 --> 00:15:40,500
de vida del software, ciclo de vida del software

414
00:15:40,500 --> 00:15:42,139
significa por qué pasos pasa el software

415
00:15:42,139 --> 00:15:44,759
este es el ciclo de vida visualmente más

416
00:15:44,759 --> 00:15:46,720
claro, que todos intuimos, análisis, diseño

417
00:15:46,720 --> 00:15:48,320
codificación, pruebas y mantenimiento

418
00:15:48,320 --> 00:15:49,559
pero efectivamente

419
00:15:49,559 --> 00:15:52,539
no todo sigue un modelo tan sencillo

420
00:15:52,539 --> 00:15:54,580
porque en función de la ampliación

421
00:15:54,580 --> 00:15:56,500
que te llegue, pues tendrías tú

422
00:15:56,500 --> 00:15:58,320
que volver a hacer todas las fases

423
00:15:58,320 --> 00:16:00,659
entonces por eso, si vamos refinando

424
00:16:00,659 --> 00:16:02,759
esto, llega una cosa que se llama el modelo en espiral

425
00:16:02,759 --> 00:16:04,539
que refleja

426
00:16:04,539 --> 00:16:06,700
lo que tú acabas de decir, en realidad yo voy

427
00:16:06,700 --> 00:16:07,600
iterando

428
00:16:07,600 --> 00:16:10,440
sobre lo mismo, que ahora quiero

429
00:16:10,440 --> 00:16:12,240
ampliar lo nuevo, hago una nueva iteración

430
00:16:12,240 --> 00:16:14,779
de análisis, diseño, vamos iterando

431
00:16:14,779 --> 00:16:16,600
¿vale? pero todo esto os lo contará

432
00:16:16,600 --> 00:16:18,679
abráis con más detalle.

433
00:16:18,840 --> 00:16:20,600
Entonces, ¿para qué venía este rollo mío?

434
00:16:21,200 --> 00:16:22,340
Bueno, pues que

435
00:16:22,340 --> 00:16:24,399
según el equipo de

436
00:16:24,399 --> 00:16:25,519
desarrollo de proyecto

437
00:16:25,519 --> 00:16:28,419
va cubriendo estas

438
00:16:28,419 --> 00:16:30,440
fases, pues las va

439
00:16:30,440 --> 00:16:32,639
documentando, las tendrá que documentar

440
00:16:32,639 --> 00:16:34,580
para que el resto de

441
00:16:34,580 --> 00:16:36,500
miembros del proyecto se enteren

442
00:16:36,500 --> 00:16:38,100
de los resultados.

443
00:16:39,179 --> 00:16:40,700
Bueno, pues para documentar el análisis

444
00:16:40,700 --> 00:16:42,259
hay un montón de documentos de Arama

445
00:16:42,259 --> 00:16:43,879
su ML, un montón de rollos.

446
00:16:44,500 --> 00:16:46,539
Y para documentar el diseño, ¿cómo lo hago?

447
00:16:46,600 --> 00:16:49,279
pues tenemos nuestros diagramitas de flujo

448
00:16:49,279 --> 00:16:51,539
que explican el programa

449
00:16:51,539 --> 00:16:54,600
que tiene que hacer

450
00:16:54,600 --> 00:16:59,080
diagramas de flujo y muchas otras herramientas

451
00:16:59,080 --> 00:17:01,899
pero los diagramas de flujo

452
00:17:01,899 --> 00:17:04,200
pues es una

453
00:17:04,200 --> 00:17:06,079
¿ya? ¿está rápido?

454
00:17:07,920 --> 00:17:08,619
ay bueno

455
00:17:08,619 --> 00:17:14,660
déjale que se vaya

456
00:17:14,660 --> 00:17:16,880
hasta luego

457
00:17:18,039 --> 00:17:20,839
vale, entonces

458
00:17:20,839 --> 00:17:23,640
los diagramas de flujo es una de tantas

459
00:17:23,640 --> 00:17:25,160
herramientas

460
00:17:25,160 --> 00:17:27,519
estándar para documentar

461
00:17:27,519 --> 00:17:29,140
los resultados

462
00:17:29,140 --> 00:17:31,539
de esta fase para que esté todo ahí documentado

463
00:17:31,539 --> 00:17:32,900
entonces

464
00:17:32,900 --> 00:17:35,279
todo esto ha venido

465
00:17:35,279 --> 00:17:37,579
por cómo expresamos

466
00:17:37,579 --> 00:17:39,380
la sentencia de decisión en un diagrama

467
00:17:39,380 --> 00:17:40,819
de flujos, es una herramienta que

468
00:17:40,819 --> 00:17:43,539
habéis visto mil veces, una forma de especificar

469
00:17:43,539 --> 00:17:45,460
los diseños que habréis visto

470
00:17:45,460 --> 00:17:47,359
por ahí mil veces, entonces

471
00:17:47,359 --> 00:17:52,720
Entonces, nuestra sentencia I, en un diagrama de flujo, sería algo así.

472
00:17:55,460 --> 00:17:57,180
Nuestra sentencia de decisión, perdón.

473
00:17:57,900 --> 00:17:59,059
Lo de I no lo he dicho todavía.

474
00:18:06,470 --> 00:18:13,549
Vale, pues a ver, los diagramas de flujo son un dibujito para ver lo que hace un programa.

475
00:18:13,750 --> 00:18:15,829
¿Cómo lo hace? Un dibujito, es más que un dibujito.

476
00:18:15,930 --> 00:18:20,529
Entonces, como un programa tiene un inicio y un fin, pues entra en un sitio, un punto, que es el inicio,

477
00:18:20,529 --> 00:18:42,390
Pues ahí arranca el programita y ahora ya empieza la línea. Las asignaciones, pues las podemos expresar en un cuadradito y ya está. Pues n igual a 3. En particular, si la asignación viene de leer del teclado, o sea, si es una sentencia de entrada y salida, se suele expresar con un romboide en lugar de con un rectangulito.

478
00:18:42,390 --> 00:18:55,430
Pero bueno, ¿vale? Por ejemplo, si la n en lugar de asignarle el valor directamente, lo que hacemos es asignarle el valor, pero de la consola, pues el simbolito que se puede usar es un roboide.

479
00:18:55,430 --> 00:18:57,549
vale, entonces el programa continúa

480
00:18:57,549 --> 00:18:59,470
y hace sus cosas

481
00:18:59,470 --> 00:19:01,309
pues n más 3

482
00:19:01,309 --> 00:19:03,950
n igual a n más 3

483
00:19:03,950 --> 00:19:05,450
lo que sea, el programa continúa

484
00:19:05,450 --> 00:19:07,849
y ahora, a lo mejor hemos

485
00:19:07,849 --> 00:19:09,210
identificado que aquí

486
00:19:09,210 --> 00:19:11,789
ahora ya queremos

487
00:19:11,789 --> 00:19:13,589
hacer una cosa o queremos hacer otra

488
00:19:13,589 --> 00:19:15,029
en función

489
00:19:15,029 --> 00:19:17,329
de precisamente

490
00:19:17,329 --> 00:19:19,369
si n

491
00:19:19,369 --> 00:19:22,190
pues por ejemplo es negativo o positivo

492
00:19:22,190 --> 00:19:23,109
por ejemplo

493
00:19:23,109 --> 00:19:25,829
vale, voy a cortarlo aquí para que

494
00:19:25,829 --> 00:19:33,250
por ejemplo, este podría ser

495
00:19:33,250 --> 00:19:34,690
mi diagrama de flujo

496
00:19:34,690 --> 00:19:35,630
entonces ahí me dicen

497
00:19:35,630 --> 00:19:37,309
si n es

498
00:19:37,309 --> 00:19:39,670
negativo

499
00:19:39,670 --> 00:19:41,809
lo que tienes que hacer es

500
00:19:41,809 --> 00:19:44,369
decirle que el número no es válido

501
00:19:44,369 --> 00:19:46,650
si n es positivo

502
00:19:46,650 --> 00:19:48,410
entonces en ese caso

503
00:19:48,410 --> 00:19:50,569
solicitas otro número

504
00:19:50,569 --> 00:19:53,009
y muestras la suma de los dos

505
00:19:53,009 --> 00:19:53,890
por ejemplo

506
00:19:53,890 --> 00:19:55,369
entonces esos son

507
00:19:55,369 --> 00:19:58,410
dos caminos posibles, muy distintos

508
00:19:58,410 --> 00:20:01,630
que va a hacer el programa

509
00:20:01,630 --> 00:20:03,150
en una ejecución

510
00:20:03,150 --> 00:20:05,029
hará uno, el de decir

511
00:20:05,029 --> 00:20:06,109
el número no es válido

512
00:20:06,109 --> 00:20:08,630
pero en otra ejecución puede que haga otro

513
00:20:08,630 --> 00:20:10,630
el de decir, pide otro

514
00:20:10,630 --> 00:20:13,289
número, sumarlo al primero, etc

515
00:20:13,289 --> 00:20:14,789
son dos cosas muy distintas

516
00:20:14,789 --> 00:20:16,049
las que hace

517
00:20:16,049 --> 00:20:19,630
vale, me tendrán que especificar en función de que

518
00:20:19,630 --> 00:20:20,690
pues si es negativo

519
00:20:20,690 --> 00:20:23,210
lo único que va a hacer es decirte

520
00:20:23,210 --> 00:20:25,589
el número no es válido

521
00:20:25,589 --> 00:20:27,549
pero si es positivo son muchas más cosas

522
00:20:27,549 --> 00:20:28,190
las que va a hacer

523
00:20:28,190 --> 00:20:31,329
Bueno, pues ahí automáticamente identificamos que hay una decisión.

524
00:20:32,369 --> 00:20:34,609
Bueno, pues en un diagrama de flujo esto lo expresamos así,

525
00:20:35,250 --> 00:20:38,250
con un rombito donde ponemos la condición.

526
00:20:39,329 --> 00:20:41,990
En este caso nuestra condición es n menor que 0.

527
00:20:42,950 --> 00:20:44,049
Esa es nuestra condición.

528
00:20:44,569 --> 00:20:47,250
La condición que define si nos vamos por un lado o nos vamos por otro.

529
00:20:49,700 --> 00:20:55,039
Y del rombito saldrán dos ramas, la del sí y la del no.

530
00:20:55,039 --> 00:20:58,640
si la condición se cumple

531
00:20:58,640 --> 00:21:00,519
aquí ya pueden pasar

532
00:21:00,519 --> 00:21:02,700
millones de cosas, las que yo quiera

533
00:21:02,700 --> 00:21:04,539
y si no se

534
00:21:04,539 --> 00:21:06,440
cumple, aquí millones de cosas

535
00:21:06,440 --> 00:21:07,500
las que yo quiera

536
00:21:07,500 --> 00:21:10,660
¿vale? y cuando esas millones de cosas

537
00:21:10,660 --> 00:21:12,839
hayan terminado, tanto en un lado como en otro

538
00:21:12,839 --> 00:21:14,400
el programa continuará

539
00:21:14,400 --> 00:21:15,579
su camino

540
00:21:15,579 --> 00:21:18,460
¿vale? las dos ramas

541
00:21:18,460 --> 00:21:20,420
de la sentencia y decisión, ahí se juntan

542
00:21:20,420 --> 00:21:22,359
aquí

543
00:21:22,359 --> 00:21:24,619
pasarán un montón de cosas, las que yo

544
00:21:24,619 --> 00:21:26,740
quiera que pasen, si n es negativo

545
00:21:26,740 --> 00:21:28,599
y aquí pasarán las cosas que yo quiero

546
00:21:28,599 --> 00:21:30,339
que pasen si n es mayor o igual que cero.

547
00:21:31,140 --> 00:21:32,259
Y luego el programa continuará.

548
00:21:32,640 --> 00:21:34,940
Por ejemplo, ¿cómo? Pues a lo mejor despidiéndose.

549
00:21:44,369 --> 00:21:44,589
¿Vale?

550
00:21:45,150 --> 00:21:47,130
Entonces, esta sentencia

551
00:21:47,130 --> 00:21:48,410
ya va fuera

552
00:21:48,410 --> 00:21:51,069
de la sentencia de decisión, porque

553
00:21:51,069 --> 00:21:53,009
el despedirse lo hago

554
00:21:53,009 --> 00:21:55,150
tanto si voy por esta

555
00:21:55,150 --> 00:21:56,769
rama como si voy por esta otra.

556
00:21:57,289 --> 00:21:59,049
El despedirse lo hago en ambos

557
00:21:59,049 --> 00:22:01,430
casos. Pues entonces el despedirse

558
00:22:01,430 --> 00:22:03,150
lo he puesto aquí, ya a continuación

559
00:22:03,150 --> 00:22:04,730
cuando ya las ramas se han juntado

560
00:22:04,730 --> 00:22:07,509
si solo me quisiera despedir

561
00:22:07,509 --> 00:22:09,190
cuando el número

562
00:22:09,190 --> 00:22:09,890
es positivo

563
00:22:09,890 --> 00:22:13,069
pues pondría la despedida aquí

564
00:22:13,069 --> 00:22:14,869
¿vale?

565
00:22:14,910 --> 00:22:17,309
para que la despedida solo se hiciera si el número

566
00:22:17,309 --> 00:22:18,589
es positivo

567
00:22:18,589 --> 00:22:22,410
pero yo me quiero despedir en ambos casos

568
00:22:22,410 --> 00:22:24,349
pues esto ya va fuera y es otra sentencia más

569
00:22:24,349 --> 00:22:25,369
y el programa podría seguir

570
00:22:25,369 --> 00:22:28,549
porque la decisión abre dos caminos

571
00:22:28,549 --> 00:22:29,670
que

572
00:22:29,670 --> 00:22:32,450
son independientes un tiempo

573
00:22:32,450 --> 00:22:34,329
luego ya

574
00:22:34,329 --> 00:22:36,589
y podría seguir en un camino

575
00:22:36,589 --> 00:22:38,410
y luego abrir otra

576
00:22:38,410 --> 00:22:40,289
sí, sí, sí, claro

577
00:22:40,289 --> 00:22:41,269
entonces ahora

578
00:22:41,269 --> 00:22:44,089
imagina aquí el programa en algún momento terminará

579
00:22:44,089 --> 00:22:45,789
pues por ejemplo aquí termina, vale

580
00:22:45,789 --> 00:22:48,190
entonces ahora aquí ya podemos seguir

581
00:22:48,190 --> 00:22:49,390
refinando efectivamente

582
00:22:49,390 --> 00:22:51,990
este es el diseño de mi programa, va a hacer esto

583
00:22:51,990 --> 00:22:53,509
vamos a seguir refinando

584
00:22:53,509 --> 00:22:56,329
ahora ya pienso, en el caso de que

585
00:22:56,329 --> 00:22:58,549
sea menor que cero, ¿qué quiero que haga?

586
00:22:58,710 --> 00:23:00,029
y solo en ese caso

587
00:23:00,029 --> 00:23:01,470
solo en ese caso

588
00:23:01,470 --> 00:23:03,410
pues hemos dicho mostrar

589
00:23:03,410 --> 00:23:05,990
no válido. Estoy poniendo aquí

590
00:23:05,990 --> 00:23:07,950
un romboide porque mostrar también

591
00:23:07,950 --> 00:23:09,890
es sentencia de salida y los romboides

592
00:23:09,890 --> 00:23:11,869
se asumen para sentencias tanto

593
00:23:11,869 --> 00:23:13,710
de entrada de datos como de salida.

594
00:23:14,430 --> 00:23:15,849
Y mostrar por consola es salida

595
00:23:15,849 --> 00:23:17,690
también. Entonces, pues aquí

596
00:23:17,690 --> 00:23:19,529
podría ser mostrar no válido.

597
00:23:21,670 --> 00:23:21,849
¡Hala!

598
00:23:22,349 --> 00:23:23,869
Esa rama ya no tiene más

599
00:23:23,869 --> 00:23:26,069
que hacer. El resto

600
00:23:26,069 --> 00:23:26,990
de cosas que haga

601
00:23:26,990 --> 00:23:30,250
ya son independientes de la decisión

602
00:23:30,250 --> 00:23:31,809
porque se van a hacer tanto

603
00:23:31,809 --> 00:23:32,970
si sí como si no.

604
00:23:33,410 --> 00:23:34,730
Luego esa rama no tiene más que hacer.

605
00:23:35,630 --> 00:23:39,549
Ahora, en el caso de que sea negativo, ¿qué quiero yo que pase?

606
00:23:40,089 --> 00:23:41,930
Pues puedo querer que pase un montón de cosas.

607
00:23:42,950 --> 00:23:47,250
Pues, por ejemplo, a lo mejor quiero que pase leer un número m,

608
00:23:47,250 --> 00:23:55,450
leer m y mostrar en la propia variable n, guardar n más m,

609
00:23:56,230 --> 00:23:59,549
es decir, a n sumarle m y guardar eso en n.

610
00:23:59,549 --> 00:24:02,569
y ahora pues a lo mejor

611
00:24:02,569 --> 00:24:04,670
quiero mostrar ese valor

612
00:24:04,670 --> 00:24:08,339
quiero aquí ahora ya

613
00:24:08,339 --> 00:24:11,160
mostrar el resultado de n

614
00:24:11,160 --> 00:24:14,160
mostrar n por ejemplo

615
00:24:14,160 --> 00:24:16,220
y ya hemos terminado

616
00:24:16,220 --> 00:24:19,160
entonces las ramas son independientes

617
00:24:19,160 --> 00:24:21,160
cada uno hace una cosa completamente distinta

618
00:24:21,160 --> 00:24:22,980
pero llega un momento

619
00:24:22,980 --> 00:24:25,099
en que esta ya ha terminado con su cometido

620
00:24:25,099 --> 00:24:26,440
y llega aquí

621
00:24:26,440 --> 00:24:29,119
y llegará un momento en que esta ya ha terminado

622
00:24:29,119 --> 00:24:30,680
con su cometido y llega aquí

623
00:24:30,680 --> 00:24:49,920
Y el programa continúa. Esa sentencia ya terminó. La sentencia de decisión terminó. El programa continúa. ¿Vale? Bueno, pues todo esto que tenemos aquí dibujado, todo esto es una sentencia de decisión.

624
00:24:49,920 --> 00:24:52,160
Una sentencia de decisión

625
00:24:52,160 --> 00:24:54,160
Es una sentencia que

626
00:24:54,160 --> 00:24:56,240
Podemos decir que es una sentencia compleja

627
00:24:56,240 --> 00:24:58,119
Porque mete un montón de cosas dentro

628
00:24:58,119 --> 00:25:00,559
No es como una sentencia de asignación

629
00:25:00,559 --> 00:25:02,339
La sentencia de asignación es sencilla

630
00:25:02,339 --> 00:25:05,019
La sentencia de asignación es nombre de variable

631
00:25:05,019 --> 00:25:06,019
Igual a valor

632
00:25:06,019 --> 00:25:09,380
La sentencia de asignación es una sola línea

633
00:25:09,380 --> 00:25:10,839
Por decirlo así, es una línea

634
00:25:10,839 --> 00:25:13,880
Pero la sentencia de decisión

635
00:25:13,880 --> 00:25:15,500
Son un montón de cosas dentro

636
00:25:15,500 --> 00:25:17,240
Es la condición

637
00:25:17,240 --> 00:25:19,380
Lo que hago en caso de que se cumpla

638
00:25:19,380 --> 00:25:21,220
lo que hago en caso de que no se cumpla

639
00:25:21,220 --> 00:25:22,920
un montón de líneas

640
00:25:22,920 --> 00:25:24,700
es la sentencia de decisión

641
00:25:24,700 --> 00:25:27,299
pero repito, es una única sentencia

642
00:25:27,299 --> 00:25:30,019
lo que pasa es que es compleja, tiene muchas líneas

643
00:25:30,019 --> 00:25:31,599
a su vez tiene metidas

644
00:25:31,599 --> 00:25:33,240
dentro sentencias de asignación

645
00:25:33,240 --> 00:25:34,779
o de las que me den la gana, etc.

646
00:25:41,460 --> 00:25:43,400
¿Vale? Pues la representación gráfica

647
00:25:43,400 --> 00:25:45,599
en un diagrama de flujo, una sentencia de decisión

648
00:25:45,599 --> 00:25:47,680
nos permite rápidamente

649
00:25:47,680 --> 00:25:49,200
entender claramente qué es lo que hace

650
00:25:49,200 --> 00:25:55,990
lo que se hace en cada rama

651
00:25:55,990 --> 00:25:58,190
se hace lógicamente una sola vez

652
00:25:58,190 --> 00:26:00,730
no lo confundamos con un bucle que es esto mismo

653
00:26:00,730 --> 00:26:02,430
pero repetido, pero eso ya es un bucle

654
00:26:02,430 --> 00:26:09,640
¿vale? bueno pues

655
00:26:09,640 --> 00:26:11,559
una vez que tenemos nuestro

656
00:26:11,559 --> 00:26:13,619
programa entendido y claro visualizado

657
00:26:13,619 --> 00:26:15,680
en la cabeza o incluso a lo mejor escrito

658
00:26:15,680 --> 00:26:17,599
su diagrama de flujo para entender lo que queremos

659
00:26:17,599 --> 00:26:19,740
hacer, es decir, tenemos su diseño

660
00:26:19,740 --> 00:26:21,640
ahora ya pasar

661
00:26:21,640 --> 00:26:23,519
esto a código, sea Java

662
00:26:23,519 --> 00:26:24,859
sea Python, sea el que sea

663
00:26:24,859 --> 00:26:26,480
esto ya es muy fácil

664
00:26:26,480 --> 00:26:29,119
esto sabemos pasarlo a código

665
00:26:29,119 --> 00:26:31,500
una sentencia con el escáner

666
00:26:31,500 --> 00:26:33,640
para leer, eso se va a pasar a código

667
00:26:33,640 --> 00:26:35,059
que es un sistema println

668
00:26:35,059 --> 00:26:37,059
pues como pasamos a código

669
00:26:37,059 --> 00:26:38,880
toda esta sentencia gordota

670
00:26:38,880 --> 00:26:41,380
pues con la sentencia if

671
00:26:41,380 --> 00:26:42,099
entonces

672
00:26:42,099 --> 00:26:45,720
como pasamos a código, esto si que es chulo

673
00:26:45,720 --> 00:26:46,779
vale

674
00:26:46,779 --> 00:26:48,839
como pasamos a código

675
00:26:48,839 --> 00:26:52,279
esto

676
00:26:52,279 --> 00:26:53,859
vale

677
00:26:53,859 --> 00:26:57,420
pues este programa, pasarlo ahora a código

678
00:26:57,420 --> 00:26:58,880
sería leer n

679
00:26:58,880 --> 00:26:59,759
pues ya lo sabemos

680
00:26:59,759 --> 00:27:02,900
tenemos el escáner, vamos a suponer que tenemos

681
00:27:02,900 --> 00:27:04,519
el escáner ya declarado.

682
00:27:08,119 --> 00:27:09,859
Next if, lo que sea.

683
00:27:10,539 --> 00:27:11,599
Esa sentencia ya está.

684
00:27:12,220 --> 00:27:13,400
Ahora, ¿qué nos viene después?

685
00:27:14,039 --> 00:27:15,500
Toda una sentencia if.

686
00:27:16,160 --> 00:27:18,000
Una sentencia if, que es una cosa gordota.

687
00:27:18,400 --> 00:27:19,900
Es la condición con sus ramas.

688
00:27:20,099 --> 00:27:21,500
Toda esa es la sentencia if.

689
00:27:22,200 --> 00:27:24,740
Vale, pues ¿cómo pasamos esto a código?

690
00:27:25,059 --> 00:27:31,619
Pues la sentencia de decisión empieza con un if, ¿vale?

691
00:27:32,900 --> 00:27:44,259
¿Y qué es lo que ponemos a continuación? A continuación ponemos la condición, la condición que sea, bueno, en nuestro caso ya la teníamos.

692
00:27:44,259 --> 00:28:04,529
Y ahora, ¿qué ponemos después? Lo que ponemos después es lo que se hace en el caso de que la condición se cumpla.

693
00:28:04,529 --> 00:28:24,990
¿Y cómo lo ponemos? Pues lo ponemos entre llaves. De nuevo, para seguir las pautas de una programación, de un código elegante que más o menos se entienda, la llave se abre a continuación del ir y se cierra en algún momento.

694
00:28:24,990 --> 00:28:26,589
cuando ya he terminado la sentencia

695
00:28:26,589 --> 00:28:28,750
estaba en la rama del sí, se cierra

696
00:28:28,750 --> 00:28:30,250
a la altura donde empezó el ir

697
00:28:30,250 --> 00:28:33,009
para que cuando uno lo visualiza vea muy claro

698
00:28:33,009 --> 00:28:34,509
que esta llave

699
00:28:34,509 --> 00:28:36,670
cierra esto

700
00:28:36,670 --> 00:28:38,549
entonces esto sería

701
00:28:38,549 --> 00:28:40,769
lo que va aquí dentro sería todo lo que

702
00:28:40,769 --> 00:28:42,690
se hace en el caso

703
00:28:42,690 --> 00:28:44,849
de que se cumpla en esta rama

704
00:28:44,849 --> 00:28:46,470
en este caso

705
00:28:46,470 --> 00:28:48,289
¿qué es lo que se hace? pues un system out

706
00:28:48,289 --> 00:28:50,450
de no válido, no se hace nada más

707
00:28:50,450 --> 00:28:54,940
no se hace nada más que eso

708
00:28:54,940 --> 00:28:57,140
una única sentencia

709
00:28:57,140 --> 00:29:02,660
Bueno, ¿cómo programo lo que se hace en el caso de que no se cumpla?

710
00:29:03,339 --> 00:29:05,700
Pues pongo aquí a continuación el SE

711
00:29:05,700 --> 00:29:09,299
Y lo mismo, abro una llave justo detrás

712
00:29:09,299 --> 00:29:12,559
Que cerraré a la misma altura del IF

713
00:29:12,559 --> 00:29:14,380
Para que el código quede claro

714
00:29:14,380 --> 00:29:17,140
Que repito, no es obligatorio

715
00:29:17,140 --> 00:29:19,680
Puede uno hacer un código a limatías

716
00:29:19,680 --> 00:29:22,400
Pero muy mal, así no tiene futuro

717
00:29:22,400 --> 00:29:26,680
Y allá entre estas llaves ponemos lo que queremos hacer aquí

718
00:29:26,680 --> 00:29:28,960
que en este caso pues sí que sería un poco más largo

719
00:29:28,960 --> 00:29:30,619
pues sería leer m

720
00:29:30,619 --> 00:29:37,819
a n

721
00:29:37,819 --> 00:29:39,500
sumarle

722
00:29:39,500 --> 00:29:44,920
más igual m

723
00:29:44,920 --> 00:29:46,839
vale

724
00:29:46,839 --> 00:29:48,119
esa es la siguiente sentencia

725
00:29:48,119 --> 00:29:50,700
a n sumarle m y meterlo en n

726
00:29:50,700 --> 00:29:52,539
y luego

727
00:29:52,539 --> 00:29:54,920
mostrar n, hemos dicho que todo eso

728
00:29:54,920 --> 00:29:56,279
se hace ahí, por ejemplo

729
00:29:56,279 --> 00:29:58,000
vale

730
00:29:58,000 --> 00:30:00,299
todo eso se hace en el caso del no

731
00:30:00,299 --> 00:30:01,700
pues va en estas llaves

732
00:30:01,700 --> 00:30:11,759
y esta sentencia ya está terminada de programar, ya se acabó, está terminada de programar, ya ha terminado.

733
00:30:11,759 --> 00:30:22,670
Luego esto que yo tengo aquí en rojo es esto de aquí, ¿vale? Esto de aquí está programado así, de esa manera.

734
00:30:25,430 --> 00:30:32,849
Aquí la condición, aquí lo que se hace en caso de que se cumpla y aquí lo que se hace en caso de que no se cumpla.

735
00:30:32,849 --> 00:30:35,029
esta es la versión básica

736
00:30:35,029 --> 00:30:36,930
del libro, luego ya admite

737
00:30:36,930 --> 00:30:38,910
modificaciones, matices, cosas

738
00:30:38,910 --> 00:30:40,130
que ahora vamos a ir diciendo

739
00:30:40,130 --> 00:30:42,269
pero bueno, esta es la versión básica

740
00:30:42,269 --> 00:30:46,460
¿vale? ahora cuando la

741
00:30:46,460 --> 00:30:48,579
sentencia de edición ha terminado, que es en este punto

742
00:30:48,579 --> 00:30:50,819
aquí, mi programa

743
00:30:50,819 --> 00:30:52,539
sigue haciendo lo que tenga que hacer

744
00:30:52,539 --> 00:30:53,619
dime

745
00:30:53,619 --> 00:30:58,619
si, las mismas, toda la misma altura

746
00:30:58,619 --> 00:31:00,359
para que quede claro que esto está

747
00:31:00,359 --> 00:31:01,619
asociado a la sentencia

748
00:31:01,619 --> 00:31:02,700
¿vale?

749
00:31:04,480 --> 00:31:28,000
Ahora, cuando esa sentencia ha terminado, que es en este punto de abajo, cuando esta sentencia ha terminado, que es en este puntito de abajo, aquí y aquí, o sea, este punto y este punto son el mismo, ahí ya las dos ramas terminaron su ejecución, o sea, terminaron su camino y se acabó.

750
00:31:28,000 --> 00:31:30,019
y ahora ya mi programa continúa

751
00:31:30,019 --> 00:31:32,640
y lo que continúa haciendo a partir de aquí

752
00:31:32,640 --> 00:31:34,299
ya no depende de ninguna condición

753
00:31:34,299 --> 00:31:36,319
mucho menos de esta, esto ya se hace

754
00:31:36,319 --> 00:31:38,660
como una sentencia más, una tras otra

755
00:31:38,660 --> 00:31:39,779
una tras otra, en este caso

756
00:31:39,779 --> 00:31:42,460
la única sentencia añadida

757
00:31:42,460 --> 00:31:44,420
que tiene el programa es mostrarle adiós

758
00:31:44,420 --> 00:31:46,640
pues venga, aquí iría un adiós

759
00:31:47,220 --> 00:31:50,319
y ya está

760
00:31:50,319 --> 00:31:52,019
y esta sentencia

761
00:31:52,019 --> 00:31:54,500
que es esta, ya está fuera del if

762
00:31:54,500 --> 00:31:56,160
ya se hace

763
00:31:56,160 --> 00:31:58,220
cuando esto ya ha terminado

764
00:31:58,220 --> 00:31:59,619
cuando estos dos caminos

765
00:31:59,619 --> 00:32:05,160
y ahora ya, empezamos a ejecutar esto

766
00:32:05,160 --> 00:32:06,500
en alguna ejecución

767
00:32:06,500 --> 00:32:08,960
vendrá, el programa hará esto

768
00:32:08,960 --> 00:32:11,339
dentro de dos minutos

769
00:32:11,339 --> 00:32:12,920
lo ejecutamos y el programa

770
00:32:12,920 --> 00:32:15,140
hace esto, a lo mejor en la siguiente

771
00:32:15,140 --> 00:32:17,079
ejecución vuelve a hacer esto, en la siguiente

772
00:32:17,079 --> 00:32:18,740
vuelve a hacer esto, luego en

773
00:32:18,740 --> 00:32:20,180
cada ejecución

774
00:32:20,180 --> 00:32:23,180
o va por aquí o va por aquí

775
00:32:23,180 --> 00:32:25,160
lógicamente, en cada ejecución

776
00:32:25,160 --> 00:32:26,900
o se hace una cosa o se

777
00:32:26,900 --> 00:32:29,299
hace la otra, dependiendo de esto

778
00:32:29,299 --> 00:32:31,319
pero las dos posibilidades

779
00:32:31,319 --> 00:32:33,480
están contempladas, las dos

780
00:32:33,480 --> 00:32:38,349
luego es una sentencia

781
00:32:38,349 --> 00:32:40,049
imprescindible, cualquier programa

782
00:32:40,049 --> 00:32:41,029
nos tiene

783
00:32:41,029 --> 00:32:43,970
cualquier situación

784
00:32:43,970 --> 00:32:46,230
normalmente nos plantea

785
00:32:46,230 --> 00:32:48,230
esta situación, oye es que

786
00:32:48,230 --> 00:32:50,549
no quiero que hagas siempre esto

787
00:32:50,549 --> 00:32:52,609
a veces querré que hagas esto

788
00:32:52,609 --> 00:32:54,289
y a veces querré que hagas esto otro

789
00:32:54,289 --> 00:32:56,470
eso cualquier situación nos lo va a plantear

790
00:32:56,470 --> 00:32:58,789
cualquiera, pues eso lo tendremos

791
00:32:58,789 --> 00:33:00,089
que programar de esta manera

792
00:33:00,089 --> 00:33:02,589
¿vale?

793
00:33:02,589 --> 00:33:07,359
pequeñas cosas antes

794
00:33:07,359 --> 00:33:09,619
de ver algún ejemplo

795
00:33:09,619 --> 00:33:11,500
pequeñas cosas

796
00:33:11,500 --> 00:33:13,019
si después

797
00:33:13,019 --> 00:33:14,700
si en alguna de las ramas

798
00:33:14,700 --> 00:33:16,480
si en alguna de las ramas

799
00:33:16,480 --> 00:33:18,740
solo hay una sentencia

800
00:33:18,740 --> 00:33:21,039
como es aquí en el caso del sí

801
00:33:21,039 --> 00:33:23,740
las llaves son opcionales

802
00:33:23,740 --> 00:33:25,200
no hay por qué ponerlas

803
00:33:25,200 --> 00:33:25,920
¿vale?

804
00:33:26,559 --> 00:33:28,619
entonces si yo no pongo estas llaves

805
00:33:28,619 --> 00:33:32,769
estas de aquí

806
00:33:32,769 --> 00:33:37,329
la máquina virtual, el compilador

807
00:33:37,329 --> 00:33:39,710
interpreta que la única

808
00:33:39,710 --> 00:33:41,630
sentencia que va asociada a la rama

809
00:33:41,630 --> 00:33:43,490
del sí, que es la de if, es la primera

810
00:33:43,490 --> 00:33:45,730
que hay, interpreta que es la única

811
00:33:45,730 --> 00:33:47,630
entonces cuidado

812
00:33:47,630 --> 00:33:49,890
si en alguna de las ramas

813
00:33:49,890 --> 00:33:51,130
hay varias cosas

814
00:33:51,130 --> 00:33:52,730
como es este caso

815
00:33:52,730 --> 00:33:54,910
tiene que estar entre llaves

816
00:33:54,910 --> 00:33:57,990
porque si no, el programa va a interpretar

817
00:33:57,990 --> 00:33:59,950
que es solo la primera de ellas

818
00:33:59,950 --> 00:34:00,930
¿vale?

819
00:34:01,829 --> 00:34:03,910
pero si solo hay una sentencia

820
00:34:03,910 --> 00:34:05,750
puedo enviar las llaves

821
00:34:05,750 --> 00:34:07,210
tanto en el if como en el else

822
00:34:07,210 --> 00:34:10,730
si el else solo tuviera una sentencia

823
00:34:10,730 --> 00:34:11,710
de todas estas

824
00:34:11,710 --> 00:34:13,369
podría quitar las llaves

825
00:34:13,369 --> 00:34:17,929
y no habría confusión sobre si este

826
00:34:17,929 --> 00:34:19,909
está dentro o no, no habría porque al no haber

827
00:34:19,909 --> 00:34:21,949
llaves, solo la primera

828
00:34:21,949 --> 00:34:24,110
está dentro del else, las demás ya

829
00:34:24,110 --> 00:34:25,409
están fuera

830
00:34:25,409 --> 00:34:26,769
entonces

831
00:34:26,769 --> 00:34:29,289
si se pone no pasa nada

832
00:34:29,289 --> 00:34:31,809
y muchas veces

833
00:34:31,809 --> 00:34:32,889
lo deja mucho más claro

834
00:34:32,889 --> 00:34:35,650
esto sí que va un poco por maní

835
00:34:35,650 --> 00:34:37,929
Estefano siempre pone

836
00:34:37,929 --> 00:34:39,489
llaves haya una o no

837
00:34:39,489 --> 00:34:41,570
por costumbre suya

838
00:34:41,570 --> 00:34:44,309
pero yo si hay una

839
00:34:44,309 --> 00:34:46,030
pues me es más ágil no ponerla

840
00:34:46,030 --> 00:34:47,949
porque además a nivel de código

841
00:34:47,949 --> 00:34:50,250
es que se ve muy claro porque siempre tabulas

842
00:34:50,250 --> 00:34:51,929
lo que va adentro lo tabulas

843
00:34:51,929 --> 00:34:53,010
entonces

844
00:34:53,010 --> 00:34:55,769
si solo es uno

845
00:34:55,769 --> 00:34:56,650
no tienes que poner la llave

846
00:34:56,650 --> 00:34:59,250
y nunca va a haber confusión

847
00:34:59,250 --> 00:35:00,309
porque

848
00:35:00,309 --> 00:35:02,670
si lo has hecho bien

849
00:35:02,670 --> 00:35:05,530
si hay otra sentencia más, esa ya se asume que está fuera

850
00:35:05,530 --> 00:35:07,030
¿vale?

851
00:35:07,929 --> 00:35:08,510
Eso por un lado.

852
00:35:08,949 --> 00:35:11,730
Y por otro, antes de parar un momento,

853
00:35:12,809 --> 00:35:17,190
la rama esta, esta es opcional.

854
00:35:18,369 --> 00:35:19,690
Puede estar o puede no estar.

855
00:35:22,070 --> 00:35:25,190
Es decir, no tiene por qué haber siempre un if asociado a un el si.

856
00:35:26,650 --> 00:35:30,090
La rama del si siempre tiene que estar.

857
00:35:30,570 --> 00:35:32,510
Pero la rama del no puede no estar.

858
00:35:32,630 --> 00:35:33,449
¿Eso qué significa?

859
00:35:34,010 --> 00:35:36,510
Significa que en el caso de que no se cumpla, yo no hago nada.

860
00:35:37,090 --> 00:35:37,409
Ya está.

861
00:35:37,409 --> 00:35:58,059
Entonces, si yo pongo una sentencia de decisión, lo que es obligatorio y siempre tiene que estar es el if con la condición. Eso es obligatorio y siempre tiene que estar. Lo que yo ponga detrás será lo que se haga si se cumple.

862
00:35:58,059 --> 00:36:00,940
Si en el caso de que no se cumpla

863
00:36:00,940 --> 00:36:01,900
Yo no quiero hacer nada

864
00:36:01,900 --> 00:36:03,920
Pues quito el ELSE directamente

865
00:36:03,920 --> 00:36:06,539
No hace falta que ponga un ELSE con unas llaves vacías dentro

866
00:36:06,539 --> 00:36:08,119
Quito el ELSE tal cual

867
00:36:08,119 --> 00:36:18,760
Es decir, si yo no pongo ELSE

868
00:36:18,760 --> 00:36:20,500
Sería como

869
00:36:20,500 --> 00:36:23,300
Tener este programa

870
00:36:23,300 --> 00:36:28,309
¿Vale?

871
00:36:28,809 --> 00:36:30,530
Y esto se puede programar

872
00:36:30,530 --> 00:36:32,949
En el caso de que se cumpla, hago algo

873
00:36:32,949 --> 00:36:35,269
Si no se cumple, nada

874
00:36:35,269 --> 00:36:38,699
¿Esto cómo se programa?

875
00:36:39,239 --> 00:36:40,639
Quitando el ELSE tal cual

876
00:36:40,639 --> 00:36:42,500
Se quita el el si y se acabó

877
00:36:42,500 --> 00:36:44,059
Pero el if o lo que es lo mismo

878
00:36:44,059 --> 00:36:46,260
La rama del si siempre tiene que estar

879
00:36:46,260 --> 00:36:50,460
La rama del si siempre tiene que estar

880
00:36:50,460 --> 00:36:52,059
La del no, que es la del el si

881
00:36:52,059 --> 00:36:53,380
Si yo no quiero que se haga nada

882
00:36:53,380 --> 00:36:55,400
La quito enterita

883
00:36:55,400 --> 00:36:56,880
Y ya está

884
00:36:56,880 --> 00:37:03,300
No, no se apaga

885
00:37:03,300 --> 00:37:04,719
Continúa

886
00:37:04,719 --> 00:37:07,820
Con lo que haya después de la sentencia de decisión

887
00:37:07,820 --> 00:37:08,739
Continúa por aquí

888
00:37:08,739 --> 00:37:10,980
Aquí no hace nada y continúa por aquí

889
00:37:10,980 --> 00:37:12,500
Continúa por ahí

890
00:37:12,500 --> 00:37:36,420
Claro, entonces me diríais, hombre, si yo tengo un programa que lo que quiero es que haga algo cuando no se cumple la condición y que no haga nada cuando sí se cumple, pues no pasa nada, ponemos la condición al revés, ¿vale? Ponemos la condición con el no delante, porque lo que se programa siempre es la rama del sí y la del no es opcional, la del no es opcional.

891
00:37:36,420 --> 00:37:38,880
entonces yo aquí pongo la condición esta

892
00:37:38,880 --> 00:37:40,980
con el no delante cambiada en función

893
00:37:40,980 --> 00:37:42,599
a lo que me interese

894
00:37:42,599 --> 00:37:44,880
para la que, porque la que tiene

895
00:37:44,880 --> 00:37:46,460
que aparecer siempre es la del sí

896
00:37:46,460 --> 00:37:53,539
es decir, si yo quiero un programa

897
00:37:53,539 --> 00:37:55,519
que me muestre no válido

898
00:37:55,519 --> 00:37:57,500
en este caso en la rama del no, por ejemplo

899
00:37:57,500 --> 00:37:59,079
quiero cambiarlo

900
00:37:59,079 --> 00:38:05,340
y quiero que me muestre

901
00:38:05,340 --> 00:38:06,300
no válido aquí

902
00:38:06,300 --> 00:38:08,659
y que aquí me lo muestre vacío

903
00:38:08,659 --> 00:38:12,650
entonces

904
00:38:12,650 --> 00:38:15,510
yo quiero hacer este programa

905
00:38:15,510 --> 00:38:17,449
diagrama de flujo no entiende

906
00:38:17,449 --> 00:38:19,429
de Java no entiende de nada, es un diagrama de flujo

907
00:38:19,429 --> 00:38:21,590
válido, si n es menor que 0

908
00:38:21,590 --> 00:38:22,329
no hagas nada

909
00:38:22,329 --> 00:38:24,889
y si no lo es, haz esto

910
00:38:24,889 --> 00:38:27,389
diríamos, jolines, pues

911
00:38:27,389 --> 00:38:28,809
entonces yo lo tendré que programar

912
00:38:28,809 --> 00:38:30,909
poniendo el if sí o sí

913
00:38:30,909 --> 00:38:33,409
con un n menor que 0, aquí unas

914
00:38:33,409 --> 00:38:35,389
llaves vacías, que feo porque no hace

915
00:38:35,389 --> 00:38:37,090
nada, y aquí un else

916
00:38:37,090 --> 00:38:39,010
y ahora aquí ya sí hacer esto

917
00:38:39,010 --> 00:38:41,349
vale, esto programa

918
00:38:41,349 --> 00:38:43,170
lo de arriba, está bien, no hay problema

919
00:38:43,170 --> 00:38:45,369
pero que feo, un if vacío

920
00:38:45,369 --> 00:38:46,869
y un else

921
00:38:46,869 --> 00:38:48,769
para poner la rama del no

922
00:38:48,769 --> 00:38:50,849
¿cómo programaríais esto en realidad?

923
00:38:53,110 --> 00:38:54,250
¿cambiaríais la condición?

924
00:38:54,769 --> 00:38:56,269
diríais, si

925
00:38:56,269 --> 00:38:58,710
la cambiada, la negada

926
00:38:58,710 --> 00:39:00,389
de n menor que 0, que sería

927
00:39:00,389 --> 00:39:02,710
si n mayor o igual que 0

928
00:39:02,710 --> 00:39:04,769
vale, si n

929
00:39:04,769 --> 00:39:05,809
mayor o igual que 0

930
00:39:05,809 --> 00:39:07,409
pues entonces

931
00:39:07,409 --> 00:39:12,000
esto, y si no

932
00:39:12,000 --> 00:39:14,320
nada, quitaría el else porque no

933
00:39:14,320 --> 00:39:18,000
lo que tienes que cambiar es el n mayor que o menor que

934
00:39:18,000 --> 00:39:19,559
claro, si mi programa

935
00:39:19,559 --> 00:39:21,320
tiene esta forma en su diagramación

936
00:39:21,320 --> 00:39:23,099
de esta manera, yo quiero hacer algo

937
00:39:23,099 --> 00:39:24,320
si no se cumple la condición

938
00:39:24,320 --> 00:39:26,679
lo único que tengo que hacer es cuando lo programe

939
00:39:26,679 --> 00:39:29,420
poner la condición al revés con el no delante

940
00:39:29,420 --> 00:39:31,400
entonces esta rama va al sí

941
00:39:31,400 --> 00:39:32,539
y esta va al no

942
00:39:32,539 --> 00:39:35,420
si yo esta condición la cambio

943
00:39:35,420 --> 00:39:37,199
esta rama va aquí

944
00:39:37,199 --> 00:39:38,760
y esta va aquí

945
00:39:38,760 --> 00:39:41,199
con lo cual ya puedo hacer un if sin su else

946
00:39:41,199 --> 00:39:42,079
normal y corriente

947
00:39:42,079 --> 00:39:46,159
¿cuál?

948
00:39:49,460 --> 00:39:51,039
con el else if

949
00:39:51,039 --> 00:39:52,980
no, no es la inversa, o sea es abrir

950
00:39:52,980 --> 00:39:54,940
otro if dentro de otro if

951
00:39:54,940 --> 00:39:57,519
dentro del else abrir otro if

952
00:39:57,519 --> 00:39:59,420
y dentro del else

953
00:39:59,420 --> 00:40:01,500
abrir otro if, sería eso

954
00:40:01,500 --> 00:40:02,940
luego lo vemos, ¿vale?

955
00:40:03,239 --> 00:40:05,199
sería como anidar más condiciones

956
00:40:05,199 --> 00:40:06,079
dentro del else

957
00:40:06,079 --> 00:40:08,380
vale

958
00:40:08,380 --> 00:40:11,420
bueno, pues ahora con ejemplo se verá más claro

959
00:40:11,420 --> 00:40:13,000
vamos a parar

960
00:40:13,000 --> 00:40:14,599
unos minutejos

961
00:40:14,599 --> 00:40:14,699
Gracias.