1
00:00:01,070 --> 00:00:17,129
No sé, ¿alguna otra consulta en cualquier ámbito? Aunque sea fuera del temario nuestro o en particular del temario. No, no tenéis nada.

2
00:00:17,129 --> 00:00:22,370
Vale, pues nada, vamos a dar una vuelta un poco a los contenidos del tema 3

3
00:00:22,370 --> 00:00:26,969
El otro día estuvimos rematando, aunque ya tenéis abiertos los contenidos de este tema

4
00:00:26,969 --> 00:00:31,530
Algunos asuntos que nos habían quedado pendientes del tema 2 en la tutoría anterior

5
00:00:31,530 --> 00:00:34,890
Y quedó grabado, claro, en la tutoría

6
00:00:34,890 --> 00:00:37,750
Y hoy, bueno, pues vamos a repasar un poco lo del tema 3

7
00:00:37,750 --> 00:00:41,009
Tema 3, tenemos esta semana por delante

8
00:00:41,009 --> 00:00:46,850
Y la semana que viene, todavía, creo que se abre el martes de la siguiente semana

9
00:00:46,850 --> 00:00:51,710
con lo cual el lunes todavía podríamos hablar sobre asuntos del tema 3

10
00:00:51,710 --> 00:00:54,170
y si hoy más o menos lo finiquitamos

11
00:00:54,170 --> 00:00:57,609
pues hacemos algunos ejercicios la semana que viene

12
00:00:57,609 --> 00:00:59,210
o dudas que podáis tener por ahí.

13
00:01:01,899 --> 00:01:06,379
En este tema 3 habla de las estructuras de control.

14
00:01:08,540 --> 00:01:12,159
El otro día habíamos hecho una pequeña referencia a ello

15
00:01:12,159 --> 00:01:15,299
y decíamos que cuando trabajamos sobre un proyecto

16
00:01:15,299 --> 00:01:17,640
la ejecución del proyecto en principio

17
00:01:17,640 --> 00:01:24,420
pues sigue una secuencia ordenada de arriba a abajo pues empezamos en el método main cualquiera

18
00:01:24,420 --> 00:01:28,799
ese punto de inicio de cualquiera de nuestros proyectos pues la ejecución se va haciendo de

19
00:01:28,799 --> 00:01:37,560
arriba abajo es secuencial pero sí que es cierto que podemos poner en nuestros códigos dos dos

20
00:01:37,560 --> 00:01:43,140
tipos de estructuras de control que son típicas de cualquier lenguaje de programación que son las que

21
00:01:43,140 --> 00:01:48,260
evaluan una condición y hace que se ejecute ese código o no, con lo cual

22
00:01:48,260 --> 00:01:52,599
podamos ir dando saltos en esa ejecución que por lo normal va a ser secuencial

23
00:01:52,599 --> 00:01:58,260
o que nos toque hacer una actividad repetitiva, una iteración.

24
00:01:59,680 --> 00:02:04,840
En este contexto, pues imaginaros que tenemos que imprimir las facturas

25
00:02:04,840 --> 00:02:10,580
de todos nuestros clientes. Tenemos en una base de datos mil clientes,

26
00:02:10,580 --> 00:02:40,400
Entonces, en lugar de poner impresión de la factura número 1 y a continuación impresión de la factura número 2 y impresión de la factura número 3 y así hasta 1000 con unos puntos suspensivos por aquí, lo que podríamos hacer es hacer el código propio y general de la impresión de una factura y hacer un bucle que esté dando vueltas a ese mismo código y en lugar de replicar 1000 veces ese código, pues tenerlo escrito una sola vez y obligar a que se ejecute 1000 veces.

27
00:02:40,580 --> 00:02:50,539
con la ventaja incluso de que si el número de veces que tenemos que ejecutar un determinado código

28
00:02:50,539 --> 00:02:57,199
fuese 1000, pues podríamos hacerlo de esta forma, indicarlo aquí en una variable al principio del código

29
00:02:57,199 --> 00:03:05,120
o incluso leerlo a través de escáner desde teclado y ejecutarlo tantas veces ese mismo código

30
00:03:05,120 --> 00:03:10,039
como veces estuviésemos en una variable, bien puesto aquí o leído por escáner.

31
00:03:10,259 --> 00:03:13,159
Si lo leemos por escáner, fijaros que la ejecución de un mismo código

32
00:03:13,159 --> 00:03:20,539
lo podríamos adaptar a diferente número de facturas en cada una de las ejecuciones.

33
00:03:21,159 --> 00:03:26,520
Y si no existiese la posibilidad de tener estos bucles o ejecuciones iterativas,

34
00:03:26,639 --> 00:03:29,300
lo que tendríamos que hacer es modificar cada vez el código fuente

35
00:03:29,300 --> 00:03:34,939
para que tuviera un número de impresiones en este contexto del ejemplo que estamos hablando

36
00:03:34,939 --> 00:03:37,740
que nos planteásemos en cada una de las ejecuciones.

37
00:03:39,080 --> 00:03:43,699
Bueno, nada como ponernos a explicar cómo funciona, pues vamos a ello.

38
00:03:43,960 --> 00:03:47,919
Mirad, entonces, las estructuras de control son de dos tipos,

39
00:03:47,919 --> 00:03:53,319
o bien de selección o bien de iteración.

40
00:03:59,169 --> 00:04:01,469
Si ponemos la tilde en un sitio, la ponemos en otro o en ninguno.

41
00:04:02,610 --> 00:04:08,830
Cuando son de selección, esta sintaxis, aunque pueda variar un poquito

42
00:04:08,830 --> 00:04:13,009
en cuanto a la forma de escribirlo, por lo menos el tipo de instrucción es común

43
00:04:13,009 --> 00:04:16,930
prácticamente a cualquier lenguaje de programación. Hay cosas que pueden ser

44
00:04:16,930 --> 00:04:20,529
particulares de Java, pero esto sí que aparece en todas partes.

45
00:04:21,370 --> 00:04:24,949
Entonces, el ar de selección, que se ejecuta un código

46
00:04:24,949 --> 00:04:27,129
en función de si una condición es cierta o no,

47
00:04:28,870 --> 00:04:32,810
la indicamos, bueno, existen dos tipos de estructuras, la estructura

48
00:04:32,810 --> 00:04:37,050
if, que la podemos completar con algún apartado

49
00:04:37,050 --> 00:04:42,379
más, ahora lo vemos, y la estructura switch. Vamos primero con la if.

50
00:04:44,040 --> 00:04:46,899
Cuando trabajamos con una sentencia

51
00:04:46,899 --> 00:04:50,620
del tipo if, if en inglés condición, lo que hacemos

52
00:04:50,620 --> 00:04:53,939
es poner aquí entre los paréntesis la condición que queremos evaluar.

53
00:04:54,500 --> 00:04:58,459
Y en caso de que esta condición sea cierta, se ejecuta el código que está

54
00:04:58,459 --> 00:05:02,160
en su ámbito, que podemos marcar un ámbito entre llaves.

55
00:05:02,980 --> 00:05:05,600
Entonces si ponemos aquí, por ejemplo, system out

56
00:05:05,600 --> 00:05:07,980
.println

57
00:05:07,980 --> 00:05:15,019
escribe

58
00:05:15,019 --> 00:05:17,100
porque es cierto

59
00:05:17,100 --> 00:05:20,040
fijaros que aquí estamos poniendo

60
00:05:20,040 --> 00:05:21,319
bueno, todavía no tenemos

61
00:05:21,319 --> 00:05:24,240
una gran variedad de posibilidad de instrucciones

62
00:05:24,240 --> 00:05:25,699
porque no las hemos dado todavía

63
00:05:25,699 --> 00:05:28,000
así que sabemos como escribir por pantalla

64
00:05:28,000 --> 00:05:30,079
pues bueno, vamos a poner aquí

65
00:05:30,079 --> 00:05:31,740
este código, pero tened en cuenta que

66
00:05:31,740 --> 00:05:34,040
en el ámbito de elif, entre la llave de apertura

67
00:05:34,040 --> 00:05:36,220
y cierre, podría estar cualquier código

68
00:05:36,220 --> 00:05:38,379
que nosotros programásemos

69
00:05:38,379 --> 00:05:40,319
para dar respuesta

70
00:05:40,319 --> 00:05:49,230
a nuestro algoritmo. Vamos a poner aquí dos instrucciones, escribe esto es cierto, segunda línea.

71
00:05:50,970 --> 00:05:57,970
Entonces, en la ejecución de nuestro código, a la que va haciendo la ejecución de forma secuencial

72
00:05:57,970 --> 00:06:03,350
buscando instrucciones de arriba a abajo, si lo que se encuentra es una estructura de control

73
00:06:03,350 --> 00:06:09,089
de tipo if, lo que hará será validar lo que hay aquí, que puede tener dos posibles valores,

74
00:06:09,089 --> 00:06:16,769
o bien verdadero o bien falso en true o false que viene a ser los dos posibles valores que

75
00:06:16,769 --> 00:06:24,389
tienen las variables primitivas de tipo boolean que habíamos hablado estos días atrás la forma

76
00:06:24,389 --> 00:06:28,350
más fácil de comprobar si esto es cierto pues podríamos poner aquí un true directamente

77
00:06:29,689 --> 00:06:36,269
entonces esto pues porque así está definido y no hay más condición que evaluar pues es verdadero

78
00:06:36,269 --> 00:06:43,069
entonces como esto es verdadero se nos ejecutaría este código si ponemos damos a la ejecución

79
00:06:44,389 --> 00:06:50,230
fijaros como por aquí efectivamente ejecuta el código que hay dentro del ámbito del if y nos

80
00:06:50,230 --> 00:07:06,139
lo muestra por pantalla o sea que poner aquí fuera del if le damos damos como es cierto se ejecuta el

81
00:07:06,139 --> 00:07:11,560
código que hay en el ámbito y luego este que ya está fuera del ámbito se ejecutará sí o sí

82
00:07:11,560 --> 00:07:14,259
si la instrucción es

83
00:07:14,259 --> 00:07:16,259
falsa, es decir

84
00:07:16,259 --> 00:07:17,899
lo que se evalúa dentro de los paréntesis

85
00:07:17,899 --> 00:07:19,959
y ser falso, la forma más clara

86
00:07:19,959 --> 00:07:21,939
de hacerlo falso es directamente ponerlo así

87
00:07:21,939 --> 00:07:24,279
fijaros que en esta ejecución

88
00:07:24,279 --> 00:07:25,839
por ser falso

89
00:07:25,839 --> 00:07:28,120
lo que está dentro del ámbito del if no se ha ejecutado

90
00:07:28,120 --> 00:07:30,180
y sí que se ejecutaría este en cualquier caso

91
00:07:30,180 --> 00:07:31,959
tanto cuando es cierto como cuando es falso

92
00:07:31,959 --> 00:07:33,899
porque son instrucciones que están fuera

93
00:07:33,899 --> 00:07:34,759
del ámbito del if

94
00:07:34,759 --> 00:07:39,860
antes de avanzar con más cosas del if

95
00:07:39,860 --> 00:07:42,220
decimos que aquí tenemos la condición

96
00:07:42,220 --> 00:07:43,240
que estamos evaluando

97
00:07:43,240 --> 00:07:49,709
y que lo que se ejecuta, en caso de ser cierto, es lo que hay dentro del ámbito del if,

98
00:07:49,829 --> 00:07:52,290
que es lo que hay entre sus llaves.

99
00:07:52,889 --> 00:07:54,870
Acordaros de los ámbitos que hablábamos otras veces.

100
00:07:55,089 --> 00:07:57,470
El ámbito del método main sería entre sus llaves.

101
00:07:57,649 --> 00:08:00,449
Fijaros cómo me lo marca aquí Eclipse, de aquí a aquí.

102
00:08:01,029 --> 00:08:04,350
El ámbito de la clase serían estas otras llaves.

103
00:08:04,350 --> 00:08:07,170
Pues el ámbito del if serían estas.

104
00:08:07,170 --> 00:08:15,370
tenemos con con if aunque normalmente siempre se aconseja poner un ámbito con unas llaves tenemos

105
00:08:15,370 --> 00:08:21,089
la posibilidad de no poner un ámbito entonces si no ponemos un ámbito bueno no pone un ámbito

106
00:08:21,089 --> 00:08:26,689
quizás no sea lo más correcto no poner unas llaves para identificar el ámbito es decir poner algo así

107
00:08:26,689 --> 00:08:38,279
imaginaos que ponemos este mismo código incluso tabulado pero lo ponemos sin las llaves que

108
00:08:38,279 --> 00:08:44,500
implica un if que no tiene llaves? Pues lo que implica es que el if solamente está aplicando a la primera

109
00:08:44,500 --> 00:08:50,059
instrucción que encuentra. Entonces por mucho que a propósito yo he tabulado este system out como para hacer

110
00:08:50,059 --> 00:08:57,799
pensar que forma parte de este if, este ya no forma parte del if porque al no haber llaves solamente considera

111
00:08:57,799 --> 00:09:07,299
una instrucción y estaría fuera del if de la misma forma que lo está este otro. Fijaros que siendo esto falso

112
00:09:07,299 --> 00:09:11,460
no se debería ejecutar el código asociado al if

113
00:09:11,460 --> 00:09:15,700
pero decimos que es esta solo al no tener llaves y si le damos a ejecutar

114
00:09:15,700 --> 00:09:19,600
efectivamente fijaros como esta al ser falso no se ejecuta

115
00:09:19,600 --> 00:09:22,539
pero esta al no haber llaves

116
00:09:22,539 --> 00:09:27,480
ya no se considera parte del ámbito de este if y si que me la he puesto

117
00:09:27,480 --> 00:09:30,919
impresa, se ha convertido en una instrucción más igual que esta

118
00:09:30,919 --> 00:09:35,620
que gráficamente sin la trampita aquí de tenerlo

119
00:09:35,620 --> 00:09:39,539
tabulado para que parezca que es del if, vendría a ser un poco

120
00:09:39,539 --> 00:09:43,580
para que gráficamente se comporte más como de verdad

121
00:09:43,580 --> 00:09:47,539
luego funciona, pues lo podríamos poner más cerquita de este otro y

122
00:09:47,539 --> 00:09:53,240
en el tabulador para que no parezca que esté asociado al if. Si ponemos un ámbito

123
00:09:53,240 --> 00:09:57,139
ya os digo, ya no sólo se preocupa

124
00:09:57,139 --> 00:10:01,039
de una sola instrucción, sino que se preocupa de todo

125
00:10:01,039 --> 00:10:05,340
lo que haya dentro del ámbito. Entonces, aquí nos ejecuta

126
00:10:05,340 --> 00:10:09,320
consideraría las dos y, como al ser falso, no ejecutaría ninguna de ellas.

127
00:10:16,659 --> 00:10:22,600
Vale, pues mirad, el if tiene la opción de simplemente evaluar si es cierto o falso

128
00:10:22,600 --> 00:10:29,580
y si es cierto ejecuta su ámbito, si no, continúa con el programa secuencial a partir del cierre de la llave.

129
00:10:30,679 --> 00:10:36,899
En este caso, lo que estábamos considerando es que, si lo que hay entre paréntesis es verdadero,

130
00:10:36,899 --> 00:10:41,279
ejecute esto y si no, pues no tenga ninguna consideración particular

131
00:10:41,279 --> 00:10:46,440
y siga con el código de normal, vamos a poner aquí un int y valor

132
00:10:46,440 --> 00:10:50,360
vamos a decir que sea igual a 3

133
00:10:50,360 --> 00:10:56,740
y ponemos aquí valor igual a 3

134
00:10:56,740 --> 00:11:02,240
si ponemos en el if una condición que ya no sea directamente

135
00:11:02,240 --> 00:11:06,360
un true o un false, lo que hará será evaluar esto, lo que hay entre paréntesis

136
00:11:06,360 --> 00:11:10,460
y el resultado de esto siempre nos tendrá que dar como salida

137
00:11:10,460 --> 00:11:17,000
un boolean verdadero o falso si ponemos algo que nos dé verdadero o falso pues no nos va a compilar

138
00:11:17,000 --> 00:11:24,460
en este caso lo que estamos haciendo es comparar un valor con 3 ya habréis visto en algún programa

139
00:11:24,460 --> 00:11:29,019
de los de ejemplo que cuando estamos comparando hay que poner dos iguales eso es muy importante

140
00:11:29,019 --> 00:11:36,360
porque si ponemos uno solo bueno directamente ni siquiera nos compila aquí si ponemos uno solo no

141
00:11:36,360 --> 00:11:43,120
está haciendo unos un igual sólo no hace funciones de comparación entre valores sino que lo que hace

