1
00:00:00,300 --> 00:00:05,059
Pues venga, el ejercicio es hacer una función

2
00:00:05,059 --> 00:00:07,459
Luego esa función si queremos probar si funciona

3
00:00:07,459 --> 00:00:09,820
Pues tendremos ya que desde un main llamarla, claro

4
00:00:09,820 --> 00:00:12,640
Pero el ejercicio es hacer la función

5
00:00:12,640 --> 00:00:15,580
Venga, pues la función necesitamos

6
00:00:15,580 --> 00:00:19,519
Parámetros que recibe en caso de que reciba alguno

7
00:00:19,519 --> 00:00:23,679
Tipo de dato que retorna si es que retorna alguno

8
00:00:23,679 --> 00:00:25,179
Y luego ya lo que hace

9
00:00:25,179 --> 00:00:28,920
Vale, pues a esta función le vamos a pasar dos números enteros

10
00:00:28,920 --> 00:00:31,320
y que hace, muestra por consola

11
00:00:31,320 --> 00:00:33,600
cosas, entonces como muestra por consola

12
00:00:33,600 --> 00:00:35,320
cosas, no devuelve nada en realidad

13
00:00:35,320 --> 00:00:37,759
porque el objetivo de la función

14
00:00:37,759 --> 00:00:39,460
es ya mostrar directamente por consola

15
00:00:39,460 --> 00:00:41,520
no devuelve, entonces tipo de retorno

16
00:00:41,520 --> 00:00:43,039
void, porque no devuelve nada

17
00:00:43,039 --> 00:00:45,700
parámetros, dos

18
00:00:45,700 --> 00:00:47,039
números enteros

19
00:00:47,039 --> 00:00:49,219
nombre, pues elegimos un nombre

20
00:00:49,219 --> 00:00:51,640
pues mostrar

21
00:00:51,640 --> 00:00:52,859
números, cualquier cosa

22
00:00:52,859 --> 00:00:55,659
pues venga, entonces la función

23
00:00:55,659 --> 00:00:57,740
sabemos que tenemos que ponerle

24
00:00:57,740 --> 00:00:59,759
un static delante, sí o sí.

25
00:01:01,039 --> 00:01:01,700
Por ahora

26
00:01:01,700 --> 00:01:03,820
tenemos que poner un static delante, sí o sí.

27
00:01:04,780 --> 00:01:05,939
Aunque no entendamos por qué.

28
00:01:06,959 --> 00:01:07,879
Valor que va a devolver

29
00:01:07,879 --> 00:01:09,819
la función. Ya hemos dicho, no me

30
00:01:09,819 --> 00:01:11,760
devuelve nada. No es que sea una función que

31
00:01:11,760 --> 00:01:13,760
diga, devuélveme la suma de todos los

32
00:01:13,760 --> 00:01:15,819
números comprendidos entre dos que yo te dé

33
00:01:15,819 --> 00:01:17,500
o devuélveme no sé qué.

34
00:01:17,879 --> 00:01:19,760
Yo estoy poniendo public static porque así la puedo

35
00:01:19,760 --> 00:01:21,659
llamar desde otros. Ah, bueno, sí.

36
00:01:22,099 --> 00:01:23,859
¿Vale? Como nosotros hasta ahora lo estamos llamando solamente

37
00:01:23,859 --> 00:01:25,799
desde el main, pero si quisieras llamarlo desde otro

38
00:01:25,799 --> 00:01:27,719
de fuera del paquete. No entendía muy bien

39
00:01:27,719 --> 00:01:30,819
Sí, eso ya lo veremos

40
00:01:30,819 --> 00:01:32,920
cuando veamos. Necesitas que sea público para llamarla

41
00:01:32,920 --> 00:01:34,159
desde fuera del paquete.

42
00:01:34,359 --> 00:01:35,519
Desde el mismo paquete no.

43
00:01:36,019 --> 00:01:38,840
Desde una clase distinta en el mismo paquete no.

44
00:01:40,000 --> 00:01:40,659
Claro, entonces sí.

45
00:01:41,579 --> 00:01:42,780
Tiene que ser público.

46
00:01:43,099 --> 00:01:44,400
Y tener el public delante.

47
00:01:44,579 --> 00:01:46,859
No vale con que sea public aquí si no hay public ahí arriba.

48
00:01:47,359 --> 00:01:48,900
Vale. Pero bueno, eso ya explicaremos

49
00:01:48,900 --> 00:01:50,540
por qué y a qué se debe.

50
00:01:51,280 --> 00:01:52,200
Vale. Entonces,

51
00:01:52,459 --> 00:01:54,939
hemos dicho que no va a devolver nada porque va a mostrar

52
00:01:54,939 --> 00:01:57,260
por consola. Pues ya nos adelantamos

53
00:01:57,260 --> 00:02:00,599
y void, venga vamos a llamarla

54
00:02:00,599 --> 00:02:03,040
mostrar secuencia porque va a mostrar la secuencia

55
00:02:03,040 --> 00:02:04,939
entre dos extremos

56
00:02:04,939 --> 00:02:06,719
y ahora que recibe

57
00:02:06,719 --> 00:02:08,840
los dos extremos de la secuencia

58
00:02:08,840 --> 00:02:09,819
que va a mostrar

59
00:02:09,819 --> 00:02:12,340
pues venga

60
00:02:12,340 --> 00:02:14,740
el numerito 1 y el

61
00:02:14,740 --> 00:02:15,900
numerito 2

62
00:02:15,900 --> 00:02:18,780
la lista de parámetros de la función

