1
00:00:00,880 --> 00:00:22,960
Las clases, por tanto, tienen dos partes, la declaración de propiedades, atributos o campos y la parte de métodos, ¿vale? Métodos es un trozo de código, un trozo de código que los objetos de esta clase pueden ejecutar, pueden llamar desde el main y eso era lo importante.

2
00:00:22,960 --> 00:00:25,260
lo que ponemos aquí en métodos

3
00:00:25,260 --> 00:00:27,239
el código que pongamos aquí en métodos

4
00:00:27,239 --> 00:00:29,019
solo lo puede

5
00:00:29,019 --> 00:00:29,920
lanzar

6
00:00:29,920 --> 00:00:33,179
alguna instancia

7
00:00:33,179 --> 00:00:34,380
u objeto de esta clase

8
00:00:34,380 --> 00:00:35,880
es la única forma de lanzarlo

9
00:00:35,880 --> 00:00:38,460
no es que lo podamos llamar desde cualquier momento

10
00:00:38,460 --> 00:00:40,759
como cualquier otra función de esta declaración

11
00:00:40,759 --> 00:00:42,000
antigua de toda la vida, no

12
00:00:42,000 --> 00:00:44,320
este trozo de código que está aquí

13
00:00:44,320 --> 00:00:46,479
solo lo puede llamar un objeto

14
00:00:46,479 --> 00:00:48,659
de la clase alumno

15
00:00:48,659 --> 00:00:49,840
por eso aquí en este main

16
00:00:49,840 --> 00:00:52,700
en este por ejemplo

17
00:00:52,700 --> 00:00:54,939
creábamos un objeto alumno

18
00:00:54,939 --> 00:00:56,600
como por ejemplo este, alumno2

19
00:00:56,600 --> 00:00:58,000
es mi objeto alumno creado

20
00:00:58,000 --> 00:00:59,619
y ahora este objeto

21
00:00:59,619 --> 00:01:02,299
puede llamar a este método

22
00:01:02,299 --> 00:01:04,680
de la manera en la que se llama punto y nombre

23
00:01:04,680 --> 00:01:06,760
del método, que los métodos

24
00:01:06,760 --> 00:01:08,459
siempre llevan paréntesis, a diferencia

25
00:01:08,459 --> 00:01:10,780
de las propiedades que no las llevan, es una variable sin más

26
00:01:10,780 --> 00:01:12,540
los métodos sí, bueno pues

27
00:01:12,540 --> 00:01:14,760
esa dinámica entendida, el método

28
00:01:14,760 --> 00:01:16,659
se programa aquí, ahora vemos

29
00:01:16,659 --> 00:01:18,980
más detalles de cómo se programan los métodos

30
00:01:18,980 --> 00:01:20,859
y al método

31
00:01:20,859 --> 00:01:22,480
lo llama un objeto

32
00:01:22,480 --> 00:01:24,560
ya desde la clase main en ejecución.

33
00:01:25,480 --> 00:01:28,620
Entonces, en función del objeto que lo llame,

34
00:01:29,739 --> 00:01:31,480
aquí lo está llamando alumno, por ejemplo.

35
00:01:32,579 --> 00:01:33,980
Aquí lo está llamando alumno2.

36
00:01:34,459 --> 00:01:36,599
Cualquier objeto de la clase alumno lo puede llamar.

37
00:01:37,359 --> 00:01:39,239
Pues en función del objeto que lo llame,

38
00:01:39,840 --> 00:01:43,540
cuando ahora ya este código se ejecute,

39
00:01:44,760 --> 00:01:46,659
¿a qué nos referimos con edad?

40
00:01:47,299 --> 00:01:48,159
Bueno, pues depende.

41
00:01:48,159 --> 00:01:51,599
En este caso nos referimos a la edad

42
00:01:51,599 --> 00:01:54,000
del alumno este

43
00:01:54,000 --> 00:01:54,920
porque es el que lo llama

44
00:01:54,920 --> 00:01:57,879
sin embargo aquí cuando se ejecute

45
00:01:57,879 --> 00:01:58,519
este código

46
00:01:58,519 --> 00:02:01,599
¿a quién nos referimos con edad?

47
00:02:02,040 --> 00:02:03,859
pues cuando se ejecute este código

48
00:02:03,859 --> 00:02:05,760
aquí con edad nos estaremos

49
00:02:05,760 --> 00:02:07,200
refiriendo a la de alumno 2

50
00:02:07,200 --> 00:02:10,199
entonces este método tendrá unos resultados

51
00:02:10,199 --> 00:02:11,439
o tendrá otros

52
00:02:11,439 --> 00:02:13,960
yo lo llamo igual, lo llamo de la misma manera

53
00:02:13,960 --> 00:02:16,180
en ambos casos punto es mayor de edad

54
00:02:16,180 --> 00:02:17,580
pero este método

55
00:02:17,580 --> 00:02:19,439
hace unas cosas diferentes a estas

56
00:02:19,439 --> 00:02:21,460
porque este método usa

57
00:02:21,460 --> 00:02:22,680
las propiedades de este

58
00:02:22,680 --> 00:02:25,759
y sin embargo este usa las propiedades

59
00:02:25,759 --> 00:02:27,759
de este otro, entonces los resultados

60
00:02:27,759 --> 00:02:28,580
son distintos

61
00:02:28,580 --> 00:02:30,400
los resultados son distintos

62
00:02:30,400 --> 00:02:33,500
bueno, eso que es lo más importante

63
00:02:33,500 --> 00:02:34,360
en realidad está claro

64
00:02:34,360 --> 00:02:37,800
bueno, pues ahora vamos a ver más detalles

65
00:02:37,800 --> 00:02:40,139
de programación de métodos

66
00:02:40,139 --> 00:02:41,780
ese es el primero que habíamos

67
00:02:41,780 --> 00:02:43,740
hecho, lo que habíamos

68
00:02:43,740 --> 00:02:45,439
dicho sí o sí, el método

69
00:02:45,439 --> 00:02:46,960
tiene un nombre

70
00:02:46,960 --> 00:02:49,740
lógicamente, en el que yo

71
00:02:49,740 --> 00:02:51,919
recojo, pues si puede ser

72
00:02:51,919 --> 00:02:53,479
explicativo sobre lo que hace, mejor

73
00:02:53,479 --> 00:02:56,000
aunque sea un nombre muy largo de método, no pasa

74
00:02:56,000 --> 00:02:58,000
nada, los métodos en Java se llaman

75
00:02:58,000 --> 00:03:00,159
con

76
00:03:00,159 --> 00:03:01,860
100 caracteres si hace falta

77
00:03:01,860 --> 00:03:03,979
lo que importa es que explique bien lo que

78
00:03:03,979 --> 00:03:06,020
hace para el que luego ve el código de otros

79
00:03:06,020 --> 00:03:07,639
pues no tenga que andar ahí metiéndose

80
00:03:07,639 --> 00:03:09,539
en cada método para ver

81
00:03:09,539 --> 00:03:10,620
lo que hace por dentro

82
00:03:10,620 --> 00:03:13,539
bueno, pues esta parte está

83
00:03:13,539 --> 00:03:15,060
claro, el nombre, ahora

84
00:03:15,060 --> 00:03:17,580
esto de aquí que hemos

85
00:03:17,580 --> 00:03:19,639
puesto nosotros, hasta ahora

86
00:03:19,639 --> 00:03:21,219
hemos hecho solo un único método

87
00:03:21,219 --> 00:03:24,979
con void. ¿Qué significa cuando

88
00:03:24,979 --> 00:03:26,939
pongo void? Cuando pongo void

89
00:03:26,939 --> 00:03:29,020
significa que el método me hace un código

90
00:03:29,020 --> 00:03:31,039
pero no me devuelve,

91
00:03:31,120 --> 00:03:32,900
no me entrega a mí

92
00:03:32,900 --> 00:03:34,939
como método main que

93
00:03:34,939 --> 00:03:37,039
llama al programa, no me devuelve ningún

94
00:03:37,039 --> 00:03:40,409
valor de retorno. Para

95
00:03:40,409 --> 00:03:42,389
entenderlo mejor, vamos a poner otro método más,

96
00:03:42,610 --> 00:03:44,270
otro método, este ya lo tenemos hecho y

97
00:03:44,270 --> 00:03:46,409
entendido, ¿verdad? Vamos a poner un

98
00:03:46,409 --> 00:03:48,009
método que sí que devuelva un valor de retorno.

99
00:03:48,490 --> 00:03:50,389
Por ejemplo, vamos a hacer

100
00:03:50,389 --> 00:03:52,169
un método que

101
00:03:52,169 --> 00:03:53,530
me devuelva

102
00:03:53,530 --> 00:03:56,210
el número de matrícula

103
00:03:56,210 --> 00:03:58,250
del alumno, porque la matrícula

104
00:03:58,250 --> 00:03:59,729
el código, vale

105
00:03:59,729 --> 00:04:01,550
vamos a hacer aquí un método

106
00:04:01,550 --> 00:04:04,270
para que me devuelva

107
00:04:04,270 --> 00:04:06,310
no que me muestre por consola, es diferente

108
00:04:06,310 --> 00:04:08,009
mostrar por consola es una cosa

109
00:04:08,009 --> 00:04:10,050
y entregarme, darme a mí

110
00:04:10,050 --> 00:04:12,069
es otra, vale, no es lo mismo

111
00:04:12,069 --> 00:04:14,150
que tú

112
00:04:14,150 --> 00:04:16,009
me escribas algo

113
00:04:16,009 --> 00:04:16,730
en la pizarra

114
00:04:16,730 --> 00:04:19,970
que yo lo veo, a que me des

115
00:04:19,970 --> 00:04:21,949
a mí eso que estás escribiendo, bueno pues

116
00:04:21,949 --> 00:04:23,970
el system out, me lo estás escribiendo

117
00:04:23,970 --> 00:04:26,009
y yo lo veo, pero no me estás entregando nada

118
00:04:26,009 --> 00:04:28,089
entonces cuando el método devuelve algo

119
00:04:28,089 --> 00:04:29,870
tú no me lo escribes en la pizarra, es que

120
00:04:29,870 --> 00:04:31,870
me das directamente lo que estás mostrando

121
00:04:31,870 --> 00:04:33,329
bueno, pues entonces

122
00:04:33,329 --> 00:04:35,870
vamos a hacer un método que me

123
00:04:35,870 --> 00:04:37,850
entregue a mí el

124
00:04:37,850 --> 00:04:39,850
número de matrícula de este alumno

125
00:04:39,850 --> 00:04:41,470
del alumno que llame al método

126
00:04:41,470 --> 00:04:43,970
pues lo primero, vamos a elegir bien el nombre

127
00:04:43,970 --> 00:04:45,910
del método, pues yo

128
00:04:45,910 --> 00:04:48,250
que sé, por ejemplo, getNumeroMatricula

129
00:04:48,250 --> 00:04:49,389
código

130
00:04:49,389 --> 00:04:53,589
GetCódigoMatricula

131
00:04:53,589 --> 00:04:57,779
Vale, ya he elegido bien el método

132
00:04:57,779 --> 00:04:59,819
Parece que está claro por su nombre lo que hace

133
00:04:59,819 --> 00:05:02,500
Ahora, ¿qué es lo que pongo delante?

134
00:05:04,459 --> 00:05:05,860
Delante, ahora este método

135
00:05:05,860 --> 00:05:07,379
Si quiero que me devuelva algo