142
00:11:43,120 --> 00:11:49,799
es funciones de asignación estaría intentando asignar hay valor un 3 cuando queremos comprobar

143
00:11:49,799 --> 00:11:56,519
por igual es necesario poner el igual igual en este caso si el valor es igual a 3 cosa que es

144
00:11:56,519 --> 00:12:02,360
cierta porque sólo hemos asignado aquí ejecutaría esto y no lo mostraría por pantalla damos

145
00:12:02,360 --> 00:12:05,039
Y efectivamente, sigue con ese comportamiento.

146
00:12:06,919 --> 00:12:12,580
La instrucción if tiene la posibilidad de poner aquí una segunda cláusula, que es la cláusula else.

147
00:12:13,019 --> 00:12:20,639
La cláusula else no tiene condición, no lo ponemos entre paréntesis, porque es si no se cumple el if.

148
00:12:21,899 --> 00:12:27,840
Si no se cumple el if, podemos poner aquí otra parte del código, porque es falso, vamos a poner aquí.

149
00:12:27,840 --> 00:12:38,200
Y cuando llegamos aquí a esta condición, lo que hace es evaluar el if, si es cierto ejecuta lo que está en su ámbito.

150
00:12:38,379 --> 00:12:42,700
Y si no es cierto, se va al else y ejecuta el ámbito del else,

151
00:12:42,840 --> 00:12:47,639
que en este caso sería, escribe porque es falso, escribe porque es falso, segunda línea.

152
00:12:50,759 --> 00:12:54,200
Fijaros, haciendo un análisis del código, como y valor vale 3,

153
00:12:54,759 --> 00:12:58,620
esta condición cuando se valore será cierta, y si es cierta,

154
00:12:59,200 --> 00:13:03,059
en principio lo que esperamos es que ejecute estas dos instrucciones y no estas.

155
00:13:03,059 --> 00:13:06,000
Estas nos ejecutarán, estas sí.

156
00:13:06,419 --> 00:13:10,700
Por eso es una estructura de control de selección.

157
00:13:10,779 --> 00:13:16,019
seleccionamos entre diferentes alternativas. Entonces si damos aquí, fijaros como las dos

158
00:13:16,019 --> 00:13:21,240
líneas que se escriben son estas dos, al ser cierta esta condición, y la que no se

159
00:13:21,240 --> 00:13:26,240
descubre, y esta siempre se escribe en cualquier caso, cierto o falso, y estas otras dos en

160
00:13:26,240 --> 00:13:32,299
cambio ahora nos están mostrando por pantalla al ser la condición cierta. Si aquí pusiéramos

161
00:13:32,299 --> 00:13:38,500
que el valor es un 4, pues esta condición ya no sería cierta, y al no ser cierta, si

162
00:13:38,500 --> 00:13:45,200
la ejecutamos, el ámbito del if no se ejecutará y el ámbito del else será el que se escriba.

163
00:13:45,539 --> 00:13:49,580
Entonces fijaros como aquí tenemos estas dos líneas, se escribe porque el falso está

164
00:13:49,580 --> 00:13:51,860
de aquí arriba y se escribe porque el falso es segunda línea.

165
00:13:54,240 --> 00:14:01,220
Lo mismo que hemos dicho antes del ámbito del if, que lo marcábamos entre llaves, pues

166
00:14:01,220 --> 00:14:03,820
lo podemos tener en consideración en el else.

167
00:14:04,259 --> 00:14:08,639
Entonces si el else no lo ponemos con llaves, fijaros que no se me queja en cuanto a compilar,

168
00:14:08,639 --> 00:14:14,220
pero él es también estará considerando una sola instrucción como como ámbito si no lo

169
00:14:14,220 --> 00:14:23,340
ponemos con las llaves si hacemos una ejecución en este caso como y valores 4 la evaluación del

170
00:14:23,340 --> 00:14:28,919
if va a dar falso esto por ser falso no se va a ejecutar y va a ejecutar lo asociado al ex como

171
00:14:28,919 --> 00:14:34,100
en él es no hemos puesto unas llaves solamente considera una instrucción entonces esta será la

172
00:14:34,100 --> 00:14:42,679
que se ponga y ésta se pondrá en cualquier caso si le damos aquí ejecutar veis no salen las dos

173
00:14:42,679 --> 00:14:49,860
está por les y está porque se pone en cualquier caso al igual que esta otra y para tener certeza

174
00:14:49,860 --> 00:14:57,759
de eso pues convertimos la condición de élite en cierta y si es cierta fijaros como ahora nos

175
00:14:57,759 --> 00:15:05,610
muestra estas dos líneas esta no nos la muestra porque al no tener las llaves es la que se

176
00:15:05,610 --> 00:15:12,090
considera ámbito de leyes pero está ya fuera del ámbito de leer sí que le está escribiendo y está

177
00:15:12,090 --> 00:15:20,669
bueno de igual forma es incorrecto el programa es incorrecto el programa si no ponemos el ámbito de

178
00:15:20,669 --> 00:15:26,970
ley del ifo leyes pues no pero el comportamiento tenemos que tener claro que es ese y se recomienda

179
00:15:26,970 --> 00:15:31,830
incluso aunque sea una sola instrucción poner siempre las llaves porque las llaves digamos

180
00:15:31,830 --> 00:15:36,830
que visualmente cuando estamos haciendo un mantenimiento del programa como que nos como

181
00:15:36,830 --> 00:15:42,889
que nos dan pistas de cuál es el ámbito del else y aquí está claro con las llaves que lo que hay

182
00:15:42,889 --> 00:15:48,509
aquí sea una instrucción o sean dos pues es lo que está asociado al else pero si lo hacemos así

183
00:15:49,509 --> 00:15:54,190
bueno pues un día estamos haciendo un mantenimiento y nos podría llevar a equivocación aunque en

184
00:15:54,190 --> 00:15:58,289
realidad cómo se comporta es como hemos dicho pero nos podría llevar a equivocación así que

185
00:15:58,289 --> 00:16:04,769
la mejor de las técnicas y la que se recomienda siempre es identifica los ámbitos con llaves

186
00:16:04,769 --> 00:16:11,730
incluso aunque sea una sola instrucción en cuyo caso el comportamiento sería el mismo con llaves

187
00:16:11,730 --> 00:16:20,549
o sin llaves y luego el if en cuanto a la estructura está de selección aparte del if else

188
00:16:20,549 --> 00:16:27,830
pues nos da alguna alternativa más que es utilizar más condiciones a evaluar el else fijaros que no

189
00:16:27,830 --> 00:16:32,129
tiene entre paréntesis ninguna no hace ninguna valoración porque es la de por defecto lo que

190
00:16:32,129 --> 00:16:39,210
pasa en cualquier caso y aquí igual que tenemos este if que sí que valora algo pues podríamos

191
00:16:39,210 --> 00:16:47,590
evaluar más cosas esto lo hacemos con un el shift es decir si pasa esto ejecuta este código si lo

192
00:16:47,590 --> 00:16:53,669
que pasa es esto otro el shift ejecuta me otro código y si no ha pasado ninguna de las anteriores

193
00:16:53,669 --> 00:16:58,830
ejecuta me este es lo que básicamente viene a decir entonces el el si fijaros como ahora

194
00:16:58,830 --> 00:17:04,230
mismo no me compila porque si de la forma que aunque el es no exige ninguna condición que

195
00:17:04,230 --> 00:17:15,000
evaluar el el shift si lo exige aquí por ejemplo podemos coger lo que haya en el el shift lo que

196
00:17:15,000 --> 00:17:19,980
haya dentro del shift también se tiene que poder evaluar con un verdadero falso pues podríamos

197
00:17:19,980 --> 00:17:27,980
poner aquí la condición de mayor si es mayor que 3 pues que haga otra serie de cosas identificamos

198
00:17:27,980 --> 00:17:49,920
el ámbito del el shift se escribe porque él valor es mayor de 3 como funciona el elicia del shift

199
00:17:49,920 --> 00:17:55,380
pues en el momento de forma secuencial en esta valoración es cuando ya se cumple uno es el que

200
00:17:55,380 --> 00:18:02,079
se ejecuta es decir si el valor es igual a 3 vamos a poner que el valor sea igual a 4 fijaros con un

201
00:18:02,079 --> 00:18:10,680
valor igual a 4 esta es cierta y está también pero la que se ejecuta es la primera en la secuencia de

202
00:18:10,680 --> 00:18:19,630
arriba abajo que se cumple y sólo se ejecuta esa que si ponemos aquí que valga 4 vamos a ejecutar

203
00:18:19,630 --> 00:18:26,849
y fijaros que lo que el código que nos lo que nos ha impreso en pantalla corresponde al código de

204
00:18:26,849 --> 00:18:32,490
este y del if no del el cif a pesar de que éste también es cierto pero en el momento en esta

205
00:18:32,490 --> 00:18:39,509
estructura de selección cuando se cumple una ya las demás se dan por descartadas se cumple una

206
00:18:39,509 --> 00:18:47,410
ejecuta su código y la secuencia del código salta después de todo el bloque y felps if es

207
00:18:47,410 --> 00:18:57,529
si el shift el shift else y continúa ya por aquí que es lo que ha sucedido si ponemos aquí un 5 en

208
00:18:57,529 --> 00:19:03,049
este caso como está ya no es cierta pero está así que lo es pues lo previsible es que nos va a

209
00:19:03,049 --> 00:19:12,170
imprimir este código. Le damos aquí y veis, ahora nos saca el código de estas dos instrucciones.

210
00:19:13,309 --> 00:19:23,829
Y ya está, ¿no? Porque al ser falsa no es ejecutado. Y si lo que ponemos es un valor de 2, al darle a

211
00:19:23,829 --> 00:19:30,029
ejecutar a la instrucción, pues lo que nos muestra es esta. ¿Por qué? Porque 2 no es igual a 4, es falso,

212
00:19:30,029 --> 00:19:37,369
no se cumple. No es mayor que 3, es falso, no se cumple, pues ejecuto la condición que haya por

213
00:19:37,369 --> 00:19:44,049
defecto en este caso es el else en cualquiera de todos los casos se cumpla una condición u otra

214
00:19:44,049 --> 00:19:52,789
la que sea el código seguirá por aquí y lo que tengamos aquí será lo que se ejecute podemos

215
00:19:52,789 --> 00:19:57,230
tener que no haya ninguna acción por defecto en caso de que no se cumplan y que no exista la

216
00:19:57,230 --> 00:20:04,250
condición else tenemos el if else if si se cumple alguna de las dos en la que se ejecuta y si no no

217
00:20:04,250 --> 00:20:10,190
hace nada por defecto es en este caso pues nos muestra el fuera él y porque dos no cumplen ni

218
00:20:10,190 --> 00:20:25,400
esta condición ni esta otra en las en las instrucciones de selección y en las de iteración

219
00:20:25,400 --> 00:20:33,559
ambas dos juegan con la valoración de una estructura aquí de una parte de código que nos

220
00:20:33,559 --> 00:20:39,980
tiene que devolver en su conjunto un verdadero o un falso y este este conjunto verdadero falso nos

221
00:20:39,980 --> 00:20:48,619
permite jugar con las con las instrucciones de tipo los operadores aritméticos que veíamos en

222
00:20:48,619 --> 00:21:04,480
el otro tema el ant el or un ant solo uno solo el diferente el mayor el menor bueno pues todas

223
00:21:04,480 --> 00:21:11,019
estas verdad entonces vamos a vamos a hacer una estructura aquí más completa mira si puede por

224
00:21:11,019 --> 00:21:15,279
ejemplo lo que sí que es cierto es que con todas estas combinaciones lo que hay

225
00:21:15,279 --> 00:21:19,480
en su conjunto entre el paréntesis tiene que devolverlos un valor asociado al

226
00:21:19,480 --> 00:21:25,420
boolean verdadero o falso para poder valorar si el código aquí se ejecuta

227
00:21:25,420 --> 00:21:30,700
si por ejemplo ponemos aquí si el valor es igual a 4

228
00:21:30,700 --> 00:21:39,069
or o vamos a poner un true aquí directamente en su conjunto esto va a

229
00:21:39,069 --> 00:21:42,930
ser verdadero, porque es verdad que esto es falso, pero con un OR

230
00:21:42,930 --> 00:21:45,329
al ser esto verdadero, pues se convierte en verdadero.

231
00:21:47,150 --> 00:21:50,529
Si os acordáis del tema anterior, la tabla de verdad de un Boolean

232
00:21:50,529 --> 00:21:55,230
para el operador OR es que en el momento

233
00:21:55,230 --> 00:21:59,210
que haya alguno verdadero o los dos verdaderos, la estructura en su conjunto

234
00:21:59,210 --> 00:22:02,509
nos devuelve verdadero. Entonces este caso sería verdadero

235
00:22:02,509 --> 00:22:09,259
si le damos, pues fijaros como efectivamente nos muestra este código.

236
00:22:09,259 --> 00:22:33,220
Y si ponemos aquí, por ejemplo, un AND, ahí está el AND, en ese caso, este operador aritmético lo que nos hace es que convierte el conjunto en que sea cierto en el caso en el que ambos valores sean ciertos.

237
00:22:33,880 --> 00:22:47,160
En cuanto uno sea falso, aquello ya es falso. Con lo cual, en este caso, este está claro que es verdadero, pero este otro, viendo que aquí ahora tiene el valor de 2, pues sería falso.

238
00:22:47,160 --> 00:22:52,920
entonces falso and true se convierte en falso con lo cual es de esperar que esta parte del

239
00:22:52,920 --> 00:22:59,259
código no se ejecute aquí la valoración también sale negativa porque valores igualados pues con

240
00:22:59,259 --> 00:23:07,829
este código es de esperar que nos muestre escribe porque es falso vamos a ver es escribe porque es

241
00:23:07,829 --> 00:23:20,200
falso y esto bueno lo podemos combinar tanto como sea necesario y valor y valor 2 igual a 5

242
00:23:20,200 --> 00:23:29,339
entonces jugando con los paréntesis aquí esta expresión acordaros que hemos dicho que era

243
00:23:29,339 --> 00:23:35,500
falsa porque al ser un ant ya es falso pero se va si evaluamos eso y luego ponemos aquí un

244
00:23:35,500 --> 00:23:46,700
word por ejemplo y valor 2 que sea igual a 5 es evaluando este paquete por ser este falso

245
00:23:46,700 --> 00:23:52,559
nos daría en su conjunto falso con lo cual tendríamos que todo este bloque es falso pero

246
00:23:52,559 --> 00:23:59,579
se encuentra con un ORD aquí y con un ORD ya sabemos que cuando cualquiera de los dos lados sea verdadero,

247
00:23:59,660 --> 00:24:04,480
se convierte en un verdadero. Como hay valor 2, lo estamos comparando con 5, que es el valor que hemos dado aquí,

248
00:24:05,259 --> 00:24:14,769
pues en su conjunto ya sería verdadero. Entonces vamos aquí a ejecutar. Fijaros cómo nos muestra aquí la línea.

249
00:24:14,769 --> 00:24:22,220
Y esta expresión podría ser tan complicada o podríamos poner tantas cosas como sean necesarias.

250
00:24:22,220 --> 00:24:35,720
Por ponerlo en contexto, imaginaos un ejercicio donde queremos sacar un mensaje en el que se indique si una persona es un niño o una niña y si es mayor o menor de edad.

251
00:24:36,519 --> 00:24:48,279
Podríamos tener un if si es niño y es menor de edad, pues tendrá que un system.out.println niño o menor de edad.

252
00:24:48,279 --> 00:24:57,500
el shift si es un niño antes es menor de edad pues niño menor de edad el shift si es niña mayor de

253
00:24:57,500 --> 00:25:04,000
edad pues niña mayor de edad y en este caso si son las cuatro posibilidades pues poner un es niña

254
00:25:04,000 --> 00:25:10,859
menor de edad para finalizar se nos pueden dar situaciones vale en las que lo que haya que

255
00:25:10,859 --> 00:25:18,900
evaluar aquí pues sea algo algo más complejo algo grande algo complicado y luego la diferencia que

256
00:25:18,900 --> 00:25:24,079
no lo hablábamos en el otro tema, entre poner dos veces el indicador

257
00:25:24,079 --> 00:25:28,700
o uno, que nos vale para la AND o nos vale para el OR, por ejemplo,

258
00:25:30,579 --> 00:25:35,720
consiste en que si nosotros ponemos el valor dos veces,

259
00:25:36,299 --> 00:25:45,799
si lo ponemos dos veces, imaginaos que tenemos aquí un AND.

