1
00:00:00,000 --> 00:00:10,000
Vale, pues estábamos todavía con el tema de programación estructurada.

2
00:00:24,000 --> 00:00:29,000
La programación estructurada que es la base de la programación orientada.

3
00:00:31,000 --> 00:00:37,000
Entonces, la programación estructurada combinaba en secuencia,

4
00:00:37,000 --> 00:00:41,000
en secuencia, una tras otra, una tras otra, cuando una se acaba empieza la siguiente,

5
00:00:41,000 --> 00:00:44,000
cuando una se acaba empieza la siguiente, sentencias, ¿verdad?

6
00:00:45,000 --> 00:00:51,000
Y de esas sentencias las que hemos visto son las de asignación de valores a variables,

7
00:00:52,000 --> 00:00:55,000
variables previamente declaradas, ¿no?

8
00:00:55,000 --> 00:00:58,000
Entonces, variables previamente declaradas, asignarles valor.

9
00:00:59,000 --> 00:01:04,000
Me da igual que sea como resultado una expresión o leídas del teclado,

10
00:01:05,000 --> 00:01:09,000
con el objeto escáner, me da igual, en ambos casos son asignaciones, ¿no?

11
00:01:10,000 --> 00:01:14,000
Asignación siempre, nombre de variable a la izquierda,

12
00:01:16,000 --> 00:01:22,000
nombre de variable a la izquierda, valor que asignamos a la derecha,

13
00:01:23,000 --> 00:01:25,000
esa es la asignación, ¿verdad?

14
00:01:26,000 --> 00:01:31,000
Aquí una expresión cualquiera, un valor o leído del teclado, me da igual,

15
00:01:31,000 --> 00:01:34,000
esta expresión a su vez puede involucrar otras variables,

16
00:01:34,000 --> 00:01:37,000
bueno, todo eso es lo que tenemos que tener ya más o menos en la cabeza dominada.

17
00:01:38,000 --> 00:01:41,000
Vale, aparte de las sentencias de asignación, ¿qué más sentencias conocemos?

18
00:01:42,000 --> 00:01:48,000
Las de decisión, las sentencias de decisión, un IF normal y corriente,

19
00:01:48,000 --> 00:01:56,000
o un IF con un ELSE, o un IF con varios ELSE-IF,

20
00:01:57,000 --> 00:02:02,000
si es que uno quiere, porque se adapta a su situación,

21
00:02:03,000 --> 00:02:08,000
en lugar de simplemente esta situación que si algo se cumple bien y si no hago esto,

22
00:02:09,000 --> 00:02:14,000
y acabo la sentencia, pues si nuestra situación es, si algo se cumple bien y si no,

23
00:02:14,000 --> 00:02:19,000
miro a ver si se cumple esta otra cosa, y si no, miro a ver si se cumple esta otra cosa,

24
00:02:19,000 --> 00:02:23,000
si nuestra situación es esta, ¿vale?, varias ramas excluyentes,

25
00:02:23,000 --> 00:02:27,000
pues podemos poner esta, y si nuestra situación es,

26
00:02:27,000 --> 00:02:30,000
en función del valor de una variable hacer una cosa u otra,

27
00:02:31,000 --> 00:02:34,000
pues elegíamos esta de aquí, ¿verdad?

28
00:02:37,000 --> 00:02:42,000
Bueno, pues estas son las sentencias de decisión que ya conocemos,

29
00:02:44,000 --> 00:02:50,000
sabemos usar y sabemos sobre todo identificar en qué situaciones me interesan a mí seleccionar.

30
00:02:52,000 --> 00:02:56,000
Estos son sentencias, lo que pasa es que son sentencias complejas,

31
00:02:56,000 --> 00:02:59,000
no como la de asignación, que es una sentencia que escribimos en una línea,

32
00:02:59,000 --> 00:03:03,000
esta no la escribimos en una línea, esta sentencia es una sentencia compleja,

33
00:03:03,000 --> 00:03:06,000
aunque es una única sentencia, la sentencia es esta,

34
00:03:06,000 --> 00:03:11,000
es una sentencia compleja que a su vez puede tener aquí un montón de ellas dentro,

