1
00:00:00,000 --> 00:00:22,480
Bueno, pues entonces, esto, por tanto, es lo que llamamos, venga, ahora ya sí que vemos, venga, vale, vamos.

2
00:00:22,480 --> 00:00:29,820
Bueno, pues esto de aquí es lo que hemos llamado

3
00:00:29,820 --> 00:00:33,320
la cabecera de la función, la cabecera.

4
00:00:33,740 --> 00:00:36,579
Y es lo que nos da toda la información que necesitamos

5
00:00:36,579 --> 00:00:37,439
para usar la función.

6
00:00:38,219 --> 00:00:40,219
El interior nos da exactamente igual.

7
00:00:40,420 --> 00:00:43,759
Aquí lo que importa no es el interior, ¿vale?

8
00:00:44,179 --> 00:00:47,119
La cabecera nos da toda la información que necesita

9
00:00:47,119 --> 00:00:48,859
el programador para usar la función.

10
00:00:49,600 --> 00:00:50,679
¿Cómo llamarla?

11
00:00:50,679 --> 00:00:55,859
qué datos tiene que pasarle para que cumpla su función

12
00:00:55,859 --> 00:00:58,979
y si devuelve algo o no.

13
00:01:00,020 --> 00:01:01,719
Vale, en este caso estas funciones que hemos hecho

14
00:01:01,719 --> 00:01:03,960
no devolvían nada porque mostraron por consola

15
00:01:03,960 --> 00:01:05,040
una información y ya está.

16
00:01:05,980 --> 00:01:07,359
Vamos ahora a usar este valor.

17
00:01:09,079 --> 00:01:11,760
Venga, pues vamos a probar en este proyecto de ejemplo nuestro,

18
00:01:11,879 --> 00:01:13,159
vamos a hacer otra función distinta.

19
00:01:14,060 --> 00:01:19,299
Esta ya, estamos hartos de que nos salude.

20
00:01:19,299 --> 00:01:21,700
entonces, ahora vamos a hacer una función

21
00:01:21,700 --> 00:01:23,739
que nos diga, anda, deja de saludarme

22
00:01:23,739 --> 00:01:25,280
casi mejor

23
00:01:25,280 --> 00:01:26,840
dime

24
00:01:26,840 --> 00:01:29,359
cuántas vocales tiene mi nombre

25
00:01:29,359 --> 00:01:31,579
que me apetece casi más saber eso

26
00:01:31,579 --> 00:01:33,060
el número de vocales que tiene mi nombre

27
00:01:33,060 --> 00:01:34,540
que no que me saludes

28
00:01:34,540 --> 00:01:37,079
pues venga, vamos a hacer una función

29
00:01:37,079 --> 00:01:39,760
a la que le pasamos nuestro nombre también

30
00:01:39,760 --> 00:01:41,560
y en lugar de saludarnos

31
00:01:41,560 --> 00:01:43,500
nos va a decir, oye, tu nombre tiene 7 vocales

32
00:01:43,500 --> 00:01:44,560
pues ya está

33
00:01:44,560 --> 00:01:45,799
vamos a

34
00:01:45,799 --> 00:01:47,780
vocales

35
00:01:47,780 --> 00:01:51,379
Venga, pues vamos a hacer otra función

36
00:01:51,379 --> 00:01:52,739
Esto lo voy a...

37
00:01:52,739 --> 00:01:53,439
Vamos allá

38
00:01:53,439 --> 00:01:56,980
Da igual, lo vas a hacer igualmente

39
00:01:56,980 --> 00:02:01,219
Venga, nombrecito

40
00:02:01,219 --> 00:02:04,879
Contar vocales

41
00:02:04,879 --> 00:02:07,829
Vale

42
00:02:07,829 --> 00:02:10,389
Datos de entrada

43
00:02:10,389 --> 00:02:13,930
Del método, de la función

44
00:02:13,930 --> 00:02:15,229
El nombre

45
00:02:15,229 --> 00:02:18,069
Me ha dicho, oye, pásame tu nombre y yo te cuento todas las vocales que quieras

46
00:02:18,069 --> 00:02:22,599
Vale

47
00:02:22,599 --> 00:02:26,360
Y aquí podríamos hacer ya el método que lo hace.

48
00:02:29,219 --> 00:02:31,159
No, no, no, hacerlo, que lo vamos a hacer.

49
00:02:31,699 --> 00:02:33,719
Y luego ya ver qué hacemos con el resultado.

50
00:02:33,960 --> 00:02:38,919
Vamos a hacer ahora mismo, antes de poner aquí esta cosa que no sabemos qué poner,

51
00:02:39,900 --> 00:02:45,099
vamos a hacer el código de la función que, string vocales, no, string nombre.

52
00:02:46,539 --> 00:02:49,759
Dado un nombre que le pasamos, nos cuenta las vocales.

53
00:02:49,759 --> 00:02:52,020
pues nada, esto ya en medio

54
00:02:52,020 --> 00:02:53,900
segundo, esto es lo de siempre

55
00:02:53,900 --> 00:02:55,500
no hay otra vez, vamos a contar

56
00:02:55,500 --> 00:02:56,960
pues entonces un contador

57
00:02:56,960 --> 00:02:59,780
que lo inicializo a cero

58
00:02:59,780 --> 00:03:03,439
vale, entonces

59
00:03:03,439 --> 00:03:05,879
el que ahora cuando tenga que hacer el código

60
00:03:05,879 --> 00:03:07,819
de esta función, no sepa contar

61
00:03:07,819 --> 00:03:09,680
las vocales que hay en esta variable

62
00:03:09,680 --> 00:03:11,759
nombre, si está empezando a tener un problema

63
00:03:11,759 --> 00:03:13,900
vale, el que no diga, ah si claro

64
00:03:13,900 --> 00:03:15,560
es todo loco, papá, vale

65
00:03:15,560 --> 00:03:17,000
y entonces

66
00:03:17,000 --> 00:03:19,560
a estudiar, a pasar a estudiar

67
00:03:19,560 --> 00:03:21,139
de dos horas a cuatro, lo que haga falta

68
00:03:21,139 --> 00:03:25,840
bueno, no hace

69
00:03:25,840 --> 00:03:27,620
falta, pero va, entonces vamos a

70
00:03:27,620 --> 00:03:29,580
hacer ahora mismo rápidamente el código de esta función

71
00:03:29,580 --> 00:03:31,639
que dado una cadena no menos cuanto las

72
00:03:31,639 --> 00:03:33,620
vocales, un contador, pues venga, un contador

73
00:03:33,620 --> 00:03:36,000
y ahora que tenemos que hacer, recorrer

74
00:03:36,000 --> 00:03:37,460
nuestra cadena

75
00:03:37,460 --> 00:03:39,120
parar

76
00:03:39,120 --> 00:03:41,639
en cada carácter, si es

77
00:03:41,639 --> 00:03:43,280
vocal, incremento contador

78
00:03:43,280 --> 00:03:45,419
pues venga, para contar

79
00:03:45,419 --> 00:03:46,939
tenemos que hacer un bucle sí o sí

80
00:03:46,939 --> 00:03:48,800
Ese bucle

81
00:03:48,800 --> 00:03:50,560
¿Qué paradas va a hacer?

82
00:03:50,680 --> 00:03:52,539
Va a hacer paradas en todos y cada uno

83
00:03:52,539 --> 00:03:54,719
De los caracteres que forman el string

84
00:03:54,719 --> 00:03:57,000
Pues el índice mío del bucle

85
00:03:57,000 --> 00:03:59,439
Puede ir desde igual a cero

86
00:03:59,439 --> 00:04:02,659
Mientras si sea menor que nombre.length

87
00:04:02,659 --> 00:04:05,419
Porque recordad que esto

88
00:04:05,419 --> 00:04:09,080
Me devolvía el número de caracteres de una cadena

89
00:04:09,080 --> 00:04:13,689
Y ahora

90
00:04:13,689 --> 00:04:14,849
¿Qué tenemos que hacer?

91
00:04:14,849 --> 00:04:16,189
Vale, pues vámonos

92
00:04:16,189 --> 00:04:18,370
Carácter por carácter

93
00:04:18,370 --> 00:04:20,769
de esta cadena

94
00:04:20,769 --> 00:04:25,870
y habrá que hacer, si esto es vocal

95
00:04:25,870 --> 00:04:27,569
si esto es vocal

96
00:04:27,569 --> 00:04:28,790
incrementas contador

97
00:04:28,790 --> 00:04:37,889
vale, ¿cómo podemos ver si esto es vocal?

98
00:04:38,529 --> 00:04:40,250
desgraciadamente A, E, I o U