136
00:05:07,379 --> 00:05:09,160
En concreto que me va a devolver

137
00:05:09,160 --> 00:05:10,819
El código de la matrícula

138
00:05:10,819 --> 00:05:13,459
Que el código de la matrícula es un entero

139
00:05:13,459 --> 00:05:15,139
Porque está aquí dentro como entero

140
00:05:15,139 --> 00:05:17,819
Luego lo que me va a devolver es un número entero

141
00:05:17,819 --> 00:05:20,040
Pues entonces tengo que poner aquí

142
00:05:20,040 --> 00:05:22,139
El tipo de dato

143
00:05:22,139 --> 00:05:23,980
Del valor que me va a devolver

144
00:05:23,980 --> 00:05:32,079
¿Vale? Entonces si el método

145
00:05:32,079 --> 00:05:35,000
Retorna o devuelve

146
00:05:35,000 --> 00:05:42,230
Algún valor

147
00:05:42,230 --> 00:05:43,930
Como es el caso de este método

148
00:05:43,930 --> 00:05:50,319
Hay que poner

149
00:05:50,319 --> 00:05:52,819
El tipo de dato de ese valor

150
00:05:52,819 --> 00:05:55,319
El tipo de dato

151
00:05:55,319 --> 00:06:02,699
Bueno, pues aquí me va a devolver

152
00:06:02,699 --> 00:06:04,319
El código de matrícula que es un entero

153
00:06:04,319 --> 00:06:04,939
Pues pongo in

154
00:06:04,939 --> 00:06:07,579
Si yo hiciera un método que me devolviera algo

155
00:06:07,579 --> 00:06:09,220
Que es una cadena, pues pondría string

156
00:06:09,220 --> 00:06:11,759
Si hiciera un método que devolviera algo

157
00:06:11,759 --> 00:06:14,000
que es un array, podría poner

158
00:06:14,000 --> 00:06:15,680
el tipo array, por ejemplo

159
00:06:15,680 --> 00:06:17,939
es decir, imaginaos que este método devuelve

160
00:06:17,939 --> 00:06:19,639
un array de números, no sé por qué

161
00:06:19,639 --> 00:06:21,579
pues podría poner esto

162
00:06:21,579 --> 00:06:23,319
y no pasa nada

163
00:06:23,319 --> 00:06:25,540
jolines, donde está el

164
00:06:25,540 --> 00:06:27,339
aquí

165
00:06:27,339 --> 00:06:30,019
¿vale? podría poner esto

166
00:06:30,019 --> 00:06:31,480
en este caso, este método

167
00:06:31,480 --> 00:06:33,579
me tendría que devolver

168
00:06:33,579 --> 00:06:35,079
un array de números

169
00:06:35,079 --> 00:06:37,600
¿vale? entonces este método

170
00:06:37,600 --> 00:06:39,680
puede hacer cosas y devolver cosas

171
00:06:39,680 --> 00:06:41,060
ahora veremos cómo las devuelve

172
00:06:41,060 --> 00:06:43,060
Pero lo que yo tengo que poner aquí delante

173
00:06:43,060 --> 00:06:44,899
Sí o sí, es el tipo de dato

174
00:06:44,899 --> 00:06:46,040
De eso que devuelve

175
00:06:46,040 --> 00:06:47,819
Array de enteros

176
00:06:47,819 --> 00:06:50,899
Entero, mondo y lirondo

177
00:06:50,899 --> 00:06:52,100
String, lo que sea

178
00:06:52,100 --> 00:06:56,910
¿Vale? Solo puede devolver

179
00:06:56,910 --> 00:06:59,170
Un valor, entonces diréis, si devuelve dos números

180
00:06:59,170 --> 00:07:00,589
¿Qué ponemos? Int, int

181
00:07:00,589 --> 00:07:01,870
Si devuelve dos números, no

182
00:07:01,870 --> 00:07:05,189
Es que los métodos solo pueden devolver

183
00:07:05,189 --> 00:07:06,490
Un valor, resultado

184
00:07:06,490 --> 00:07:07,430
Solo uno

185
00:07:07,430 --> 00:07:12,259
Bueno, devuelve

186
00:07:12,259 --> 00:07:13,079
Un array

187
00:07:13,079 --> 00:07:15,639
Lo que pasa es que el array tiene dentro muchas cosas

188
00:07:15,639 --> 00:07:18,540
Pero es un objeto array

189
00:07:18,540 --> 00:07:19,379
¿Vale?

190
00:07:22,300 --> 00:07:24,100
No podría devolver dos arrays

191
00:07:24,100 --> 00:07:25,819
Dos arrays no, pero uno sí

192
00:07:25,819 --> 00:07:27,439
Porque es un objeto array

193
00:07:27,439 --> 00:07:32,300
Vale

194
00:07:32,300 --> 00:07:35,319
Bueno, pues por ahora

195
00:07:35,319 --> 00:07:36,720
Y ahora ya hemos puesto int

196
00:07:36,720 --> 00:07:38,899
Por ahora ya sabemos que paréntesis tiene que tener

197
00:07:38,899 --> 00:07:41,100
Pues vamos a dejar los paréntesis sí o sí

198
00:07:41,100 --> 00:07:43,480
Por ahora vacíos, todavía no lo estamos metiendo en paréntesis

199
00:07:43,480 --> 00:07:45,180
Porque este de antes

200
00:07:45,180 --> 00:07:46,899
Los hemos puesto vacíos

201
00:07:46,899 --> 00:07:49,600
sin más, y este de aquí también vacíos

202
00:07:49,600 --> 00:07:52,740
todo método tiene que tener sus paréntesis

203
00:07:52,740 --> 00:07:56,259
y ahora ya sí, vamos a calcular

204
00:07:56,259 --> 00:07:58,860
el valor que este método tiene que devolver

205
00:07:58,860 --> 00:08:02,500
bueno, pues es el código de matrícula del alumno este

206
00:08:02,500 --> 00:08:05,519
lo tengo yo para devolverlo

207
00:08:05,519 --> 00:08:07,100
vamos a ver las propiedades del alumno

208
00:08:07,100 --> 00:08:10,319
las propiedades del alumno son su NIV, nombre, edad, anda, sí

209
00:08:10,319 --> 00:08:13,720
una propiedad del alumno que llame a ese método

210
00:08:13,720 --> 00:08:14,980
es matrícula

211
00:08:14,980 --> 00:08:19,920
Y matrícula yo puedo acceder a su código con punto código, ¿verdad?

212
00:08:20,660 --> 00:08:34,539
Pues entonces el valor que yo quiero devolver, si lo guardo aquí en una variable auxiliar, pues sería este, matrícula.código, ¿verdad?

213
00:08:35,639 --> 00:08:38,100
Este es el valor que yo querría devolver.

214
00:08:38,100 --> 00:08:40,600
la propiedad matrícula

215
00:08:40,600 --> 00:08:42,340
de este alumno que llama al método

216
00:08:42,340 --> 00:08:44,299
a la que tengo acceso

217
00:08:44,299 --> 00:08:45,759
que está aquí arriba directamente

218
00:08:45,759 --> 00:08:47,940
la propiedad matrícula

219
00:08:47,940 --> 00:08:50,299
y dentro de la propiedad matrícula

220
00:08:50,299 --> 00:08:51,720
solo su código

221
00:08:51,720 --> 00:08:54,139
es lo que yo quiero que este método devuelva

222
00:08:54,139 --> 00:08:56,340
vale, aquí lo tengo en una variable guardadita

223
00:08:56,340 --> 00:08:58,419
una variable local, ahí auxiliar

224
00:08:58,419 --> 00:08:59,559
una variable guardada

225
00:08:59,559 --> 00:09:01,960
pero claro, ahora este método tiene que

226
00:09:01,960 --> 00:09:03,600
mandarlo para afuera

227
00:09:03,600 --> 00:09:05,100
tiene que mandarlo para afuera

228
00:09:05,100 --> 00:09:07,399
no imprimirlo, porque esto

229
00:09:07,399 --> 00:09:08,779
no es mandarlo para afuera

230
00:09:08,779 --> 00:09:11,740
esto sería escribirmelo en la pizarra

231
00:09:11,740 --> 00:09:13,139
no me lo está mandando para afuera

232
00:09:13,139 --> 00:09:15,700
con lo cual este método, si yo quiero hacerlo

233
00:09:15,700 --> 00:09:17,039
así, quiero que lo muestre

234
00:09:17,039 --> 00:09:18,419
tendría que poner aquí un void

235
00:09:18,419 --> 00:09:20,440
entonces si pongo un void, vale

236
00:09:20,440 --> 00:09:22,360
pero en este caso

237
00:09:22,360 --> 00:09:25,440
me está mostrando en la pizarrita

238
00:09:25,440 --> 00:09:26,740
no me lo está entregando a mí

239
00:09:26,740 --> 00:09:29,279
yo quiero que me lo entregue a mí

240
00:09:29,279 --> 00:09:30,980
para eso he puesto aquí un int

241
00:09:30,980 --> 00:09:33,860
para decirle, oye tú, tienes que retornarme

242
00:09:33,860 --> 00:09:35,620
este valor

243
00:09:35,620 --> 00:09:37,360
bueno pues como

244
00:09:37,360 --> 00:09:40,080
cuál es la sentencia para que el método

245
00:09:40,080 --> 00:09:41,399
mande para afuera

246
00:09:41,399 --> 00:09:44,100
tire ese valor para afuera para que

247
00:09:44,100 --> 00:09:45,419
alguien lo recoja desde fuera

248
00:09:45,419 --> 00:09:47,879
pues la sentencia para que ese método lance

249
00:09:47,879 --> 00:09:49,960
fuera ese valor para que alguien fuera lo pueda

250
00:09:49,960 --> 00:09:51,820
recoger es la sentencia

251
00:09:51,820 --> 00:09:53,940
return vale pues

252
00:09:53,940 --> 00:09:56,000
return y después ponemos ese valor

253
00:09:56,000 --> 00:09:57,740
que el método tiene que lanzar para afuera

254
00:09:57,740 --> 00:09:59,059
para que alguien recoja

255
00:09:59,059 --> 00:10:01,940
¿qué valor es?

256
00:10:02,179 --> 00:10:02,620
result

257
00:10:02,620 --> 00:10:07,200
¡Hala! Pues ya tengo este método

258
00:10:07,200 --> 00:10:08,779
Estupendamente hecho

259
00:10:08,779 --> 00:10:16,100
Podría ahorrarme la variable local

260
00:10:16,100 --> 00:10:17,279
Incluso si me da la gana

261
00:10:17,279 --> 00:10:20,379
Y poner directamente return matricula.código

262
00:10:20,379 --> 00:10:23,220
Pongo return matricula.código

263
00:10:23,220 --> 00:10:24,679
Y hasta me ahorro

264
00:10:24,679 --> 00:10:25,659
Esta variable local

265
00:10:25,659 --> 00:10:27,879
Da igual, eso ya son detallitos

266
00:10:27,879 --> 00:10:29,059
¿Vale? Son detallitos

267
00:10:29,059 --> 00:10:30,519
¿Vale?

268
00:10:31,620 --> 00:10:33,600
Cualquier variable que uno declare aquí

269
00:10:33,600 --> 00:10:36,259
A lo mejor yo aquí declaro una variable

270
00:10:36,259 --> 00:10:38,259
Porque voy a hacer una suma de no sé qué