63
00:02:18,780 --> 00:02:20,599
puede ser tan larga como a uno le

64
00:02:20,599 --> 00:02:22,360
de la gana o como uno necesite

65
00:02:22,360 --> 00:02:24,780
siempre y cuando estén todos

66
00:02:24,780 --> 00:02:25,879
separados por comas

67
00:02:25,879 --> 00:02:27,840
vale

68
00:02:27,840 --> 00:02:30,599
hay otra manera de expresar la lista

69
00:02:30,599 --> 00:02:32,699
de parámetros que se incorporó a partir de cierta

70
00:02:32,699 --> 00:02:34,759
versión de Java, por si la veis

71
00:02:34,759 --> 00:02:36,740
alguna vez, con tres puntos, pero bueno

72
00:02:36,740 --> 00:02:38,159
esa no la mencionamos porque

73
00:02:38,159 --> 00:02:40,280
liamos y tampoco se usa tanto

74
00:02:40,280 --> 00:02:46,270
entonces ahora ya podemos hacer el código

75
00:02:46,270 --> 00:02:48,550
el código que va a hacer, mostrar todos

76
00:02:48,550 --> 00:02:50,770
los números entre N1 y N2

77
00:02:50,770 --> 00:02:52,509
bueno, pues esto

78
00:02:52,509 --> 00:02:54,689
ya directamente que plantaríais aquí

79
00:02:54,689 --> 00:02:58,349
un bucle for

80
00:02:58,349 --> 00:03:01,669
un bucle for donde aprovechamos la variable índice

81
00:03:01,669 --> 00:03:06,389
para que esa variable índice arranque desde n1 y acabe en n2

82
00:03:06,389 --> 00:03:08,389
y uso esa variable índice para mostrar

83
00:03:08,389 --> 00:03:16,639
y ya está, perdón, 0 no, n1

84
00:03:16,639 --> 00:03:25,949
entonces jugamos con los límites del for

85
00:03:25,949 --> 00:03:27,990
en la medida en la que nos interesa

86
00:03:27,990 --> 00:03:30,569
aquí nos interesa decir, oye, el primero es l1

87
00:03:30,569 --> 00:03:33,889
voy incrementando de 1 en 1 y el segundo es n2

88
00:03:33,889 --> 00:03:36,250
pues ya está, juego con esos límites para hacer lo que sea

89
00:03:36,250 --> 00:03:39,069
En este caso, lo que queremos hacer es

90
00:03:39,069 --> 00:03:41,729
Mostrarlo sin más

91
00:03:41,729 --> 00:03:42,789
Pues ya está

92
00:03:42,789 --> 00:03:49,849
Ya, ya, ya

93
00:03:49,849 --> 00:03:50,830
Bueno, sí, pero vamos

94
00:03:50,830 --> 00:03:52,210
¿Vale?

95
00:03:52,849 --> 00:03:54,669
Entonces esto es lo que se nos podría ocurrir

96
00:03:54,669 --> 00:03:57,009
Pues ya está, un for, jugamos con el índice

97
00:03:57,009 --> 00:03:58,550
Ya está, empieza valiendo en e1

98
00:03:58,550 --> 00:03:59,689
Se va incrementando

99
00:03:59,689 --> 00:04:02,909
Y mientras no haya llegado en e2, lo mostramos

100
00:04:02,909 --> 00:04:04,270
Y ya está

101
00:04:04,270 --> 00:04:05,629
Y nada más

102
00:04:05,629 --> 00:04:07,509
entonces

103
00:04:07,509 --> 00:04:09,050
te lo quería preguntar, porque no lo he probado

104
00:04:09,050 --> 00:04:11,009
si cambio una variable dentro de ese

105
00:04:11,009 --> 00:04:12,930
pero como no retorno nada, la variable

106
00:04:12,930 --> 00:04:14,569
original no se toca, ¿no?

107
00:04:14,770 --> 00:04:16,370
no, no, no, no, no

108
00:04:16,370 --> 00:04:19,370
no, no, no, ahora vamos a hacer el ejemplo

109
00:04:19,370 --> 00:04:20,529
claro, por ejemplo

110
00:04:20,529 --> 00:04:23,310
vale, bueno, antes de hacer

111
00:04:23,310 --> 00:04:24,509
ese ejemplo, ¿esto está claro?

112
00:04:25,050 --> 00:04:27,290
está claro, ¿no? entonces ahora llevamos a la función

113
00:04:27,290 --> 00:04:29,129
a la función, ¿cómo la llamaríamos?

114
00:04:29,509 --> 00:04:31,089
pues con su nombre, como siempre

115
00:04:31,089 --> 00:04:33,230
pero ahora hay que pasarle unos valores

116
00:04:33,230 --> 00:04:33,970
concretos

117
00:04:33,970 --> 00:04:36,209
¿vale? pues por ejemplo

118
00:04:36,209 --> 00:04:38,529
si le pasamos el 6 y le pasamos el 12

119
00:04:38,529 --> 00:04:40,250
pues está claro que esta

120
00:04:40,250 --> 00:04:42,750
función va a

121
00:04:42,750 --> 00:04:44,449
mostrar todos los

122
00:04:44,449 --> 00:04:45,509
números entre 6 y 12

123
00:04:45,509 --> 00:04:48,389
¿vale? y podría hacer

124
00:04:48,389 --> 00:04:50,370
más cosas, podría pues en lugar de mostrar

125
00:04:50,370 --> 00:04:52,370
los números, pues a lo mejor hacer