99
00:04:40,250 --> 00:04:41,949
no están consecutivas

100
00:04:41,949 --> 00:04:43,910
en la tabla ASCII, porque si estuvieran

101
00:04:43,910 --> 00:04:45,930
consecutivas, estupendísimo, haríamos

102
00:04:45,930 --> 00:04:48,050
si ese carácter es

103
00:04:48,050 --> 00:04:49,889
mayor o igual que 7

104
00:04:49,889 --> 00:04:52,370
y menor o igual que 12, estás comprendido

105
00:04:52,370 --> 00:04:53,110
en la tabla

106
00:04:53,110 --> 00:04:55,449
claro, pero no está

107
00:04:55,449 --> 00:04:57,709
entonces esta condición la tenemos que hacer

108
00:04:57,709 --> 00:04:59,509
si este carácter es igual a

109
00:04:59,509 --> 00:05:01,350
vamos a poner solo minúsculas

110
00:05:01,350 --> 00:05:04,430
y así uno por uno

111
00:05:04,430 --> 00:05:07,889
y así con las cinco vocales

112
00:05:07,889 --> 00:05:13,279
¿qué significa amai?

113
00:05:13,480 --> 00:05:14,500
o sea, sé lo que significa

114
00:05:14,500 --> 00:05:16,139
pero ¿qué uso le dais?

115
00:05:17,000 --> 00:05:18,680
porque ya habíamos quedado con lo de chill

116
00:05:18,680 --> 00:05:20,480
mi hija me ha dicho que me habéis mentido

117
00:05:20,480 --> 00:05:22,899
que esta clase chill no significa

118
00:05:22,899 --> 00:05:23,899
lo que me decís vosotros

119
00:05:23,899 --> 00:05:25,920
¿qué significa para vosotros?

120
00:05:25,920 --> 00:05:29,339
Pues mi hija dice que no

121
00:05:29,339 --> 00:05:33,399
Dice que chill

122
00:05:33,399 --> 00:05:36,000
Dice que chill significa de puta madre

123
00:05:36,000 --> 00:05:37,319
¿No?

124
00:05:37,939 --> 00:05:39,019
De puta madre

125
00:05:39,019 --> 00:05:40,800
¿No? ¿No significa eso?

126
00:05:42,480 --> 00:05:43,560
Alguien me engaña

127
00:05:43,560 --> 00:05:51,879
Para mí chill

128
00:05:51,879 --> 00:05:53,339
De toda la vida ha sido calma

129
00:05:53,339 --> 00:05:54,300
De ahí el chill out

130
00:05:54,300 --> 00:05:57,980
o sea que me engaña ella

131
00:05:57,980 --> 00:06:03,300
me tiene 16

132
00:06:03,300 --> 00:06:04,819
y si me toma el pelo

133
00:06:04,819 --> 00:06:24,100
vale

134
00:06:24,100 --> 00:06:26,000
pues la condición de ser vocal

135
00:06:26,000 --> 00:06:27,079
minúscula

136
00:06:27,079 --> 00:06:29,459
es esta

137
00:06:29,459 --> 00:06:32,100
no tenemos, no hay nariz

138
00:06:32,100 --> 00:06:34,019
no hay huevos, es esta, no hay otra posibilidad

139
00:06:34,019 --> 00:06:35,060
¿vale?

140
00:06:36,779 --> 00:06:37,779
no porque

141
00:06:37,779 --> 00:06:38,600
eso

142
00:06:38,600 --> 00:06:41,860
es un char, variable

143
00:06:41,860 --> 00:06:44,040
primitiva, se compara

144
00:06:44,040 --> 00:06:46,240
con doble igual, solo las variables

145
00:06:46,240 --> 00:06:48,100
objeto como string se comparan

146
00:06:48,100 --> 00:06:48,660
con equals

147
00:06:48,660 --> 00:06:52,120
fijaos aquí que estupendo lo de tener

148
00:06:52,120 --> 00:06:54,180
funciones, porque imaginaos que yo

149
00:06:54,180 --> 00:06:55,560
tuviera que hacer esto varias veces

150
00:06:55,560 --> 00:06:58,199
pues que en mi código apareciera este rollo

151
00:06:58,199 --> 00:07:00,040
varias veces, lo dejaría horroroso

152
00:07:00,040 --> 00:07:01,759
lo tengo metido en una función

153
00:07:01,759 --> 00:07:04,319
está ahí metido, oculto y ya está

154
00:07:04,319 --> 00:07:06,379
bueno, pues este es el código

155
00:07:06,379 --> 00:07:08,439
que me cuenta

156
00:07:08,439 --> 00:07:10,920
todas las veces

157
00:07:10,920 --> 00:07:12,279
que hay una vocal

158
00:07:12,279 --> 00:07:14,060
en nombre, está clarísimo, ¿no?

159
00:07:14,540 --> 00:07:16,660
vale, una vez que este for ha terminado

160
00:07:16,660 --> 00:07:19,480
una vez que este for ha terminado

161
00:07:19,480 --> 00:07:20,860
ahora yo digo

162
00:07:20,860 --> 00:07:21,779
¿qué hago con cont?

163
00:07:22,120 --> 00:07:23,220
¿Lo muestro por consola?

164
00:07:23,360 --> 00:07:25,199
Bueno, pues podría mostrarlo por consola

165
00:07:25,199 --> 00:07:27,620
y tengo una versión ya de esta función

166
00:07:27,620 --> 00:07:29,480
y en ese caso aquí pondría

167
00:07:29,480 --> 00:07:30,959
mi void, ¿vale?

168
00:07:32,240 --> 00:07:33,420
Aquí pondría mi void

169
00:07:33,420 --> 00:07:35,339
y lo muestro por consola, ¿vale?

170
00:07:35,819 --> 00:07:37,100
Podríamos probarlo y ya está.

171
00:07:39,850 --> 00:07:41,170
Sí, para luego poder

172
00:07:41,170 --> 00:07:42,709
llamarla y que no me dé el error,

173
00:07:43,129 --> 00:07:44,410
efectivamente tengo que poner el static.

174
00:07:44,850 --> 00:07:47,089
Si no pongo el static, solo la puedo usar

175
00:07:47,089 --> 00:07:47,850
de una manera.

176
00:07:49,069 --> 00:07:51,170
Vale, bueno, pero

177
00:07:51,170 --> 00:07:53,089
esta versión podría no gustarnos.

178
00:07:53,689 --> 00:07:57,129
podría no gustarnos

179
00:07:57,129 --> 00:07:58,170
pues por algo

180
00:07:58,170 --> 00:07:59,829
bastante habitual

181
00:07:59,829 --> 00:08:01,209
que es, vamos a ver

182
00:08:01,209 --> 00:08:04,389
el desarrollador que hace esta función

183
00:08:04,389 --> 00:08:06,550
dice, oye, tú hazme una función

184
00:08:06,550 --> 00:08:08,269
que cuente vocales, vale, vale, yo te la hago

185
00:08:08,269 --> 00:08:10,949
y el tío ya se ha metido en mi territorio

186
00:08:10,949 --> 00:08:12,509
y se ha empeñado

187
00:08:12,509 --> 00:08:13,750
en que el resultado

188
00:08:13,750 --> 00:08:15,629
va por consola

189
00:08:15,629 --> 00:08:18,709
digo, oye, perdona, tú te estás excediendo

190
00:08:18,709 --> 00:08:19,949
en tus funciones

191
00:08:19,949 --> 00:08:21,790
tú dame a mí el valor

192
00:08:21,790 --> 00:08:24,569
y yo ya decidiré si lo pongo

193
00:08:24,569 --> 00:08:26,589
en la consola, lo pongo en una interfaz

194
00:08:26,589 --> 00:08:28,889
gráfica, se lo paso a una variable

195
00:08:28,889 --> 00:08:30,569
para que esa variable no se quede.

196
00:08:31,730 --> 00:08:32,169
Entonces,

197
00:08:32,690 --> 00:08:33,629
esta versión

198
00:08:33,629 --> 00:08:36,230
me muestra el resultado por consola,

199
00:08:36,730 --> 00:08:38,570
pero puede ser que yo no quiera

200
00:08:38,570 --> 00:08:39,769
que se muestre por consola.

201
00:08:40,889 --> 00:08:42,629
Puede ser que yo quiera ese valor

202
00:08:42,629 --> 00:08:44,809
para hacer lo que a mí me dé la gana con él.

203
00:08:45,230 --> 00:08:46,769
Que es una situación distinta.

204
00:08:47,769 --> 00:08:48,210
Entonces,