271
00:10:38,259 --> 00:10:41,779
porque el método tiene que hacer la suma de los precios

272
00:10:41,779 --> 00:10:44,580
de no sé cuántos, lo que sea, pues cualquier variable que yo

273
00:10:44,580 --> 00:10:47,820
declare aquí dentro para hacer la operativa que sea

274
00:10:47,820 --> 00:10:50,899
son variables locales a este método, está en este bloque

275
00:10:50,899 --> 00:10:53,779
recordáis lo de los bloques, ¿no? un bloque es cualquier

276
00:10:53,779 --> 00:10:56,320
código entre llaves, un bloque se abre en un if

277
00:10:56,320 --> 00:10:59,740
se abre en un for, un bloque se abre en muchos sitios

278
00:10:59,740 --> 00:11:02,220
pues también ahora ya

279
00:11:02,220 --> 00:11:05,720
vemos que un bloque se abre cada vez que

280
00:11:05,720 --> 00:11:07,919
haces un método, cada vez que haces un método

281
00:11:07,919 --> 00:11:08,700
se abre un bloque

282
00:11:08,700 --> 00:11:11,659
con lo cual, todas las variables

283
00:11:11,659 --> 00:11:13,240
que declaremos ahí dentro

284
00:11:13,240 --> 00:11:15,179
desaparecen

285
00:11:15,179 --> 00:11:18,019
tal cual la ejecución del método termine

286
00:11:18,019 --> 00:11:19,580
porque serán variables locales

287
00:11:19,580 --> 00:11:21,580
igual que todas las variables que

288
00:11:21,580 --> 00:11:23,740
declaramos locales a un if, al bloque

289
00:11:23,740 --> 00:11:25,700
de un if, en cuanto el if termina esas variables

290
00:11:25,700 --> 00:11:27,879
han desaparecido, pues aquí igual

291
00:11:27,879 --> 00:11:32,080
entonces esta variable int result

292
00:11:32,080 --> 00:11:33,620
sería local

293
00:11:33,620 --> 00:11:35,700
porque la he declarado aquí dentro, cuando el método

294
00:11:35,700 --> 00:11:37,820
termina, se va a la basura, pero es que

295
00:11:37,820 --> 00:11:39,659
no me importa nada que se vaya a la basura, porque

296
00:11:39,659 --> 00:11:42,120
la he usado solo como contenedor

297
00:11:42,120 --> 00:11:43,700
auxiliar para

298
00:11:43,700 --> 00:11:45,879
pasársela al return y decirle al return, oye tú

299
00:11:45,879 --> 00:11:47,559
lanza este contenido fuera

300
00:11:47,559 --> 00:11:49,100
que es el que tengo que entregar

301
00:11:49,100 --> 00:11:51,980
esa variable es local, desaparece

302
00:11:51,980 --> 00:11:52,539
¿vale?

303
00:11:53,639 --> 00:11:55,620
bueno, pues este método ya estaría

304
00:11:55,620 --> 00:11:57,600
completo, ahora ¿cómo lo usamos?

305
00:12:00,159 --> 00:12:01,580
pues ya sabemos cómo se

306
00:12:01,580 --> 00:12:03,539
usan los métodos, tiene que haber

307
00:12:03,539 --> 00:12:05,679
un objeto, en mi

308
00:12:05,679 --> 00:12:07,740
programa que se está ejecutando, en mi programa

309
00:12:07,740 --> 00:12:08,799
que arranca con un main

310
00:12:08,799 --> 00:12:11,620
tiene que haber un objeto para ejecutarlo, si no ese

311
00:12:11,620 --> 00:12:13,320
método no puede ser lanzado

312
00:12:13,320 --> 00:12:15,440
venga, pues vamos a

313
00:12:15,440 --> 00:12:17,899
lanzarlo por ejemplo con el objeto

314
00:12:17,899 --> 00:12:19,720
alumno2, alguno

315
00:12:19,720 --> 00:12:21,480
que tuviera matrícula, alumno, alumno tiene

316
00:12:21,480 --> 00:12:23,419
matrícula porque se la hemos puesto antes

317
00:12:23,419 --> 00:12:25,779
hemos creado alumno en este main

318
00:12:25,779 --> 00:12:27,980
le hemos puesto sus datos

319
00:12:27,980 --> 00:12:30,080
y le hemos metido una matrícula

320
00:12:30,080 --> 00:12:32,440
pues venga, ahora resulta

321
00:12:32,440 --> 00:12:33,139
que yo quiero

322
00:12:33,139 --> 00:12:40,480
mostrar la

323
00:12:40,480 --> 00:12:43,120
el código de matrícula

324
00:12:43,120 --> 00:12:43,700
del alumno

325
00:12:43,700 --> 00:12:49,559
el código de

326
00:12:49,559 --> 00:12:52,919
matrícula

327
00:12:52,919 --> 00:12:56,950
del alumno, este que está

328
00:12:56,950 --> 00:12:59,090
en esta variable, del alumno que está en la variable

329
00:12:59,090 --> 00:13:00,289
alumno que he creado arriba

330
00:13:00,289 --> 00:13:03,070
bueno, pues entonces, este objeto

331
00:13:03,070 --> 00:13:05,090
alumno es el que tiene que llamar

332
00:13:05,090 --> 00:13:07,029
al método que hace eso, es el que tiene que

333
00:13:07,029 --> 00:13:07,730
llamar

334
00:13:07,730 --> 00:13:10,309
pues venga, que llame a este método

335
00:13:10,309 --> 00:13:12,750
y lo llama con sus paréntesis

336
00:13:12,750 --> 00:13:15,509
como hay que llamar a los métodos, hay que poner el paréntesis

337
00:13:15,509 --> 00:13:18,149
vale, el método ya está llamado

338
00:13:18,149 --> 00:13:21,009
vale, el objeto alumno

339
00:13:21,009 --> 00:13:22,649
llama a este método, muy bien

340
00:13:22,649 --> 00:13:24,789
ya sabemos lo que hará este método

341
00:13:24,789 --> 00:13:26,889
entonces, se mete

342
00:13:26,889 --> 00:13:28,789
aquí, coge el

343
00:13:28,789 --> 00:13:31,070
código de la matrícula del alumno

344
00:13:31,070 --> 00:13:32,289
que llama al método

345
00:13:32,289 --> 00:13:34,789
que en este caso es alumno, coge

346
00:13:34,789 --> 00:13:36,289
su código de matrícula

347
00:13:36,289 --> 00:13:38,830
y pum, me lo

348
00:13:38,830 --> 00:13:40,330
lanza, me lo lanza

349
00:13:40,330 --> 00:13:42,610
para que yo lo recoja, y yo estoy aquí

350
00:13:42,610 --> 00:13:44,809
yo he llamado

351
00:13:44,809 --> 00:13:46,870
al método, el método me ha lanzado una cosa

352
00:13:46,870 --> 00:13:48,769
y yo estoy aquí que o la

353
00:13:48,769 --> 00:13:50,029
recojo o se va a la basura

354
00:13:50,029 --> 00:13:52,950
pues tal y con lo que he escrito no lo he recogido

355
00:13:52,950 --> 00:13:54,629
en ningún sitio, con lo cual

356
00:13:54,629 --> 00:13:56,690
se está yendo a la basura, es decir

357
00:13:56,690 --> 00:13:58,690
es un poco estúpido que yo llame a este

358
00:13:58,690 --> 00:14:00,629
método para que me devuelva

359
00:14:00,629 --> 00:14:02,769
con el return, me devuelva un valor

360
00:14:02,769 --> 00:14:04,690
y yo aquí no lo

361
00:14:04,690 --> 00:14:06,590
recoja, porque se va tal cual

362
00:14:06,590 --> 00:14:08,549
a la basura, vale, pues

363
00:14:08,549 --> 00:14:10,009
¿cómo recogemos ese valor?

364
00:14:10,370 --> 00:14:12,570
¿cómo recogemos el valor que

365
00:14:12,570 --> 00:14:14,149
este me ha lanzado con el return?

366
00:14:14,149 --> 00:14:25,929
¿Cómo lo recogemos? Pues asignándoselo mediante una asignación. Se lo asigno yo a la variable, por ejemplo, lo puedo guardar, por ejemplo, en esta, yo qué sé.

367
00:14:33,100 --> 00:14:44,879
Pues ahora ya este valor se va a guardar en esta variable, se va a guardar en esta variable, que yo la quiero mostrar, que es la idea,

368
00:14:44,879 --> 00:14:46,679
Porque si no, ¿para qué la he calculado?

369
00:14:48,980 --> 00:14:50,179
Pues la muestro y ya está

370
00:14:50,179 --> 00:14:51,980
¿Vale?

371
00:15:00,980 --> 00:15:01,379
¿Entendido?

372
00:15:06,389 --> 00:15:08,350
Repito, yo podría llamar al método así

373
00:15:08,350 --> 00:15:10,210
Y no pasa nada

374
00:15:10,210 --> 00:15:12,269
Podría llamar al método así

375
00:15:12,269 --> 00:15:14,830
Pero es una pérdida de tiempo

376
00:15:14,830 --> 00:15:16,549
Porque el valor que me está entregando

377
00:15:16,549 --> 00:15:18,009
No lo estoy guardando en ningún sitio

378
00:15:18,009 --> 00:15:19,509
Luego al no guardarlo en ningún sitio

379
00:15:19,509 --> 00:15:21,669
Luego no puedo aprovecharme de él

380
00:15:21,669 --> 00:15:23,850
Para mostrarlo, para hacer el cálculo que toque

381
00:15:23,850 --> 00:15:26,049
¿Para qué lo llamo un método?

382
00:15:26,049 --> 00:15:27,190
Para que me devuelva un valor

383
00:15:27,190 --> 00:15:29,190
si no recojo ese valor en ningún sitio

384
00:15:29,190 --> 00:15:31,590
entonces cuando

385
00:15:31,590 --> 00:15:33,509
llamamos a métodos que devuelven

386
00:15:33,509 --> 00:15:34,049
valores

387
00:15:34,049 --> 00:15:37,570
pues guardamos ese valor en algún sitio

388
00:15:37,570 --> 00:15:39,990
porque es que si no, menuda tontería

389
00:15:39,990 --> 00:15:41,629
y ahora ya con ese

390
00:15:41,629 --> 00:15:43,950
valor resultante de esa llamada

391
00:15:43,950 --> 00:15:45,070
yo hago ya lo que quiera

392
00:15:45,070 --> 00:15:49,159
lo que quiera, vale

393
00:15:49,159 --> 00:15:53,850
entonces

394
00:15:53,850 --> 00:15:57,070
si lo ponemos aquí por ejemplo

395
00:15:57,070 --> 00:15:58,669
para luego

396
00:15:58,669 --> 00:15:59,850
en la ejecución verlo

397
00:15:59,850 --> 00:16:06,250
¿Y si ponemos el... para llamar al método en SIS?

398
00:16:08,490 --> 00:16:08,929
Claro.

399
00:16:11,139 --> 00:16:13,059
Sí, sí, sí, ahora lo escribo.

400
00:16:15,279 --> 00:16:17,179
Y te ahorras la variable.

401
00:16:18,899 --> 00:16:19,580
¿Vale?

402
00:16:21,019 --> 00:16:24,960
Aquí está el código de matrícula.

403
00:16:24,960 --> 00:16:27,879
La matrícula es este, 43.