126
00:04:52,370 --> 00:04:54,310
la suma, pues nada, haríamos aquí

127
00:04:54,310 --> 00:04:56,009
la suma acumulativa y devolveríamos la suma

128
00:04:56,009 --> 00:04:57,610
lo que fuera, ya está

129
00:04:57,610 --> 00:05:00,629
¿vale? entonces en relación a la

130
00:05:00,629 --> 00:05:01,550
pregunta que

131
00:05:01,550 --> 00:05:03,069
que hacías tú

132
00:05:03,069 --> 00:05:06,230
claro, sí, sí, no, pero

133
00:05:06,230 --> 00:05:08,730
vale, es que eso tiene que ver

134
00:05:08,730 --> 00:05:10,370
con paso por valor y referencia de objetos

135
00:05:10,370 --> 00:05:12,110
entonces ya insistiremos en ello

136
00:05:12,110 --> 00:05:14,250
cuando veamos objetos, pero

137
00:05:14,250 --> 00:05:16,430
sí que se puede responder

138
00:05:16,430 --> 00:05:17,149
a tu pregunta

139
00:05:17,149 --> 00:05:20,470
entonces, vamos a

140
00:05:20,470 --> 00:05:22,610
la pregunta que ha hecho Juanjo

141
00:05:22,610 --> 00:05:24,629
es, claro, yo aquí

142
00:05:24,629 --> 00:05:27,129
le paso, sí, sí, sí

143
00:05:27,129 --> 00:05:28,649
sí, va a poner una función

144
00:05:28,649 --> 00:05:29,610
específica para

145
00:05:29,610 --> 00:05:32,029
La pregunta que ha hecho Juanjo

146
00:05:32,029 --> 00:05:33,790
Yo tengo una variable

147
00:05:33,790 --> 00:05:34,790
Y hago aquí una función

148
00:05:34,790 --> 00:05:46,850
A la que le paso un parámetro n

149
00:05:46,850 --> 00:05:48,949
Y ahora aquí hago

150
00:05:48,949 --> 00:05:51,189
n igual a 8

151
00:05:51,189 --> 00:05:52,449
Por ejemplo

152
00:05:52,449 --> 00:05:54,250
¿Vale? Y mi función termina

153
00:05:54,250 --> 00:05:56,569
Vale, imagina, entonces le voy a pasar aquí

154
00:05:56,569 --> 00:05:58,569
Una variable, un valor

155
00:05:58,569 --> 00:05:59,850
Le paso un valor

156
00:05:59,850 --> 00:06:02,589
¿Vale? Y a ese valor n

157
00:06:02,589 --> 00:06:04,089
Que le he pasado le pongo a 8

158
00:06:04,089 --> 00:06:06,610
Y luego hago con él lo que sea, vamos a suponer que lo mostramos

159
00:06:06,610 --> 00:06:07,129
Por ejemplo

160
00:06:07,129 --> 00:06:10,910
Y aquí se verá el 8

161
00:06:10,910 --> 00:06:12,189
Es evidente que ahí veremos el 8

162
00:06:12,189 --> 00:06:15,569
Entonces vamos a poner aquí dentro de la función

163
00:06:15,569 --> 00:06:20,089
Dentro de la función

164
00:06:20,089 --> 00:06:28,870
Vale, entonces ahora

165
00:06:28,870 --> 00:06:31,610
Vamos a llamar aquí a la función pasándole esta variable

166
00:06:31,610 --> 00:06:35,550
La función se llama cambiarNumero

167
00:06:35,550 --> 00:06:44,420
Más liso, pues no lo tiene más liso

168
00:06:44,420 --> 00:06:48,759
No pillo nada

169
00:06:48,759 --> 00:06:52,459
Vale, entonces vamos a llamar a cambianúmero

170
00:06:52,459 --> 00:06:53,500
Pasándole esta variable

171
00:06:53,500 --> 00:06:55,959
Esta variable que tiene el valor 9

172
00:06:55,959 --> 00:06:57,720
Dentro de la función

173
00:06:57,720 --> 00:06:59,639
Ponemos a 8

174
00:06:59,639 --> 00:07:01,620
Mostramos y ahora vamos a mostrar

175
00:07:01,620 --> 00:07:04,160
Vamos a mostrar lo que vale n

176
00:07:04,160 --> 00:07:04,860
Aquí después

177
00:07:04,860 --> 00:07:10,019
Vamos a mostrar el valor de n

178
00:07:10,019 --> 00:07:11,980
Vamos a poner aquí fuera de la función

179
00:07:11,980 --> 00:07:16,920
Fuera de la función

180
00:07:16,920 --> 00:07:20,480
Vale, a ver

181
00:07:20,480 --> 00:07:21,980
Esto es importante

182
00:07:21,980 --> 00:07:24,279
Para que uno, pues el programa

183
00:07:24,279 --> 00:07:25,459
No haga cosas que no espera

184
00:07:25,459 --> 00:07:27,699
Vale, entonces, ¿entendéis lo que estoy haciendo?

185
00:07:28,899 --> 00:07:30,060
He creado una función

186
00:07:30,060 --> 00:07:32,699
Cambia número, que recibe un parámetro

187
00:07:32,699 --> 00:07:33,980
A través de este

188
00:07:33,980 --> 00:07:36,500
De esta variable de aquí, recibe un parámetro

189
00:07:36,500 --> 00:07:38,319
Que hace la función dentro

190
00:07:38,319 --> 00:07:40,699
Este parámetro que ha recibido

191
00:07:40,699 --> 00:07:42,980
Lo pone a 8 y ahora muestra su valor