205
00:08:48,529 --> 00:08:50,669
vamos a hacer una versión en la cual

206
00:08:50,669 --> 00:08:52,789
esta función te hace

207
00:08:52,789 --> 00:08:54,909
la cuenta y luego te dice, y ahora te entrego

208
00:08:54,909 --> 00:08:56,690
el valor. Y tú con ese valor

209
00:08:56,690 --> 00:08:58,690
haz lo que quieras. Que lo quieras por

210
00:08:58,690 --> 00:09:00,690
consola, que lo quieras en interfaz gráfica, que lo quieras en

211
00:09:00,690 --> 00:09:02,750
no sé qué, lo querés mandar por email, haz lo que quieras

212
00:09:02,750 --> 00:09:04,870
con él. Pero yo no te condeno

213
00:09:04,870 --> 00:09:06,830
a mostrarlo por consola y que haya un tío

214
00:09:06,830 --> 00:09:08,690
ahí en la consola esperando a que lo saques

215
00:09:08,690 --> 00:09:09,750
para apuntarlo en un papel.

216
00:09:10,590 --> 00:09:12,669
No tiene mucha operatividad eso.

217
00:09:13,230 --> 00:09:14,110
Vale, vamos a hacer una versión

218
00:09:14,110 --> 00:09:16,870
de contar vocales

219
00:09:16,870 --> 00:09:19,470
versión 2.

220
00:09:19,470 --> 00:09:28,460
versión 2

221
00:09:28,460 --> 00:09:30,299
entonces ahora cuando hemos llegado a este punto

222
00:09:30,299 --> 00:09:32,740
tenemos cont

223
00:09:32,740 --> 00:09:34,740
y como terminemos ahí

224
00:09:34,740 --> 00:09:36,240
este pobre cont

225
00:09:36,240 --> 00:09:38,940
se pierde, en cuanto la función termine

226
00:09:38,940 --> 00:09:41,059
ese cont como es una variable

227
00:09:41,059 --> 00:09:43,179
local a esas llaves, pum, desaparecería

228
00:09:43,179 --> 00:09:44,379
con lo cual esta función

229
00:09:44,379 --> 00:09:46,279
habrá hecho la cuenta para nada

230
00:09:46,279 --> 00:09:48,840
para que luego el valor desaparezca

231
00:09:48,840 --> 00:09:50,799
vale, pues que va a hacer

232
00:09:50,799 --> 00:09:53,039
antes de cerrarse y terminar

233
00:09:53,039 --> 00:09:54,659
lo va a devolver

234
00:09:54,659 --> 00:09:56,799
lo va a mandar para arriba, lo va a devolver

235
00:09:56,799 --> 00:09:58,000
como resultado

236
00:09:58,000 --> 00:10:00,360
lo va a devolver como resultado final

237
00:10:00,360 --> 00:10:01,940
¿y cómo puede hacer eso?

238
00:10:02,340 --> 00:10:04,600
devolverlo como resultado final, pues con una sentencia

239
00:10:04,600 --> 00:10:05,480
que se llama retun

240
00:10:05,480 --> 00:10:08,340
y esa sentencia retun

241
00:10:08,340 --> 00:10:10,320
admite un único

242
00:10:10,320 --> 00:10:11,879
parámetro

243
00:10:11,879 --> 00:10:15,600
un valor, un único valor

244
00:10:15,600 --> 00:10:17,539
pues cont, en nuestro caso

245
00:10:17,539 --> 00:10:19,379
cont, ¿vale?

246
00:10:20,639 --> 00:10:22,899
vale, ahora lo arreglamos

247
00:10:22,899 --> 00:10:23,919
estoy muy

248
00:10:23,919 --> 00:10:24,919
impaciente

249
00:10:24,919 --> 00:10:26,759
vale, entonces

250
00:10:26,759 --> 00:10:28,960
con esto decimos

251
00:10:28,960 --> 00:10:30,580
oye, coge ese cont

252
00:10:30,580 --> 00:10:33,179
y mándalo a quien te llamó

253
00:10:33,179 --> 00:10:35,220
y mándalo a quien te llamó, vale, estupendo

254
00:10:35,220 --> 00:10:35,620
ya está

255
00:10:35,620 --> 00:10:39,100
¿qué ocurre? que si mi función

256
00:10:39,100 --> 00:10:40,980
devuelve un valor y lo entrega

257
00:10:40,980 --> 00:10:43,340
el tipo que devuelve

258
00:10:43,340 --> 00:10:45,200
hay que ponerlo aquí en lugar

259
00:10:45,200 --> 00:10:47,139
del void, porque si yo pongo

260
00:10:47,139 --> 00:10:49,080
void, es que no devuelvo

261
00:10:49,080 --> 00:10:51,100
nada, no hay ningún retun que devuelva valores

262
00:10:51,100 --> 00:10:53,179
aquí ponía void, pero es que no había

263
00:10:53,179 --> 00:10:54,559
ningún retun que devolviera nada

264
00:10:54,559 --> 00:10:57,000
claro, aquí si hay un retun

265
00:10:57,000 --> 00:10:58,620
que devuelve un entero, un int

266
00:10:58,620 --> 00:11:00,360
porque cont está declarado como int

267
00:11:00,360 --> 00:11:02,700
como cont está declarado como int devuelve un int

268
00:11:02,700 --> 00:11:03,899
pues entonces tengo que indicarlo

269
00:11:03,899 --> 00:11:06,539
que esta función me va a devolver un int

270
00:11:06,539 --> 00:11:08,080
¿vale?

271
00:11:08,720 --> 00:11:10,620
entonces ahora ya sí que deja de quejarse

272
00:11:11,440 --> 00:11:20,139
esta función tiene un retun

273
00:11:20,139 --> 00:11:22,639
que implica, te entrego este valor

274
00:11:22,639 --> 00:11:24,700
a ti que me has llamado, te lo entrego

275
00:11:24,700 --> 00:11:26,220
ahora veremos como lo recoge el otro

276
00:11:26,220 --> 00:11:28,639
pero él lo entrega, te entrego este valor

277
00:11:28,639 --> 00:11:30,679
a ti que me has llamado, un valor además

278
00:11:30,679 --> 00:11:32,820
entero, porque conto es entero

279
00:11:32,820 --> 00:11:34,759
vale, pues si hace eso

280
00:11:34,759 --> 00:11:36,500
la cabecera

281
00:11:36,500 --> 00:11:38,759
lo tiene que indicar, que ahí

282
00:11:38,759 --> 00:11:40,759
va a haber un valor de entrega

283
00:11:40,759 --> 00:11:42,019
que es de tipo entero

284
00:11:42,019 --> 00:11:44,059
entonces tienes que poner el int

285
00:11:44,059 --> 00:11:45,200
vale

286
00:11:45,200 --> 00:11:48,620
si aquí devolviéramos un valor que es

287
00:11:48,620 --> 00:11:50,080
double, pues pondríamos aquí double

288
00:11:50,080 --> 00:11:52,519
si devolviéramos un valor que es un string

289
00:11:52,519 --> 00:11:54,759
pondríamos ahí string, si devolviéramos un valor que es un array

290
00:11:54,759 --> 00:11:56,799
pondríamos ahí el array

291
00:11:56,799 --> 00:11:59,259
¿vale? pero bueno, ahora quedémonos con los casos

292
00:11:59,259 --> 00:12:00,039
más sencillos

293
00:12:00,039 --> 00:12:05,000
¿vale? entonces lo que va antes del nombre

294
00:12:05,000 --> 00:12:07,120
lo que va antes, justo antes

295
00:12:07,120 --> 00:12:08,740
siempre es

296
00:12:08,740 --> 00:12:11,139
o un tipo de dato o void

297
00:12:11,139 --> 00:12:12,980
no hay más alternativas

298
00:12:12,980 --> 00:12:14,620
void es

299
00:12:14,620 --> 00:12:17,019
no devuelvo nada, no hay return

300
00:12:17,019 --> 00:12:18,980
y si no es

301
00:12:18,980 --> 00:12:19,379
un tipo

302
00:12:19,379 --> 00:12:22,259
y el tipo puede ser cualquiera

303
00:12:22,259 --> 00:12:24,740
primitivo, objeto, cualquiera

304
00:12:24,740 --> 00:12:27,360
¿vale? el tipo puede ser cualquiera

305
00:12:27,360 --> 00:12:30,039
pero tiene que ser el mismo tipo del dato devuelto

306
00:12:30,039 --> 00:12:32,419
ahí tiene que haber un tipo de dato siempre

307
00:12:32,419 --> 00:12:35,399
¿vale? pues esta función

308
00:12:35,399 --> 00:12:36,940
ahora