404
00:16:28,259 --> 00:16:31,879
Esto de aquí es esto.

405
00:16:31,879 --> 00:16:35,759
entonces efectivamente lo que dice él

406
00:16:35,759 --> 00:16:38,840
yo aquí he usado una variable auxiliar

407
00:16:38,840 --> 00:16:40,559
para guardarlo ahí

408
00:16:40,559 --> 00:16:42,740
y luego pasarle esa variable

409
00:16:42,740 --> 00:16:43,559
al system out

410
00:16:43,559 --> 00:16:46,919
pero bueno, podría hacerlo así

411
00:16:46,919 --> 00:16:47,840
y estaría haciendo lo mismo

412
00:16:47,840 --> 00:16:50,159
directamente al system out

413
00:16:50,159 --> 00:16:52,100
pasarle ya la llamada al método también

414
00:16:52,100 --> 00:16:56,580
podríamos pasar la llamada al método

415
00:16:56,580 --> 00:16:57,539
porque este método

416
00:16:57,539 --> 00:17:00,000
ya te va a devolver el valor

417
00:17:00,000 --> 00:17:02,220
y ese valor ya se lo estás enchufando tú

418
00:17:02,220 --> 00:17:02,840
al system out

419
00:17:02,840 --> 00:17:05,599
nos ahorramos el intermediario

420
00:17:05,599 --> 00:17:07,440
este me da

421
00:17:07,440 --> 00:17:08,940
un valor que yo enchufo a la variable

422
00:17:08,940 --> 00:17:11,319
y ahora le enchufo la variable

423
00:17:11,319 --> 00:17:12,099
al system out

424
00:17:12,099 --> 00:17:14,579
pues aquí me ahorro el intermediario

425
00:17:14,579 --> 00:17:17,220
este me entrega un valor que en lugar

426
00:17:17,220 --> 00:17:19,059
de guardarlo en un contenedor intermedio

427
00:17:19,059 --> 00:17:21,160
se lo enchufo directamente a este

428
00:17:21,160 --> 00:17:22,819
de aquí, pero bueno, eso ya es un detalle

429
00:17:22,819 --> 00:17:25,180
si por ahora os es más claro

430
00:17:25,180 --> 00:17:27,240
de esta

431
00:17:27,240 --> 00:17:29,079
manera, mejor para entender

432
00:17:29,079 --> 00:17:30,680
bien que el método

433
00:17:30,680 --> 00:17:32,920
que tiene aquí un tipo de dato

434
00:17:32,920 --> 00:17:34,900
que tiene aquí un tipo, el método

435
00:17:34,900 --> 00:17:36,980
que no tiene iVoid, el que tenga ahí un tipo

436
00:17:36,980 --> 00:17:38,400
me devuelve algo

437
00:17:38,400 --> 00:17:40,819
y yo ese algo o lo guardo

438
00:17:40,819 --> 00:17:42,720
en algún sitio, o se lo enchufo

439
00:17:42,720 --> 00:17:44,900
a otro método, pero bueno, o lo guardo en algún sitio

440
00:17:44,900 --> 00:17:46,200
o lo pierdo

441
00:17:46,200 --> 00:17:48,740
¿el Void solo es para...?

442
00:17:48,740 --> 00:17:50,859
el Void es para métodos que no devuelvan

443
00:17:50,859 --> 00:17:52,819
nada, normalmente si no devuelves

444
00:17:52,819 --> 00:17:55,140
nada, pues de alguna manera tendrás que dar la realimentación

445
00:17:55,140 --> 00:17:56,720
entonces la sueles dar por System.out

446
00:17:56,720 --> 00:17:58,920
claro, pero puede ser un método

447
00:17:58,920 --> 00:18:00,299
que a lo mejor se conecta a una base de datos

448
00:18:00,299 --> 00:18:01,000
y hace algo con ella.

449
00:18:01,359 --> 00:18:02,500
Por ejemplo, podría ser

450
00:18:02,500 --> 00:18:04,839
algo que no te devuelva ningún valor resultado.

451
00:18:05,460 --> 00:18:05,640
¿Vale?

452
00:18:08,329 --> 00:18:09,490
Hombre, esta misma idea

453
00:18:09,490 --> 00:18:11,089
de mostrar el código de matrícula,

454
00:18:11,509 --> 00:18:13,029
claro, uno podría haberla hecho así,

455
00:18:14,170 --> 00:18:22,079
con un...

456
00:18:22,079 --> 00:18:22,240
¿No?

457
00:18:22,279 --> 00:18:24,420
La podríamos haber hecho, pues, de esta otra manera.

458
00:18:31,730 --> 00:18:31,930
¿Vale?

459
00:18:31,950 --> 00:18:33,049
Lo podríamos haber hecho así.

460
00:18:33,470 --> 00:18:34,509
Y entonces, este método

461
00:18:34,509 --> 00:18:36,470
te la muestra directamente,

462
00:18:36,609 --> 00:18:37,410
el código.

463
00:18:37,789 --> 00:18:39,289
No te lo devuelve para que tú le muestres.

464
00:18:39,289 --> 00:18:40,650
Diríais, uy, pues, mucho mejor,

465
00:18:40,769 --> 00:18:41,329
me ahorro tiempo.

466
00:18:41,750 --> 00:18:42,109
Pues no.

467
00:18:42,109 --> 00:18:44,769
está muchísimo peor

468
00:18:44,769 --> 00:18:46,430
muchísimo peor

469
00:18:46,430 --> 00:18:48,769
¿por qué es muchísimo peor?

470
00:18:49,089 --> 00:18:51,150
pues a nivel conceptual de desarrollo

471
00:18:51,150 --> 00:18:51,869
de diseño

472
00:18:51,869 --> 00:18:54,430
en una aplicación

473
00:18:54,430 --> 00:18:56,289
sobre todo en un software

474
00:18:56,289 --> 00:18:58,089
lo que queremos es que sea

475
00:18:58,089 --> 00:19:00,670
y esta palabra ya la he usado alguna vez pero insistiré en ella

476
00:19:00,670 --> 00:19:01,789
porque a lo mejor suena rara

477
00:19:01,789 --> 00:19:05,069
queremos que un software sea lo más desacoplado

478
00:19:05,069 --> 00:19:07,690
posible, que tenga el mayor nivel de desacoplamiento

479
00:19:07,690 --> 00:19:08,890
posible

480
00:19:08,890 --> 00:19:11,210
¿qué significa que un software

481
00:19:11,210 --> 00:19:12,230
sea desacoplado

482
00:19:12,230 --> 00:19:15,430
que cada parte

483
00:19:15,430 --> 00:19:17,230
se hace completamente

484
00:19:17,230 --> 00:19:18,490
por separado, por ejemplo

485
00:19:18,490 --> 00:19:21,109
la parte de dar resultados

486
00:19:21,109 --> 00:19:22,730
al usuario, le hago

487
00:19:22,730 --> 00:19:25,049
en este trozo de código, la parte de

488
00:19:25,049 --> 00:19:26,849
la operativa matemática, la hago aquí

489
00:19:26,849 --> 00:19:29,309
la parte de comunicarse con la base de datos

490
00:19:29,309 --> 00:19:31,569
la hago aquí, en lugar de hacerlo todo mezclado

491
00:19:31,569 --> 00:19:32,549
todo mezclado

492
00:19:32,549 --> 00:19:35,509
pues yo separo conceptualmente

493
00:19:35,509 --> 00:19:36,869
cada parte de la aplicación

494
00:19:36,869 --> 00:19:38,490
en clases distintas

495
00:19:38,490 --> 00:19:40,910
eso es que esté desacoplado

496
00:19:40,910 --> 00:19:42,910
y eso es bueno, ¿por qué?

497
00:19:43,490 --> 00:19:46,130
porque si yo hago cualquier pequeño cambio

498
00:19:46,130 --> 00:19:49,349
me voy solo a esa parte, oye es un cambio solo en la vista

499
00:19:49,349 --> 00:19:51,670
en lo que se llama la vista de la aplicación, que es lo que ve el usuario

500
00:19:51,670 --> 00:19:55,289
en la interfaz gráfica, el cambio es solamente en la vista

501
00:19:55,289 --> 00:19:57,930
pues me voy a la parte de la vista y cambio ahí

502
00:19:57,930 --> 00:20:00,910
el resto de la aplicación no tengo ni que mirarla, ni que abrirla, ni que nada

503
00:20:00,910 --> 00:20:02,569
por eso es bueno que esté desacoplada

504
00:20:02,569 --> 00:20:05,690
bueno, pues este método

505
00:20:05,690 --> 00:20:08,490
está desacoplado y el de abajo no

506
00:20:08,490 --> 00:20:10,910
¿por qué? porque el de arriba

507
00:20:10,910 --> 00:20:12,470
separa

508
00:20:12,470 --> 00:20:14,690
la parte de cómo ve las cosas

509
00:20:14,690 --> 00:20:16,849
el usuario, de la parte del cálculo

510
00:20:16,849 --> 00:20:18,170
y eso es bueno

511
00:20:18,170 --> 00:20:20,930
este método te calcula y te da el valor

512
00:20:20,930 --> 00:20:23,230
y te dice, ahora tú decide cómo lo muestras

513
00:20:23,230 --> 00:20:24,470
cómo te da a ti la gana mostrarlo

514
00:20:24,470 --> 00:20:26,049
¿que quieres un system out?

515
00:20:26,710 --> 00:20:29,210
pues pon un system out o pon lo que te dé la gana

516
00:20:29,210 --> 00:20:30,849
a mí es que me la trae floja

517
00:20:30,849 --> 00:20:33,230
¿que quieres mostrar una interfaz gráfica?

518
00:20:33,730 --> 00:20:35,089
pues muy bien, ahora coges

519
00:20:35,089 --> 00:20:36,329
el código que yo te doy

520
00:20:36,329 --> 00:20:38,210
Y los metes en una interfaz gráfica.

521
00:20:38,490 --> 00:20:39,410
Pero está separado.

522
00:20:39,650 --> 00:20:40,970
Este método de aquí no se entera.

523
00:20:41,650 --> 00:20:42,589
Este método dice,

524
00:20:43,230 --> 00:20:45,609
oye, yo me limito a darte el valor.

525
00:20:46,609 --> 00:20:47,269
Y tú ya,

526
00:20:47,690 --> 00:20:49,289
desde tu otra parte del software,

527
00:20:49,849 --> 00:20:50,990
decides cómo lo muestras.

528
00:20:51,089 --> 00:20:51,789
Ese es tu problema.

529
00:20:53,009 --> 00:20:54,630
Sin embargo, de esta manera,

530
00:20:55,170 --> 00:20:57,130
el propio método te está comprometiendo,

531
00:20:57,230 --> 00:20:58,789
te está forzando, te está obligando

532
00:20:58,789 --> 00:21:00,750
a mostrarlo en un system out.

533
00:21:01,390 --> 00:21:02,890
Si tú cambias la aplicación

534
00:21:02,890 --> 00:21:05,029
y de repente te gusta que sea con interfaz gráfica,

535
00:21:05,029 --> 00:21:07,630
pues tienes que ir aquí al método, quitar este

536
00:21:07,630 --> 00:21:09,589
system out, entonces estás mezclando

537
00:21:09,589 --> 00:21:11,809
conceptos, estás mezclando, hacer los cálculos

538
00:21:11,809 --> 00:21:13,069
con cómo se ven