192
00:07:42,980 --> 00:07:44,500
Dentro de la función su valor

193
00:07:44,500 --> 00:07:46,040
Vale, yo llamo aquí a la función

194
00:07:46,040 --> 00:07:47,939
Pasándole un valor entero

195
00:07:47,939 --> 00:07:49,439
Pues este en particular

196
00:07:49,439 --> 00:07:50,800
Le paso este

197
00:07:50,800 --> 00:07:54,399
Y ahora, una vez que esta función ha terminado

198
00:07:54,399 --> 00:07:57,420
Voy a llamar al valor de n

199
00:07:57,420 --> 00:07:58,000
Vale

200
00:07:58,000 --> 00:08:00,319
¿Qué creéis que va a mostrar aquí?

201
00:08:01,660 --> 00:08:02,139
9

202
00:08:02,139 --> 00:08:03,660
¿9 u 8?

203
00:08:03,860 --> 00:08:04,100
9

204
00:08:04,100 --> 00:08:07,839
Todo el mundo cree que 9

205
00:08:07,839 --> 00:08:20,079
dentro de la función 8

206
00:08:20,079 --> 00:08:21,680
y fuera de la función 9

207
00:08:21,680 --> 00:08:23,480
efectivamente, a ver

208
00:08:23,480 --> 00:08:26,339
¿cómo funciona el paso de parámetros

209
00:08:26,339 --> 00:08:27,139
en funciones?

210
00:08:28,079 --> 00:08:29,939
importante que lo entendáis porque si no

211
00:08:29,939 --> 00:08:32,159
el programa puede hacer cosas que no esperáis

212
00:08:32,159 --> 00:08:33,240
que haga y no sabéis por qué

213
00:08:33,240 --> 00:08:34,820
¿cómo funciona?

214
00:08:35,879 --> 00:08:36,519
vamos a ver

215
00:08:36,519 --> 00:08:39,419
cuando uno declara una función

216
00:08:39,419 --> 00:08:41,039
aquí indicamos

217
00:08:41,039 --> 00:08:42,879
que tiene que recibir un valor

218
00:08:42,879 --> 00:08:44,820
lo indicamos de esta manera

219
00:08:44,820 --> 00:08:46,379
pero lo que recibe

220
00:08:46,379 --> 00:08:47,720
es el valor

221
00:08:47,720 --> 00:08:50,240
no recibe la caja entera

222
00:08:50,240 --> 00:08:51,620
para trabajar con ella

223
00:08:51,620 --> 00:08:53,399
recibe el valor

224
00:08:53,399 --> 00:08:56,500
entonces vamos a verlo en la pizarra

225
00:08:56,500 --> 00:08:56,980
para que quede

226
00:08:56,980 --> 00:09:16,700
vale, vamos a hacer esa función que hemos hecho antes

227
00:09:16,700 --> 00:09:18,000
teníamos cambia número

228
00:09:18,000 --> 00:09:18,740
int n

229
00:09:18,740 --> 00:09:21,080
entonces cuando llamamos

230
00:09:21,080 --> 00:09:22,899
desde nuestro main

231
00:09:22,899 --> 00:09:24,919
nuestro main pues tenía

232
00:09:24,919 --> 00:09:27,600
int n igual a 9

233
00:09:27,600 --> 00:09:29,419
y luego ya llamábamos

234
00:09:29,419 --> 00:09:33,059
a cambia número

235
00:09:33,059 --> 00:09:34,500
pasándole n

236
00:09:34,500 --> 00:09:36,539
¿vale?

237
00:09:36,759 --> 00:09:38,580
esto es lo que está en nuestro main

238
00:09:38,580 --> 00:09:40,820
esto es lo que está en nuestro main ¿verdad?

239
00:09:41,299 --> 00:09:42,840
una variable que le ponemos a 9

240
00:09:42,840 --> 00:09:44,000
y le pasamos el valor

241
00:09:44,000 --> 00:09:45,960
y llamamos a esta función

242
00:09:45,960 --> 00:09:48,980
¿vale? pues ¿qué se hace cuando se hace

243
00:09:48,980 --> 00:09:51,019
una llamada a una función pasándole un valor?

244
00:09:51,659 --> 00:09:52,899
bueno pues a cambia número

245
00:09:52,899 --> 00:09:56,379
a cambio de número, nosotros tenemos aquí está claro en el main nuestro

246
00:09:56,379 --> 00:10:01,019
en este main tenemos una cajita que se llama n

247
00:10:01,019 --> 00:10:04,539
eso ya lo sabemos porque eso es lo que hacemos cuando declaramos una variable

248
00:10:04,539 --> 00:10:08,360
cuando declaramos una variable hacemos que aparezca en memoria

249
00:10:08,360 --> 00:10:12,720
una cajita con nombre n y en esa cajita ya se van dando

250
00:10:12,720 --> 00:10:16,919
los valores que vaya siendo necesario, en este caso le hemos dado el 9

251
00:10:16,919 --> 00:10:19,659
pues con esta sentencia de aquí

252
00:10:19,659 --> 00:10:23,529
con esta sentencia de declaración

253
00:10:23,529 --> 00:10:25,610
int n igual a 9 lo que hemos hecho es esto

254
00:10:25,610 --> 00:10:28,370
crear la caja, ponerle el nombre n

255
00:10:28,370 --> 00:10:29,090
y pasarle 9

256
00:10:29,090 --> 00:10:31,669
ahora, ¿qué hacemos cuando llegamos a la función?

257
00:10:32,450 --> 00:10:34,309
cuando llegamos a la función, cambia número