309
00:12:36,940 --> 00:12:39,440
la verdad es que tiene un poquito más

310
00:12:39,440 --> 00:12:41,039
tendría más sentido, claro

311
00:12:41,039 --> 00:12:42,779
todo depende de lo que me han pedido

312
00:12:42,779 --> 00:12:45,399
si a ti te han pedido, haz una función que lo muestre por consola

313
00:12:45,399 --> 00:12:47,279
pues está estupendo, te lo muestra por consola

314
00:12:47,279 --> 00:12:48,759
pero en general

315
00:12:48,759 --> 00:12:50,039
si hablamos en general

316
00:12:50,039 --> 00:12:52,340
siempre será más útil

317
00:12:52,340 --> 00:12:54,179
que te entreguen el valor

318
00:12:54,179 --> 00:12:55,799
y la aplicación decida

319
00:12:55,799 --> 00:12:58,340
porque a esta función le puede llamar mucha gente

320
00:12:58,340 --> 00:13:00,159
y habrá gente que a lo mejor quiera

321
00:13:00,159 --> 00:13:02,299
que se muestre la cuenta por consola

322
00:13:02,299 --> 00:13:03,820
fenomenal, pero habrá gente que no

323
00:13:03,820 --> 00:13:05,980
entonces dice, mira, yo te entrego el valor

324
00:13:05,980 --> 00:13:07,899
y tú haces con él lo que te dé la gana

325
00:13:07,899 --> 00:13:10,379
vale, pues

326
00:13:10,379 --> 00:13:11,919
el retorno es mejor

327
00:13:11,919 --> 00:13:14,539
a ver, hace la función

328
00:13:14,539 --> 00:13:15,600
más usable

329
00:13:15,600 --> 00:13:18,460
porque no condena a que lo muestres

330
00:13:18,460 --> 00:13:20,039
por consola, te lo entrega

331
00:13:20,039 --> 00:13:22,419
y el programa que lo llama hace con ese valor

332
00:13:22,419 --> 00:13:22,980
lo que quiera

333
00:13:22,980 --> 00:13:25,500
vale, pues ahora vamos a llamarlos

334
00:13:25,500 --> 00:13:27,019
desde el main

335
00:13:27,019 --> 00:13:32,480
vale, pues

336
00:13:32,480 --> 00:13:35,240
si llamamos por ejemplo

337
00:13:35,240 --> 00:13:37,860
la primera versión, contar vocales

338
00:13:37,860 --> 00:13:41,240
con el nombre que hemos leído

339
00:13:41,240 --> 00:13:45,570
contar vocales, vale

340
00:13:45,570 --> 00:13:47,529
voy a poner aquí una línea

341
00:13:47,529 --> 00:13:49,649
para que podamos distinguir

342
00:13:49,649 --> 00:13:51,549
la salida de esta segunda parte

343
00:13:51,549 --> 00:13:55,419
vale, aquí en vez de

344
00:13:55,419 --> 00:13:56,720
78 le voy a poner

345
00:13:56,720 --> 00:13:59,039
1 para que no me muestre tantas veces

346
00:13:59,039 --> 00:14:06,080
Bueno, la llamada a la primera versión

347
00:14:06,080 --> 00:14:07,720
Contar vocales, yo le paso el nombre

348
00:14:07,720 --> 00:14:08,600
La primera versión

349
00:14:08,600 --> 00:14:10,299
Pues lo llamamos

350
00:14:10,299 --> 00:14:12,519
Y efectivamente

351
00:14:12,519 --> 00:14:14,299
Pepe

352
00:14:14,299 --> 00:14:15,720
Dos

353
00:14:15,720 --> 00:14:18,059
¿Vale? Dos vocales

354
00:14:18,059 --> 00:14:23,379
Ahora vamos a llamar a la segunda versión

355
00:14:23,379 --> 00:14:29,600
A la segunda versión

356
00:14:29,600 --> 00:14:31,759
La llamamos por su nombre

357
00:14:31,759 --> 00:14:37,129
También

358
00:14:37,129 --> 00:14:38,769
Como a todas las funciones

359
00:14:38,769 --> 00:14:41,250
Contar vocales, versión 2

360
00:14:41,250 --> 00:14:43,350
y le pasamos el parámetro.

361
00:14:45,820 --> 00:14:46,580
¿Y ahora qué pasa?

362
00:14:47,000 --> 00:14:49,539
Yo podría llamarla así también.

363
00:14:50,019 --> 00:14:51,299
Esa es la llamada de la primera versión.

364
00:14:52,200 --> 00:14:52,879
Ahora, ahora.

365
00:14:53,480 --> 00:14:54,879
Esta es la llamada de la primera versión

366
00:14:54,879 --> 00:14:56,419
que no devuelve nada

367
00:14:56,419 --> 00:14:59,019
y que le paso el parámetro y me lo ha mostrado por consola

368
00:14:59,019 --> 00:14:59,980
como acabamos de comprobar.

369
00:15:00,419 --> 00:15:02,820
La llamada de la segunda versión igual, por su nombre

370
00:15:02,820 --> 00:15:04,340
y pasándole el parámetro. ¿Pero qué ocurre?

371
00:15:04,379 --> 00:15:06,299
Que si yo esto lo dejo así, lo puedo dejar así,

372
00:15:07,879 --> 00:15:09,100
esta me está entregando un valor.

373
00:15:09,279 --> 00:15:10,720
Lo está haciendo sí o sí porque tiene un retorno.

374
00:15:10,720 --> 00:15:13,179
Pero ese valor, tal cual me lo está entregando,

375
00:15:13,259 --> 00:15:16,080
la máquina virtual lo está tirando a la basura.

376
00:15:16,759 --> 00:15:17,679
Luego no vale para nada.

377
00:15:20,240 --> 00:15:23,960
Entonces, para que ese valor lo podamos recoger en algún sitio,

378
00:15:24,720 --> 00:15:25,980
pues lo tendremos que recoger en algún lado,

379
00:15:26,059 --> 00:15:27,559
en alguna caja habrá que recoger ese valor.

380
00:15:28,019 --> 00:15:29,940
¿Qué es recoger un valor en una caja?

381
00:15:30,259 --> 00:15:31,179
Una asignación.

382
00:15:31,840 --> 00:15:33,059
No ha sido eso de toda la vida.

383
00:15:33,980 --> 00:15:36,419
Una asignación era mi variable, que es una caja,

384
00:15:36,860 --> 00:15:38,179
a la que yo le doy un valor.

385
00:15:38,960 --> 00:15:40,059
Pues esta es la misma situación.

386
00:15:40,059 --> 00:15:42,179
contar vocales me ha entregado un valor

387
00:15:42,179 --> 00:15:44,860
se lo tendré que asignar a alguna variable

388
00:15:44,860 --> 00:15:47,220
porque si no se lo asigno a ninguna variable

389
00:15:47,220 --> 00:15:49,100
a la basura que se ha ido

390
00:15:49,100 --> 00:15:50,419
¿a qué variable?

391
00:15:50,600 --> 00:15:52,379
pues a la que me dé la gana, tiene que ser entera

392
00:15:52,379 --> 00:15:53,700
porque lo que me devuelve es entero

393
00:15:53,700 --> 00:15:57,200
entonces por ejemplo, esto pues tendría sentido

394
00:15:57,200 --> 00:15:58,059
¿vale?

395
00:15:59,539 --> 00:16:00,580
en mi variable

396
00:16:00,580 --> 00:16:02,179
num vocales que es entera

397
00:16:02,179 --> 00:16:05,100
le asigno el retun de este

398
00:16:05,100 --> 00:16:06,360
¿vale?

399
00:16:06,940 --> 00:16:09,220
entonces la recogida del retorno

400
00:16:09,220 --> 00:16:12,379
siempre es mediante una sentencia de asignación

401
00:16:12,379 --> 00:16:14,100
y ese valor

402
00:16:14,100 --> 00:16:15,679
se va a donde tú le hayas dicho

403
00:16:15,679 --> 00:16:17,279
vale

404
00:16:17,279 --> 00:16:20,200
ahora ya con este en un vocales

405
00:16:20,200 --> 00:16:21,860
uno ya hace lo que le dé la gana

406
00:16:21,860 --> 00:16:24,379
y así tiene mucho más sentido por el programa principal

407
00:16:24,379 --> 00:16:26,159
a veces lo querrá para una cosa

408
00:16:26,159 --> 00:16:28,480
a veces lo querrá para otra, depende de para lo que lo quieras

409
00:16:28,480 --> 00:16:29,539
tú lo recoges