35
00:03:11,000 --> 00:03:15,000
y aquí un montón de ellas dentro, y aquí un montón de ellas dentro a su vez,

36
00:03:15,000 --> 00:03:20,000
que a su vez esas pueden ser otros if, eso ya uno va poniendo ahí los ladrillos

37
00:03:20,000 --> 00:03:23,000
y las combinaciones que resuelvan lo que dan, ¿vale?

38
00:03:23,000 --> 00:03:27,000
Bueno, pues solo nos falta un tipo de sentencia de la aprobación estructurada,

39
00:03:27,000 --> 00:03:31,000
solo nos falta un tipo de sentencia, porque lo que decía el teorema de la aprobación estructurada

40
00:03:31,000 --> 00:03:35,000
es que cualquier tarea que le queramos encomendar a un ordenador,

41
00:03:35,000 --> 00:03:39,000
se puede hacer combinando en secuencia decisiones y bucles,

42
00:03:39,000 --> 00:03:43,000
más la asignación de valores a datos, o sea, no lo dice ese teorema,

43
00:03:43,000 --> 00:03:46,000
pero bueno, es evidente que habrá que asignar valores a datos.

44
00:03:46,000 --> 00:03:49,000
Bueno, pues decisiones, sentencias, ya la tenemos,

45
00:03:49,000 --> 00:03:52,000
pues solo nos falta entonces el otro tipo de sentencias,

46
00:03:52,000 --> 00:03:59,000
que son las que se llaman las sentencias repetitivas,

47
00:04:03,000 --> 00:04:08,000
o, en resumen, los bucles de toda la vida, ¿vale?

48
00:04:08,000 --> 00:04:10,000
Los bucles de toda la vida.

49
00:04:10,000 --> 00:04:14,000
Es el único tipo de sentencia en realidad que nos falta de la aprobación estructurada,

50
00:04:14,000 --> 00:04:17,000
y con eso se puede hacer cualquier cosa,

51
00:04:17,000 --> 00:04:20,000
claro, porque lo difícil no es conocer las sentencias y la sintaxis

52
00:04:20,000 --> 00:04:23,000
y las diferentes variantes que hay de una versión de Java a otra,

53
00:04:23,000 --> 00:04:27,000
eso no es lo difícil, eso sí que está en los papeles escritos,

54
00:04:27,000 --> 00:04:34,000
lo difícil es entender un enunciado y a partir de ahí componer estas sentencias,

55
00:04:34,000 --> 00:04:37,000
componerlas para que resuelvan lo que hemos pedido, ¿vale?

56
00:04:37,000 --> 00:04:43,000
Lo difícil es eso, conocer la sintaxis de un lenguaje con sus detalles.

57
00:04:43,000 --> 00:04:47,000
Bueno, pues vamos a terminar de conocer esos ladrillos

58
00:04:47,000 --> 00:04:50,000
que podemos necesitar para construir ese programa.

59
00:04:50,000 --> 00:04:53,000
Pues venga, vamos con los bucles entonces.

60
00:05:04,000 --> 00:05:05,000
¿Vale?

61
00:05:17,000 --> 00:05:21,000
Vale, pues las sentencias de decisión visualizamos ya en un diagrama de flujo,

62
00:05:21,000 --> 00:05:24,000
ya lo visualizamos para entenderla, ¿qué es esto?

63
00:05:24,000 --> 00:05:30,000
El programa viene por aquí y de repente tiene dos posibilidades,

64
00:05:30,000 --> 00:05:32,000
o hacer una cosa o hacer otra.

65
00:05:32,000 --> 00:05:38,000
Esas dos posibilidades irán en función de una condición, ¿vale?

66
00:05:39,000 --> 00:05:42,000
Entonces si se cumple hago esto y si no hago esto.

67
00:05:42,000 --> 00:05:49,000
Esta era nuestra sentencia de decisión visualizada en un diagrama de flujo,

68
00:05:49,000 --> 00:05:50,000
¿vale?

69
00:05:50,000 --> 00:05:56,000
Era esta, esta era nuestra sentencia de decisión, ¿vale?

70
00:05:58,000 --> 00:06:01,000
Que la rama del no, no queremos que se haga nada,

71
00:06:01,000 --> 00:06:03,000
entonces significa que esto se programa como ELSI.