258
00:10:34,309 --> 00:10:35,850
pues entonces

259
00:10:35,850 --> 00:10:37,389
la máquina virtual

260
00:10:37,389 --> 00:10:39,970
salta al código que hay aquí

261
00:10:39,970 --> 00:10:48,059
que el código que hay aquí es este

262
00:10:48,059 --> 00:10:49,279
salta al código que hay aquí

263
00:10:49,279 --> 00:10:51,899
¿y qué es lo que le pasa a este código?

264
00:10:52,019 --> 00:10:52,740
¿qué es lo que le pasa?

265
00:10:53,200 --> 00:10:54,399
no le pasa a la caja

266
00:10:54,399 --> 00:10:56,960
no le pasa la caja, saca el valor

267
00:10:56,960 --> 00:10:58,980
saca el valor 9

268
00:10:58,980 --> 00:11:00,960
y se lo pasa a la función

269
00:11:00,960 --> 00:11:02,679
y le dice, oye

270
00:11:02,679 --> 00:11:04,340
créate tú una caja temporal

271
00:11:04,340 --> 00:11:07,059
que llames como se ponga ahí, como tú quieras

272
00:11:07,059 --> 00:11:08,659
porque ya sabemos que esta variable

273
00:11:08,659 --> 00:11:10,720
este nombre se puede llamar como uno quisiera

274
00:11:10,720 --> 00:11:12,720
entonces le dice, oye, créate tú

275
00:11:12,720 --> 00:11:14,779
una caja temporal, llámala como quieras

276
00:11:14,779 --> 00:11:16,860
una caja temporal, en este caso la estoy llamando n

277
00:11:16,860 --> 00:11:18,980
créate tú una caja temporal

278
00:11:18,980 --> 00:11:20,840
porque en esa caja local

279
00:11:20,840 --> 00:11:22,600
tuya, temporal tuya

280
00:11:22,600 --> 00:11:25,080
te voy a pasar el numerito este

281
00:11:25,080 --> 00:11:26,559
de aquí, entonces

282
00:11:26,559 --> 00:11:28,019
el numerito

283
00:11:28,019 --> 00:11:30,720
es el que se pasa aquí

284
00:11:30,720 --> 00:11:33,220
a esta caja temporal de aquí, el 9

285
00:11:33,220 --> 00:11:34,700
entonces

286
00:11:34,700 --> 00:11:37,120
en un código como este tenemos dos

287
00:11:37,120 --> 00:11:39,299
cajas, la de la clase

288
00:11:39,299 --> 00:11:41,019
main, la del método main

289
00:11:41,019 --> 00:11:42,779
la n que tiene el 9

290
00:11:42,779 --> 00:11:45,039
y ahora cuando hemos llamado a la función

291
00:11:45,039 --> 00:11:46,879
cada una de estas

292
00:11:46,879 --> 00:11:48,860
es una cajita o una variable

293
00:11:48,860 --> 00:11:51,080
local suya, que desaparece

294
00:11:51,080 --> 00:11:52,940
en cuanto la función termina, es una variable

295
00:11:52,940 --> 00:11:54,539
local suya, entonces

296
00:11:54,539 --> 00:11:56,980
esta función durante el tiempo que

297
00:11:56,980 --> 00:11:58,940
se está ejecutando tiene su propia variable

298
00:11:58,940 --> 00:12:00,980
local n, y que ha

299
00:12:00,980 --> 00:12:02,679
ocurrido cuando la hemos llamado

300
00:12:02,679 --> 00:12:04,980
que se ha inicializado con

301
00:12:04,980 --> 00:12:07,320
este valor, si le hubiéramos

302
00:12:07,320 --> 00:12:08,720
dado aquí 10 en vez de n

303
00:12:08,720 --> 00:12:11,200
pues esta variable local se habría inicializado

304
00:12:11,200 --> 00:12:12,080
con 10, depende

305
00:12:12,080 --> 00:12:15,139
esta variable local que crea

306
00:12:15,139 --> 00:12:17,000
esta función a la que llama

307
00:12:17,000 --> 00:12:19,039
n, se inicializa

308
00:12:19,039 --> 00:12:20,919
con el número que vemos aquí, pero

309
00:12:20,919 --> 00:12:25,879
tenemos dos variables separadas una es la de mi clase main las que están en main que están ahí

310
00:12:25,879 --> 00:12:32,500
todas con sus valores y luego cada vez que se llama una función se crean tantas variables locales como

311
00:12:32,500 --> 00:12:38,600
haya en parámetros tantas y son sus propias variables locales y esas variables locales se

312
00:12:38,600 --> 00:12:45,179
llenan con los valores que le demos aquí entonces cuando hemos hecho un igual a 8 el 8 se ha colocado

313
00:12:45,179 --> 00:12:49,200
en esta variable local de ahí se ha colocado ahí

314
00:12:49,200 --> 00:12:52,059
pero sin embargo

315
00:12:52,059 --> 00:12:53,279
cuando ya hemos salido

316
00:12:53,279 --> 00:12:55,120
cuando ya hemos vuelto aquí

317
00:12:55,120 --> 00:12:57,600
esta variable local ya ha desaparecido

318
00:12:57,600 --> 00:12:59,740
cuando ya hemos vuelto aquí esa variable ha desaparecido

319
00:12:59,740 --> 00:13:00,919
y ha quedado esta

320
00:13:00,919 --> 00:13:03,799
y esta sigue teniendo el valor que tenía

321
00:13:03,799 --> 00:13:05,139
el 9, ¿vale?