410
00:16:29,539 --> 00:16:31,519
y luego haces con él lo que quieras

411
00:16:31,519 --> 00:16:33,240
por ejemplo en este caso

412
00:16:33,240 --> 00:16:36,039
podríamos, pues sí, mostrarlo por

413
00:16:36,039 --> 00:16:37,480
por consola

414
00:16:37,480 --> 00:16:40,039
Pero podría ser cualquier otra cosa

415
00:16:40,039 --> 00:16:41,899
Las vocales son

416
00:16:41,899 --> 00:16:46,500
NumVocales

417
00:16:46,500 --> 00:16:49,039
Entonces esta primera versión

418
00:16:49,039 --> 00:16:51,019
Nos lo va a mostrar directamente porque lo hace

419
00:16:51,019 --> 00:16:53,179
Y luego cuando hagamos esta ejecución

420
00:16:53,179 --> 00:16:54,919
Pues nos lo va a hacer también

421
00:16:54,919 --> 00:16:58,840
Entonces ejecutamos esto

422
00:16:58,840 --> 00:17:00,360
Bueno, este primer número no hacía nada

423
00:17:00,360 --> 00:17:03,139
Pepito

424
00:17:03,139 --> 00:17:05,240
Pues esta es la primera llamada

425
00:17:05,240 --> 00:17:06,339
Y esta es la segunda

426
00:17:06,339 --> 00:17:33,269
Vale, pues entonces la llamada a una función

427
00:17:33,269 --> 00:17:34,349
Que devuelve un valor

428
00:17:34,349 --> 00:17:36,930
hay que interpretarla como el propio

429
00:17:36,930 --> 00:17:38,829
valor, como si fuera

430
00:17:38,829 --> 00:17:40,430
una expresión más, el propio valor

431
00:17:40,430 --> 00:17:42,869
y ese propio valor yo lo asigno a una

432
00:17:42,869 --> 00:17:44,509
variable, hago lo que sea

433
00:17:44,509 --> 00:17:46,829
podríamos haberlo pasado al system out también

434
00:17:46,829 --> 00:17:48,470
tranquilamente

435
00:17:48,470 --> 00:17:50,490
también y no pasa nada

436
00:17:50,490 --> 00:17:51,910
podríamos haber hecho esto

437
00:17:51,910 --> 00:17:55,579
¿verdad?

438
00:17:56,940 --> 00:17:58,779
podríamos haberse lo pasado a un system out

439
00:17:58,779 --> 00:18:00,859
porque esto ¿qué hace?

440
00:18:01,680 --> 00:18:03,259
esto me entrega su valor

441
00:18:03,259 --> 00:18:05,220
me entrega su valor

442
00:18:05,220 --> 00:18:06,339
y ese mismo valor

443
00:18:06,339 --> 00:18:08,460
ya lo coge el system out

444
00:18:08,460 --> 00:18:11,440
aquí el valor que me entrega

445
00:18:11,440 --> 00:18:13,099
lo coge la variable a la que se lo asigno

446
00:18:13,099 --> 00:18:16,220
aquí el valor que me entrega

447
00:18:16,220 --> 00:18:17,380
se lo paso al system out

448
00:18:17,380 --> 00:18:18,319
o sea lo que importa

449
00:18:18,319 --> 00:18:19,940
es que esta llamada

450
00:18:19,940 --> 00:18:21,640
es como si fuera un número

451
00:18:21,640 --> 00:18:22,759
es igual que un número

452
00:18:22,759 --> 00:18:24,740
y que número es en particular

453
00:18:24,740 --> 00:18:26,420
el número que hay en el return

454
00:18:26,420 --> 00:18:28,440
luego esta llamada

455
00:18:28,440 --> 00:18:30,099
equivale a un número entero

456
00:18:30,099 --> 00:18:32,420
equivale al return que me han devuelto

457
00:18:32,420 --> 00:18:34,140
para asignar a variable

458
00:18:34,140 --> 00:18:35,819
para meterlo en un system out

459
00:18:35,819 --> 00:18:37,680
para meter una expresión para lo que sea

460
00:18:37,680 --> 00:18:39,579
equivale al número devuelto

461
00:18:39,579 --> 00:18:41,440
equivale al número devuelto

462
00:18:41,440 --> 00:18:42,200
tal cual

463
00:18:42,200 --> 00:18:43,599
dime

464
00:18:43,599 --> 00:18:47,759
en la primera versión no podríamos

465
00:18:47,759 --> 00:18:49,980
no, en la primera versión

466
00:18:49,980 --> 00:18:51,519
si yo trato de hacer por ejemplo

467
00:18:51,519 --> 00:18:53,839
meterlo en

468
00:18:53,839 --> 00:18:54,980
una variable

469
00:18:54,980 --> 00:19:01,220
esta que no tiene retún

470
00:19:01,220 --> 00:19:05,869
me va a decir el compilador

471
00:19:05,869 --> 00:19:07,690
me va a decir

472
00:19:07,690 --> 00:19:10,309
oye, que contar vocales no es un número

473
00:19:10,309 --> 00:19:12,869
porque no hay ahí ningún retón que te devuelva un número

474
00:19:12,869 --> 00:19:14,250
tiene un void

475
00:19:14,250 --> 00:19:17,029
entonces dice, no puedo meter, no puedo asignarlo

476
00:19:17,029 --> 00:19:17,730
ahí, no puedo

477
00:19:17,730 --> 00:19:19,130
no puedo

478
00:19:19,130 --> 00:19:24,369
es para que te devuelva un número

479
00:19:24,369 --> 00:19:27,109
y ese número ya haces con él lo que quieras

480
00:19:27,109 --> 00:19:28,349
pero esta como tenía void

481
00:19:28,349 --> 00:19:30,769
esta no te devuelve nada, te hace código

482
00:19:30,769 --> 00:19:33,210
te hace cosas, pero no te entrega un número

483
00:19:33,210 --> 00:19:35,150
con lo cual si no te entrega un número

484
00:19:35,150 --> 00:19:37,349
no puedes ni asignarlo

485
00:19:37,349 --> 00:19:38,910
a un sitio, ni hacer nada con ello

486
00:19:38,910 --> 00:19:40,009
¿vale?

487
00:19:40,309 --> 00:19:50,869
a las funciones que tengan retun

488
00:19:50,869 --> 00:19:53,049
a las funciones que tengan retun

489
00:19:53,049 --> 00:19:55,190
tú ya usas ese número devuelto

490
00:19:55,190 --> 00:19:57,049
como quieras, aquí por ejemplo

491
00:19:57,049 --> 00:19:58,529
hemos asignado una variable

492
00:19:58,529 --> 00:20:00,789
aquí lo he usado también

493
00:20:00,789 --> 00:20:03,009
para pasárselo al system.not para que lo muestre

494
00:20:03,009 --> 00:20:04,750
tú tienes que verlo como un número

495
00:20:04,750 --> 00:20:06,769
como un valor entero, toda esa función tienes que verlo

496
00:20:06,769 --> 00:20:08,849
como un valor entero, con la particularidad

497
00:20:08,849 --> 00:20:10,529
de que ese valor entero es la cuenta

498
00:20:10,529 --> 00:20:11,710
de las vocales de nombre

499
00:20:11,710 --> 00:20:14,450
entonces tú cuando ves esto dices

500
00:20:14,450 --> 00:20:16,730
ah, vale, esto es el numerito

501
00:20:16,730 --> 00:20:18,549
de vocales que tiene nombre

502
00:20:18,549 --> 00:20:20,289
es lo que tú ves cuando haces eso

503
00:20:20,289 --> 00:20:21,809
y es ese número, todos los efectos

504
00:20:21,809 --> 00:20:24,309
como este hecho por dentro ya te da exactamente igual

505
00:20:24,309 --> 00:20:25,769
tú ves que eso es un número

506
00:20:25,769 --> 00:20:27,710
y ese número haces con él lo que quieras

507
00:20:27,710 --> 00:20:28,930
claro

508
00:20:28,930 --> 00:20:33,150
cada función solo puede devolver un valor

509
00:20:33,150 --> 00:20:38,609
si tú quieres que una función te devuelva dos datos

510
00:20:38,609 --> 00:20:40,630
lo que puedes hacer es meterlos en un array

511
00:20:40,630 --> 00:20:42,130
y devolver un array

512
00:20:42,130 --> 00:20:43,670
porque un array también lo puedes devolver

513
00:20:43,670 --> 00:20:44,730
Porque es un único dato

514
00:20:44,730 --> 00:20:47,630
¿Vale? Solo puedes devolver

515
00:20:47,630 --> 00:20:49,690
Un dato, ahora podemos poner un ejemplo