260
00:25:47,220 --> 00:25:51,940
Si este es falso, digamos que igual que la ejecución del programa

261
00:25:51,940 --> 00:25:57,180
se hace de arriba a abajo, cuando valora algo de esto, lo intenta hacer de izquierda a derecha.

262
00:25:58,819 --> 00:26:08,039
Entonces, si aquí se da cuenta que hay un OR, un AND, si esto es falso, voy a quitar para no complicar

263
00:26:08,039 --> 00:26:15,900
la doble estructura, con ese AND, si esto es falso, ya con toda certeza todo esto va a ser falso,

264
00:26:16,000 --> 00:26:22,220
porque esto es un AND. Entonces, si es un AND y esto es falso, me da igual el valor que sea este,

265
00:26:22,220 --> 00:26:26,279
que sea verdadero o falso, que ya va a ser falso en su conjunto al encontrarse

266
00:26:26,279 --> 00:26:29,539
en uno de los lados delante el falso. Entonces, si ponemos aquí

267
00:26:29,539 --> 00:26:34,400
dos veces el carácter, esta parte ni siquiera se evalúa. Digamos que ahorramos

268
00:26:34,400 --> 00:26:38,079
a la ejecución del programa Java que haga

269
00:26:38,079 --> 00:26:40,259
esa operación. Entonces, ganamos en rendimiento.

270
00:26:41,579 --> 00:26:44,279
Porque esto va a ser así.

271
00:26:46,619 --> 00:26:50,200
Imaginaos que esto es un OR de la misma forma que

272
00:26:50,200 --> 00:26:56,680
antes si resulta que esto es verdadero en este caso no lo es pero si tuviéramos aquí un 4 pues

273
00:26:56,680 --> 00:27:02,680
esto ya es verdadero si es verdadero al tener aquí un or me da igual lo que hay aquí verdadero falso

274
00:27:02,680 --> 00:27:08,259
a la hora de evaluarlo que ya en su conjunto va a ser verdadero con lo cual cuando podemos

275
00:27:08,259 --> 00:27:16,119
prescindir de valorar el segundo de los de los bloques entonces no lo ejecuta si hemos puesto

276
00:27:16,119 --> 00:27:21,880
aquí doble bien en el or o bien en el and y entonces ya pues si es un or ejecuta esto y si

277
00:27:21,880 --> 00:27:31,329
es un and lo descarta y en cambio si sólo ponemos una de ellas el or o el and independientemente de

278
00:27:31,329 --> 00:27:39,339
lo que haya dado la evaluación de esta parte ejecutará esta otra y podemos decir bueno y eso

279
00:27:39,339 --> 00:27:44,400
no parece que nunca tenga sentido no porque si ya va a ser falso para qué vamos a perder tiempo

280
00:27:44,400 --> 00:27:50,420
ejecutando esto. Pero es que las instrucciones en Java, luego ya más adelante, bueno, pues pueden irse

281
00:27:50,420 --> 00:28:00,259
complicando un poco. Entonces, imaginaros que lo que tenemos es lo siguiente. Tenemos y valor 2 más más

282
00:28:00,259 --> 00:28:12,779
igual a 5. Esta parte del código, aparte de la comparación, lo que está haciendo es incrementar

283
00:28:12,779 --> 00:28:21,759
valor 2 hace esta operación como si como si tuviéramos esto aquí digamos incremento y valor

284
00:28:21,759 --> 00:28:29,240
2 y esto lo quitamos más o menos podría parecerse aunque igual no tiene mismo comportamiento en el

285
00:28:29,240 --> 00:28:35,859
100% de las veces pero podríamos decir incrementamos y valor 22 esta es esta notación

286
00:28:35,859 --> 00:28:48,960
en java es igual que poner que es igual a y valor 2 más 1 vale más o menos sí entonces como que

287
00:28:48,960 --> 00:28:55,019
incrementamos y valor 2 y luego lo comparamos pero pero esto podemos llegar a hacerlo ya os digo

288
00:28:56,519 --> 00:29:14,470
aquí directamente lo comento ahora termino de deciros lo que estoy diciendo y ahora hago

289
00:29:14,470 --> 00:29:23,049
referencia a esto que me preguntas entonces en este caso si tenemos esta instrucción o tenemos

290
00:29:23,049 --> 00:29:47,049
Esta otra sí que es diferente. ¿Por qué? Porque una vez terminado el if, yValor2 aquí nos ha incrementado, en caso de que sea verdadero, si tenemos dos veces el or, como esto es verdadero, esta parte de código ya no se considera, no se ejecuta.

291
00:29:47,049 --> 00:29:59,599
Con lo cual, y valor de or dos nos incrementa. Y si tenemos uno solo, esta parte de código, que aún así sigue siendo verdadera, porque ya es verdadera esta primera parte, sí se ejecuta.

292
00:29:59,599 --> 00:30:18,980
Entonces, sí que hay una diferencia entre poner los dos OR o poner el 1. Es decir, el hecho de que esta parte la obliguemos a que se ejecute, aunque ya se haya decidido aquí si es verdadero o falso, o no se ejecute, puede tener connotaciones, por ejemplo, en este caso, en la variable 2.

293
00:30:18,980 --> 00:30:23,359
entonces es lo que diferencia ponerlo dos veces o ponerlo una

294
00:30:23,359 --> 00:30:28,200
con el and doble la parte segunda no se ejecuta

295
00:30:28,200 --> 00:30:31,880
si ya decide el valor la primera de las partes

296
00:30:31,880 --> 00:30:36,160
igual que con el or doble y en cambio con el and

297
00:30:36,160 --> 00:30:40,160
sencillo o el and o el or sencillo siempre

298
00:30:40,160 --> 00:30:44,240
se ejecuta la segunda parte independientemente de que esta parte ya haya

299
00:30:44,240 --> 00:30:52,000
decidido si es verdadero o falso ¿se entiende esto? la diferencia

300
00:30:52,000 --> 00:30:53,720
entre poner un 2 o 1?

301
00:30:56,210 --> 00:30:57,509
Sí. Vale. Genial.

302
00:30:58,450 --> 00:30:59,670
Mirad, otra

303
00:30:59,670 --> 00:31:01,630
cosa que me preguntaban

304
00:31:01,630 --> 00:31:03,650
era, ¿qué diferencia hay entre

305
00:31:03,650 --> 00:31:05,450
poner...

306
00:31:05,450 --> 00:31:07,789
Cuando estamos incrementando

307
00:31:07,789 --> 00:31:09,089
el valor de una variable

308
00:31:09,089 --> 00:31:11,549
en 1,

309
00:31:13,329 --> 00:31:13,690
pues tenemos

310
00:31:13,690 --> 00:31:15,250
la posibilidad de decir si ese valor

311
00:31:15,250 --> 00:31:17,730
y valor es igual

312
00:31:17,730 --> 00:31:18,690
a i

313
00:31:18,690 --> 00:31:21,970
valor más 1.

314
00:31:21,970 --> 00:31:25,690
podemos poner y valor más más

315
00:31:25,690 --> 00:31:30,250
digamos como un atajo para no tener que escribir tanto, incrementarlo en una

316
00:31:30,250 --> 00:31:33,569
podemos poner más más y valor

317
00:31:33,569 --> 00:31:38,430
esto también está haciendo un incremento, si la instrucción

318
00:31:38,430 --> 00:31:42,269
está así sola, si tenemos que y valor

319
00:31:42,269 --> 00:31:46,250
aquí vale 4 y ponemos esta, cuando el programa siga por aquí va a valer

320
00:31:46,250 --> 00:31:52,490
y valor 5, si la que ponemos es esta, cuando el

321
00:31:52,490 --> 00:31:59,690
programa si va por aquí abajo va a seguir valiendo 5 y si la ponemos esta por aquí abajo va a valer

322
00:31:59,690 --> 00:32:04,529
también 5 con lo cual en esta en este justo tal cual hemos puesto el código las tres son

323
00:32:04,529 --> 00:32:13,130
totalmente equivalentes la diferencia está si tenemos por ejemplo y valor 3 y decimos que sea

324
00:32:13,130 --> 00:32:31,480
igual a y valor más más o ponemos y valor int y valor 3 igual a más más y valor. Esto lo cuento

325
00:32:31,480 --> 00:32:38,180
por una pregunta que me hacía un compañero antes. Lo digo para cuando los que vean la grabación me

326
00:32:38,180 --> 00:32:45,119
preguntaba por la diferencia entre poner el más más aquí o poner el más más aquí. En esta instrucción

327
00:32:45,119 --> 00:33:03,920
lo que hace es asigna el valor que tiene iValor a iValor3, vendría siendo un 4, pues le asigna un 4 y en la ejecución por aquí iValor3 valdrá 4 e iValor valdrá 5.

328
00:33:03,920 --> 00:33:12,880
fijaros entramos con y valor valiendo 4 al estar el más más aquí después lo primero que hace es

329
00:33:12,880 --> 00:33:24,009
asignar el y valor a y valor 3 con lo cual y valor 3 valdrá 4 entonces el código por aquí implicará

330
00:33:24,009 --> 00:33:30,970
que si queremos trabajar con la variable y valor 3 valdrá 4 y valor 5 antes de terminar se incrementa

331
00:33:30,970 --> 00:33:33,349
por este más más, con lo cual iValor valdrá 5.

332
00:33:33,670 --> 00:33:36,630
Por aquí iValor 3 valdrá 4, iValor 5.

333
00:33:37,609 --> 00:33:38,630
En cambio, si lo hacemos así,

334
00:33:41,750 --> 00:33:44,470
antes de hacer esta asignación del valor a iValor 3,

335
00:33:44,650 --> 00:33:45,809
lo que hace es incrementarlo.

336
00:33:45,809 --> 00:33:49,309
Con lo cual iValor, que vale 4, lo incrementa a 5,

337
00:33:49,730 --> 00:33:50,869
con lo cual iValor vale 5,

338
00:33:51,450 --> 00:33:55,509
y en ese momento asigna el valor a iValor 3.

339
00:33:55,650 --> 00:33:57,710
Con lo cual, con este código,

340
00:33:58,150 --> 00:34:00,990
ambas iValor y iValor 3 valdría 5.

341
00:34:02,009 --> 00:34:02,710
Vamos a probarlo.

342
00:34:03,109 --> 00:35:08,880
Ponemos aquí y valor 3, y valor, entonces damos aquí, a ver qué es lo que me ha pasado, y valor 3, tiene la mayúscula, la variable, entonces damos a ejecutar aquí y fijaros, me dice que y valor 3 vale 4 y valor vale 5, es decir, y valor lo ha incrementado después de haber asignado su valor que tiene a y valor 3 que de partida era un 4.

343
00:35:08,880 --> 00:35:32,199
En cambio, si ponemos este otro código, fijaros como en este caso ambas variables valen 5. Entonces sí que tienes un matiz el poner el más más aquí o el poner el más más aquí. ¿Por qué os decía que aquí no importaba mucho?

344
00:35:32,199 --> 00:35:44,239
Bueno, no importaba en absoluto, porque en realidad no le estamos asignando el valor a ningún sitio. Estas tres son equivalentes. A la salida de aquí, iValor va a haber incrementado en todos los casos.

345
00:35:44,239 --> 00:36:05,420
Entonces, si entramos con iValor 4, tanto con esta como con esta, iValor va a pasar a valer 5, que es lo mismo que sucede en esta y en esta. En ambos casos, iValor pasa a valer 5. Lo tengas posfijo, el más más o lo tengas prefijo.

346
00:36:05,420 --> 00:36:19,000
La diferencia está en el valor que se asigna a la variable que tiene a la izquierda. Antes de ejecutar la instrucción, aquí incrementa la variable y aquí la incrementa después de ejecutar la instrucción.

347
00:36:19,239 --> 00:36:41,989
¿Sí? ¿Bien? ¿Más o menos? Vale. Vale, pues nada. Entonces, no sé si me dejo más cosas de las instrucciones estas de selección con el if. Yo creo que poco más que contaros del if.

348
00:36:43,989 --> 00:36:53,909
si habéis visto alguna cosa que me que me dejo en el tintero de la teoría si lo habéis echado un

349
00:36:53,909 --> 00:37:00,869
ojillo me decís y si no si la caes en la cuenta luego después pues ya me decís en por los foros

350
00:37:00,869 --> 00:37:11,940
mira la segunda instrucción de selección que tenemos a las instrucción switch vamos a utilizar

351
00:37:11,940 --> 00:37:20,809
por ejemplo aquí un entero y hicimos switch y valor la instrucción switch a ver si me acuerdo

352
00:37:20,809 --> 00:37:24,250
de la sintaxis, la uso menos y nunca me acuerdo exactamente bien

353
00:37:24,250 --> 00:37:29,110
aquí va entre paréntesis

354
00:37:29,110 --> 00:37:58,590
o no va entre paréntesis y valor, voy a tener que buscar

355
00:37:58,590 --> 00:38:01,269
la instrucción switch porque no me acuerdo

356
00:38:01,269 --> 00:38:23,949
voy a consultar un segundo la sintaxis de la instrucción switch

357
00:38:23,949 --> 00:38:50,730
estructura de selección por aquí, ah vale me falta

358
00:38:50,730 --> 00:39:11,440
abrir un ámbito, no es esto, expresión

359
00:39:11,440 --> 00:39:37,260
case así que es así no no sé si veis algo que me esté dejando alguien por ahí sí sí dime me estoy

360
00:39:37,260 --> 00:39:45,849
dejando alguna cosita por el s eso es eso es si lo estoy viendo aquí ahora mismo ahora mismo yo

361
00:39:45,849 --> 00:39:55,119
también aquí con el que hay valor y los dos puntos estaba me faltaba ante la llave y luego que es 32

362
00:39:55,119 --> 00:40:01,780
puntos ahí está vale gracias no la siente switch la verdad es que bueno es una expresión es una

363
00:40:01,780 --> 00:40:05,059
estructura de control muy utilizada, o sea, no es para nada

364
00:40:05,059 --> 00:40:07,519
una cosa así residual, pero yo tengo

365
00:40:07,519 --> 00:40:10,800
poca costumbre de utilizarla y hay momentos en los que

366
00:40:10,800 --> 00:40:13,880
queda más claro el código utilizando la estructura SWITCH que la ETH

367
00:40:13,880 --> 00:40:16,760
o el SILF, pero como puedes utilizar una u otra

368
00:40:16,760 --> 00:40:19,820
de forma intercambiable, pues

369
00:40:19,820 --> 00:40:23,019
suelo utilizar más la otra y nunca me acuerdo bien de esta estructura.

370
00:40:23,780 --> 00:40:25,340
Bueno, pues nada, esta es la jugada.

371
00:40:26,780 --> 00:40:28,659
Entonces, la forma de

372
00:40:28,659 --> 00:40:30,679
trabajar con el SWITCH, también tenemos

373
00:40:30,679 --> 00:40:35,599
un ámbito, aquí identificamos la variable, el switch

374
00:40:35,599 --> 00:40:39,360
no permite poner expresiones tan complejas como el if o el shift

375
00:40:39,360 --> 00:40:43,079
que sí que te permite poner ans y entre paréntesis y se evalúa una cosa muy gorda

376
00:40:43,079 --> 00:40:47,199
el switch permite mucho menos, prácticamente casi

377
00:40:47,199 --> 00:40:51,440
en valores enteros y poco más y lo que

378
00:40:51,440 --> 00:40:54,340
teníamos antes en el if que decíamos

379
00:40:54,340 --> 00:40:59,320
a lo que comparamos el valor que estamos poniendo aquí, este sería

380
00:40:59,320 --> 00:41:02,260
el equivalente a un if, pues sería

381
00:41:02,260 --> 00:41:04,079
en este caso, if

382
00:41:04,079 --> 00:41:07,539
y valor es

383
00:41:07,539 --> 00:41:08,159
igual

384
00:41:08,159 --> 00:41:11,500
a 3, pues este if y valor

385
00:41:11,500 --> 00:41:13,559
es igual a 3, aquí se traslada

386
00:41:13,559 --> 00:41:15,599
en esta expresión, aquí poniendo

387
00:41:15,599 --> 00:41:17,719
el y valor, el igual o igual no se pone

388
00:41:17,719 --> 00:41:19,280
y se dice en el caso de que sea 3

389
00:41:19,280 --> 00:41:20,960
trabaja sobre

390
00:41:20,960 --> 00:41:25,750
este código que pongamos

391
00:41:25,750 --> 00:41:27,710
colgando del case 3

392
00:41:27,710 --> 00:41:29,550
vendría a ser el equivalente

393
00:41:29,550 --> 00:41:36,429
si es 3, nos ejecuta