322
00:13:06,000 --> 00:13:07,419
sigue teniendo el valor que tenía

323
00:13:07,419 --> 00:13:10,019
¿vale? entonces, un segundo

324
00:13:10,019 --> 00:13:12,259
dos minutos para verlo con otro ejemplo

325
00:13:12,259 --> 00:13:13,759
que quede claro, que no os enfriéis

326
00:13:13,759 --> 00:13:14,779
y ya paramos, ¿vale?

327
00:13:15,460 --> 00:13:17,059
vamos a verlo con otro ejemplo

328
00:13:17,059 --> 00:13:19,440
y luego ya paramos

329
00:13:19,440 --> 00:13:20,139
para que no

330
00:13:20,139 --> 00:13:23,159
os enfriéis ahora que lo tenéis

331
00:13:23,159 --> 00:13:24,860
¿y el programa a la hora de ejecutarse

332
00:13:24,860 --> 00:13:27,220
cuenta con las funciones

333
00:13:27,220 --> 00:13:28,860
para guardar RAM?

334
00:13:31,259 --> 00:13:32,519
no, no es que cuenta

335
00:13:32,519 --> 00:13:35,600
a ver, el proceso tendrá

336
00:13:35,600 --> 00:13:37,659
el sistema operativo, su planificador de procesos

337
00:13:37,659 --> 00:13:39,360
tendrá una RAM y la irá llenando

338
00:13:39,360 --> 00:13:40,139
hasta que se acabe

339
00:13:40,139 --> 00:13:42,860
depende de la RAM que tenga el equipo

340
00:13:42,860 --> 00:13:44,220
¿no hay tres programas?

341
00:13:44,220 --> 00:13:47,200
¿Se declaran las variables para dejar el espacio para el programa?

342
00:13:47,440 --> 00:13:50,059
¿Se declaran las variables para que el programa tenga el espacio?

343
00:13:50,639 --> 00:13:51,600
No, a ver.

344
00:13:51,679 --> 00:13:52,059
¿En teoría?

345
00:13:52,440 --> 00:13:55,399
No, no, porque es que sobre todo en un programa orientado a objetos

346
00:13:55,399 --> 00:13:57,539
es que no sabes cuántos objetos van a aparecer.

347
00:13:58,100 --> 00:14:02,720
Entonces el proceso tendrá su rama asociada y se va de forma dinámica para el programa.

348
00:14:03,039 --> 00:14:06,500
¿Vale? Entonces si me escucháis y os concentráis, paramos antes.

349
00:14:08,830 --> 00:14:10,350
Otro ejemplo de esto mismo.

350
00:14:10,350 --> 00:14:12,830
Imaginaos que tenemos una función

351
00:14:12,830 --> 00:14:14,389
Que la

352
00:14:14,389 --> 00:14:16,190
Imaginaos que la llamamos

353
00:14:16,190 --> 00:14:18,889
Intercambia

354
00:14:18,889 --> 00:14:19,649
Por ejemplo

355
00:14:19,649 --> 00:14:21,529
Y yo le paso

356
00:14:21,529 --> 00:14:22,950
X

357
00:14:22,950 --> 00:14:29,389
Imaginaos que tenemos esta función

358
00:14:29,389 --> 00:14:32,169
X e Y, por ejemplo

359
00:14:32,169 --> 00:14:33,629
¿Y qué vamos a hacer?

360
00:14:33,730 --> 00:14:35,289
Vamos a intercambiar estos dos valores

361
00:14:35,289 --> 00:14:38,190
Vamos a hacer un código que intercambie estos dos valores

362
00:14:38,190 --> 00:14:38,769
Por ejemplo

363
00:14:38,769 --> 00:14:40,289
¿Vale?

364
00:14:40,289 --> 00:14:42,230
esto, nada, devuelvo y voy

365
00:14:42,230 --> 00:14:44,250
vamos a hacer un código que intercambie estos dos

366
00:14:44,250 --> 00:14:46,009
vale, pues entonces este código

367
00:14:46,009 --> 00:14:47,769
pues ya sabemos como lo haríamos

368
00:14:47,769 --> 00:14:50,509
int aus igual a x

369
00:14:50,509 --> 00:14:53,230
x igual a y

370
00:14:53,230 --> 00:14:57,190
e y igual a

371
00:14:57,190 --> 00:14:57,950
aus, ¿no?

372
00:15:01,710 --> 00:15:02,269
¿vale?

373
00:15:03,409 --> 00:15:03,970
entonces

374
00:15:03,970 --> 00:15:06,789
¿qué ocurre cuando esta función se le llama?

375
00:15:07,409 --> 00:15:08,929
cuando esta función es llamada

376
00:15:08,929 --> 00:15:10,029
desde cualquier sitio

377
00:15:10,029 --> 00:15:17,029
Esta función automáticamente crea dos variables locales x e y

378
00:15:17,029 --> 00:15:19,509
Dos variables locales x e y

379
00:15:19,509 --> 00:15:24,269
Entonces tenéis que ver los parámetros de una función

380
00:15:24,269 --> 00:15:26,909
Los parámetros como variables locales suyas

381
00:15:26,909 --> 00:15:29,370
Tenéis que verlos como variables locales suyas

382
00:15:29,370 --> 00:15:32,429
Entonces esta función en el momento en que es llamada

383
00:15:32,429 --> 00:15:35,210
Crea dos variables locales x e y

384
00:15:35,210 --> 00:15:37,529
Y trabaja con ellas