72
00:06:03,000 --> 00:06:07,000
Que la rama del no a su vez queremos abrir otra posibilidad,

73
00:06:07,000 --> 00:06:10,000
pues eso sería el ELSI, el IF, el SEIF, ¿vale?

74
00:06:10,000 --> 00:06:15,000
Pero al fin y al cabo todas las sentencias que hemos visto responden a esta estructura.

75
00:06:15,000 --> 00:06:18,000
Otra cosa es que luego yo aquí abro la rama del no, la vuelvo a abrir,

76
00:06:18,000 --> 00:06:21,000
entonces será un ELSI, pero responde a esto.

77
00:06:21,000 --> 00:06:24,000
Pero en cualquier caso aquí no hay nada que se repita.

78
00:06:24,000 --> 00:06:29,000
Si se cumple yo hago esto y si no se cumple hago esto.

79
00:06:29,000 --> 00:06:32,000
Y ya está, pero lo hago una sola vez.

80
00:06:32,000 --> 00:06:37,000
Y una vez que ya lo he hecho voy al punto de cierre,

81
00:06:37,000 --> 00:06:40,000
ya se termina la sentencia IF-ELSI o IF-ELSI-IF,

82
00:06:40,000 --> 00:06:44,000
si es que aquí tiene varios anidados, se termina y el programa continúa.

83
00:06:44,000 --> 00:06:47,000
No hay nada que se repita, ¿vale?

84
00:06:47,000 --> 00:06:49,000
Pero hay una situación que se puede dar a menudo

85
00:06:49,000 --> 00:06:54,000
y es que necesitamos que un conjunto de sentencias se repitan varias veces.

86
00:06:54,000 --> 00:06:58,000
A veces que es imprescindible que un conjunto de sentencias se repitan varias veces.

87
00:06:59,000 --> 00:07:03,000
¿Vale? Es una situación, por ejemplo, cuando estamos haciendo un programa

88
00:07:03,000 --> 00:07:07,000
que hemos hecho ahora varias veces, que leer un número entero

89
00:07:07,000 --> 00:07:12,000
comprendido entre cero y mil, luego después con él hacer no sé cuántos.

90
00:07:12,000 --> 00:07:17,000
Hasta ahora cuando hemos planteado un enunciado así, pues decíamos,

91
00:07:17,000 --> 00:07:22,000
asumimos que el que va a usar la aplicación va a respetar las normas

92
00:07:22,000 --> 00:07:25,000
y va a meter un número entre cero y mil, lo asumimos.

93
00:07:26,000 --> 00:07:29,000
Pero imaginaos que ahora ya refinamos un poquito más el programa

94
00:07:29,000 --> 00:07:33,000
y decimos, no, yo no voy a contar de partida con que el usuario

95
00:07:33,000 --> 00:07:36,000
va a meter un número de cero a mil.

96
00:07:36,000 --> 00:07:38,000
Entonces, yo le voy a pedir un número.

97
00:07:38,000 --> 00:07:42,000
Si no está entre cero y mil, se lo voy a volver a pedir otra vez.

98
00:07:42,000 --> 00:07:46,000
Si no está entre cero y mil, se lo voy a volver a pedir otra vez.

99
00:07:46,000 --> 00:07:49,000
Entonces, si queremos que el programa sea un poquito más robusto

100
00:07:49,000 --> 00:07:54,000
y que se esté ahí pidiendo números todo el rato hasta que se meta un número válido,

101
00:07:55,000 --> 00:07:58,000
eso no lo podemos hacer con lo que conocemos, no lo podemos hacer,

102
00:07:58,000 --> 00:08:02,000
porque eso implica automáticamente que la sentencia de pedir número

103
00:08:02,000 --> 00:08:04,000
se haga un montón de veces.

104
00:08:04,000 --> 00:08:06,000
¿Cuántas? No lo sabemos.

105
00:08:06,000 --> 00:08:09,000
Depende de lo que tarde el tío en meter el número correcto.

106
00:08:09,000 --> 00:08:11,000
Entonces, un ejemplo.

107
00:08:11,000 --> 00:08:15,000
Es un ejemplo que estoy poniendo de situación que si uno quiere programarla