516
00:20:49,690 --> 00:20:52,519
¿Vale?

517
00:20:53,619 --> 00:20:54,720
Bueno, pues a ver

518
00:20:54,720 --> 00:20:57,160
¿Entendido?

519
00:20:58,160 --> 00:20:59,900
Vale, pues aquí vosotros

520
00:20:59,900 --> 00:21:01,859
Que siempre os adelantáis

521
00:21:01,859 --> 00:21:03,240
Y esta vez no os habéis adelantado

522
00:21:03,240 --> 00:21:07,779
Ya, pero creía que ibas

523
00:21:07,779 --> 00:21:09,059
Como locos a decirme

524
00:21:09,059 --> 00:21:12,339
Entonces, ¿por qué no lo has llamado igual?

525
00:21:12,940 --> 00:21:14,279
Porque también se distinguen

526
00:21:14,279 --> 00:21:15,359
Porque esta tiene un void

527
00:21:15,359 --> 00:21:16,779
y esta tiene un int

528
00:21:16,779 --> 00:21:19,559
ya pero no, justo

529
00:21:19,559 --> 00:21:23,359
claro, porque

530
00:21:23,359 --> 00:21:25,579
aquí son distinguibles a la vista

531
00:21:25,579 --> 00:21:26,859
esta devuelve un boi y esta un int

532
00:21:26,859 --> 00:21:29,859
claro, pero yo a contar

533
00:21:29,859 --> 00:21:31,299
vocales 2 a esta

534
00:21:31,299 --> 00:21:33,039
si a mí me da la gana

535
00:21:33,039 --> 00:21:34,880
la puedo llamar

536
00:21:34,880 --> 00:21:36,819
tirando su valor a la basura

537
00:21:36,819 --> 00:21:39,660
la puedo llamar así, nadie me obliga

538
00:21:39,660 --> 00:21:40,460
a recoger su valor

539
00:21:40,460 --> 00:21:43,740
si yo la llamo así y el nombre

540
00:21:43,740 --> 00:21:45,880
fuera el mismo, la máquina virtual

541
00:21:45,880 --> 00:21:47,000
¿cómo sabe a cuál está llamando?

542
00:21:47,299 --> 00:21:49,799
Si a la primera o a la segunda, no puede saberlo.

543
00:21:50,319 --> 00:21:50,960
No puede saberlo.

544
00:21:51,640 --> 00:21:55,150
Entonces, cuando las

545
00:21:55,150 --> 00:21:56,769
funciones se distinguen

546
00:21:56,769 --> 00:21:58,910
solo en el tipo de retorno,

547
00:21:59,509 --> 00:22:00,869
ahí ya sí que se tiene que llamar distinto.

548
00:22:05,029 --> 00:22:05,509
Ya.

549
00:22:06,589 --> 00:22:08,269
¿Seguro que no os habéis adelantado

550
00:22:08,269 --> 00:22:09,250
ninguno por eso?

551
00:22:09,250 --> 00:22:10,230
Muy poca fe de la clase.

552
00:22:11,049 --> 00:22:11,710
De verdad.

553
00:22:15,240 --> 00:22:18,160
Pues sí. Tengo poca confianza en vosotros.

554
00:22:18,380 --> 00:22:19,859
Tengo que aumentar mi confianza.

555
00:22:19,859 --> 00:22:22,920
Vale, vale

556
00:22:22,920 --> 00:22:26,319
¿Qué me ha llamado este?

557
00:22:27,339 --> 00:22:28,759
Algo me ha llamado, ¿a que sí?

558
00:22:28,779 --> 00:22:29,640
No, no, no te ha dicho nada

559
00:22:29,640 --> 00:22:31,279
Ah

560
00:22:31,279 --> 00:22:34,339
Creía que me había llamado ilusa

561
00:22:34,339 --> 00:22:38,519
Ilusa es una palabra del castellano

562
00:22:38,519 --> 00:22:39,700
Significa

563
00:22:39,700 --> 00:22:41,740
Higiénico, inocente

564
00:22:41,740 --> 00:22:44,720
Seguro

565
00:22:44,720 --> 00:22:45,779
Quien habla español viene

566
00:22:45,779 --> 00:22:49,819
No, ilusa

567
00:22:49,819 --> 00:22:51,039
A ver, perdona

568
00:22:51,039 --> 00:22:53,200
se lo habría dicho a cualquiera

569
00:22:53,200 --> 00:22:55,900
porque los que no sabéis castellano

570
00:22:55,900 --> 00:22:56,599
sois todos

571
00:22:56,599 --> 00:23:01,839
todos los menores de 25

572
00:23:01,839 --> 00:23:02,880
aproximadamente

573
00:23:02,880 --> 00:23:07,819
todos los que

574
00:23:07,819 --> 00:23:11,640
no, os he llamado víctimas

575
00:23:11,640 --> 00:23:12,940
de un sistema educativo

576
00:23:12,940 --> 00:23:14,859
y un entorno sociocultural

577
00:23:14,859 --> 00:23:16,779
tremendamente dañino

578
00:23:16,779 --> 00:23:18,140
y pobre

579
00:23:18,140 --> 00:23:19,779
y poco estimulante

580
00:23:19,779 --> 00:23:21,000
eso

581
00:23:21,000 --> 00:23:24,319
os he llamado víctimas de la sociedad

582
00:23:24,319 --> 00:23:25,720
en la que os estáis criando

583
00:23:25,720 --> 00:23:28,480
efectivamente

584
00:23:28,480 --> 00:23:30,299
y de poca cultura del esfuerzo

585
00:23:30,299 --> 00:23:32,259
poca curiosidad, poca capacidad

586
00:23:32,259 --> 00:23:34,220
de concentración porque te llega todo demasiado

587
00:23:34,220 --> 00:23:35,960
fácil, entonces

588
00:23:35,960 --> 00:23:37,940
me pierdes la...

589
00:23:37,940 --> 00:23:39,420
bueno, todo eso les hemos llamado de golpe

590
00:23:39,420 --> 00:23:42,079
conclusión

591
00:23:42,079 --> 00:23:44,720
conclusión

592
00:23:44,720 --> 00:23:46,279
en cualquier caso no es vuestro

593
00:23:46,279 --> 00:23:48,440
caso la falta de concentración porque ya me decís

594
00:23:48,440 --> 00:23:50,440
que estaba clarísimo

595
00:23:50,440 --> 00:23:51,839
que

596
00:23:51,839 --> 00:23:54,220
las funciones no se podían llamar igual

597
00:23:54,220 --> 00:23:56,119
aunque el tipo de dato fuera distinto

598
00:23:56,119 --> 00:23:58,720
porque la máquina virtual no podría distinguirlas

599
00:23:58,720 --> 00:24:00,000
si yo las llamo

600
00:24:00,000 --> 00:24:01,180
tirando a la basura

601
00:24:01,180 --> 00:24:03,099
el valor del otro

602
00:24:03,099 --> 00:24:08,079
no porque la máquina

603
00:24:08,079 --> 00:24:10,460
no

604
00:24:10,460 --> 00:24:11,920
porque si se llaman igual

605
00:24:11,920 --> 00:24:14,519
y yo llamo a la segunda

606
00:24:14,519 --> 00:24:16,460
pero pasando del

607
00:24:16,460 --> 00:24:18,420
valor de retorno, ignorándolo porque no me da

608
00:24:18,420 --> 00:24:20,579
la gana, pues entonces

609
00:24:20,579 --> 00:24:22,480
y se llamaran igual, estaría

610
00:24:22,480 --> 00:24:23,680
haciendo estas dos llamadas.

611
00:24:24,339 --> 00:24:26,359
Y siempre sería la

612
00:24:26,359 --> 00:24:27,900
primera versión. O sea, nunca,

613
00:24:28,279 --> 00:24:29,319
esta sería inaccesible.

614
00:24:30,420 --> 00:24:32,359
Esta otra

615
00:24:32,359 --> 00:24:34,480
que me devuelve el donde está por ahí arriba.

616
00:24:34,480 --> 00:24:35,339
¿Dónde está?

617
00:24:37,700 --> 00:24:40,140
¿Vale?

618
00:24:43,819 --> 00:24:44,539
Entonces...

619
00:24:44,539 --> 00:24:58,779
O devuelven datos de tipos distintos.

620
00:24:59,539 --> 00:25:06,400
Es decir, cuando las funciones se diferencian en el tipo de datos solamente, los parámetros son iguales,

621
00:25:06,400 --> 00:25:11,859
el nombre tiene que ser distinto, porque si no, no se van a poder distinguir a la hora de llamar.