539
00:21:13,069 --> 00:21:15,690
¿vale? ahora nosotros

540
00:21:15,690 --> 00:21:18,029
en nuestro ejemplo este cortito y sencillito

541
00:21:18,029 --> 00:21:19,869
pues está haciendo

542
00:21:19,869 --> 00:21:21,390
lo mismo esto que esto, está haciendo lo mismo

543
00:21:21,390 --> 00:21:23,710
pero bueno, es que estamos aquí con programas

544
00:21:23,710 --> 00:21:25,630
de cuatro líneas donde no es tan

545
00:21:25,630 --> 00:21:27,450
grave separar por partes ¿vale?

546
00:21:27,549 --> 00:21:29,569
pero sí es importante que cojáis esta idea

547
00:21:29,569 --> 00:21:31,130
esta idea de

548
00:21:31,130 --> 00:21:33,349
buena práctica de diseño

549
00:21:33,349 --> 00:21:35,250
no es no buena, es que es imprescindible

550
00:21:35,250 --> 00:21:37,710
la del desacoplamiento

551
00:21:37,710 --> 00:21:39,069
de la aplicación, separo partes

552
00:21:39,069 --> 00:21:41,430
y de hecho hay un montón de patrones de diseño relacionados con eso

553
00:21:41,430 --> 00:21:42,650
el modelo vista y controlador

554
00:21:42,650 --> 00:21:44,750
vista por un lado, controles por otro

555
00:21:44,750 --> 00:21:47,410
casi todo lo que se llaman patrones

556
00:21:47,410 --> 00:21:48,490
de diseño, que es

557
00:21:48,490 --> 00:21:51,210
cómo organizar el código

558
00:21:51,210 --> 00:21:53,589
de tu aplicación, cómo organizarlo

559
00:21:53,589 --> 00:21:54,769
pues están orientados a eso

560
00:21:54,769 --> 00:21:55,970
a separar en partes

561
00:21:55,970 --> 00:21:58,269
vale, pues entonces

562
00:21:58,269 --> 00:22:01,450
vamos bien

563
00:22:01,450 --> 00:22:04,029
vale

564
00:22:04,029 --> 00:22:07,849
vámonos ahora a meternos

565
00:22:07,849 --> 00:22:09,569
y ya completamos

566
00:22:09,569 --> 00:22:11,230
la parte de declaración de métodos

567
00:22:11,230 --> 00:22:11,930
de un poco

568
00:22:11,930 --> 00:22:14,950
el resumen más por encima

569
00:22:14,950 --> 00:22:17,349
vamos ahora a meternos con estos paréntesis

570
00:22:17,349 --> 00:22:19,509
porque yo hasta ahora con los métodos

571
00:22:19,509 --> 00:22:20,509
estos que he declarado

572
00:22:20,509 --> 00:22:23,450
me he limitado a ponerlos ahí

573
00:22:23,450 --> 00:22:25,450
porque son obligatorios, todos los métodos

574
00:22:25,450 --> 00:22:27,730
tienen que llevar paréntesis en la declaración

575
00:22:27,730 --> 00:22:29,829
y luego en la llamada

576
00:22:29,829 --> 00:22:31,849
también, hay que ponerlos

577
00:22:31,849 --> 00:22:33,529
para la llamada, pero

578
00:22:33,529 --> 00:22:35,490
hasta ahora no he dicho para qué valen esos paréntesis

579
00:22:35,490 --> 00:22:37,730
bueno

580
00:22:37,730 --> 00:22:39,069
pues esos paréntesis

581
00:22:39,069 --> 00:22:41,630
valen para darle

582
00:22:41,630 --> 00:22:43,369
al método alguna información

583
00:22:43,369 --> 00:22:45,410
del exterior para que trabaje con ella

584
00:22:45,410 --> 00:22:47,529
porque si el

585
00:22:47,529 --> 00:22:49,250
método tiene los paréntesis vacíos

586
00:22:49,250 --> 00:22:50,609
y ahí no hay nada

587
00:22:50,609 --> 00:22:53,589
el método solamente puede trabajar

588
00:22:53,589 --> 00:22:55,650
con las propiedades del objeto

589
00:22:55,650 --> 00:22:57,450
con eso claro que puede

590
00:22:57,450 --> 00:22:59,450
trabajar, las tiene ahí encima y trabaja con las

591
00:22:59,450 --> 00:23:00,910
propiedades del objeto para hacer lo que sea

592
00:23:00,910 --> 00:23:02,329
pero ya está

593
00:23:02,329 --> 00:23:05,089
no puede trabajar con más información

594
00:23:05,089 --> 00:23:06,950
luego se puede

595
00:23:06,950 --> 00:23:08,950
crear variables locales, claro, pero son variables

596
00:23:08,950 --> 00:23:10,930
locales que se crea él y le da

597
00:23:10,930 --> 00:23:11,789
él el valor que quiera

598
00:23:11,789 --> 00:23:14,210
pero puede ocurrir que haya un método

599
00:23:14,210 --> 00:23:16,690
que necesite información del exterior para

600
00:23:16,690 --> 00:23:18,769
trabajar, por ejemplo

601
00:23:18,769 --> 00:23:20,869
imaginaos, ahora vamos a

602
00:23:20,869 --> 00:23:22,710
hacer un método dentro de la clase

603
00:23:22,710 --> 00:23:28,490
matrícula para variar

604
00:23:28,490 --> 00:23:30,609
que este método

605
00:23:30,609 --> 00:23:49,170
No necesite, oye, yo de secretaría te dice, necesito de las matrículas de los usuarios, necesito saber cómo es la cantidad, a ver qué podemos hacer que tenga sentido, porque las matrículas no llevan IVA, ¿verdad?

606
00:23:49,170 --> 00:23:52,210
Pero da igual, le vamos a poner un IVA

607
00:23:52,210 --> 00:23:54,490
El de secretaría dice

608
00:23:54,490 --> 00:23:56,970
Oye, necesito saber cuál es la cantidad que tiene que pagar

609
00:23:56,970 --> 00:23:59,230
Si le pongo el IVA

610
00:23:59,230 --> 00:24:00,109
Necesito saberlo

611
00:24:00,109 --> 00:24:02,930
Con lo cual, vamos a añadir un método

612
00:24:02,930 --> 00:24:06,690
Matrícula

613
00:24:06,690 --> 00:24:08,769
Cantidad con IVA, por ejemplo

614
00:24:08,769 --> 00:24:09,349
Yo que sé

615
00:24:09,349 --> 00:24:14,960
Cantidad con IVA

616
00:24:14,960 --> 00:24:18,799
Este método tiene que calcular lo que cuesta la matrícula

617
00:24:18,799 --> 00:24:20,160
Ya con el IVA incluido

618
00:24:20,160 --> 00:24:21,779
Y devolvérmelo

619
00:24:21,779 --> 00:24:23,440
devolvérmelo para lo que sea

620
00:24:23,440 --> 00:24:25,059
con lo cual este método

621
00:24:25,059 --> 00:24:27,940
que le pondría yo ahí como tipo de retorno

622
00:24:27,940 --> 00:24:29,880
le pondríamos un double

623
00:24:29,880 --> 00:24:31,599
porque me va a devolver una cantidad double

624
00:24:31,599 --> 00:24:32,900
va a operar con la cantidad

625
00:24:32,900 --> 00:24:36,559
aquí mis paréntesis

626
00:24:36,559 --> 00:24:42,960
vale

627
00:24:42,960 --> 00:24:44,480
pero claro

628
00:24:44,480 --> 00:24:47,240
ahora yo me pongo a programar el método y digo

629
00:24:47,240 --> 00:24:47,980
oye espérate

630
00:24:47,980 --> 00:24:50,940
para calcular yo la cantidad con IVA

631
00:24:50,940 --> 00:24:52,900
me tendrás que decir

632
00:24:52,900 --> 00:24:54,160
cuál es el IVA

633
00:24:54,160 --> 00:24:58,200
porque yo no tengo esa información, la única información que yo tengo es

634
00:24:58,200 --> 00:25:03,200
el código de la matrícula del alumno, la descripción de esa matrícula

635
00:25:03,200 --> 00:25:07,359
y lo que cuesta, y me estás pidiendo que haga un cálculo para el cual necesito

636
00:25:07,359 --> 00:25:09,720
que tú me digas algo, me des una información

637
00:25:09,720 --> 00:25:15,200
bueno, pues esa información del exterior que puede hacer falta para que un método

638
00:25:15,200 --> 00:25:19,559
trabaje, se pasa aquí en los paréntesis, y es lo que se llama

639
00:25:19,559 --> 00:25:27,210
parámetros, ¿vale? entonces, si un método

640
00:25:27,210 --> 00:25:32,809
necesita datos

641
00:25:32,809 --> 00:25:37,490
ajenos al objeto, como en este caso

642
00:25:37,490 --> 00:25:40,970
IVA es ajeno al objeto, no tiene nada que ver con el objeto, el IVA es el IVA, lo que sea

643
00:25:40,970 --> 00:25:45,069
datos ajenos al objeto

644
00:25:45,069 --> 00:25:49,829
para operar, hay que pasárselo

645
00:25:49,829 --> 00:25:51,049
como parámetro

646
00:25:51,049 --> 00:26:02,400
pasárselo como parámetro

647
00:26:02,400 --> 00:26:06,700
Vale, ¿y cómo se pasan los parámetros?

648
00:26:06,940 --> 00:26:08,259
Aquí en los paréntesis

649
00:26:08,259 --> 00:26:12,180
Bueno, pues parámetros se pueden pasar

650
00:26:12,180 --> 00:26:13,740
De 1 a 2.000 millones

651
00:26:13,740 --> 00:26:16,079
Bueno, de 0

652
00:26:16,079 --> 00:26:18,480
Aquí, por ejemplo, no estoy pasando ninguno

653
00:26:18,480 --> 00:26:19,480
Los métodos que he hecho aquí

654
00:26:19,480 --> 00:26:22,619
Como no necesito información del exterior, 0 parámetros

655
00:26:22,619 --> 00:26:24,480
Aquí tampoco necesitaba

656
00:26:24,480 --> 00:26:26,220
Información del exterior, 0 parámetros

657
00:26:26,220 --> 00:26:28,099
Aquí sí, necesito

658
00:26:28,099 --> 00:26:30,200
Un parámetro, el IVA, un valor

659
00:26:30,200 --> 00:26:31,000
Double, por ejemplo

660
00:26:31,000 --> 00:26:32,920
bueno, pues yo ahí tengo que poner

661
00:26:32,920 --> 00:26:35,119
el parámetro

662
00:26:35,119 --> 00:26:37,380
exactamente igual que como declaraba

663
00:26:37,380 --> 00:26:38,019
una variable

664
00:26:38,019 --> 00:26:40,920
el iba como va a ser, pues

665
00:26:40,920 --> 00:26:42,140
vamos a ponerle que sea entero

666
00:26:42,140 --> 00:26:44,299
pues int

667
00:26:44,299 --> 00:26:47,019
y el nombre que yo le doy a ese parámetro

668
00:26:47,019 --> 00:26:49,599
el nombre que a mí me da la gana darle a ese parámetro

669
00:26:49,599 --> 00:26:50,319
el que yo quiera

670
00:26:50,319 --> 00:26:52,740
venga, pues le voy a dar el parámetro iba

671
00:26:52,740 --> 00:26:55,339
ala, pues ya está

672
00:26:55,339 --> 00:26:57,339
ya tengo una declaración