394
00:41:36,429 --> 00:41:44,909
este código, si es 4 ejecuta este código, pero switch con el if, el if, el if que hemos visto antes eran

395
00:41:44,909 --> 00:41:53,130
excluyentes, aquí el switch no es excluyente y cómo funciona es que en el momento que encuentra de

396
00:41:53,130 --> 00:42:02,329
arriba a abajo un case que le gusta ejecuta todo el código en adelante, fijaros que bueno pues

397
00:42:02,329 --> 00:42:05,210
conociendo cómo funciona case, podría interesarnos

398
00:42:05,210 --> 00:42:10,389
en algún momento. Entonces, fijaros, si aquí

399
00:42:10,389 --> 00:42:13,489
decimos que iValor es igual a 3, que es este primer case,

400
00:42:13,650 --> 00:42:15,710
como este es cierto, ya empieza a ejecutar por aquí,

401
00:42:16,809 --> 00:42:19,590
pero al ser este cierto, no solamente ejecuta el case 3,

402
00:42:19,789 --> 00:42:22,610
sino que ya él considera y ejecuta

403
00:42:22,610 --> 00:42:24,769
todo el código que encuentra de ahí en adelante.

404
00:42:25,449 --> 00:42:28,489
Fijaros, si le damos aquí una ejecución, nos dice vale 3,

405
00:42:28,590 --> 00:42:31,710
vale 4 y dos veces vale 4 porque este no ha cambiado

406
00:42:31,710 --> 00:42:46,500
Es decir, tiene un comportamiento un poquito diferente a como lo hace el if-else if en ese aspecto. Cuando en un if-else if se cumple una de las condiciones, el resto ya no se ejecuta.

407
00:42:47,519 --> 00:42:59,420
Lo que sí que es cierto es que podemos utilizar una etiqueta, una instrucción que haga que se rompa la ejecución del switch, también lo vamos a ver luego en los bucles, en un momento dado.

408
00:42:59,420 --> 00:43:35,809
Entonces, por ejemplo, si queremos que cuando se cumpla la condición 3, su comportamiento se parezca mucho más a la del if, el shift y solo se ejecute lo que cuelgue de su case, entonces después de lo que queremos que se ejecute podemos poner un break y el resto de la instrucción case que se encuentra por debajo ya no se ejecuta. Es como que este break da un salto del ámbito del switch y continúa ejecutando por aquí abajo, fuera del switch.

409
00:43:35,809 --> 00:43:39,469
entonces con el break ahora, fijaros, le damos aquí

410
00:43:39,469 --> 00:43:43,449
y ya me pone vale 3, este vale 4, este vale 5

411
00:43:43,449 --> 00:43:45,630
no lo pone y me dice fuera del switch

412
00:43:45,630 --> 00:43:51,530
en verdad si tenemos un enunciado podría ser

413
00:43:51,530 --> 00:43:54,730
que con el 3 nos interesase que se ejecutase el 3 y el 4

414
00:43:54,730 --> 00:44:00,570
pues podríamos poner un break aquí, si ponemos un break

415
00:44:00,570 --> 00:44:03,469
aquí, ¿qué es lo que va a suceder? pues si se cumple la condición

416
00:44:03,469 --> 00:44:06,510
3 nos mostrará este, intentará ejecutar todo el código

417
00:44:06,510 --> 00:44:09,570
del switch de aquí hacia abajo, con lo cual ejecutará este

418
00:44:09,570 --> 00:44:11,369
y al encontrarse un break

419
00:44:11,369 --> 00:44:13,750
saltará del switch y se vendrá acá

420
00:44:13,750 --> 00:44:16,690
si se cumple la condición 4

421
00:44:16,690 --> 00:44:18,070
como no se ha cumplido la 3

422
00:44:18,070 --> 00:44:20,010
este nunca se ejecutaría

423
00:44:20,010 --> 00:44:22,769
se ejecutaría este y al encontrarse un break

424
00:44:22,769 --> 00:44:24,369
se viene aquí

425
00:44:24,369 --> 00:44:28,659
vamos a hacer una ejecución con valor 3

426
00:44:28,659 --> 00:44:31,179
fijaros, no muestra el 3

427
00:44:31,179 --> 00:44:32,780
y el 4, ¿por qué no muestra el 5?

428
00:44:32,780 --> 00:44:34,159
porque se acaba de encontrar un break

429
00:44:34,159 --> 00:44:35,679
y de aquí hacia abajo ya

430
00:44:35,679 --> 00:44:39,219
no ejecuta el código asociado con el switch

431
00:44:39,219 --> 00:44:40,460
se viene, rompe

432
00:44:40,460 --> 00:44:44,940
hace un break del switch, digamos, con lo cual se viene aquí al final del switch

433
00:44:44,940 --> 00:44:48,460
y continúa la ejecución con el código que pudiéramos tener aquí,

434
00:44:48,699 --> 00:44:52,320
que sería el que esté dando respuesta al problema que queramos resolver.

435
00:44:52,539 --> 00:44:54,880
En este caso, un system of println y poco más.

436
00:44:56,880 --> 00:45:00,360
Entonces, si lo que queremos es un comportamiento que sea lo más parecido posible

437
00:45:00,360 --> 00:45:04,719
a un if, el if, el if, lo que podríamos hacer es poner un break en cada una de ellas.

438
00:45:06,960 --> 00:45:11,019
Aquí tendríamos if y valores igual a 3, ejecútame este código.

439
00:45:11,019 --> 00:45:17,199
el shift y valores igual a 4 ejecuta me este el shift y valores igual a 5 ejecuta me este

440
00:45:18,579 --> 00:45:26,639
y en las en las instrucciones y felps y felps y teníamos un el final verdad pues aquí es un

441
00:45:26,639 --> 00:45:53,190
default la instrucción default es el si no se cumple ninguna otra ninguna de las anteriores

442
00:45:53,190 --> 00:46:01,050
si ahora mismo ejecutamos como y valor vale 3 sí que se cumple una pues no ejecuta el default pero

443
00:46:01,050 --> 00:46:08,309
y vale 13 pues los que es que tenemos por aquí no se cumple ninguno le damos aquí y lo que nos

444
00:46:08,309 --> 00:46:16,449
sale es la del default que sería el equivalente al el shift del que hablábamos antes si resulta

445
00:46:16,449 --> 00:46:23,489
que no hemos puesto breaks el default por lo que creo recordar también se considera como

446
00:46:23,489 --> 00:46:33,360
una instrucción más decimos que sea 3 para que se cumple el primer que es esto nos muestra el

447
00:46:33,360 --> 00:46:37,280
el 3, el 4, el 5, ninguna de las anteriores, es decir, todo el código

448
00:46:37,280 --> 00:46:40,019
que cuelga desde el momento en el que se cumple la condición.

449
00:46:46,070 --> 00:46:49,650
Ahí tenéis, ahora ha sido 4, pues este nos ha cumplido, pero este ya sí,

450
00:46:49,769 --> 00:46:51,610
a partir de aquí ejecuta todas.

451
00:46:52,250 --> 00:46:55,070
Si ponemos breaks, pues ya os digo, se lo va saltando.

452
00:46:59,179 --> 00:47:02,199
Podemos agrupar también condiciones, me parece recordar.

453
00:47:02,199 --> 00:47:06,440
Entonces, imaginaos que decimos vale 3 o vale 4.

454
00:47:06,539 --> 00:47:10,619
Imaginaos que resulta que para el valor 3 y 4, el código que queremos

455
00:47:10,619 --> 00:47:14,119
que se ejecute sea este mismo, entonces podríamos poner

456
00:47:14,119 --> 00:47:22,440
algo así, el mismo código, o me parece

457
00:47:22,440 --> 00:47:25,119
recordar que podemos separarlos por comas aquí los valores

458
00:47:25,119 --> 00:47:31,940
entonces esto lo que hace es que si valor vale 3 o y valor vale 4

459
00:47:31,940 --> 00:47:36,239
el código que se ejecuta pues será este, vamos aquí

460
00:47:36,239 --> 00:47:39,699
ejecutar, como no hemos puesto break, ejecuta de ahí para abajo

461
00:47:39,699 --> 00:47:43,659
ha entrado porque vale 4, pero si vale 3

462
00:47:43,659 --> 00:47:48,639
pues sigue ejecutándolo, es decir, para considerar

463
00:47:48,639 --> 00:47:52,940
un conjunto de valores que tienen

464
00:47:52,940 --> 00:47:56,940
las mismas consecuencias en el código, para los cuales se ejecuta el mismo código

465
00:47:56,940 --> 00:48:01,139
podemos separarlo por comas, y bueno, pues imaginaos que tenemos 50 valores

466
00:48:01,139 --> 00:48:05,380
que tienen el mismo comportamiento, pues separamos los 50 valores aquí con comas

467
00:48:05,380 --> 00:48:08,880
y no tendríamos que poner 50 veces entradas case

468
00:48:08,880 --> 00:48:11,840
repitiendo esas 50 veces el mismo código

469
00:48:11,840 --> 00:48:20,260
y bueno, no sé, poco más que contra los del switch case

470
00:48:20,260 --> 00:48:24,400
yo creo, matiz un poco diferenciador

471
00:48:24,400 --> 00:48:28,400
pues la jugada esta del break, la opción de meter el break

472
00:48:28,400 --> 00:48:32,380
para que se comporte como el if, el shift y no ejecute

473
00:48:32,380 --> 00:48:35,159
todo hacia abajo y si no tener en cuenta que va a ejecutarlo

474
00:48:35,159 --> 00:48:40,699
en el momento que una se acierta, todo el código que se encuentre hasta el final del ámbito

475
00:48:40,699 --> 00:48:51,380
del switch, si no tenéis preguntas

476
00:48:51,380 --> 00:49:01,320
pasamos a las estructuras de control de repetición hemos visto las de selección que son estas dos y

477
00:49:01,320 --> 00:49:10,940
las de repetición o iteración si las de selección lo que hacen es ejecutar una parte de código en

478
00:49:10,940 --> 00:49:15,639
función de si es verdadero o falso las de repetición lo que hacen es estar repitiendo

479
00:49:15,639 --> 00:49:24,139
un código durante el tiempo en el que se cumple la condición la primera de la que podemos hablar

480
00:49:24,139 --> 00:49:35,659
es la estructura de control while, mientras lo que hace es estar ejecutando el código que tiene dentro de su ámbito

481
00:49:35,659 --> 00:49:45,119
mientras lo que hay aquí sea cierto, entonces imaginaros que tenemos aquí una variable int y valor que inicialmente vale 0

482
00:49:45,119 --> 00:49:50,929
decimos mientras y valor sea

483
00:49:50,929 --> 00:49:59,539
menor de 5, aquí pondremos el código

484
00:49:59,539 --> 00:50:03,179
de lo que tenga que suceder, imaginaros que estamos

485
00:50:03,179 --> 00:50:07,679
como os comentaba al principio, hablando de imprimir todas las facturas que tiene

486
00:50:07,679 --> 00:50:11,699
mi empresa, todas las facturas o un mensaje a todos los

487
00:50:11,699 --> 00:50:15,340
clientes, entonces a lo mejor podría tener una base de datos con todos los clientes

488
00:50:15,340 --> 00:50:18,340
y aquí acceder a la base de datos por esta zona de código

489
00:50:18,340 --> 00:50:22,019
y hacer una consulta de todos los clientes

490
00:50:22,019 --> 00:50:24,820
que en un momento dado me da 1000 y en otro momento me da

491
00:50:24,820 --> 00:50:27,639
20.000 o los que sea, los que tenga

492
00:50:27,639 --> 00:50:30,619
y para cada uno de ellos igual recojo cierta información

493
00:50:30,619 --> 00:50:33,440
y hago aquí un determinado proceso, lo que me pide el programa

494
00:50:33,440 --> 00:50:37,340
mientras vaya teniendo clientes

495
00:50:37,340 --> 00:50:40,099
en la base de datos, ve repitiéndome

496
00:50:40,099 --> 00:50:43,119
este proceso, hará el proceso para uno

497
00:50:43,119 --> 00:50:46,159
llegará aquí y volverá a hacer la comprobación de si esto

498
00:50:46,159 --> 00:50:52,119
ver cierto o no. Ahora el proceso de nuevo, después de hacer el proceso de nuevo, volverá en el momento

499
00:50:52,119 --> 00:51:00,210
que llega al final del while, antes de continuar el código por aquí, fuera del while, antes de continuar

500
00:51:00,210 --> 00:51:06,050
por aquí, lo que hará será volver a evaluar la condición esta, a ver si sigue siendo verdadera o falsa,

501
00:51:06,110 --> 00:51:12,630
en caso de que sea verdadero, otra vueltecita que nos damos. Si ya es falso, continúa después del ámbito

502
00:51:12,630 --> 00:51:14,650
del while y ejecuta el código

503
00:51:14,650 --> 00:51:15,630
que pongamos aquí.

504
00:51:16,969 --> 00:51:17,809
Vamos a poner aquí un system.

505
00:51:32,079 --> 00:51:33,320
Entonces aquí un

506
00:51:33,320 --> 00:51:35,940
bucle que se me ocurre sencillo

507
00:51:35,940 --> 00:51:39,460
pues sería poner un system.out.println

508
00:51:39,460 --> 00:51:41,920
Ya os digo que el código que hay

509
00:51:41,920 --> 00:51:43,340
aquí podría ser cualquiera.

510
00:51:43,940 --> 00:51:45,860
De momento como estamos trabajando mucho con el

511
00:51:45,860 --> 00:51:47,940
system.out pues decimos que

512
00:51:47,940 --> 00:51:49,000
la variable y valor

513
00:51:49,000 --> 00:51:54,630
vale y sacamos por pantalla

514
00:51:54,630 --> 00:51:55,690
el valor que tiene y valor.

515
00:51:56,449 --> 00:51:58,570
Cada vez y valor con una línea de nuevo.

516
00:51:58,949 --> 00:52:16,329
¿Qué sucede en este caso? Pues fijaros, si no pusiéramos más código y valor vale 0, diría y valor es menor que 0, esto lo evalúa verdadero o falso, en caso de ser verdadero ejecuta el código que hay dentro del bucle del while, en caso de ser falso nos vendríamos a continuar trabajando por aquí.

517
00:52:16,329 --> 00:52:20,010
es cierto, y valor es menor que 5

518
00:52:20,010 --> 00:52:22,989
porque vale 0, entonces nos diría aquí y valor vale 0

519
00:52:22,989 --> 00:52:26,289
y cuando llega al final del while de su ámbito

520
00:52:26,289 --> 00:52:29,030
antes de continuar por aquí se viene a hacer una nueva

521
00:52:29,030 --> 00:52:31,889
valoración de la condición y diría

522
00:52:31,889 --> 00:52:35,190
y valor es menor que 5, pues sí, porque vale 0

523
00:52:35,190 --> 00:52:38,050
entonces nos diría y valor vale 0

524
00:52:38,050 --> 00:52:40,909
se vendría aquí, se daría cuenta que se acaba el ámbito

525
00:52:40,909 --> 00:52:43,389
vendría aquí, y valor es menor que 5, sí

526
00:52:43,389 --> 00:52:48,510
si no cambiamos algo para que esta condición

527
00:52:48,510 --> 00:52:52,610
deje de cumplirse como verdadera, nos quedaríamos aquí en un bucle infinito

528
00:52:52,610 --> 00:52:56,110
se quedaría el ordenador bloqueado, entonces dentro de

529
00:52:56,110 --> 00:53:00,389
entre cada una de las valoraciones de esta condición

530
00:53:00,389 --> 00:53:03,429
tendrá que ir pasando algo para que

531
00:53:03,429 --> 00:53:08,010
en algún momento eso se convierta en falso, entonces

532
00:53:08,010 --> 00:53:11,369
si por ejemplo ponemos que y valor

533
00:53:11,369 --> 00:53:18,300
más más, acordaros de lo que decíamos antes

534
00:53:18,300 --> 00:53:21,139
esto sería igual a iValor es igual a iValor más uno

535
00:53:21,139 --> 00:53:25,539
y si lo ponemos en una línea solo, daría igual poner más más iValor también

536
00:53:25,539 --> 00:53:30,079
después de mostrar aquí el valor que tiene iValor, lo incrementaría, entonces cuando

537
00:53:30,079 --> 00:53:34,039
llegue aquí, iValor tendría uno más, entonces en la primera vuelta

538
00:53:34,039 --> 00:53:39,559
pasaría de iValor cero a iValor uno, iValor vale uno

539
00:53:39,559 --> 00:53:43,420
es menor que cinco, todavía lo es, como es cierto, nos mostraría que hay el valor uno