622
00:25:11,859 --> 00:25:20,519
Vale, el retun

623
00:25:20,519 --> 00:25:24,759
en realidad es una sentencia que puede aparecer

624
00:25:24,759 --> 00:25:28,420
en las funciones que devuelven void

625
00:25:28,420 --> 00:25:32,819
el retun también puede aparecer, pero en ese caso, ¿cómo aparecería?

626
00:25:33,259 --> 00:25:34,640
Sin parámetros, sin nada.

627
00:25:35,200 --> 00:25:40,839
Sirve para terminar la función en ese momento. Aquí ponerlo es estúpido

628
00:25:40,839 --> 00:25:44,759
porque es que la función va a acabar en ese momento igualmente, la función acaba cuando acaba el código

629
00:25:44,759 --> 00:25:46,420
pero imaginaos que

630
00:25:46,420 --> 00:25:49,059
por ejemplo, yo quiero, voy a modificar

631
00:25:49,059 --> 00:25:50,880
ahora este contar vocales para

632
00:25:50,880 --> 00:25:53,339
si nombre es null, no hacer nada

633
00:25:53,339 --> 00:25:55,039
tiene mucho sentido porque

634
00:25:55,039 --> 00:25:57,039
si nombre es null y yo

635
00:25:57,039 --> 00:25:59,200
entro aquí, aquí me va a salir un

636
00:25:59,200 --> 00:26:00,619
null pointer exception

637
00:26:00,619 --> 00:26:03,160
porque si nombre es null, un null

638
00:26:03,160 --> 00:26:05,240
no puede llamar la función

639
00:26:05,240 --> 00:26:07,279
length porque es null, null pointer exception

640
00:26:07,279 --> 00:26:08,440
claro

641
00:26:08,440 --> 00:26:10,740
entonces yo podría hacer, mira voy a

642
00:26:10,740 --> 00:26:13,140
modificar esta versión mía para que sea

643
00:26:13,140 --> 00:26:14,420
más bonita y voy a decir, oye

644
00:26:14,420 --> 00:26:17,000
vamos a ver si nombre es null, porque si nombre es null

645
00:26:17,000 --> 00:26:18,500
quiero terminar en ese momento

646
00:26:18,500 --> 00:26:21,079
y se acabó, pues entonces haríamos

647
00:26:21,079 --> 00:26:22,940
si nombre es

648
00:26:22,940 --> 00:26:23,779
igual a null

649
00:26:23,779 --> 00:26:26,859
entonces aquí le pega muy bien

650
00:26:26,859 --> 00:26:28,039
poner return

651
00:26:28,039 --> 00:26:30,980
return es

652
00:26:30,980 --> 00:26:32,980
la sentencia que termina

653
00:26:32,980 --> 00:26:35,119
la función en la que

654
00:26:35,119 --> 00:26:37,299
estás en ese momento y ya no hace más

655
00:26:37,299 --> 00:26:39,039
que es justo

656
00:26:39,039 --> 00:26:41,119
lo que querríamos aquí, si nombre es igual a null

657
00:26:41,119 --> 00:26:42,819
función terminada, se acabó

658
00:26:42,819 --> 00:26:44,579
y como esta es void

659
00:26:44,579 --> 00:26:46,359
no ponemos nada

660
00:26:46,359 --> 00:26:48,740
imaginaos que yo quiero devolver

661
00:26:48,740 --> 00:26:50,700
un entero aquí, pues pondría aquí el entero

662
00:26:50,700 --> 00:26:52,799
que fuera, pero si es void

663
00:26:52,799 --> 00:26:54,700
no se devuelve nada

664
00:26:54,700 --> 00:26:56,779
¿se pone el igual igual en vez del

665
00:26:56,779 --> 00:26:57,119
equals?

666
00:26:57,500 --> 00:27:00,460
sí, porque nombre

667
00:27:00,460 --> 00:27:02,160
es una dirección de memoria

668
00:27:02,160 --> 00:27:04,900
y lo que estoy mirando es que la dirección de memoria

669
00:27:04,900 --> 00:27:05,539
sea null

670
00:27:05,539 --> 00:27:07,819
no, es que cuando un objeto es null

671
00:27:07,819 --> 00:27:10,819
lo que significa es que la dirección de memoria tiene null

672
00:27:10,819 --> 00:27:12,640
entonces ahí sí que lo hago con igual igual

673
00:27:12,640 --> 00:27:14,720
¿Vale? A ver, esto

674
00:27:14,720 --> 00:27:17,319
Empieza a ser importante

675
00:27:17,319 --> 00:27:19,759
Todo es importante

676
00:27:19,759 --> 00:27:20,180
Pero

677
00:27:20,180 --> 00:27:23,079
¿Qué pasa cuando tenemos

678
00:27:23,079 --> 00:27:25,539
Un objeto como es el caso de string o array

679
00:27:25,539 --> 00:27:27,519
A raíz de lo que me ha preguntado ella

680
00:27:27,519 --> 00:27:29,480
Ya sabemos que lo que realmente

681
00:27:29,480 --> 00:27:30,240
Tenemos es

682
00:27:30,240 --> 00:27:33,079
Una variable que es una dirección de memoria

683
00:27:33,079 --> 00:27:37,170
Que apunta

684
00:27:37,170 --> 00:27:38,970
A mi objeto

685
00:27:38,970 --> 00:27:41,450
Entonces cuando tenemos un string

686
00:27:41,450 --> 00:27:44,130
En realidad la variable string

687
00:27:44,130 --> 00:27:46,410
tiene la dirección, porque es un objeto

688
00:27:46,410 --> 00:27:48,230
y a través de esa dirección

689
00:27:48,230 --> 00:27:50,549
llegamos aquí ya a todos los caracteres, a todo eso

690
00:27:50,549 --> 00:27:52,349
vale, pues cuando

691
00:27:52,349 --> 00:27:53,369
escribimos esto

692
00:27:53,369 --> 00:27:56,710
vamos a suponer que

693
00:27:56,710 --> 00:28:00,009
esta variable se llama

694
00:28:00,009 --> 00:28:03,960
nombre

695
00:28:03,960 --> 00:28:11,119
vale, imaginaos que tenemos aquí mi string

696
00:28:11,119 --> 00:28:12,920
nombre, vale

697
00:28:12,920 --> 00:28:14,539
entonces, para ver yo

698
00:28:14,539 --> 00:28:17,180
si nombre no tiene nada, o sea si es un objeto

699
00:28:17,180 --> 00:28:18,960
que no existe, pues

700
00:28:18,960 --> 00:28:20,420
¿qué ocurre cuando un objeto no existe?

701
00:28:20,500 --> 00:28:21,920
que directamente aquí dentro

702
00:28:21,920 --> 00:28:23,920
directamente aquí dentro

703
00:28:23,920 --> 00:28:26,740
ya está escrito, entre comillas

704
00:28:26,740 --> 00:28:28,759
esto, con lo cual

705
00:28:28,759 --> 00:28:30,920
para ver si un objeto no tiene nada

706
00:28:30,920 --> 00:28:32,599
no lo hago con equals, porque directamente

707
00:28:32,599 --> 00:28:33,880
hago nombre

708
00:28:33,880 --> 00:28:36,940
hay una dirección de memoria

709
00:28:36,940 --> 00:28:37,380
claro

710
00:28:37,380 --> 00:28:39,480
eso es un hexadecimal en realidad

711
00:28:39,480 --> 00:28:42,339
a ver, null, la máquina virtual de java

712
00:28:42,339 --> 00:28:44,759
lo interpreta a dirección de memoria

713
00:28:44,759 --> 00:28:47,140
no asignada, y cuando un objeto

714
00:28:47,140 --> 00:28:49,140
está sin inicializar

715
00:28:49,140 --> 00:28:51,099
lo que tiene físicamente dentro es

716
00:28:51,099 --> 00:28:53,220
hexadecimal dirección de memoria

717
00:28:53,220 --> 00:28:55,039
no asignada, que en Java

718
00:28:55,039 --> 00:28:56,039
por comodidad se llama null

719
00:28:56,039 --> 00:28:59,099
entonces cuando hacemos nombre

720
00:28:59,099 --> 00:29:01,180
igual a null, decimos, esta misma variable

721
00:29:01,180 --> 00:29:02,839
tiene dentro null

722
00:29:02,839 --> 00:29:04,819
porque si tiene dentro null, ¿qué significa?

723
00:29:04,980 --> 00:29:07,279
que mi objeto no existe, eso es lo que significa

724
00:29:07,279 --> 00:29:09,660
sale null

725
00:29:09,660 --> 00:29:11,099
pone null escrito