673
00:26:57,339 --> 00:26:57,900
de método

674
00:26:57,900 --> 00:27:00,799
en la que estoy indicando, oye tú

675
00:27:00,799 --> 00:27:03,279
para operar voy a

676
00:27:03,279 --> 00:27:05,299
necesitar que me pases un número

677
00:27:05,299 --> 00:27:07,380
entero, es lo que estoy diciendo

678
00:27:07,380 --> 00:27:09,220
cuando me pases un número entero

679
00:27:09,220 --> 00:27:10,619
yo operaré

680
00:27:10,619 --> 00:27:13,599
haré lo que sea y te lo devolveré

681
00:27:13,599 --> 00:27:15,519
de vuelta, el resultado

682
00:27:15,519 --> 00:27:17,440
necesito que me pases

683
00:27:17,440 --> 00:27:19,380
un número entero y ese número entero será el que sea

684
00:27:19,380 --> 00:27:21,339
pero el método lo va a

685
00:27:21,339 --> 00:27:22,859
identificar con este nombrecito

686
00:27:22,859 --> 00:27:24,779
el nombre que le ha dado la gana ponerle a él

687
00:27:24,779 --> 00:27:27,359
tú pásame un número entero que yo lo

688
00:27:27,359 --> 00:27:29,099
paso en mi cajita que se llama IVA

689
00:27:29,099 --> 00:27:31,240
como si se llama pepito, la cajita

690
00:27:31,240 --> 00:27:32,940
eso es lo de menos

691
00:27:32,940 --> 00:27:34,920
lo importante es esto

692
00:27:34,920 --> 00:27:37,700
el tipo de dato, entonces tú pásame

693
00:27:37,700 --> 00:27:39,819
un tipo de dato coherente

694
00:27:39,819 --> 00:27:41,720
con esa declaración

695
00:27:41,720 --> 00:27:43,059
de ahí, yo eso

696
00:27:43,059 --> 00:27:45,640
lo meto en mi cajita y ahora ya opero

697
00:27:45,640 --> 00:27:47,359
aquí y hago lo que tenga que hacer, ahora ya

698
00:27:47,359 --> 00:27:48,640
sí que lo puedo hacer

699
00:27:48,640 --> 00:27:51,400
pues venga, aquí que tenemos que hacer

700
00:27:51,400 --> 00:27:51,759
el

701
00:27:51,759 --> 00:27:55,480
el este

702
00:27:55,480 --> 00:27:57,900
pues será, si lo ponemos en una

703
00:27:57,900 --> 00:28:00,059
variable aparte

704
00:28:00,059 --> 00:28:01,680
pues el doble resultado

705
00:28:01,680 --> 00:28:03,099
pues el doble resultado será

706
00:28:03,099 --> 00:28:04,440
la cantidad

707
00:28:04,440 --> 00:28:07,680
más la cantidad con el IVA que será

708
00:28:07,680 --> 00:28:09,519
cantidad

709
00:28:09,519 --> 00:28:12,950
por

710
00:28:12,950 --> 00:28:15,170
IVA

711
00:28:15,170 --> 00:28:16,950
ahora aquí ya

712
00:28:16,950 --> 00:28:19,369
cuando mezclemos tipos de datos distintos

713
00:28:19,369 --> 00:28:21,650
acordaos de que ahí se salte

714
00:28:21,650 --> 00:28:23,549
la alarma para ver si todo va bien

715
00:28:23,549 --> 00:28:25,369
entonces cantidad por IVA

716
00:28:25,369 --> 00:28:26,309
estoy mezclando

717
00:28:26,309 --> 00:28:29,390
un entero que es IVA con

718
00:28:29,390 --> 00:28:30,950
un double, no pasa nada

719
00:28:30,950 --> 00:28:33,470
porque cuando hay una operación matemática

720
00:28:33,470 --> 00:28:35,390
que mezcla tipos numéricos

721
00:28:35,390 --> 00:28:35,849
distintos

722
00:28:35,849 --> 00:28:39,250
el de menos precisión promociona

723
00:28:39,250 --> 00:28:41,269
el de más precisión, con lo cual

724
00:28:41,269 --> 00:28:43,109
todo esto se va a promocionar a double

725
00:28:43,109 --> 00:28:45,410
y ahora con ese double que tengo que hacer

726
00:28:45,410 --> 00:28:46,849
yo, pues dividirlo entre 100

727
00:28:46,849 --> 00:28:54,859
¿verdad? ¿vale?

728
00:28:56,539 --> 00:28:57,299
y ahora

729
00:28:57,299 --> 00:28:58,559
este de su resultado

730
00:28:58,559 --> 00:29:11,890
se lo

731
00:29:11,890 --> 00:29:13,529
devuelvo

732
00:29:13,529 --> 00:29:15,390
¿vale?

733
00:29:16,990 --> 00:29:23,089
caerá ahí, o sea, este método

734
00:29:23,089 --> 00:29:25,490
aquí estamos en la parte de declaración, acordaros

735
00:29:25,490 --> 00:29:27,650
aquí, yo no se está ejecutando

736
00:29:27,650 --> 00:29:29,210
nada, es como cuando os decía aquí

737
00:29:29,210 --> 00:29:31,509
aquí no se está ejecutando nada, aquí estoy

738
00:29:31,509 --> 00:29:33,430
diciendo lo que va a pasar cuando se ejecute

739
00:29:33,430 --> 00:29:34,910
pero no se está ejecutando nada

740
00:29:34,910 --> 00:29:36,630
entonces, aquí lo mismo

741
00:29:36,630 --> 00:29:39,730
aquí no se está ejecutando nada, yo estoy diciendo

742
00:29:39,730 --> 00:29:41,230
cuando esto se ejecute

743
00:29:41,230 --> 00:29:43,130
tú me pasarás

744
00:29:43,130 --> 00:29:45,269
un valor entero y yo haré esto con él

745
00:29:45,269 --> 00:29:47,430
cuando esto se ejecute, no se está ejecutando nada, no estamos

746
00:29:47,430 --> 00:29:49,369
en un main todavía, esto

747
00:29:49,369 --> 00:29:51,470
lo que te dice es, vale, cuando tú

748
00:29:51,470 --> 00:29:53,490
me llames, me llamarás

749
00:29:53,490 --> 00:29:55,329
dándome un número entero, y yo

750
00:29:55,329 --> 00:29:56,970
con ese número entero haré esto

751
00:29:56,970 --> 00:29:58,470
y te lo devolveré.

752
00:29:59,230 --> 00:30:01,549
Pero aún no se está ejecutando nada, con lo cual

753
00:30:01,549 --> 00:30:03,650
no necesito

754
00:30:03,650 --> 00:30:04,809
ningún valor numérico aquí.

755
00:30:05,329 --> 00:30:06,869
Solo necesito decir lo que voy a hacer.

756
00:30:09,240 --> 00:30:10,660
Vale, antes de ahora ver

757
00:30:10,660 --> 00:30:12,900
cómo ejecutamos este método.

758
00:30:14,279 --> 00:30:14,759
Cuidado

759
00:30:14,759 --> 00:30:16,799
con lo de mezclar los int y los

760
00:30:16,799 --> 00:30:18,680
double y todo eso, por eso digo que siempre

761
00:30:18,680 --> 00:30:20,720
hay situaciones en las que uno tiene que decir

762
00:30:20,720 --> 00:30:22,440
uy, cuidado que esta es una situación en la que

763
00:30:22,440 --> 00:30:24,359
se me tiene que activar una neurona extra

764
00:30:24,359 --> 00:30:26,440
imaginaos que ahora

765
00:30:26,440 --> 00:30:28,920
me cambia la aplicación y me dice, no, no, las cantidades

766
00:30:28,920 --> 00:30:30,980
solo enteras, que es que con decimales

767
00:30:30,980 --> 00:30:33,279
me hago un lío que no veas

768
00:30:33,279 --> 00:30:34,960
entonces

769
00:30:34,960 --> 00:30:36,599
dices, ah, no pasa nada

770
00:30:36,599 --> 00:30:38,779
yo te lo cambio a int, magnífico

771
00:30:38,779 --> 00:30:40,200
pues la hemos cagado

772
00:30:40,200 --> 00:30:41,559
porque ahora ya

773
00:30:41,559 --> 00:30:44,700
esto se convierte

774
00:30:44,700 --> 00:30:45,480
en un entero

775
00:30:45,480 --> 00:30:48,619
esto se convierte en división entera

776
00:30:48,619 --> 00:30:50,559
con lo cual esto va a ser cero siempre

777
00:30:50,559 --> 00:30:52,779
siempre va a ser cero porque es el cociente

778
00:30:52,779 --> 00:30:55,200
¿vale? no es lo mismo

779
00:30:55,200 --> 00:30:57,019
la división entera que la división con decimales

780
00:30:57,019 --> 00:30:59,339
entonces si esto es un número entero

781
00:30:59,339 --> 00:31:01,279
esta es la división

782
00:31:01,279 --> 00:31:03,000
entera que es el cociente y esto va a ser

783
00:31:03,000 --> 00:31:05,240
una cantidad menos de 100

784
00:31:05,240 --> 00:31:07,220
con lo cual

785
00:31:07,220 --> 00:31:08,900
yo al dividirla

786
00:31:08,900 --> 00:31:10,500
pues me puede dar cero perfectamente

787
00:31:10,500 --> 00:31:12,359
entonces esto tiene que ser double

788
00:31:12,359 --> 00:31:13,240
tiene que ser double

789
00:31:13,240 --> 00:31:16,019
si esta cantidad es double no hay problema

790
00:31:16,019 --> 00:31:18,119
porque ya iba a promocionar automáticamente

791
00:31:18,119 --> 00:31:24,660
Bueno, ahora vamos a ver

792
00:31:24,660 --> 00:31:25,720
Cómo ejecutamos esto

793
00:31:25,720 --> 00:31:31,539
Pues esto lo tiene que ejecutar un objeto

794
00:31:31,539 --> 00:31:33,819
Como todos los métodos, lo tiene que ejecutar un objeto

795
00:31:33,819 --> 00:31:34,500
No hay otra

796
00:31:34,500 --> 00:31:37,440
Bueno, pues vámonos a un main que ya tenga objetos

797
00:31:37,440 --> 00:31:40,460
Venga, este main de aquí

798
00:31:40,460 --> 00:31:42,019
Tiene ya un objeto alumno

799
00:31:42,019 --> 00:31:43,779
Con un montón de datos que los hemos metido

800
00:31:43,779 --> 00:31:46,200
Pues vamos a ver cuál es el precio

801
00:31:46,200 --> 00:31:47,000
Con IVA

802
00:31:47,000 --> 00:32:11,930
Vale, pues a ver, ¿de qué objeto

803
00:32:11,930 --> 00:32:13,269
queremos mostrar

804
00:32:13,269 --> 00:32:15,170
ese precio

805
00:32:15,170 --> 00:32:17,910
del objeto alumno

806
00:32:17,910 --> 00:32:20,289
vale, pues entonces tendrá que ser el objeto alumno

807
00:32:20,289 --> 00:32:22,210
el que llame al método, para que el método

808
00:32:22,210 --> 00:32:24,109
trabaje con los datos de alumno

809
00:32:24,109 --> 00:32:26,190
venga, ¿tengo algún método

810
00:32:26,190 --> 00:32:28,369
que me haga esto que me han pedido? uy, sí, qué suerte