108
00:08:15,000 --> 00:08:19,000
va a necesitar un bucle, porque necesita aquí un conjunto de sentencias

109
00:08:19,000 --> 00:08:23,000
que en este caso pedir número y leerlas se repitan muchas veces.

110
00:08:24,000 --> 00:08:27,000
Y como es ejemplo puede haber un montón de situaciones.

111
00:08:27,000 --> 00:08:33,000
Pues ver si un número, ver los divisores que tiene.

112
00:08:33,000 --> 00:08:35,000
Así muy en general.

113
00:08:35,000 --> 00:08:37,000
Entonces, un número n.

114
00:08:37,000 --> 00:08:39,000
¿Qué tendríamos que hacer?

115
00:08:39,000 --> 00:08:41,000
Ir a n-1 y ver si lo divide.

116
00:08:41,000 --> 00:08:43,000
Ir a n-2 y ver si lo divide.

117
00:08:43,000 --> 00:08:46,000
Es decir, tendríamos que hacer un montón de veces,

118
00:08:46,000 --> 00:08:48,000
ver si un número divide al n.

119
00:08:48,000 --> 00:08:49,000
Un montón de veces.

120
00:08:49,000 --> 00:08:51,000
¿Cuántas? No sé.

121
00:08:51,000 --> 00:08:52,000
Depende del número n.

122
00:08:52,000 --> 00:08:54,000
Si es 5, pues tengo que comprobar entre 4 y 2.

123
00:08:54,000 --> 00:08:56,000
Si es 7, pues entre 6 y 2.

124
00:08:56,000 --> 00:08:57,000
Depende.

125
00:08:57,000 --> 00:08:59,000
Entonces, lo que estoy poniendo es ejemplos

126
00:08:59,000 --> 00:09:02,000
de situaciones que cuando uno ya las analiza y las estudia

127
00:09:02,000 --> 00:09:05,000
llega a la conclusión de que va a tener que hacer algo

128
00:09:05,000 --> 00:09:06,000
un montón de veces.

129
00:09:06,000 --> 00:09:08,000
A priori, no sabemos cuántas.

130
00:09:08,000 --> 00:09:10,000
Depende de los datos de entrada.

131
00:09:11,000 --> 00:09:13,000
En el ejemplo que he dicho antes,

132
00:09:13,000 --> 00:09:16,000
cuando nosotros identificamos que nuestro programa va a tener que hacer

133
00:09:16,000 --> 00:09:18,000
varias veces leer un número,

134
00:09:18,000 --> 00:09:20,000
a priori no sabemos cuántas.

135
00:09:20,000 --> 00:09:23,000
Si en una ejecución el usuario ha metido el número ya bien

136
00:09:23,000 --> 00:09:26,000
la primera vez, se va a ejecutar solo uno.

137
00:09:26,000 --> 00:09:27,000
Esa sentencia.

138
00:09:27,000 --> 00:09:29,000
Pero en la siguiente ejecución,

139
00:09:29,000 --> 00:09:31,000
si el usuario no mete el número correcto

140
00:09:31,000 --> 00:09:33,000
entre 0 y 1.000 hasta la vez número 30,

141
00:09:33,000 --> 00:09:35,000
pues eso se va a hacer 30 veces.

142
00:09:35,000 --> 00:09:36,000
¿Vale?

143
00:09:36,000 --> 00:09:38,000
Entonces, a priori no sabemos cuántas veces

144
00:09:38,000 --> 00:09:40,000
se va a ejecutar un conjunto de sentencias

145
00:09:40,000 --> 00:09:43,000
que nos hemos dado cuenta que se van a repetir.

146
00:09:43,000 --> 00:09:44,000
No sabemos.

147
00:09:44,000 --> 00:09:46,000
Depende de los datos de entrada.

148
00:09:47,000 --> 00:09:49,000
Bueno, pues cuando identificamos que esa situación se da,

149
00:09:49,000 --> 00:09:52,000
automáticamente identificamos que vamos a necesitar un bucle.

150
00:09:52,000 --> 00:09:53,000
¿Vale?

151
00:09:53,000 --> 00:09:55,000
Cuando identificamos que un conjunto de sentencias