726
00:29:11,099 --> 00:29:12,839
sí, pone null escrito

727
00:29:12,839 --> 00:29:14,339
que significa que no está asignada

728
00:29:14,339 --> 00:29:16,579
pone null, vale

729
00:29:16,579 --> 00:29:44,220
Pero, sin embargo, si este objeto nombre ya tuviera algo dentro, entonces yo ahora podría querer hacer otra cosa, es ver si lo que hay aquí es Pepito, entonces ahora ya no haría nombre igual a Pepito,

730
00:29:44,220 --> 00:29:46,519
Porque yo lo que quiero es ver lo que hay aquí, esto.

731
00:29:47,079 --> 00:29:48,960
Y para ver lo que hay aquí es con equals.

732
00:29:49,359 --> 00:29:50,980
Pero para ver lo que hay aquí es con null.

733
00:29:51,480 --> 00:29:52,859
Con doble igual.

734
00:29:53,740 --> 00:29:53,960
¿Vale?

735
00:29:54,480 --> 00:29:58,059
Entonces, por eso, para ver si un string es igual a Pepito, Juanito,

736
00:29:58,099 --> 00:29:59,980
lo hacemos con equals, porque queremos ver lo que hay ahí.

737
00:30:01,000 --> 00:30:03,720
Pero para ver si un objeto es null, no tiene nada,

738
00:30:04,140 --> 00:30:05,039
lo hacemos con doble igual,

739
00:30:05,119 --> 00:30:06,619
porque lo que queremos ver es lo que hay ahí.

740
00:30:07,500 --> 00:30:10,220
Ver si la dirección de memoria es dirección no asignada.

741
00:30:11,440 --> 00:30:11,799
¿Vale?

742
00:30:18,420 --> 00:30:19,880
Y con cualquier cosa que sea objeto.

743
00:30:19,880 --> 00:30:20,920
Pero nosotros hasta ahora

744
00:30:20,920 --> 00:30:22,740
Cosas que son objeto han sido

745
00:30:22,740 --> 00:30:24,759
Stream y Arrays, nada más

746
00:30:24,759 --> 00:30:26,279
Sobre todo Stream, ¿vale?

747
00:30:26,319 --> 00:30:27,400
Vamos a trabajar más

748
00:30:27,400 --> 00:30:28,759
Vale

749
00:30:28,759 --> 00:30:33,279
Lo que vamos a ver es ArrayList

750
00:30:33,279 --> 00:30:34,119
¿Qué son ArrayList?

751
00:30:34,720 --> 00:30:35,940
Hombre, claro, son las colecciones

752
00:30:35,940 --> 00:30:38,700
Los ArrayList, los List, los Set, los Map

753
00:30:38,700 --> 00:30:41,220
Las colecciones, la jerarquía de colecciones

754
00:30:41,220 --> 00:30:41,759
De Java

755
00:30:41,759 --> 00:30:42,799
Claro

756
00:30:42,799 --> 00:30:47,140
Claro, lo que pasa es que todo eso son colecciones

757
00:30:47,140 --> 00:30:48,420
De datos, ¿vale?

758
00:30:48,420 --> 00:30:50,339
entonces son clases adicionales

759
00:30:50,339 --> 00:30:51,240
que están construidas

760
00:30:51,240 --> 00:30:53,579
que físicamente por dentro son un array

761
00:30:53,579 --> 00:30:56,259
pero las funciones que tienen

762
00:30:56,259 --> 00:30:58,079
son para tapar

763
00:30:58,079 --> 00:31:00,380
su manejo y tú llamas al método

764
00:31:00,380 --> 00:31:01,819
insertar y te lo hacen

765
00:31:01,819 --> 00:31:03,380
pero están construidas por código

766
00:31:03,380 --> 00:31:05,019
todas las colecciones

767
00:31:05,019 --> 00:31:08,240
tendremos que verlas

768
00:31:08,240 --> 00:31:09,200
claro

769
00:31:09,200 --> 00:31:12,440
ArrayList lo que te hace dentro

770
00:31:12,440 --> 00:31:13,900
es exactamente

771
00:31:13,900 --> 00:31:15,900
lo que nosotros hemos hecho de crear uno nuevo

772
00:31:15,900 --> 00:31:18,019
copiar y eso mismo

773
00:31:18,019 --> 00:31:18,680
es lo que te hace bien.

774
00:31:21,200 --> 00:31:22,279
Pero como ya te lo he hecho

775
00:31:22,279 --> 00:31:24,059
dentro y le he puesto un numerito de función,

776
00:31:24,200 --> 00:31:25,680
pues te vamos a la función y listo.

777
00:31:27,380 --> 00:31:28,059
Vale, bueno.

778
00:31:29,000 --> 00:31:29,359
Dudas.

779
00:31:30,960 --> 00:31:31,319
Problemas.

780
00:31:33,599 --> 00:31:33,960
Algo

781
00:31:33,960 --> 00:31:36,019
de...

782
00:31:38,339 --> 00:31:39,619
¿Tu existencia es un problema o es una duda?

783
00:31:40,079 --> 00:31:40,480
Ambas.

784
00:31:42,319 --> 00:31:44,339
A ver, una duda

785
00:31:44,339 --> 00:31:45,059
sí que es.

786
00:31:45,380 --> 00:31:46,660
Un problema no, hombre.

787
00:31:48,019 --> 00:31:50,559
claro, una duda es

788
00:31:50,559 --> 00:31:52,299
para nosotros no, para tus padres

789
00:31:52,299 --> 00:31:54,579
igual, la cosa está más chunga

790
00:31:54,579 --> 00:31:54,980
pero

791
00:31:54,980 --> 00:32:02,299
uy, pues entonces tienen un problema

792
00:32:02,299 --> 00:32:03,140
muchísimo más grande

793
00:32:03,140 --> 00:32:13,940
bueno

794
00:32:13,940 --> 00:32:16,220
a ver, venga

795
00:32:16,220 --> 00:32:19,039
Venga, como nos quedan

796
00:32:19,039 --> 00:32:20,059
9 minutos

797
00:32:20,059 --> 00:32:22,859
Vamos a hacer... ¿Qué te pasa?

798
00:32:23,880 --> 00:32:25,079
Ah, es que está así congelado

799
00:32:25,079 --> 00:32:28,740
Sí, claro, justo

800
00:32:28,740 --> 00:32:29,559
Es lo que iba a decir

801
00:32:29,559 --> 00:32:32,640
En esos 9 minutos, pues por ejemplo, simplemente

802
00:32:32,640 --> 00:32:35,140
Hacer este... Ah, sí, sí, sí

803
00:32:35,920 --> 00:32:36,859
Sí

804
00:32:36,859 --> 00:32:37,720
¡Ay!

805
00:32:38,460 --> 00:32:39,440
Bueno, espera

806
00:32:39,440 --> 00:32:42,559
Se me acumula el trabajo

807
00:32:42,559 --> 00:32:43,480
Un momento

808
00:32:43,480 --> 00:32:46,400
una función chorra

809
00:32:46,400 --> 00:32:48,400
para que en estos 8 minutos efectivamente

810
00:32:48,400 --> 00:32:50,259
hagáis lo que Pedro ha pedido

811
00:32:50,259 --> 00:32:52,700
que es, vamos a asimilarlo un poco más

812
00:32:52,700 --> 00:32:53,140
¿vale?

813
00:32:54,900 --> 00:32:56,500
no, hombre

814
00:32:56,500 --> 00:32:57,500
calladitos todos veis

815
00:32:57,500 --> 00:33:02,200
vale, vamos a hacer

816
00:33:02,200 --> 00:33:03,400
una función

817
00:33:03,400 --> 00:33:06,559
que recibe

818
00:33:13,480 --> 00:33:21,519
Venga, la primera chorradita que se me ha ocurrido

819
00:33:21,519 --> 00:33:24,420
Recibe dos nombres por parámetro

820
00:33:24,420 --> 00:33:28,359
Y te devuelve

821
00:33:28,359 --> 00:33:40,359
El que tenga más vocales

822
00:33:40,359 --> 00:33:41,299
¡Hala, ya está!

823
00:33:42,480 --> 00:33:44,319
Recibe dos cadenas, dos nombres

824
00:33:44,319 --> 00:33:46,779
y te devuelve el nombre

825
00:33:46,779 --> 00:33:47,839
que tenga más vocales

826
00:33:47,839 --> 00:33:49,839
esto, ya está, punto pelota

827
00:33:49,839 --> 00:33:53,220
vale, y ahora ya, solo de cara a asimilarlo

828
00:33:53,220 --> 00:33:54,539
sí, dime