540
00:53:43,420 --> 00:54:11,179
pasaría al 2, comprobaría, 2 menor que 5, sí, también, igual para 3, cuando vale 4, todavía esto sigue siendo cierto, es menor que 5, con lo cual nos mostraría aquí el 4, y resulta que cuando vale el siguiente incremento, pasaría y valor a valer 5, se vendría aquí y diría, y valor es menor que 5, no, porque ya es igual, como ya la condición es falsa, no ejecutaría el ámbito del while, se vendría por aquí,

541
00:54:11,179 --> 00:54:15,219
y ya seguiría ejecutando el código a partir de este punto.

542
00:54:17,480 --> 00:54:18,139
Entonces, damos aquí.

543
00:54:24,940 --> 00:54:29,719
Claro, bueno, te respondo ahora mismo.

544
00:54:30,460 --> 00:54:34,039
Mirad la ejecución, nos ha mostrado valor 0, 1, 2, 3, 4

545
00:54:34,039 --> 00:54:35,519
y luego ya fuera el while.

546
00:54:35,679 --> 00:54:37,599
Ya el valor, cuando hay valor vale 5,

547
00:54:38,079 --> 00:54:40,579
ya no lo ha mostrado porque esta condición ha sido falsa.

548
00:54:41,300 --> 00:54:43,440
Mirad, me preguntaban para la grabación

549
00:54:43,440 --> 00:54:46,059
si en lugar de poner esto, pongo esto otro.

550
00:54:46,059 --> 00:54:53,230
en ambos casos cuando acaba la instrucción

551
00:54:53,230 --> 00:54:57,550
tanto para este como para este, iValor se ve incrementado

552
00:54:57,550 --> 00:55:01,650
si iValor aquí vale 0 antes de ejecutar esta instrucción, aquí iValor

553
00:55:01,650 --> 00:55:05,030
va a valer 1, si iValor vale 2, aquí iValor vale 3

554
00:55:05,030 --> 00:55:09,170
se incrementa tanto en este como en este, con lo cual en este caso

555
00:55:09,170 --> 00:55:13,849
nos da igual, cuando tiene influencia el más más como prefijo

556
00:55:13,849 --> 00:55:16,530
o como sufijo, cuando aparte de

557
00:55:16,530 --> 00:55:21,650
la actuación que tenga sobre esta variable tiene más implicaciones

558
00:55:21,650 --> 00:55:25,409
como os ponía antes, si tenemos aquí un int y valor 2

559
00:55:25,409 --> 00:55:28,880
y decimos aquí en este

560
00:55:28,880 --> 00:55:33,719
y valor 2 igual, y aquí ponemos

561
00:55:33,719 --> 00:55:37,820
y valor 2 igual

562
00:55:37,820 --> 00:55:44,179
bajo el supuesto de que esta es la primera vuelta y valor vale 0

563
00:55:44,179 --> 00:55:48,139
a la salida de aquí y valor

564
00:55:48,139 --> 00:55:55,639
se ve incrementado y vale 1, pero este incremento, si tiene el más más como prefijo, lo hace

565
00:55:55,639 --> 00:56:01,739
antes de hacer la asignación, con lo cual iValor vale 1 sí o sí y como lo ha hecho

566
00:56:01,739 --> 00:56:10,619
antes de la asignación, iValor2 también valdría 1. Y aquí el incremento, como lo

567
00:56:10,619 --> 00:56:17,619
tiene justo después de iValor, lo hace después de hacer la asignación, con lo cual iValor2

568
00:56:17,619 --> 00:56:20,679
valdría 0, pero y valor 1 en ambos casos

569
00:56:20,679 --> 00:56:24,219
valdría 1. ¿Quién se ve afectado

570
00:56:24,219 --> 00:56:26,900
en realidad con que esté el más más

571
00:56:26,900 --> 00:56:29,360
como prefijo o como sufijo? Y valor 2.

572
00:56:30,059 --> 00:56:32,679
Entonces, si yo cojo y hago esto, que no

573
00:56:32,679 --> 00:56:35,179
se ve implicado ningún y valor 2,

574
00:56:35,820 --> 00:56:37,480
estas dos instrucciones son equivalentes.

575
00:56:39,420 --> 00:56:41,860
Estas dos, y si no os gusta poner

576
00:56:41,860 --> 00:56:44,679
sufijos y prefijos, pues también tendríamos aquí

577
00:56:44,679 --> 00:57:01,019
valor más uno en este caso estas tres instrucciones serían equivalentes se entiende se vale vale pues

578
00:57:01,019 --> 00:57:10,139
esta sería la jugada vale en definitiva la retomando un poco la estructura de control

579
00:57:10,139 --> 00:57:17,599
de repetición una de las posibilidades que tenemos es el wild cuando llega al wild se valora si esta

580
00:57:17,599 --> 00:57:24,119
condición es verdadera o falsa. Si la condición es verdadera, se ejecuta su ámbito. Si es falsa,

581
00:57:24,320 --> 00:57:31,940
se deja de ejecutar. Si ha sido verdadera una, dos o mil veces, las que sean, en el momento que

582
00:57:31,940 --> 00:57:38,000
llega al final del ámbito del while, en lugar de continuar por aquí directamente, se queda de

583
00:57:38,000 --> 00:57:43,619
nuevo la condición. Si sigue siendo cierta, damos otra vuelta. En el momento que ya sea falsa, se

584
00:57:43,619 --> 00:57:53,539
marcha. La instrucción while tiene la posibilidad de que el código que hay dentro de su ámbito no

585
00:57:53,539 --> 00:58:00,920
se ejecute ninguna vez. Si y valor inicialmente vale 10, cuando llega aquí directamente es falso

586
00:58:00,920 --> 00:58:09,699
y su código no se ejecuta nunca. Pero si le damos aquí a ejecutarlo, ¿veis? Fuera del while no me ha

587
00:58:09,699 --> 00:58:13,619
puesto este mensaje ninguna vez. ¿Por qué? Porque ha evaluado

588
00:58:13,619 --> 00:58:20,219
esto y se ha dado cuenta que era falso. Es decir, igual

589
00:58:20,219 --> 00:58:24,559
se puede dar entre 0 y n veces

590
00:58:24,559 --> 00:58:28,719
y esa n veces dependerá de cuándo termina por cumplirse esta condición.

591
00:58:29,400 --> 00:58:32,780
Si aquí ponemos la condición true con este código

592
00:58:32,780 --> 00:58:41,269
bueno, fijaros que ya el sistema

593
00:58:41,269 --> 00:58:45,849
Eclipse se ha dado cuenta que este código no se va a ejecutar nunca

594
00:58:45,849 --> 00:58:49,409
y se me está quejando la compilación porque ha dicho se te va a quedar el código siempre ahí

595
00:58:49,409 --> 00:58:55,469
aquí tienes código muerto que no se va a ejecutar nunca si lo tenemos así como esto siempre sería

596
00:58:55,469 --> 00:59:04,019
true se quedaría en un bucle infinito aquí existe una posibilidad que tiene que ver con

597
00:59:05,280 --> 00:59:10,480
para gestionar los wild pero no es muy recomendable es mejor siempre poner es más

598
00:59:10,480 --> 00:59:15,480
recomendable poner aquí la condición por la que te sales del bucle que podría ser mantener aquí

599
00:59:15,480 --> 00:59:21,780
un true y poner aquí un break os acordáis del break que hemos puesto antes en el switch cuando

600
00:59:21,780 --> 00:59:27,000
hemos puesto un break en el switch lo que hacía era dejar de ejecutar el switch pues si metemos

601
00:59:27,000 --> 00:59:34,500
dentro de una iteración un break lo que hace es dejar de ejecutar el bucle entonces en este caso

602
00:59:34,500 --> 00:59:39,179
con la instrucción break fijaros como ahora ya me compila esto porque esto ya no es un bucle

603
00:59:39,179 --> 00:59:45,179
infinito al asistir un break aquí aunque esto se va a volver siempre como cierto si se encuentra

604
00:59:45,179 --> 00:59:51,099
este break rompe el while y seguiría ejecutando a partir de aquí mirad algo parecido a lo que

605
00:59:51,099 --> 00:59:56,679
habíamos hecho antes utilizando el break aunque ya os digo que esto no nos suelen recomendar mucho

606
00:59:56,679 --> 01:00:03,159
es mejor poner la condición aquí en el while que es donde esperas tú encontrar el motivo por el

607
01:00:03,159 --> 01:00:08,679
que se repite el bucle y no poner aquí algo tan genérico como algo tan genérico como un true y

608
01:00:08,679 --> 01:00:13,920
que luego en mitad del código de repente aparezca un break porque aquí tenemos tres líneas que lo

609
01:00:13,920 --> 01:00:17,840
vemos muy fácil, pero si tuviéramos un código muy extenso, pues a lo mejor

610
01:00:17,840 --> 01:00:21,420
localizar el break costaba más, y aquí en cambio, si lo ponemos

611
01:00:21,420 --> 01:00:25,380
directamente vemos la condición ahí y sabemos cómo salirnos, pero

612
01:00:25,380 --> 01:00:28,519
un equivalente a lo de antes, fijaros, si ponemos aquí un if

613
01:00:28,519 --> 01:00:41,670
si valor es igual a 5, que haga el break

614
01:00:41,670 --> 01:00:45,690
entonces fijaros que este código viene a ser lo mismo que lo que hemos

615
01:00:45,690 --> 01:00:49,690
puesto antes aquí, porque esto, siempre que lo evalúa, lo evalúa

616
01:00:49,690 --> 01:00:53,610
acierto, es cierto, aquí nos mostraría el 0, incrementa

617
01:00:53,610 --> 01:00:57,730
1, luego diría, oye, y valor es igual a 5, no, porque vale

618
01:00:57,730 --> 01:01:01,289
1, que lo acabo de incrementar, pues no ejecuto el break, me vengo aquí

619
01:01:01,289 --> 01:01:05,789
evalúo el while y como siempre es cierto, vuelvo a entrar

620
01:01:05,789 --> 01:01:09,429
me vengo por aquí, y incremento a 2

621
01:01:09,429 --> 01:01:13,610
y valor vale 2, vale 5, no, porque vale 2, no ejecuto el break

622
01:01:13,610 --> 01:01:17,909
llego al final del ámbito del while, vuelvo por aquí, evalúo

623
01:01:17,909 --> 01:01:22,909
esto es true pues vuelvo a ejecutarlo habrá un momento en el que este incremento convierta el

624
01:01:22,909 --> 01:01:29,369
valor de valor a 5 en ese caso si valor es igual a 5 ejecuta el break y el break lo que nos saca

625
01:01:29,369 --> 01:01:36,679
es del bucle con lo cual se nos vendría por aquí vamos a hacer una ejecución para que lo veáis

626
01:01:38,480 --> 01:01:48,000
1 2 3 4 y se nos sale con el wine y luego tenemos otra etiqueta que en los switches

627
01:01:48,000 --> 01:01:54,119
sí que se utiliza mucho el break esta es una herramienta que tenéis disponible pero es más

628
01:01:54,119 --> 01:01:59,099
aconsejable poner la condición aquí que no poner aquí un verdadero y luego jugar con la condición

629
01:01:59,099 --> 01:02:06,679
para salirme por ahí en mitad del bucle y tenemos otra otra opción otra etiqueta que es la etiqueta

630
01:02:06,679 --> 01:02:17,980
continua y vamos a poner aquí vamos a devolver aquí que el valor sea igual a 5 y aquí en cuando

631
01:02:17,980 --> 01:02:23,800
sea igual a 3 en lugar de la etiqueta break vamos a poner la etiqueta continua esta etiqueta lo que

632
01:02:23,800 --> 01:02:43,500
hace es vamos a poner así el código no vamos a subir para ver cómo funciona el continuo este

633
01:02:43,500 --> 01:02:50,260
código aquí arriba está aquí está etiqueta lo que hace cuando se encuentra un continuo que ejecuta

634
01:02:50,260 --> 01:02:58,039
lo que hace es dejar pegar un salto al final del ámbito del while pero de esta ejecución y se

635
01:02:58,039 --> 01:03:03,179
vuelve aquí. Si nos encontramos un break, como hemos visto antes, lo que hacía era romper el

636
01:03:03,179 --> 01:03:08,639
while por completo y ya continuaba el código por aquí. En cambio, si lo que encuentra es un

637
01:03:08,639 --> 01:03:14,179
continue, lo que hace es parar esa iteración, esa vuelta que está dando el código. Es decir,

638
01:03:14,179 --> 01:03:18,659
si llegamos por aquí por el while y ejecuta este continue, en lugar de ejecutar esta instrucción,

639
01:03:18,760 --> 01:03:23,320
directamente se vendrá aquí, sin ejecutar esta parte de código porque está después del continue,

640
01:03:23,320 --> 01:03:27,559
y se vendría a evaluar esto de nuevo.

641
01:03:29,590 --> 01:03:30,630
¿En este código qué pasaría?

642
01:03:30,750 --> 01:03:33,849
Pues bueno, sería en realidad un bucle infinito, ahora vemos por qué.

643
01:03:34,889 --> 01:03:36,829
Y ahora lo modificamos para que deje de serlo.

644
01:03:36,829 --> 01:03:42,130
Si el valor vale 0, como no es 0, no ejecutaría el continue,

645
01:03:42,269 --> 01:03:45,150
se vendría por aquí, nos mostraría 0 y diría valor 1.

646
01:03:47,150 --> 01:03:49,289
Y valor valdría 1, se vendría por aquí.

647
01:03:50,010 --> 01:03:54,429
Y valor que vale 1 no es igual a 5, como no es igual a 3, no hace el continue,

648
01:03:54,829 --> 01:04:01,130
no mostraría el 1, incrementaría a 2, la siguiente vuelta incrementaría a 3,

649
01:04:02,909 --> 01:04:06,690
en esa vuelta en la que hay que incrementar a 3, llegaría aquí al final del ámbito,

650
01:04:07,369 --> 01:04:14,590
diría, ¿y valor es igual a 5? No, pues, o sea, es distinto de 5, tendría que ser el código,

651
01:04:14,849 --> 01:04:21,110
¿y valor es distinto de 5? Sí, como esto es verdadero, me meto, pero ¿y valor es igual a 3? Sí,

652
01:04:21,110 --> 01:04:33,690
Entonces haría un continue. Este continue no ejecutaría este código, se vendría por aquí y se vendría aquí. Y diría, ¿y valores distintos de 5? Sí, porque vale 3. En este caso no lo hemos incrementado, ¿verdad?

653
01:04:33,690 --> 01:04:42,150
entonces como vale 3 volvería a entrar por aquí por el continuo volvería a saltar y se vendría

654
01:04:42,150 --> 01:04:47,849
aquí con lo cual nos habríamos quedado en un bucle infinito sin ejecutar este código nunca y en

655
01:04:47,849 --> 01:04:53,289
particular sin ejecutar esta instrucción que es la que nos está llevando a que lleguemos a llegar a

656
01:04:53,289 --> 01:04:59,750
una condición de salida entonces aquí por ejemplo vamos a poner antes del continuo y vamos a poner

657
01:04:59,750 --> 01:05:05,809
un valor más más también para que también se incremente para que cuando valga 3 lo incrementa

658
01:05:05,809 --> 01:05:16,179
4 haga el continuo y no muestre ese valor lo incrementaría 5 en este caso y ya esto sería

659
01:05:16,179 --> 01:05:29,260
falso fijaros como la vez que ha valido 3 no nos ha mostrado por pantalla porque porque ha hecho

660
01:05:29,260 --> 01:05:38,750
un continuo veis continuo no ha ejecutado este código bueno pues si en algún momento dado dentro

661
01:05:38,750 --> 01:05:42,969
de una iteración, dentro de un while, nos interesa que en algún

662
01:05:42,969 --> 01:05:46,849
momento una de esas vueltas no ejecute

663
01:05:46,849 --> 01:05:49,889
el código que hay por aquí abajo, pues podremos poner un continue

664
01:05:49,889 --> 01:05:58,460
y se salta esa vuelta del bucle. Es en cuanto al break y al continue.

665
01:05:59,340 --> 01:06:01,119
Si tenéis dudas, me decís.

666
01:06:04,900 --> 01:06:09,239
Vamos con otra instrucción de control de estas de repetición.

667
01:06:09,780 --> 01:06:13,199
El while, hemos dicho que podría darse la situación

668
01:06:13,199 --> 01:06:16,940
en la que no se ejecutase ninguna vez.

669
01:06:17,239 --> 01:06:19,980
Si tenemos como condición que iValor sea menor que 5

670
01:06:19,980 --> 01:06:23,099
y ponemos aquí un 10, directamente la primera vez