152
00:09:55,000 --> 00:09:57,000
se va a arrepentir unas cuantas veces,

153
00:09:58,000 --> 00:10:00,000
que la pregunta inmediata sería

154
00:10:00,000 --> 00:10:01,000
¿Cuántas?

155
00:10:02,000 --> 00:10:04,000
Depende de los datos de entrada,

156
00:10:04,000 --> 00:10:07,000
o sea, depende de la situación de la ejecución.

157
00:10:07,000 --> 00:10:09,000
En alguna ejecución a lo mejor se repite más,

158
00:10:09,000 --> 00:10:10,000
en otra a lo mejor se repite menos.

159
00:10:10,000 --> 00:10:11,000
Depende. ¿Cuántas?

160
00:10:11,000 --> 00:10:14,000
Pues esa situación se programa con un bucle,

161
00:10:14,000 --> 00:10:16,000
con una sentencia repetitiva.

162
00:10:16,000 --> 00:10:17,000
¿Vale?

163
00:10:17,000 --> 00:10:20,000
Pues, en diagrama de flujo,

164
00:10:20,000 --> 00:10:23,000
un bucle tiene este aspecto.

165
00:10:25,000 --> 00:10:27,000
Aquí se evalúa una condición.

166
00:10:28,000 --> 00:10:30,000
Que la condición se cumple,

167
00:10:31,000 --> 00:10:34,000
hago todo lo que tenga que hacer,

168
00:10:34,000 --> 00:10:35,000
una o mil sentencias,

169
00:10:35,000 --> 00:10:37,000
las que yo crea que se quieren repetir.

170
00:10:38,000 --> 00:10:39,000
¿Vale?

171
00:10:39,000 --> 00:10:41,000
Y luego, bueno,

172
00:10:41,000 --> 00:10:42,000
me he quedado sin,

173
00:10:42,000 --> 00:10:44,000
voy a poner la rama del sí por abajo,

174
00:10:44,000 --> 00:10:45,000
porque si no,

175
00:10:45,000 --> 00:10:47,000
se me va a pegar con lo otro.

176
00:10:48,000 --> 00:10:50,000
¿Que sí se cumple la condición?

177
00:10:50,000 --> 00:10:51,000
Que sí se cumple.

178
00:10:51,000 --> 00:10:53,000
Pues hago aquí todo lo que tenga que hacer,

179
00:10:53,000 --> 00:10:55,000
conjunto de sentencias que se repiten.

180
00:10:55,000 --> 00:10:56,000
Y ahora ya,

181
00:10:58,000 --> 00:11:00,000
vuelvo arriba otra vez.

182
00:11:00,000 --> 00:11:02,000
Y vuelvo a evaluar condición.

183
00:11:02,000 --> 00:11:04,000
¿Se sigue cumpliendo?

184
00:11:04,000 --> 00:11:05,000
Sí.

185
00:11:05,000 --> 00:11:07,000
Pues hago lo que tenga que hacer.

186
00:11:07,000 --> 00:11:09,000
Y el programa vuelve arriba otra vez,

187
00:11:09,000 --> 00:11:11,000
vuelve a evaluar condición.

188
00:11:11,000 --> 00:11:12,000
¿Se sigue cumpliendo?

189
00:11:12,000 --> 00:11:14,000
Sí, hago lo que tenga que hacer.

190
00:11:14,000 --> 00:11:16,000
Entonces, esto se parece a esto,

191
00:11:16,000 --> 00:11:17,000
pero no es igual,

192
00:11:17,000 --> 00:11:18,000
porque aquí en la rama del sí,

193
00:11:18,000 --> 00:11:20,000
una vez que ejecuta lo que tenga que hacer,

194
00:11:20,000 --> 00:11:21,000
se acabó, he terminado.

195
00:11:21,000 --> 00:11:22,000
Y me voy.

196
00:11:22,000 --> 00:11:25,000
Entonces, a veces confundís

197
00:11:25,000 --> 00:11:28,000
esto con esto a la hora de programarlo

198
00:11:28,000 --> 00:11:30,000
y no representan la misma situación.

199
00:11:30,000 --> 00:11:31,000
Esta situación.

200
00:11:31,000 --> 00:11:33,000
Evalúo condición.