811
00:32:28,369 --> 00:32:29,789
tengo un método

812
00:32:29,789 --> 00:32:31,089
que hace justo

813
00:32:31,089 --> 00:32:32,750
lo que

814
00:32:32,750 --> 00:32:35,990
lo que yo quería

815
00:32:35,990 --> 00:32:38,150
ah, perdón, perdón, perdón

816
00:32:38,150 --> 00:32:39,329
mucho más divertido, claro

817
00:32:39,329 --> 00:32:42,529
el método matrícula

818
00:32:42,529 --> 00:32:44,349
lo he metido aquí

819
00:32:44,349 --> 00:32:46,269
en la clase matrícula

820
00:32:46,269 --> 00:32:48,049
luego lo tiene que llamar

821
00:32:48,049 --> 00:32:49,609
un objeto matrícula

822
00:32:49,609 --> 00:32:50,529
¿vale?

823
00:32:51,349 --> 00:32:53,309
al método matrícula, perdón

824
00:32:53,309 --> 00:32:54,829
al método cantidad con IVA

825
00:32:54,829 --> 00:32:57,230
lo tiene que llamar un objeto matrícula

826
00:32:57,230 --> 00:32:58,150
¿vale?

827
00:32:58,869 --> 00:33:00,250
yo quiero que lo llame

828
00:33:00,250 --> 00:33:03,529
el objeto matrícula de este alumno

829
00:33:03,529 --> 00:33:05,730
luego ¿qué escribiría aquí?

830
00:33:05,789 --> 00:33:06,990
dictarme alumno

831
00:33:06,990 --> 00:33:09,289
punto matrícula

832
00:33:09,289 --> 00:33:13,250
Punto, cantidad con IVA.

833
00:33:14,970 --> 00:33:18,589
Pero claro, ahora es el momento, ahora sí que sí,

834
00:33:19,029 --> 00:33:21,349
es el momento de decir, ahora que te vas a ejecutar,

835
00:33:21,890 --> 00:33:24,809
ahora que ya te vas a ejecutar, ahora ya sí que sí,

836
00:33:25,009 --> 00:33:27,730
te tengo que dar el valor concreto con el que te vas a ejecutar.

837
00:33:27,910 --> 00:33:30,609
Ahora es el momento, porque ahora sí que se va a ejecutar el método.

838
00:33:31,289 --> 00:33:33,470
Entonces, ahora ya le damos el valor que sea,

839
00:33:33,569 --> 00:33:37,049
ahora ya hay que darle un valor, 13, 1 leído por teclado,

840
00:33:37,289 --> 00:33:38,109
un valor concreto.

841
00:33:39,289 --> 00:33:41,650
Entonces, en el momento de la llamada al método...

842
00:33:41,650 --> 00:33:45,630
Sí, este sería el IVA, que yo he decidido que sea 13.

843
00:33:46,410 --> 00:33:47,849
Claro, como podría ser cualquier otro.

844
00:33:57,829 --> 00:34:02,450
En el momento de llamar al método, los parámetros tienen que tener un valor.

845
00:34:03,869 --> 00:34:07,069
Tienen ya un valor concreto, porque ya estoy ejecutando.

846
00:34:12,159 --> 00:34:15,460
Igual que alumno matrícula, ya es un objeto concreto.

847
00:34:15,460 --> 00:34:17,360
alumno, ya es un objeto concreto

848
00:34:17,360 --> 00:34:19,000
vale, entonces de nuevo

849
00:34:19,000 --> 00:34:21,619
como este método me devuelve

850
00:34:21,619 --> 00:34:22,920
me lo devuelve como retorno

851
00:34:22,920 --> 00:34:25,579
si lo llamo así, pues vaya pérdida

852
00:34:25,579 --> 00:34:27,719
de tiempo, pues vamos a guardarlo

853
00:34:27,719 --> 00:34:28,500
en algún sitio

854
00:34:28,500 --> 00:34:30,940
para no perderlo

855
00:34:30,940 --> 00:34:33,880
lo guardamos en algún sitio

856
00:34:33,880 --> 00:34:34,900
para no perderlo

857
00:34:34,900 --> 00:34:46,250
y ya está lo que nos haya salido

858
00:34:46,250 --> 00:34:47,690
uy, me falta el

859
00:34:47,690 --> 00:34:49,670
esto

860
00:34:49,670 --> 00:34:53,139
vale

861
00:34:53,139 --> 00:34:56,400
entonces en el momento de llamar al método

862
00:34:56,400 --> 00:34:58,559
ahí es cuando se va a ejecutar en el main

863
00:34:58,559 --> 00:34:59,380
cuando yo lo llamo

864
00:34:59,380 --> 00:35:02,380
y ahí ya tengo que comprometerme, paso el valor

865
00:35:02,380 --> 00:35:03,159
tal cual

866
00:35:03,159 --> 00:35:06,199
ni pongo el tipo de datos ni pongo nada

867
00:35:06,199 --> 00:35:07,659
porque aquí no estoy declarando nada

868
00:35:07,659 --> 00:35:10,019
la declaración la hice aquí

869
00:35:10,019 --> 00:35:11,820
por eso aquí sí que puse el tipo de datos

870
00:35:11,820 --> 00:35:14,619
aquí puse ya el valor

871
00:35:14,619 --> 00:35:15,840
entonces

872
00:35:15,840 --> 00:35:18,500
ejecutamos esto por si hemos escrito algo mal

873
00:35:18,500 --> 00:35:22,340
pues el precio de la matrícula

874
00:35:22,340 --> 00:35:24,059
con el 13 ha subido

875
00:35:24,059 --> 00:35:25,760
de 76 a 85

876
00:35:25,760 --> 00:35:27,500
vale

877
00:35:27,500 --> 00:35:35,079
que hay más parámetros

878
00:35:35,079 --> 00:35:37,880
porque necesita más cosas

879
00:35:37,880 --> 00:35:38,679
pues separados

880
00:35:38,679 --> 00:35:40,900
separados por comas

881
00:35:40,900 --> 00:35:41,599
y ya está

882
00:35:41,599 --> 00:35:42,920
y aquí todos los parámetros

883
00:35:42,920 --> 00:35:43,760
que hicieran falta

884
00:35:43,760 --> 00:35:45,340
si es que hicieran falta más

885
00:35:45,340 --> 00:35:46,000
porque este método

886
00:35:46,000 --> 00:35:46,960
hiciera muchas cosas raras

887
00:35:46,960 --> 00:35:47,800
y entra muchas cosas

888
00:35:47,800 --> 00:35:50,099
pues uno pone los parámetros

889
00:35:50,099 --> 00:35:51,039
que le den la gana

890
00:35:51,039 --> 00:35:54,039
que necesito esos tres

891
00:35:54,039 --> 00:35:54,960
para hacer lo que sea

892
00:35:54,960 --> 00:35:55,900
que voy a hacer ahí dentro

893
00:35:55,900 --> 00:35:57,480
pues a la uno tras otro

894
00:35:57,480 --> 00:35:58,500
separados por comas

895
00:35:58,500 --> 00:35:59,639
eso sí

896
00:35:59,639 --> 00:36:01,119
luego en la llamada

897
00:36:01,119 --> 00:36:03,960
Tendríamos que pasarle

898
00:36:03,960 --> 00:36:04,960
Las tres cosas

899
00:36:04,960 --> 00:36:07,380
En la llamada tendría que pasarle

900
00:36:07,380 --> 00:36:09,019
El

901
00:36:09,019 --> 00:36:12,559
Número entero

902
00:36:12,559 --> 00:36:15,099
El número dabel

903
00:36:15,099 --> 00:36:17,219
El string

904
00:36:17,219 --> 00:36:19,800
Si yo he dicho aquí

905
00:36:19,800 --> 00:36:21,500
Que necesito

906
00:36:21,500 --> 00:36:22,619
Tres parámetros

907
00:36:22,619 --> 00:36:24,980
Que luego, es mentira, vamos, no los necesito

908
00:36:24,980 --> 00:36:26,760
Si yo he dicho ahí que necesito tres

909
00:36:26,760 --> 00:36:29,340
Pues tengo que pasar luego en la llamada

910
00:36:29,340 --> 00:36:31,739
Esos tres, en ese orden exactamente

911
00:36:31,739 --> 00:36:33,699
tal cual, en ese orden tal cual

912
00:36:33,699 --> 00:36:35,900
y con el mismo

913
00:36:35,900 --> 00:36:37,920
tipo, por ejemplo

914
00:36:37,920 --> 00:36:39,579
como aquí, en ese orden tal cual

915
00:36:39,579 --> 00:36:40,300
y con el mismo tipo

916
00:36:40,300 --> 00:36:47,840
no, return solo

917
00:36:47,840 --> 00:36:48,699
puede volver un valor

918
00:36:48,699 --> 00:36:51,780
y por eso aquí solo ponemos un tipo de dato

919
00:36:51,780 --> 00:36:53,099
porque solo puede volver un valor

920
00:36:53,099 --> 00:36:59,119
claro, claro

921
00:36:59,119 --> 00:37:01,360
parámetros puede haber todos los que hagan falta

922
00:37:01,360 --> 00:37:03,519
y tú con esos parámetros operas, haces lo que sea

923
00:37:03,519 --> 00:37:05,719
pero solamente puedes

924
00:37:05,719 --> 00:37:07,639
devolver un valor, a ver

925
00:37:07,639 --> 00:37:09,860
si quieres devolver muchos, los metes

926
00:37:09,860 --> 00:37:11,260
en un array y devuelves el array

927
00:37:11,260 --> 00:37:13,320
porque el array es un objeto

928
00:37:13,320 --> 00:37:15,360
entonces tú devuelves un array

929
00:37:15,360 --> 00:37:17,599
podrías devolver un array de cosas

930
00:37:17,599 --> 00:37:21,289
uy, vale, entonces aquí

931
00:37:21,289 --> 00:37:23,610
estoy devolviendo muchos enteros

932
00:37:23,610 --> 00:37:25,429
en realidad, pero un único

933
00:37:25,429 --> 00:37:27,210
objeto array, tendría que crear aquí un array

934
00:37:27,210 --> 00:37:29,250
y devolverlo, pero lo que

935
00:37:29,250 --> 00:37:31,289
devuelves es un único

936
00:37:31,289 --> 00:37:33,469
valor, me da igual que ese valor sea de un objeto

937
00:37:33,469 --> 00:37:35,550
de un array, de un stream

938
00:37:35,550 --> 00:37:36,489
pero un único valor

939
00:37:36,489 --> 00:37:37,730
Vale

940
00:37:37,730 --> 00:37:39,849
Entonces, dime

941
00:37:39,849 --> 00:37:52,969
Bueno, pero eso

942
00:37:52,969 --> 00:37:54,469
Ya es que sería otro programa

943
00:37:54,469 --> 00:37:56,030
Entonces, pues tú aquí

944
00:37:56,030 --> 00:37:58,550
Podrías, aquí antes de esto

945
00:37:58,550 --> 00:38:01,010
Preguntar y decir, ¿cuál va a ser el IVA que quiere usar?

946
00:38:01,550 --> 00:38:03,030
Tú lo metes ese IVA en una variable

947
00:38:03,030 --> 00:38:04,230
Y luego le pasas aquí la variable

948
00:38:04,230 --> 00:38:05,730
Vale

949
00:38:05,730 --> 00:38:07,590
Voy a quitar esto