671
01:06:23,099 --> 01:06:25,239
ya es falso esto y no se ejecuta ninguna vez.

672
01:06:25,780 --> 01:06:28,599
Si queremos tener un bucle que garantice

673
01:06:28,599 --> 01:06:30,780
que al menos se ejecuta una vez,

674
01:06:31,659 --> 01:06:34,179
utilizaremos en lugar del while otra estructura

675
01:06:34,179 --> 01:06:37,219
que es el doWhile, que al final van a ser intercambiables

676
01:06:37,219 --> 01:06:38,260
y ahora os muestro cómo.

677
01:06:38,260 --> 01:06:41,460
como en este caso, hacemos

678
01:06:41,460 --> 01:06:45,579
el código que queramos que se vaya repitiendo

679
01:06:45,579 --> 01:06:48,420
antes de hacer la comprobación, que la ponemos en el while

680
01:06:48,420 --> 01:06:51,300
pues aquí nos garantizamos que este bucle

681
01:06:51,300 --> 01:06:52,840
se ejecuta al menos una vez

682
01:06:52,840 --> 01:06:57,260
¿cuál es la sintaxis? pues ponemos

683
01:06:57,260 --> 01:07:00,340
do while y aquí ponemos el punto y coma del final de la instrucción

684
01:07:00,340 --> 01:07:02,599
en este caso

685
01:07:02,599 --> 01:07:06,300
un poco interpretando lo que ponen las palabras

686
01:07:06,300 --> 01:07:07,780
pues decimos do, haz esto

687
01:07:07,780 --> 01:07:11,860
y luego hazlo mientras que pase esto.

688
01:07:12,659 --> 01:07:15,780
Entonces, hará al menos una vez esto, hará la comprobación

689
01:07:15,780 --> 01:07:18,099
y si la comprobación es cierta, vuelve a hacer el do.

690
01:07:20,090 --> 01:07:24,070
Es casi exactamente igual que el while anterior,

691
01:07:24,570 --> 01:07:27,949
pero nos garantiza que al menos se ejecuta una vez el código.

692
01:07:28,929 --> 01:07:32,030
Puede ser que necesitamos que se ejecute siempre una vez algo

693
01:07:32,030 --> 01:07:34,030
o puede que no sea necesario.

694
01:07:34,190 --> 01:07:36,309
Si no es necesario, utilizamos un while.

695
01:07:36,309 --> 01:07:38,449
si no podemos optar

696
01:07:38,449 --> 01:07:39,170
por un do while

697
01:07:39,170 --> 01:07:41,590
entonces fijaros que aquí

698
01:07:41,590 --> 01:07:44,150
con un valor de iValor igual a 10

699
01:07:44,150 --> 01:07:46,289
aunque ya la condición

700
01:07:46,289 --> 01:07:47,889
esta primera vez es falsa

701
01:07:47,889 --> 01:07:49,449
como se encuentra primero el do

702
01:07:49,449 --> 01:07:52,690
no va a ejecutar al menos una vez el system.out.println

703
01:07:52,690 --> 01:07:53,110
este

704
01:07:53,110 --> 01:07:56,389
le damos aquí y veis

705
01:07:56,389 --> 01:07:57,789
ha puesto iValor 10

706
01:07:57,789 --> 01:08:00,150
como consecuencia de ejecutar esta instrucción

707
01:08:00,150 --> 01:08:04,750
bueno pues nada pues esto

708
01:08:04,750 --> 01:08:06,289
es así el do while

709
01:08:06,289 --> 01:08:07,929
prácticamente igual que el while

710
01:08:07,929 --> 01:08:12,630
pero garantizando una primera ejecución. Si a alguien le gusta mucho más

711
01:08:12,630 --> 01:08:16,609
utilizar un while mejor que el do while pero quiere que se ejecute una vez

712
01:08:16,609 --> 01:08:20,550
pues tiene la opción de hacer lo siguiente. Pone aquí

713
01:08:20,550 --> 01:08:24,529
la condición del while y antes del while pone

714
01:08:24,529 --> 01:08:28,470
el código que está dentro una vez. Con lo cual la vez que se ejecuta con el do

715
01:08:28,470 --> 01:08:31,810
se ejecuta porque no estamos haciendo ninguna valoración

716
01:08:31,810 --> 01:08:35,909
y este es el while que el do while se encontraría al final.

717
01:08:35,909 --> 01:09:09,619
Entonces este código, justo poniendo una ejecución primero y luego utilizando la estructura de repetición while, es equivalente a, vamos a ejecutarla, ¿veis? Me muestra un valor, como es lógico porque se lo encuentra y ya está, incrementa y luego valora. Esta es equivalente a esta otra.

718
01:09:09,619 --> 01:09:22,239
Bueno, la tercera forma que tenemos para trabajar con Arrays

719
01:09:22,239 --> 01:09:23,739
Con Arrays, perdón

720
01:09:23,739 --> 01:09:26,340
Estaba pensando en lo que voy a contar luego después

721
01:09:26,340 --> 01:09:28,279
Si nos da tiempo y si no el próximo día

722
01:09:28,279 --> 01:09:30,220
Y se me ha ido a los Arrays

723
01:09:30,220 --> 01:09:32,640
La tercera estructura que tenemos es

724
01:09:32,640 --> 01:09:35,239
Para hacer las repeticiones es la FOR

725
01:09:35,239 --> 01:09:39,109
La instrucción FOR

726
01:09:39,109 --> 01:09:41,909
Tiene también un ámbito por aquí

727
01:09:41,909 --> 01:09:43,710
Aquí ponemos el código

728
01:09:43,710 --> 01:09:45,890
Y tiene aquí tres bloques

729
01:09:45,890 --> 01:10:15,039
Entonces, primero aparece una inicialización. Vamos a poner inti igual a 0, por ejemplo. Luego aparece una comprobación, mientras sí, sea menor que 5 y luego aparece una actualización de la condición que normalmente aquí vamos a poner una actualización de la condición que estamos evaluando aquí.

730
01:10:15,039 --> 01:10:21,420
y cómo funciona el ford y después después buscamos variantes y os cuento más cosas del ford pero

731
01:10:21,420 --> 01:10:27,180
vamos primero con esta básica cuando llega el código por aquí lo primero que hace en la primera

732
01:10:27,180 --> 01:10:33,520
vuelta siempre es hacer esta inicialización entonces dice y vale cero y justo a continuación

733
01:10:33,520 --> 01:10:37,859
hace esta comprobación que vendría a ser la comprobación por ejemplo que antes teníamos en

734
01:10:37,859 --> 01:10:44,819
el while la única que teníamos aquí pues en el ford la expresamos aquí después de hacer esta

735
01:10:44,819 --> 01:10:52,420
comprobación si es cierta ejecuta el código, el código que tengamos puesto aquí y cuando termina

736
01:10:52,420 --> 01:10:57,579
el ámbito se viene y hace esta actualización. Después de esta actualización vuelve a hacer

737
01:10:57,579 --> 01:11:05,520
esta comprobación. Es decir, la primera vez que llegamos ejecuta esta inicialización, solamente

738
01:11:05,520 --> 01:11:12,399
la hace la primera vez que llegamos. Después de esa inicialización comprueba si es cierto, ejecuta

739
01:11:12,399 --> 01:11:18,699
el ámbito del fort y una vez terminado la ejecución del ámbito de fort actualiza después

740
01:11:18,699 --> 01:11:26,140
de actualizar comprueba si es cierta vuelve a ejecutar el fort es un bucle repetitivo después

741
01:11:26,140 --> 01:11:33,779
de terminar actualiza después de actualizar comprueba si el verdadero otra vez la jugada

742
01:11:33,779 --> 01:11:42,079
si el falso en el momento que esto sea falso se vendrá por aquí y dejará ejecutar el fort antes

743
01:11:42,079 --> 01:11:46,279
en el while decíamos, para que no se nos quede en un bucle infinito,

744
01:11:46,520 --> 01:11:57,569
que decíamos aquí, mientras ia sea menor

745
01:11:57,569 --> 01:12:01,689
de 5, y por aquí dentro del código

746
01:12:01,689 --> 01:12:05,229
decíamos, de alguna forma tendrá que haber una evolución aquí

747
01:12:05,229 --> 01:12:09,770
para que esta condición en algún momento se convierta en falsa y eso no sea un bucle

748
01:12:09,770 --> 01:12:13,909
infinito. En un for lo más normal es que esa condición que poníamos

749
01:12:13,909 --> 01:12:17,670
por aquí, la trabajemos aquí. ¿Ok? Alternativas,

750
01:12:17,670 --> 01:12:27,069
Ahora os cuento más cosas, pero la trabajemos aquí. Esto es lo que hará avanzar a la variable con la que estamos trabajando en la comparación.

751
01:12:28,569 --> 01:12:37,789
Y probablemente, mirad, como aquí en el while, habíamos hecho, antes de empezar a ejecutar, una primera inicialización de la variable que aparece por aquí.

752
01:12:37,789 --> 01:12:39,310
pues lo más normal es que en el for

753
01:12:39,310 --> 01:12:41,670
esa inicialización la tengamos aquí

754
01:12:41,670 --> 01:12:50,949
entonces ponemos aquí un system.out

755
01:12:50,949 --> 01:12:53,470
println

756
01:12:53,470 --> 01:12:57,319
y vale

757
01:12:57,319 --> 01:13:01,899
más y

758
01:13:01,899 --> 01:13:04,680
fijaros ahora aquí dentro del ámbito del for

759
01:13:04,680 --> 01:13:05,899
solo ponemos esta instrucción

760
01:13:05,899 --> 01:13:08,560
no ponemos el avance porque lo estamos considerando aquí

761
01:13:08,560 --> 01:13:10,220
y no hemos inicializado

762
01:13:10,220 --> 01:13:11,399
porque lo estamos haciendo aquí

763
01:13:11,399 --> 01:13:12,800
por encima del for

764
01:13:12,800 --> 01:13:15,180
y la condición que siempre se va a evaluar

765
01:13:15,180 --> 01:13:16,079
pues va a ser esta

766
01:13:16,079 --> 01:13:18,340
entonces si damos aquí una ejecución

767
01:13:19,180 --> 01:13:28,079
Fijaros que la primera vez inicializa 0, comprueba, efectivamente es menor que 5, 0, me muestra aquí el valor de i y me escribe esta línea.

768
01:13:28,539 --> 01:13:37,180
Llega al final del ámbito, volvemos por aquí, va a la zona de actualización, 0, más, más, pues se convierte en un 1i y 1 es menor que 5.

769
01:13:37,680 --> 01:13:45,399
Esto ya no lo vuelve a ejecutar porque solo lo hizo la primera vez. Como 1 es menor que 5, es cierto, vuelve dentro del for y me muestra la línea 1.

770
01:13:45,399 --> 01:13:50,000
vamos repitiendo hasta el momento en el que este y más más

771
01:13:50,000 --> 01:13:54,539
bueno, con este y más más hay un momento en el que pasa a valer

772
01:13:54,539 --> 01:13:57,899
y de 3 a 4, como 4 es menor que 5

773
01:13:57,899 --> 01:14:00,600
ejecuta por aquí, me muestra esta entrada

774
01:14:00,600 --> 01:14:06,079
llegamos al final del ámbito, del for, ese 4 con el y más más

775
01:14:06,079 --> 01:14:09,220
se convierte en 5 y antes de ejecutar por aquí comprueba

776
01:14:09,220 --> 01:14:12,899
y dice 5 es menor que 5, no, porque ya es igual, se termina el for

777
01:14:12,899 --> 01:14:15,039
y nos salimos por aquí

778
01:14:15,039 --> 01:14:17,119
y nos muestra esto

779
01:14:17,119 --> 01:14:22,359
el formato que ponemos aquí

780
01:14:22,359 --> 01:14:24,260
es inicialización

781
01:14:24,260 --> 01:14:26,899
comprobación

782
01:14:26,899 --> 01:14:30,359
y actualización

783
01:14:30,359 --> 01:14:33,239
alternativas que tenemos en el for

784
01:14:33,239 --> 01:14:33,880
pues fijaros

785
01:14:33,880 --> 01:14:35,020
esta actualización

786
01:14:35,020 --> 01:14:36,399
aquí hemos hecho que vaya de uno en uno

787
01:14:36,399 --> 01:14:38,140
pero si ponemos que i

788
01:14:38,140 --> 01:14:39,380
aquí podemos poner instrucciones

789
01:14:39,380 --> 01:14:40,399
más complejas

790
01:14:40,399 --> 01:14:41,020
¿verdad?

791
01:14:41,100 --> 01:14:42,920
podemos poner que i sea igual a i más 2

792
01:14:42,920 --> 01:14:47,619
en lugar de un i++, i++ era una instrucción de java

793
01:14:47,619 --> 01:14:51,560
pues aquí podemos poner instrucciones, pues este i

794
01:14:51,560 --> 01:14:55,539
igual a i más 2 implica que i va a ir

795
01:14:55,539 --> 01:14:58,359
incrementando de 2 en 2, entonces fijaros como la ejecución

796
01:14:58,359 --> 01:15:03,439
la primera vale 0, la segunda vale 2 y la segunda vale 4

797
01:15:03,439 --> 01:15:08,739
es decir que no hay que ir de uno en uno, aquí podemos poner código más complejo

798
01:15:08,739 --> 01:15:14,390
si nosotros definimos aquí esta variable como un parámetro

799
01:15:14,390 --> 01:15:17,409
del for pasa algo parecido a lo que decíamos de los

800
01:15:17,409 --> 01:15:19,989
métodos que también podían recibir parámetros

801
01:15:19,989 --> 01:15:23,470
y esta variable se convierte en una variable disponible

802
01:15:23,470 --> 01:15:26,569
en este ámbito, entonces fijaros que

803
01:15:26,569 --> 01:15:29,909
en un primer ejemplo hemos puesto que la actualización

804
01:15:29,909 --> 01:15:31,649
de esta variable que es la que comprobamos aquí

805
01:15:31,649 --> 01:15:35,409
trabajamos sobre ella aquí, pero aquí dentro del código también podríamos

806
01:15:35,409 --> 01:15:37,989
poner, fijaros, si ponemos aquí un i igual a 10

807
01:15:37,989 --> 01:15:42,390
pues antes de llegar al final del ámbito del for

808
01:15:42,390 --> 01:15:45,689
i va a pasar a valer 10, esta variable i es esta misma

809
01:15:45,689 --> 01:15:47,890
fijaros como me lo chiva Eclipse

810
01:15:47,890 --> 01:15:49,890
que al marcarla me lo pone aquí

811
01:15:49,890 --> 01:15:51,529
un poquito más marcado con

812
01:15:51,529 --> 01:15:53,850
fondo más marrón

813
01:15:53,850 --> 01:15:55,329
y negro o marrón y gris

814
01:15:55,329 --> 01:15:57,949
pues entonces si va a pasar a valer 10

815
01:15:57,949 --> 01:16:00,029
después de este incremento

816
01:16:00,029 --> 01:16:01,649
va a pasar incluso a valer 12

817
01:16:01,649 --> 01:16:03,310
y 12 ya va a ser

818
01:16:03,310 --> 01:16:05,930
menor que 5 con lo cual

819
01:16:05,930 --> 01:16:07,689
aquí solamente vamos a tener una iteración

820
01:16:07,689 --> 01:16:09,989
es decir esta variable la podemos modificar por aquí

821
01:16:09,989 --> 01:16:14,539
dentro, veis, me muestra el

822
01:16:14,539 --> 01:16:16,520
de 0, cuando llega aquí

823
01:16:16,520 --> 01:16:40,420
¿Qué vale y? Pues vale 10. Además, lo primero que va a hacer al llegar al for va a ser incrementarlo en 2. Va a valer 12. En definitiva, 12 es menor que 5. Pues entonces deja ejecutarse el for y solamente me ha dado una vuelta este for. Es decir, que aunque la estructura normal es inicialización, comprobación, actualización, podemos trabajar con esas variables por aquí.

824
01:16:40,420 --> 01:16:45,680
mirad otra cosa, si nosotros definimos esta variable aquí

825
01:16:45,680 --> 01:16:50,279
esta variable está disponible en el ámbito del for

826
01:16:50,279 --> 01:16:54,319
el for es este, es la llave, entonces si yo cojo y pongo aquí

827
01:16:54,319 --> 01:17:00,640
un system.out.println

828
01:17:00,640 --> 01:17:08,739
y vale, fijaros

829
01:17:08,739 --> 01:17:12,960
como directamente Eclipse no me deja, no me compila, porque dice esta variable