385
00:15:37,529 --> 00:15:41,090
¿qué ocurre cuando la función ya termina?

386
00:15:41,769 --> 00:15:43,230
estas variables locales

387
00:15:43,230 --> 00:15:44,110
han desaparecido

388
00:15:44,110 --> 00:15:46,809
¿vale? luego los parámetros

389
00:15:46,809 --> 00:15:49,029
de una función son variables locales suyas

390
00:15:49,029 --> 00:15:50,909
que se crean en el momento

391
00:15:50,909 --> 00:15:52,330
en que entramos en la función

392
00:15:52,330 --> 00:15:54,909
se trabaja con ellas y luego

393
00:15:54,909 --> 00:15:57,210
desaparecen, son variables locales

394
00:15:57,210 --> 00:15:58,950
¿vale? entonces ¿qué ocurre

395
00:15:58,950 --> 00:16:00,570
si ahora llamáramos a esta función

396
00:16:00,570 --> 00:16:04,269
desde un main cualquiera?

397
00:16:04,629 --> 00:16:06,210
pues imaginaos que ahora tenemos un main

398
00:16:06,210 --> 00:16:36,159
Int x igual a 7, int y igual a 9, y ahora llamamos a intercambia, llamamos a intercambia pasándole x e y, vale, pues entonces cuando hacemos esta llamada, lo que estamos pasando a la función intercambia son solo estos valores, estamos diciendo, oye función, cuando te crees tú tu variable local x y tu variable local y,

399
00:16:36,159 --> 00:16:38,379
porque recuerdo, los parámetros de una función

400
00:16:38,379 --> 00:16:40,840
son variables que se crean en ese momento

401
00:16:40,840 --> 00:16:41,980
y son locales a la función

402
00:16:41,980 --> 00:16:44,799
pues estamos diciendo, oye, cuando te crees tú

403
00:16:44,799 --> 00:16:46,139
tu propia variable local x

404
00:16:46,139 --> 00:16:48,059
y tu propia variable local y

405
00:16:48,059 --> 00:16:51,059
inicializa x con este valor que yo te doy

406
00:16:51,059 --> 00:16:52,799
que resulta que es 7

407
00:16:52,799 --> 00:16:55,179
e inicializa y con este valor

408
00:16:55,179 --> 00:16:56,000
que yo te doy aquí

409
00:16:56,000 --> 00:16:57,559
que resulta que es 9

410
00:16:57,559 --> 00:17:00,419
como si yo le diera 11 y 13

411
00:17:00,419 --> 00:17:02,799
le estaríamos diciendo, oye, cuando te crees

412
00:17:02,799 --> 00:17:04,299
tu propia variable local x

413
00:17:04,299 --> 00:17:06,700
y te crees tu propia variable local y

414
00:17:06,700 --> 00:17:09,299
inicializa la x con el 11

415
00:17:09,299 --> 00:17:11,079
y la y con el 13

416
00:17:11,079 --> 00:17:13,319
es decir, lo que pasamos aquí

417
00:17:13,319 --> 00:17:15,079
son solamente

418
00:17:15,079 --> 00:17:17,920
los valores con los que inicializamos

419
00:17:17,920 --> 00:17:19,420
las variables locales

420
00:17:19,420 --> 00:17:21,579
que se crean cuando entramos en la función

421
00:17:21,579 --> 00:17:22,759
¿vale?

422
00:17:23,400 --> 00:17:25,160
entonces cuando esta función ha terminado

423
00:17:25,160 --> 00:17:26,539
x e y

424
00:17:26,539 --> 00:17:28,680
las variables del main

425
00:17:28,680 --> 00:17:30,740
no se han enterado de nada de lo que ha pasado

426
00:17:30,740 --> 00:17:31,839
no se han enterado de nada

427
00:17:31,839 --> 00:17:33,660
porque con quien ha trabajado la función

428
00:17:33,660 --> 00:17:36,000
es con las variables locales suyas

429
00:17:36,000 --> 00:17:37,200
que ha creado

430
00:17:37,200 --> 00:17:39,759
y lo que pasamos aquí

431
00:17:39,759 --> 00:17:41,480
son sólo valores

432
00:17:41,480 --> 00:17:43,640
para inicializar esas variables locales

433
00:17:43,640 --> 00:17:44,839
sólo pasamos valores

434
00:17:44,839 --> 00:17:47,880
no pasamos la variable, la caja entera

435
00:17:47,880 --> 00:17:49,700
porque si pasáramos

436
00:17:49,700 --> 00:17:51,700
la caja entera, todo lo que

437
00:17:51,700 --> 00:17:53,720
hiciéramos aquí, luego se vería

438
00:17:53,720 --> 00:17:55,920
al salir, pero es que no pasamos

439
00:17:55,920 --> 00:17:57,700
la caja entera, pasamos

440
00:17:57,700 --> 00:17:59,960
dos valores que inicializan

441
00:17:59,960 --> 00:18:01,200
las cajitas locales

442
00:18:01,200 --> 00:18:03,420
y cuando la función termina

443
00:18:03,420 --> 00:18:05,880
estas cajitas locales han desaparecido

444
00:18:05,880 --> 00:18:08,099
la función habrá devuelto un valor

445
00:18:08,099 --> 00:18:10,420
o lo que sea, pero las cajitas locales

446
00:18:10,420 --> 00:18:12,119
x y y han desaparecido

447
00:18:12,119 --> 00:18:14,099
¿vale? entonces por eso

448
00:18:14,099 --> 00:18:15,539
se dice que el paso

449
00:18:15,539 --> 00:18:18,039
de parámetros a