950
00:38:07,590 --> 00:38:11,949
Eso ya es que son detalles

951
00:38:11,949 --> 00:38:13,730
Pues del programa

952
00:38:13,730 --> 00:38:16,269
Yo aquí es que he hecho el ejemplo

953
00:38:16,269 --> 00:38:18,429
Pasándole el 13 sí o sí

954
00:38:18,429 --> 00:38:20,449
Pero bueno

955
00:38:20,449 --> 00:38:22,510
Este programa pues podría ser

956
00:38:22,510 --> 00:38:24,309
Pide antes el IVA por teclado

957
00:38:24,309 --> 00:38:28,010
Pero eso ya son detalles del programa

958
00:38:28,010 --> 00:38:29,409
A mí lo que me importa ahora es

959
00:38:29,409 --> 00:38:32,269
El paso, que entendáis el paso

960
00:38:32,269 --> 00:38:33,010
A los métodos

961
00:38:33,010 --> 00:38:35,809
¿Qué IVA quiere? Pues aquí lo lees

962
00:38:35,809 --> 00:38:37,150
Tenemos escáner

963
00:38:37,150 --> 00:38:38,809
No

964
00:38:38,809 --> 00:38:54,550
Vale, entonces

965
00:38:54,550 --> 00:38:56,449
¿Qué IVA quiere?

966
00:38:56,829 --> 00:38:58,230
Pues entonces lo leemos aquí

967
00:38:58,230 --> 00:39:00,250
En nuestro int

968
00:39:00,250 --> 00:39:03,090
Lo llamo de otra manera

969
00:39:03,090 --> 00:39:05,369
Lo puedo llamar como me dé la gana

970
00:39:05,369 --> 00:39:08,989
IVA matrícula

971
00:39:08,989 --> 00:39:10,670
Como a mí me dé la gana, es una variable del main

972
00:39:10,670 --> 00:39:12,409
IVA matrícula

973
00:39:12,409 --> 00:39:15,230
Igual a scan.nextInt

974
00:39:15,230 --> 00:39:17,250
Y ahora

975
00:39:17,250 --> 00:39:19,030
A la llamada al método

976
00:39:19,030 --> 00:39:20,730
Le paso esa variable

977
00:39:20,730 --> 00:39:24,150
me da igual pasar el valor

978
00:39:24,150 --> 00:39:26,289
concreto que pasar una variable

979
00:39:26,289 --> 00:39:28,230
con ese, entonces yo le paso esta

980
00:39:28,230 --> 00:39:30,150
variable y entonces ahora ya este método

981
00:39:30,150 --> 00:39:32,190
va a operar con el valor que

982
00:39:32,190 --> 00:39:34,289
tenga esta variable dentro, el que sea

983
00:39:34,289 --> 00:39:35,690
que esta variable

984
00:39:35,690 --> 00:39:38,210
se puede llamar como le dé la gana

985
00:39:38,210 --> 00:39:40,409
no tiene por qué llamarse igual que esta

986
00:39:40,409 --> 00:39:44,469
que esta, estos son cosas independientes

987
00:39:44,469 --> 00:39:46,329
¿vale? es decir

988
00:39:46,329 --> 00:39:47,250
aquí en la llamada

989
00:39:47,250 --> 00:39:49,269
este le dice, oye

990
00:39:49,269 --> 00:39:51,889
él se ha creado una caja verde

991
00:39:51,889 --> 00:39:53,929
donde tiene un 7

992
00:39:53,929 --> 00:39:56,550
y ahora en el momento de hacer

993
00:39:56,550 --> 00:39:58,429
cantidad con IVA de la caja verde

994
00:39:58,429 --> 00:40:00,269
saca el 7 y te lo da

995
00:40:00,269 --> 00:40:02,429
ahora cantidad con IVA

996
00:40:02,429 --> 00:40:03,630
tiene ese 7 en la mano

997
00:40:03,630 --> 00:40:06,329
y lo mete en su cajita azul

998
00:40:06,329 --> 00:40:08,130
¿qué más me da? lo mete en su cajita azul

999
00:40:08,130 --> 00:40:09,909
y ahora ya opera con él, lo que importa es el 7

1000
00:40:09,909 --> 00:40:12,449
me da igual que el envolvente para el método

1001
00:40:12,449 --> 00:40:13,489
aquí se llame IVA

1002
00:40:13,489 --> 00:40:14,789
y aquí se llame

1003
00:40:14,789 --> 00:40:18,449
IVA matrícula, me da lo mismo

1004
00:40:18,449 --> 00:40:20,070
no es el envolvente de ese valor

1005
00:40:20,070 --> 00:40:21,289
que se está pasando uno al otro.

1006
00:40:21,750 --> 00:40:21,949
Dime.

1007
00:40:25,800 --> 00:40:28,400
Sí, tú aquí podrías usar cualquier cosa

1008
00:40:28,400 --> 00:40:31,099
que dé como resultado un número.

1009
00:40:31,780 --> 00:40:33,119
Entonces, scanNextInt

1010
00:40:33,119 --> 00:40:35,519
te da como resultado un número también.

1011
00:40:36,260 --> 00:40:38,480
Luego yo lo puedo pasar aquí, ¿vale?

1012
00:40:38,519 --> 00:40:39,719
Porque esto me da un número.

1013
00:40:39,840 --> 00:40:42,059
Pues ese número se enchufa a cantidad con IVA.

1014
00:40:47,119 --> 00:40:47,980
Eso tenías que poner antes.

1015
00:40:48,960 --> 00:40:50,559
Claro, aquí lo único que puedes poner

1016
00:40:50,559 --> 00:40:52,860
es algo que se transforme a un número entero.

1017
00:40:53,059 --> 00:41:07,400
Entonces, scan next in se transforma en un número entero, luego es válido. Y va matrícula también, porque es una variable. El propio 13 también, o sea, cualquier cosa que sea en realidad un número entero. Es lo que hay que poner ahí, ¿vale?

1018
00:41:07,400 --> 00:41:15,340
No, no, no, no, que más da

1019
00:41:15,340 --> 00:41:16,639
Espera, vamos a ponerlo como estaba

1020
00:41:16,639 --> 00:41:24,460
Vale, aquí

1021
00:41:24,460 --> 00:41:26,980
En este extremo

1022
00:41:26,980 --> 00:41:29,000
De la llamada, o sea, hay dos personas que se están

1023
00:41:29,000 --> 00:41:31,139
Comunicando, hay dos extremos

1024
00:41:31,139 --> 00:41:32,860
Este es un extremo de la

1025
00:41:32,860 --> 00:41:34,840
Comunicación, este es el A

1026
00:41:34,840 --> 00:41:36,840
Y el otro es este

1027
00:41:36,840 --> 00:41:38,800
Que es el B, entonces aquí

1028
00:41:38,800 --> 00:41:39,340
Tenemos

1029
00:41:39,340 --> 00:41:41,000
El

1030
00:41:41,000 --> 00:41:45,639
A ver

1031
00:41:45,639 --> 00:41:54,340
Aquí tenemos el método

1032
00:41:54,340 --> 00:41:54,760
¿Vale?

1033
00:41:57,829 --> 00:42:00,269
El método que te está diciendo

1034
00:42:00,269 --> 00:42:02,670
Que necesita una cosita

1035
00:42:02,670 --> 00:42:04,269
Entera que tú le tienes que pasar

1036
00:42:04,269 --> 00:42:05,710
Es lo que te está diciendo

1037
00:42:05,710 --> 00:42:07,610
Y aquí tenemos el main

1038
00:42:07,610 --> 00:42:10,690
Entonces el main

1039
00:42:10,690 --> 00:42:11,809
Es el que llama al método

1040
00:42:11,809 --> 00:42:13,090
Vamos a llamarle a este método

1041
00:42:13,090 --> 00:42:15,650
El main es el que llama al método

1042
00:42:15,650 --> 00:42:17,429
Y le pasa el valor

1043
00:42:17,429 --> 00:42:18,829
¿Vale? Entonces

1044
00:42:18,829 --> 00:42:22,110
Este lo que te está diciendo es

1045
00:42:22,110 --> 00:42:23,510
Tú pásame un número

1046
00:42:23,510 --> 00:42:25,010
pásame un número el que tú quieras

1047
00:42:25,010 --> 00:42:27,190
yo ese número lo voy a coger

1048
00:42:27,190 --> 00:42:30,130
y lo voy a poner en mi caja que se llama IVA

1049
00:42:30,130 --> 00:42:32,269
mi caja yo la he llamado IVA

1050
00:42:32,269 --> 00:42:34,449
entonces tú pásame un número que yo lo voy a meter aquí

1051
00:42:34,449 --> 00:42:36,429
entonces este es el main que ha hecho

1052
00:42:36,429 --> 00:42:40,119
el main lo que ha hecho es

1053
00:42:40,119 --> 00:42:41,920
pues ha leído por teclado

1054
00:42:41,920 --> 00:42:43,539
y en una cajita suya

1055
00:42:43,539 --> 00:42:46,739
en una cajita suya

1056
00:42:46,739 --> 00:42:47,900
que se llama

1057
00:42:47,900 --> 00:42:49,539
IVA no sé qué

1058
00:42:49,539 --> 00:42:50,579
IVA M por ejemplo

1059
00:42:50,579 --> 00:42:53,599
en una cajita suya que se llama IVA no sé qué

1060
00:42:53,599 --> 00:42:54,579
con el escáner

1061
00:42:54,579 --> 00:42:57,019
ha metido un 7, por ejemplo

1062
00:42:57,019 --> 00:42:59,320
vale, pues entonces, ahora aquí

1063
00:42:59,320 --> 00:43:02,480
nosotros pasamos esta variable

1064
00:43:02,480 --> 00:43:04,340
¿qué significa hacer esto?

1065
00:43:04,500 --> 00:43:07,179
pues significa, llevamos a este método

1066
00:43:07,179 --> 00:43:09,820
cogemos la caja que se llama IVA-M

1067
00:43:09,820 --> 00:43:13,320
cogemos esta caja y sacamos el 7 fuera

1068
00:43:13,320 --> 00:43:15,239
sacamos el 7 fuera

1069
00:43:15,239 --> 00:43:18,260
ahora este 7 viaja por aquí

1070
00:43:18,260 --> 00:43:21,619
y se mete en esta que se llama IVA o como se llame

1071
00:43:21,619 --> 00:43:23,840
me da lo mismo, y ahora a partir de aquí

1072
00:43:23,840 --> 00:43:25,880
este método, cuando

1073
00:43:25,880 --> 00:43:27,820
se refiera a IVA, se va a

1074
00:43:27,820 --> 00:43:29,659
referir al 7 que salió de esta otra

1075
00:43:29,659 --> 00:43:31,360
variable, ¿entiendes?

1076
00:43:32,039 --> 00:43:33,679
De esta variable con este

1077
00:43:33,679 --> 00:43:36,000
nombre sale el 7 y cae

1078
00:43:36,000 --> 00:43:36,960
en esta otra

1079
00:43:36,960 --> 00:43:39,900
me da igual como se llamen, porque de esta

1080
00:43:39,900 --> 00:43:41,639
sale para caer en esta

1081
00:43:41,639 --> 00:43:43,960
y a partir de aquí ya se va a llamar así

1082
00:43:43,960 --> 00:43:45,900
¿vale?

1083
00:43:48,619 --> 00:43:49,760
Venga, pues a ver