830
01:17:12,960 --> 01:17:17,779
la estás utilizando en este ámbito, en el ámbito de la clase main

831
01:17:17,779 --> 01:17:21,359
y en el ámbito de la clase main no está definida esta variable porque es una variable

832
01:17:21,359 --> 01:17:25,760
que está acotada al ámbito de la clase for, de la instrucción

833
01:17:25,760 --> 01:17:29,479
for. Imaginaos que esta variable que ha ido

834
01:17:29,479 --> 01:17:33,439
ahí evolucionando con estas actualizaciones incluso por aquí

835
01:17:33,439 --> 01:17:37,340
queremos tenerla disponible para escribirla aquí. Entonces

836
01:17:37,340 --> 01:17:40,380
¿dónde tendría que estar definida? Pues en el ámbito donde está

837
01:17:40,380 --> 01:17:45,159
donde estamos utilizando esta instrucción

838
01:17:45,159 --> 01:17:48,920
que es la del main. Entonces esto podríamos coger y decir

839
01:17:48,920 --> 01:17:52,800
mira, esta variable que es la que vamos a utilizar, la vamos a definir

840
01:17:52,800 --> 01:17:56,739
aquí. Si queréis no la inicializamos porque

841
01:17:56,739 --> 01:18:00,739
nos interesa inicializarla aquí en el for, pero

842
01:18:00,739 --> 01:18:04,600
la definimos en este otro ámbito. Entonces veis como ahora ya sí que me compila

843
01:18:04,600 --> 01:18:09,619
por aquí. Entonces le damos aquí y este i vale

844
01:18:09,619 --> 01:18:16,260
y pues nos muestra este 12 que este 12 como os decía es este 10 al volver al ford lo primero

845
01:18:16,260 --> 01:18:22,239
que hace es la actualización lo pasa 12 hace la comprobación 12 es menor que 5 falso se sale del

846
01:18:22,239 --> 01:18:27,199
ford y cuando me muestra aquí el valor que tiene y pues me dice que efectivamente que es 12 porque

847
01:18:27,199 --> 01:18:32,840
la tengo disponible aquí en esta instrucción la variable y pues porque es una variable que

848
01:18:32,840 --> 01:18:36,000
está definida en ese ámbito, en el ámbito

849
01:18:36,000 --> 01:18:38,920
del main. Volviendo a la

850
01:18:38,920 --> 01:18:41,220
memoria RAM que os hablaba en otras clases, pues

851
01:18:41,220 --> 01:18:44,819
aquí lo que sucede es cuando llegamos aquí, fijaros que esto es

852
01:18:44,819 --> 01:18:48,000
un dato primitivo de Java, con lo cual no es necesario

853
01:18:48,000 --> 01:18:50,739
poner la instrucción que sí que ponemos en los

854
01:18:50,739 --> 01:18:52,979
referenciados del new, ¿verdad? Que decíamos

855
01:18:52,979 --> 01:18:56,439
por ser primitivo, ya no va a hacer la reserva,

856
01:18:56,979 --> 01:18:59,500
pues ¿en qué momento nos pedirá el sistema operativo

857
01:18:59,500 --> 01:19:02,699
para este dato primitivo que nos guarde un trocito

858
01:19:02,699 --> 01:19:05,539
de memoria random de guardar información que vaya teniendo

859
01:19:05,539 --> 01:19:07,560
y a lo largo del programa, aquí

860
01:19:07,560 --> 01:19:12,140
¿en qué momento dejará de estar disponible esta variable?

861
01:19:12,340 --> 01:19:14,340
cuando se salga de su ámbito, su ámbito

862
01:19:14,340 --> 01:19:17,920
lo hemos definido ahí, es el main, pues dejará de estar disponible

863
01:19:17,920 --> 01:19:20,720
aquí, si deja de estar disponible aquí y la queremos usar

864
01:19:20,720 --> 01:19:23,539
aquí, todavía es posible hacerlo

865
01:19:23,539 --> 01:19:26,640
con lo que hablábamos antes, si lo ponemos aquí

866
01:19:26,640 --> 01:19:31,470
fijaros que ya me deja de compilar aquí y ¿cuál es la

867
01:19:31,470 --> 01:19:35,569
explicación de esto? Pues aquí todavía no hemos hecho esa reserva. ¿En qué

868
01:19:35,569 --> 01:19:39,390
momento el programa pedirá al sistema operativo espacio

869
01:19:39,390 --> 01:19:42,970
donde guardar información por una variable de tipo Java primitiva

870
01:19:42,970 --> 01:19:47,170
que es un entero? Pues lo hará aquí.

871
01:19:47,489 --> 01:19:51,729
¿Y esta variable en qué ámbito lo estamos definiendo? En el ámbito del for. ¿Cuándo dejará de existir

872
01:19:51,729 --> 01:19:55,550
esta variable i? Cuando acabe el ámbito del for, que será

873
01:19:55,550 --> 01:19:59,449
aquí. Entonces, si aquí deja de existir, donde tengo ahora mismo el cursor, por aquí,

874
01:19:59,449 --> 01:20:02,310
y la quiero utilizar aquí, pues ya coge y me dice

875
01:20:02,310 --> 01:20:09,260
esa variable no existe. Bueno, ¿a dónde quiero llegar

876
01:20:09,260 --> 01:20:11,279
con todo esto? Pues que

877
01:20:11,279 --> 01:20:15,060
hablar del for como

878
01:20:15,060 --> 01:20:18,420
inicialización aquí, comprobación

879
01:20:18,420 --> 01:20:21,340
y actualización, pues bueno, esa es la estructura

880
01:20:21,340 --> 01:20:24,239
base del for, pero luego nos da para hacer muchas

881
01:20:24,239 --> 01:20:30,359
alternativas, muchas jugadas por ahí. ¿Se entiende

882
01:20:30,359 --> 01:20:35,600
el for? ¿Alguna duda por aquí sobre esto que os cuento?

883
01:20:35,600 --> 01:20:48,039
no principio no seguís por ahí eso sí verdad se vale bueno vale perfecto vale pues mira bueno

884
01:20:48,039 --> 01:20:57,750
otra con la estructura del ford a partir de una cierta versión en java existe la posibilidad de

885
01:20:57,750 --> 01:21:06,149
recorrer a raíz o colecciones que viene a ser indicar aquí el tipo de datos y que lo vaya

886
01:21:06,149 --> 01:21:09,369
ejecutando aquí. Es algo que en la teoría os habla de un for each.

887
01:21:11,619 --> 01:21:15,180
Para poder conocer ese for, pues primero vamos a hablar un poquito de los arrays

888
01:21:15,180 --> 01:21:19,699
y si nos da tiempo hablamos de ese for hoy y si no, pues lo comentamos

889
01:21:19,699 --> 01:21:25,390
luego en la siguiente clase. Cuando estamos

890
01:21:25,390 --> 01:21:29,449
trabajando con nuestros programas, al final tienen

891
01:21:29,449 --> 01:21:33,529
que ir haciendo cosas sobre datos.

892
01:21:34,449 --> 01:21:37,409
Si queremos

893
01:21:37,409 --> 01:21:39,489
imprimir facturas, pues al final tendremos

894
01:21:39,489 --> 01:21:41,310
que coger el nombre de la persona esa

895
01:21:41,310 --> 01:21:43,369
a la que le vamos a enviar la factura o la publicidad

896
01:21:43,369 --> 01:21:45,229
de algo, por no entrar con facturas que

897
01:21:45,229 --> 01:21:46,430
nos va a tocar pagar si no.

898
01:21:47,229 --> 01:21:49,409
Y el nombre de esa persona, pues en un momento dado

899
01:21:49,409 --> 01:21:51,189
habrá que ir guardándolo en algún sitio, que

900
01:21:51,189 --> 01:21:52,390
será una variable

901
01:21:52,390 --> 01:21:55,289
invita que sea de tipo string

902
01:21:55,289 --> 01:21:57,069
para guardar una cadena de caracteres.

903
01:21:58,029 --> 01:21:59,170
A lo mejor esa persona tendrá

904
01:21:59,170 --> 01:22:01,329
un saldo en una cuenta, si es de un

905
01:22:01,329 --> 01:22:03,270
banco, y eso lo tendremos que poner

906
01:22:03,270 --> 01:22:05,250
en una variable de tipo entero.

907
01:22:05,890 --> 01:22:07,369
Habrá un momento en el que

908
01:22:07,409 --> 01:22:16,390
Durante la ejecución del programa en un determinado ámbito, vayamos a definir una variable tipo long, si tenemos mucho dinero, o una variable tipo int, si tenemos un poco menos.

909
01:22:16,970 --> 01:22:22,989
Con el int ya, si lo llenamos de números, ya sale un número interesante para tenerlo en euros en nuestra cuenta.

910
01:22:24,449 --> 01:22:33,989
Entonces, esas variables, estos días atrás hablábamos que existen las variables primitivas, que hacen la reserva esa de memoria RAM directamente, y las referenciadas.

911
01:22:33,989 --> 01:22:36,829
diferenciadas. Por ejemplo, un objeto de una clase

912
01:22:36,829 --> 01:22:39,850
que estamos definiendo nosotros, que para hacer la reserva

913
01:22:39,850 --> 01:22:45,119
de memoria RAM utilizábamos el new. En nuestras clases

914
01:22:45,119 --> 01:22:47,800
definimos, aparte de los parámetros,

915
01:22:48,060 --> 01:22:50,039
por ejemplo, el nombre este que decimos o

916
01:22:50,039 --> 01:22:53,659
la cantidad de dinero que tenemos, definimos una serie

917
01:22:53,659 --> 01:22:56,539
de métodos para poder ir trabajando y haciendo cosas

918
01:22:56,539 --> 01:22:58,260
con los objetos de esa clase.

919
01:22:59,460 --> 01:23:02,859
Y en las primitivas decíamos que

920
01:23:02,859 --> 01:23:04,720
cuando definimos un int i,

921
01:23:04,720 --> 01:23:12,770
y si poníamos aquí un y punto, no nos ofrecían

922
01:23:12,770 --> 01:23:16,529
nada de clase. Estas variables de tipo primitiva solamente son la variable

923
01:23:16,529 --> 01:23:20,890
y ya está. En cambio, como a veces queremos hacer cosas con estas variables,

924
01:23:21,109 --> 01:23:24,189
teníamos las clases Wrapper, las clases Wrapper

925
01:23:24,189 --> 01:23:28,310
que envuelven a los tipos primitivos, por ejemplo,

926
01:23:28,770 --> 01:23:32,609
la clase Integer tenía una serie de métodos estáticos que no teníamos que

927
01:23:32,609 --> 01:23:36,630
instanciar un objeto, también hablábamos de la etiqueta estática,

928
01:23:36,630 --> 01:23:44,090
Entonces, si poníamos aquí un punto, ya nos ofrecía cosas, parámetros y cosas que hacer con ella, las clases Wrapper.

929
01:23:47,689 --> 01:23:59,010
Es muy típico y sobre todo trabajando con bucles, querer hacer una serie de cosas que se vayan repitiendo sobre un conjunto de datos que son del mismo tipo.

930
01:24:00,329 --> 01:24:07,529
¿Qué conjuntos de datos del mismo tipo tenemos? Pues tenemos dos posibilidades y hay temas por delante que hablaremos bastante de ellos.

931
01:24:07,529 --> 01:24:20,649
No os preocupéis si no llegamos a grandes detalles. Por un lado están los Arrays y por otro lado están las colecciones. Las colecciones van luego por ahí por el tema 7 más o menos y los Arrays hablamos de ellos un poquito antes.

932
01:24:20,649 --> 01:24:30,010
Cuando definimos un array, estamos definiendo un conjunto de datos que son del mismo tipo

933
01:24:30,010 --> 01:24:37,289
y la reserva de memoria RAM para el conjunto de datos se hace en el momento en el que defines el array.

934
01:24:37,489 --> 01:24:48,250
Esto quiere decir que podemos decidir tener un array de 20 clientes y definimos un array de 20 objetos de la clase cliente.

935
01:24:48,250 --> 01:25:04,130
Podemos tener un array de 20 enteros y definimos un array de 20 enteros. En el momento en el que definimos el array de 20 enteros, el sistema, el programa pedirá al sistema operativo el trozo de memoria necesario para poder guardar la información de esos 20 enteros.

936
01:25:04,130 --> 01:25:08,569
eso los arrays, son estructuras de datos

937
01:25:08,569 --> 01:25:11,649
estáticas, estructura de datos porque podemos tener

938
01:25:11,649 --> 01:25:16,630
conjuntamente una serie de datos y el tamaño de esos datos

939
01:25:16,630 --> 01:25:19,930
lo cerramos en el momento en el que definamos la estructura

940
01:25:19,930 --> 01:25:26,260
los accesos a este tipo de estructuras suelen ser rápidos desde el programa

941
01:25:26,260 --> 01:25:30,420
eso está bien para el rendimiento, pero tiene un inconveniente, imaginaros

942
01:25:30,420 --> 01:25:34,819
que intentamos hacer un array de los clientes que van a mi tienda

943
01:25:34,819 --> 01:25:38,340
y en el programa yo digo, hago una suposición y digo

944
01:25:38,340 --> 01:25:42,420
nunca en mi tienda va a haber más de 20 clientes, voy a definir un array de 20 clientes

945
01:25:42,420 --> 01:25:46,619
y luego un día pongo una oferta y me llegan 21 clientes

946
01:25:46,619 --> 01:25:50,420
pues ese array ya no me vale porque el tamaño del array lo tienes

947
01:25:50,420 --> 01:25:53,539
que definir de antemano, como dijiste es que iban a ser 20

948
01:25:53,539 --> 01:25:58,159
pues ha llegado el 21 y ese array ya no te da la funcionalidad de tener

949
01:25:58,159 --> 01:26:01,760
todos los clientes que están en ese momento en tu tienda

950
01:26:01,760 --> 01:26:08,420
inconveniente ventaja los accesos a raíz son más rápidos en comparación a lo que os voy a contar

951
01:26:08,420 --> 01:26:16,500
ahora por aquí que son las colecciones o los mapas una colección lo que hace es ir creciendo es

952
01:26:16,500 --> 01:26:24,739
también un conjunto de variables bien referenciadas o primitivas todas ellas del mismo tipo pero que

953
01:26:24,739 --> 01:26:30,439
va creciendo hay un tema de colecciones vale lo veremos muy en profundidad más adelante pero ya

954
01:26:30,439 --> 01:26:34,140
que os voy a contar los Arrays, os pongo en el contexto global de toda la situación.

955
01:26:34,800 --> 01:26:38,500
Entonces, las colecciones van creciendo en función de la demanda. Es decir, yo tengo

956
01:26:38,500 --> 01:26:42,520
una colección para, yo defino una colección de clientes como los que van

957
01:26:42,520 --> 01:26:46,539
a ir a mi tienda y de primeras, cuando defino la colección, no cierro

958
01:26:46,539 --> 01:26:50,619
un tamaño, como si pasan los Arrays. Entonces, la colección

959
01:26:50,619 --> 01:26:54,220
está vacía. Si viene un primer cliente, añado un cliente y es

960
01:26:54,220 --> 01:26:58,460
en ese momento para ese cliente, para el que se hace una reserva de memoria, pero para ese

961
01:26:58,460 --> 01:27:01,439
cliente, no para el conjunto de clientes que preveo puede

962
01:27:01,439 --> 01:27:04,300
haber en mi tienda en un futuro. Viene un segundo cliente,

963
01:27:04,439 --> 01:27:07,840
pues reservo memoria para un segundo cliente. Se marcha un cliente,

964
01:27:07,880 --> 01:27:10,119
pues a la par que en mi código

965
01:27:10,119 --> 01:27:13,439
hago las cosas que correspondan a que el cliente

966
01:27:13,439 --> 01:27:16,479
deja mi tienda, elimino de la colección ese cliente

967
01:27:16,479 --> 01:27:19,560
y se libera la memoria RAM que estaba ocupando ese segundo cliente

968
01:27:19,560 --> 01:27:24,739
y se me queda la colección con uno solo. Como hay que hacer

969
01:27:24,739 --> 01:27:27,619
más gestión que con los arrays, que ya está la memoria

970
01:27:27,619 --> 01:27:30,420
reservada y no hay que andar haciendo o deshaciendo,

971
01:27:30,739 --> 01:27:47,619
Las colecciones en cuanto a rendimiento suelen ser un poco más costosas que los accesos a los arrays, pero bueno, tienen algunas muchas ventajas también. Y una de ellas, por ejemplo, es que imaginaros que me gusta mucho el fútbol y voy a un estadio que tenga 50.000 espectadores.