450
00:18:18,039 --> 00:18:19,640
funciones es por valor

451
00:18:19,640 --> 00:18:22,039
se llama así, por valor, porque lo que

452
00:18:22,039 --> 00:18:24,200
se pasa es el valor, no se pasa la caja entera

453
00:18:24,200 --> 00:18:25,960
¿vale? se pasa

454
00:18:25,960 --> 00:18:28,059
el valor, paso el valor de

455
00:18:28,059 --> 00:18:30,180
x para tu cajita local y paso

456
00:18:30,180 --> 00:18:31,960
el valor de y para tu cajita local

457
00:18:31,960 --> 00:18:33,599
se pasa el valor

458
00:18:33,599 --> 00:18:37,119
entonces a veces sería útil

459
00:18:37,119 --> 00:18:39,039
pasar la caja entera

460
00:18:39,039 --> 00:18:41,400
sería utilísimo pasar la caja entera

461
00:18:41,400 --> 00:18:43,160
oye, ya que haces cosas

462
00:18:43,160 --> 00:18:44,240
con lo que yo te paso

463
00:18:44,240 --> 00:18:45,660
que eso que haces

464
00:18:45,660 --> 00:18:47,680
afecte ya al programa

465
00:18:47,680 --> 00:18:49,660
ojalá pudiera yo pasarte la caja entera

466
00:18:49,660 --> 00:18:55,720
pero en cualquier caso

467
00:18:55,720 --> 00:18:57,839
sí, podríamos devolver los valores

468
00:18:57,839 --> 00:18:59,019
y luego asignarlos

469
00:18:59,019 --> 00:19:01,319
ahora mismo no tendríamos

470
00:19:01,319 --> 00:19:03,160
o sea, devolver un array con dos valores

471
00:19:03,160 --> 00:19:03,859
y asignarlos

472
00:19:03,859 --> 00:19:07,019
pero ni siquiera hace falta

473
00:19:07,019 --> 00:19:09,019
o sea, hay una manera de

474
00:19:09,019 --> 00:19:11,079
oye, mira, te voy a pasar la caja

475
00:19:11,079 --> 00:19:13,140
entera, entera, te paso la caja entera

476
00:19:13,140 --> 00:19:15,160
y así todas las operaciones que

477
00:19:15,160 --> 00:19:17,079
hagas no van a ser con

478
00:19:17,079 --> 00:19:19,119
copias locales, sino con

479
00:19:19,119 --> 00:19:21,160
cajas enteras, pero pasar la caja

480
00:19:21,160 --> 00:19:23,079
entera significa pasarlo en

481
00:19:23,079 --> 00:19:23,839
modo objeto

482
00:19:23,839 --> 00:19:26,680
entonces, cuando veamos objetos

483
00:19:26,680 --> 00:19:29,019
veremos cómo puedo pasar

484
00:19:29,019 --> 00:19:31,039
yo la caja enterita para que todo lo que haga

485
00:19:31,039 --> 00:19:31,700
aquí dentro

486
00:19:31,700 --> 00:19:33,400
se refleje

487
00:19:33,400 --> 00:19:34,640
en el mail

488
00:19:34,640 --> 00:19:35,660
porque al haber pasado

489
00:19:35,660 --> 00:19:36,480
el contenedor

490
00:19:36,480 --> 00:19:37,519
si yo trabajo

491
00:19:37,519 --> 00:19:38,559
con este contenedor

492
00:19:38,559 --> 00:19:39,200
aquí dentro

493
00:19:39,200 --> 00:19:39,779
lo que haga

494
00:19:39,779 --> 00:19:40,539
se va a reflejar

495
00:19:40,539 --> 00:19:41,859
pero con lo que

496
00:19:41,859 --> 00:19:42,259
estamos haciendo

497
00:19:42,259 --> 00:19:43,099
nosotros hasta ahora

498
00:19:43,099 --> 00:19:44,579
lo que estamos creando

499
00:19:44,579 --> 00:19:45,299
es siempre

500
00:19:45,299 --> 00:19:47,180
cajitas locales

501
00:19:47,180 --> 00:19:48,059
variables locales

502
00:19:48,059 --> 00:19:49,480
y pasamos el valor

503
00:19:49,480 --> 00:19:51,279
cuando esta función

504
00:19:51,279 --> 00:19:51,920
ha terminado

505
00:19:51,920 --> 00:19:53,660
eso ha desaparecido

506
00:19:53,660 --> 00:19:54,019
¿vale?

507
00:19:54,099 --> 00:19:54,579
por eso se llama

508
00:19:54,579 --> 00:19:55,279
paso por valor

509
00:19:55,279 --> 00:19:56,000
y lo otro se llama

510
00:19:56,000 --> 00:19:56,880
paso por referencia

511
00:19:56,880 --> 00:19:57,319
pero bueno

512
00:19:57,319 --> 00:19:58,519
vale, ahora sí que

513
00:19:58,519 --> 00:19:59,519
paramos entonces

514
00:19:59,519 --> 00:20:03,119
Justo, un objeto es una dirección

515
00:20:03,119 --> 00:20:04,279
Entonces le pasas la dirección

516
00:20:04,279 --> 00:20:06,980
Entonces te da igual llegar a esa dirección

517
00:20:06,980 --> 00:20:08,279
Desde una función que desde aquí

518
00:20:08,279 --> 00:20:09,059
O vas al mismo lado

519
00:20:09,059 --> 00:20:11,200
Es justo eso, claro

520
00:20:11,200 --> 00:20:13,640
Venga, pues