972
01:27:47,619 --> 01:27:50,539
entonces mi programa tendría que tener

973
01:27:50,539 --> 01:27:52,439
en consideración, si lo quiero hacer

974
01:27:52,439 --> 01:27:54,180
un array de espectadores

975
01:27:54,180 --> 01:27:56,239
tendría que hacer una reserva de antemano

976
01:27:56,239 --> 01:27:57,699
en el momento en el que lo defino

977
01:27:57,699 --> 01:28:00,579
de 50.000, para 50.000 personas

978
01:28:00,579 --> 01:28:02,399
con lo cual bloquearía

979
01:28:02,399 --> 01:28:04,659
mucha memoria RAM para esas 50.000

980
01:28:04,659 --> 01:28:06,340
posibles espectadores que van a ir a ver

981
01:28:06,340 --> 01:28:08,560
mi partido, y resulta que ese día

982
01:28:08,560 --> 01:28:10,159
en lugar de ir a ver al

983
01:28:10,159 --> 01:28:11,539
equipo principal

984
01:28:11,539 --> 01:28:14,279
al equipo principal, es un partido

985
01:28:14,279 --> 01:28:15,680
de Alevines y van 10 padres

986
01:28:16,640 --> 01:28:25,779
Pues resulta que, si lo he hecho con un array, obligatoriamente en el sistema estoy bloqueando espacio para esos 50.000, aunque luego voy a utilizar simplemente 10.

987
01:28:26,979 --> 01:28:36,779
Cosa que no me sucede con las colecciones, porque como lo voy haciendo bajo demanda, el día que hay 50.000 reservaré espacio de memoria RAM para 50.000 y el día que haya 10.000 la reservaré para 10.000.

988
01:28:38,020 --> 01:28:44,840
Estas, los arrays, se llaman estructuras de datos estáticas y estas se llaman estructuras de datos dinámicas.

989
01:28:45,680 --> 01:28:50,779
Las colecciones ya las veremos y una vez puesto en contexto vamos a hablar un poquito de los Arrays.

990
01:28:51,600 --> 01:28:52,960
¿Cómo definimos los Arrays?

991
01:28:53,899 --> 01:28:57,960
En los Arrays la característica que tienen es que definimos un conjunto de variables,

992
01:28:58,340 --> 01:29:03,460
todas ellas a través del mismo número y hacemos su reserva de forma inicial.

993
01:29:03,960 --> 01:29:09,539
En algún ejercicio ya hemos hecho uso de algún Array y desde el primer día los hemos tenido a la vista.

994
01:29:09,539 --> 01:29:11,840
Esto es un Array de Strings.

995
01:29:11,840 --> 01:29:15,060
args es un array de strings

996
01:29:15,060 --> 01:29:21,119
las teclas que se asocian a los arrays son los corchetes

997
01:29:21,119 --> 01:29:24,300
si lo que quiero es definir dentro de mi código un array de enteros

998
01:29:24,300 --> 01:29:29,060
pues puedo definir ir, aquí le doy el nombre común

999
01:29:29,060 --> 01:29:34,539
a todos ellos y ponemos los corchetes que los podemos poner antes

1000
01:29:34,539 --> 01:29:38,319
o después del nombre, podemos poner inar

1001
01:29:38,319 --> 01:29:41,880
ponemos aquí un igual a new, int

1002
01:29:41,880 --> 01:29:47,340
tres. Vamos a poner. Mirad, este array

1003
01:29:47,340 --> 01:29:53,310
inar es un array

1004
01:29:53,310 --> 01:29:56,689
de enteros. Y si ponemos inar

1005
01:29:56,689 --> 01:30:00,670
entre corchetes, cada uno de ellos será un entero.

1006
01:30:01,810 --> 01:30:05,369
El número de enteros que estoy definiendo en este

1007
01:30:05,369 --> 01:30:09,130
caso es tres. Le hemos dado ese tamaño inicial que os decía.

1008
01:30:10,630 --> 01:30:13,189
Con lo cual, esta instrucción

1009
01:30:13,189 --> 01:30:22,470
lo que habrá hecho habrá sido ir a la memoria RAM y decir necesito espacio para tres variables de tipo entero.

1010
01:30:23,649 --> 01:30:28,210
Y ese espacio para los arrays se reserva en memoria RAM de forma contigua.

1011
01:30:29,489 --> 01:30:34,090
Entonces el sistema operativo dirá pues en la posición, es decir, la 20.000, por ejemplo,

1012
01:30:35,369 --> 01:30:41,649
a partir de esta posición voy a hacer una reserva para tres enteros y el primero de los enteros estará en la posición 20.000,

1013
01:30:41,649 --> 01:30:49,170
el segundo estará en la posición 20.000 más el espacio que ocupa un entero

1014
01:30:49,170 --> 01:30:55,569
y el tercero de ellos estará en la posición más el espacio que ocupan dos enteros.

1015
01:31:01,220 --> 01:31:05,539
Y lo que dice es que a la posición 20.000, como si fuera un puntero,

1016
01:31:06,479 --> 01:31:13,119
una referencia de las que hablábamos en clases anteriores, es donde apunta IAR, la variable IAR.

1017
01:31:13,119 --> 01:31:16,539
y ar que es un array de enteros

1018
01:31:16,539 --> 01:31:19,560
y ar apunta a la posición 20.000

1019
01:31:19,560 --> 01:31:23,640
el tamaño total es de 3 enteros

1020
01:31:23,640 --> 01:31:25,039
entonces si yo cojo y digo

1021
01:31:25,039 --> 01:31:27,239
y ar entre corchetes

1022
01:31:27,239 --> 01:31:28,960
empiezo a poner aquí un índice

1023
01:31:28,960 --> 01:31:30,720
empezando por 0 en los arrays

1024
01:31:30,720 --> 01:31:35,840
lo que decimos es que y ar y corchetes

1025
01:31:35,840 --> 01:31:37,239
si lo vemos aquí en la definición

1026
01:31:37,239 --> 01:31:39,600
y ar y corchetes que es un entero

1027
01:31:39,600 --> 01:31:44,119
entonces y ar es un array de enteros

1028
01:31:44,119 --> 01:31:47,279
IAR es una raya de enteros

1029
01:31:47,279 --> 01:31:53,359
IAR entre corchetes es un entero, es una variable de tipo entero

1030
01:31:53,359 --> 01:31:56,319
Entonces aquí podré coger y asignarle un valor

1031
01:31:56,319 --> 01:31:59,340
de un valor entero, igual que aquí

1032
01:31:59,340 --> 01:32:04,220
consideramos que I era un entero y le asignábamos un valor de entero

1033
01:32:04,220 --> 01:32:10,140
Es decir, con IAR 0 trabajamos como un entero

1034
01:32:10,140 --> 01:32:15,430
¿En qué posición se empezará a guardar en memoria RAM este 5?

1035
01:32:15,430 --> 01:32:27,770
pues empezará a guardar, si IAR apunta al 20.000 y este es el primero, pues hemos dicho que el primero de los enteros empezará a guardarse en la posición 20.000.

1036
01:32:29,010 --> 01:32:38,689
Si yo digo IAR1 igual a 15, resulta que aquí lo que hará será, dirá, IAR está en la posición 20.000,

1037
01:32:38,689 --> 01:32:43,949
quiero trabajar sobre el entero, no el primero sino el segundo

1038
01:32:43,949 --> 01:32:48,229
que es el que tiene el índice 1, pues irá a la posición 20.000 más el espacio

1039
01:32:48,229 --> 01:32:52,050
que ocupa un primer entero, y en esa zona de memoria RAM guardará un 15

1040
01:32:52,050 --> 01:32:58,529
y con la misma idea, si guardamos para

1041
01:32:58,529 --> 01:33:02,949
IR2, el 25, este IR2

1042
01:33:02,949 --> 01:33:06,590
vendrá al 20.000, se fijará en el índice

1043
01:33:06,590 --> 01:33:11,109
conocerá que es un array de enteros sobre el 20.000

1044
01:33:11,109 --> 01:33:14,109
considerará el espacio de un entero por 2

1045
01:33:14,109 --> 01:33:17,270
y en esa posición será donde me guarde

1046
01:33:17,270 --> 01:33:20,090
el 25. Es decir,

1047
01:33:20,170 --> 01:33:22,909
podemos trabajar con variables de tipo

1048
01:33:22,909 --> 01:33:25,010
entero. Fijaros que

1049
01:33:25,010 --> 01:33:29,069
aquí lo que hemos dicho es que son 3 enteros

1050
01:33:29,069 --> 01:33:32,149
y para cada uno de los 3 enteros no hemos

1051
01:33:32,149 --> 01:33:35,229
hecho ningún new. ¿Por qué? Porque los tipos enteros son primitivos

1052
01:33:35,229 --> 01:33:37,869
de Java y venimos diciendo que cuando definimos

1053
01:33:37,869 --> 01:33:41,170
un tipo entero, no es necesario hacer el new.

1054
01:33:41,350 --> 01:33:44,670
Hemos hecho un new, es cierto, para dar tamaño a un array,

1055
01:33:44,949 --> 01:33:46,770
pero no para cada uno de los enteros,

1056
01:33:47,090 --> 01:33:50,810
cosa que sí tendremos que hacer luego con los tipos referenciados en los arrays.

1057
01:33:52,710 --> 01:33:55,369
Continuamos con ello haciendo un ejemplo en algún momento.

1058
01:33:57,510 --> 01:34:05,949
Entonces, fijaros, los arrays, que son estructuras que tienen elementos iguales,

1059
01:34:05,949 --> 01:34:09,529
del mismo tipo, trabajan mucho con los bucles.

1060
01:34:09,810 --> 01:34:13,989
Si ponemos aquí un for y decimos int i

1061
01:34:13,989 --> 01:34:18,010
igual a cero, para recorrer todos los elementos

1062
01:34:18,010 --> 01:34:21,409
de un bucle, decimos mientras i

1063
01:34:21,409 --> 01:34:27,720
esta variable sea menor, y los arrays

1064
01:34:27,720 --> 01:34:31,899
tienen una serie de métodos también, decimos menor y una serie

1065
01:34:31,899 --> 01:34:35,800
de parámetros. Todo array tiene la longitud que le hemos

1066
01:34:35,800 --> 01:34:44,239
asignado a través del parámetro length, que esa length se ha aplicado de inicio al crear el array

1067
01:34:44,239 --> 01:34:57,630
aquí y decimos aquí un y más más, se me queja aquí porque ya tengo definida la variable y la voy a

1068
01:34:57,630 --> 01:35:14,479
quitar, pues yo puedo coger y decir system.out.println valor de la posición y del array

1069
01:35:14,479 --> 01:35:23,550
de la posición y del array

1070
01:35:23,550 --> 01:35:28,010
es, y aquí pongo el entero

1071
01:35:28,010 --> 01:35:39,939
y ar y, a ver que es lo que me he dejado

1072
01:35:39,939 --> 01:35:45,470
por ahí, me falta un más aquí, no sé si se entiende este for

1073
01:35:45,470 --> 01:35:49,960
cuando inicializo una variable y

1074
01:35:49,960 --> 01:35:54,979
que mi intención es utilizarla como índice en el array

1075
01:35:54,979 --> 01:35:58,819
irá desde la posición

1076
01:35:58,819 --> 01:36:07,880
0 hasta mientras sea menor que la longitud que tiene la raíz la longitud que tiene la raya es

1077
01:36:07,880 --> 01:36:14,779
de 3 entonces como incremento y de uno en uno ejecutará esto para la posición valor de y 0

1078
01:36:14,779 --> 01:36:21,439
para valor de y 1 también que es menor que la longitud para valor de y 2 para valor de y 3 ya

1079
01:36:21,439 --> 01:36:25,699
no me lo ejecutará con lo cual las posiciones sobre las que ir trabajando en el array será

1080
01:36:25,699 --> 01:36:29,640
la 0, la 1 y la 2 y mostrar aquí su valor

1081
01:36:29,640 --> 01:36:33,119
y para ayudarme, en la posición

1082
01:36:33,119 --> 01:36:37,579
cuando i valga 0, la posición 0, me mostrará el valor de la raíz en la posición 0

1083
01:36:37,579 --> 01:36:41,619
la posición 1, me mostrará el valor de la raíz en la posición 1

1084
01:36:41,619 --> 01:36:45,579
posición 2, me mostrará el valor de la raíz en la posición 3

1085
01:36:45,579 --> 01:36:49,680
y cuando i valga 3, ya esto no lo va a ejecutar porque

1086
01:36:49,680 --> 01:36:53,960
para el valor de 3, cuando i valga 3, ya no será menor que la longitud

1087
01:36:53,960 --> 01:36:58,180
del array, porque se lo hemos asignado a 3, ya será igual, con lo cual

1088
01:36:58,180 --> 01:37:10,960
saldrá del for y se terminó, entonces si damos aquí una ejecución

1089
01:37:10,960 --> 01:37:15,060
pues nos dice para la posición 0, 1 y 2

1090
01:37:15,060 --> 01:37:19,159
el array, el entero del array vale 0, lógico

1091
01:37:19,159 --> 01:37:22,859
los enteros por defecto se inicializan a 0 y no hemos

1092
01:37:22,859 --> 01:37:26,539
modificado ninguno de los dos valores, de todos los valores

1093
01:37:26,539 --> 01:37:29,520
entonces ponemos aquí por ejemplo, keyArr 0

1094
01:37:29,520 --> 01:37:32,340
valga 1

1095
01:37:32,340 --> 01:37:35,659
vamos a decir que la posición 1

1096
01:37:35,659 --> 01:37:38,420
valga 10

1097
01:37:38,420 --> 01:37:43,239
y la posición 2 valga 15

1098
01:37:43,239 --> 01:37:49,109
fijaros como ha ido accediendo

1099
01:37:49,109 --> 01:37:50,430
a las diferentes posiciones

1100
01:37:50,430 --> 01:37:53,329
aquí con asignación a enteros

1101
01:37:53,329 --> 01:37:55,670
que tenemos disponibles en el array

1102
01:37:55,670 --> 01:37:56,750
y por aquí

1103
01:37:56,750 --> 01:37:59,289
luego a cada una de las posiciones

1104
01:37:59,289 --> 01:38:00,270
a través de un bucle

1105
01:38:00,270 --> 01:38:02,909
entonces los bucles y los arrays

1106
01:38:02,909 --> 01:38:04,810
pues suelen ser muy amigos

1107
01:38:04,810 --> 01:38:14,109
solemos utilizar muchas veces bucles recorriendo a raíz para trabajar sobre el elemento de la raya

1108
01:38:14,109 --> 01:38:20,850
aquí mostramos su valor por pantalla pero otras veces pues haremos otras cosas de igual forma que

1109
01:38:20,850 --> 01:38:26,170
recorremos los a la raíz también es posible recorrer pero ya lo veremos las colecciones

1110
01:38:26,170 --> 01:38:49,390
alguna cosilla por ahí alguna duda vale pues pues yo creo que casi lo vamos a ir dejando por aquí

1111
01:38:49,390 --> 01:38:53,050
y ya, no sé si tenéis alguna consulta más por ahí

1112
01:38:53,050 --> 01:38:56,210
el próximo día terminamos de ver los bucles

1113
01:38:56,210 --> 01:38:57,010
el for each

1114
01:38:57,010 --> 01:39:02,010
y ya está, yo creo que no da mucho más de sí la teoría

1115
01:39:02,010 --> 01:39:04,029
de este tema, entonces el próximo día

1116
01:39:04,029 --> 01:39:07,069
si no me planteáis cosas en los foros

1117
01:39:07,069 --> 01:39:10,109
que queráis que atendamos más en la tutoría

1118
01:39:10,109 --> 01:39:14,010
pues no sé, miramos, completamos con el for each

1119
01:39:14,010 --> 01:39:17,289
y abrimos algunos ejercicios

1120
01:39:17,289 --> 01:39:19,310
de los que os propone

1121
01:39:19,310 --> 01:39:20,289
y que vayáis haciendo

1122
01:39:20,289 --> 01:39:22,829
y lo vamos resolviendo aquí en la tutoría

1123
01:39:22,829 --> 01:39:23,550
algunos de ellos

1124
01:39:23,550 --> 01:39:27,939
vale

1125
01:39:27,939 --> 01:39:30,920
pues os parece

1126
01:39:30,920 --> 01:39:32,300
vamos cerrando, os parece entonces

1127
01:39:32,300 --> 01:39:33,939
no tenéis ninguna consulta que hacerme

1128
01:39:33,939 --> 01:39:39,850
vale, pues nada

1129
01:39:39,850 --> 01:39:41,609
pues detengo la