1
00:00:00,000 --> 00:00:08,820
A ver, voy a grabar esta clase, por lo tanto si preguntáis algo o habláis mientras hay esta grabación

2
00:00:08,820 --> 00:00:12,300
es porque me dais vuestro consentimiento a hablar y grabaros, ¿vale?

3
00:00:12,339 --> 00:00:16,359
Si no, levantáis la mano y lo paro y bla bla bla bla, ya lo hemos dicho varias veces.

4
00:00:20,140 --> 00:00:28,339
Vale, entonces, hoy vamos a ver, esta parte de aquí en realidad es una extensión,

5
00:00:28,339 --> 00:00:34,500
una parte extra con respecto a lo que hemos visto de estructuras de control, ¿vale?

6
00:00:34,659 --> 00:00:39,420
Esto de aquí lo podríamos ver como una estructura de control. ¿Os acordáis la estructura de

7
00:00:39,420 --> 00:00:44,740
control que hemos visto nosotros? Los condicionales, los iterativos, for, while, if, lo que hacían

8
00:00:44,740 --> 00:00:52,880
era cambiar un poco el normal flujo de ejecución de un programa, ¿no? Ya llegaba un momento

9
00:00:52,880 --> 00:00:54,579
Y allí tomaba una decisión

10
00:00:54,579 --> 00:00:56,219
Si era verdadera o condición

11
00:00:56,219 --> 00:01:00,179
Hacía una serie de instrucciones

12
00:01:00,179 --> 00:01:03,539
Si no era verdadera esa condición

13
00:01:03,539 --> 00:01:04,819
Hacía otra cosa, ¿vale?

14
00:01:05,239 --> 00:01:07,540
O hacía una serie de instrucciones

15
00:01:07,540 --> 00:01:09,319
Y cuando llegaba al final de estas instrucciones

16
00:01:09,319 --> 00:01:12,040
Volvía al principio si una condición era verdadera

17
00:01:12,040 --> 00:01:13,500
Entonces en vez de tener

18
00:01:13,500 --> 00:01:18,420
Como hacíamos los ejercicios cuando estábamos al principio de curso

19
00:01:18,420 --> 00:01:21,620
Hacer una instrucción tras otra, tras otra, tras otra

20
00:01:21,620 --> 00:01:22,700
Y seguir hasta el final

21
00:01:22,700 --> 00:01:26,099
Pues cambiaba un poquito la secuencia

22
00:01:26,099 --> 00:01:28,219
Volvía atrás o cosa por esto

23
00:01:28,219 --> 00:01:34,620
Las funciones o procedimientos tienen una función parecida en un cierto sentido

24
00:01:34,620 --> 00:01:41,280
En el sentido que llega un momento en que puedo pillar un trozo de código

25
00:01:41,280 --> 00:01:43,000
Una parte de mi programa

26
00:01:43,000 --> 00:01:45,239
Sacarlo del main

27
00:01:45,239 --> 00:01:49,079
Que hasta ahora nosotros siempre hemos trabajado y solo hemos utilizado el main

28
00:01:49,079 --> 00:01:59,400
Y darle un nombre, para que si yo quiero utilizar esta función, utilizar este trozo de código

29
00:01:59,400 --> 00:02:04,140
Pueda referirme, pueda referenciar este trozo de código con su nombre

30
00:02:04,140 --> 00:02:08,240
¿Para qué me sirve esto? Para muchas cosas

31
00:02:08,240 --> 00:02:16,060
En particular, para ser básico, como la primera cosa digamos más sencilla para entender

32
00:02:16,060 --> 00:02:17,500
Es para organizar código

33
00:02:17,500 --> 00:02:19,680
En vez de tener todo el código

34
00:02:19,680 --> 00:02:20,919
Dentro del main

35
00:02:20,919 --> 00:02:22,439
Entonces se me vuelve complejo

36
00:02:22,439 --> 00:02:23,479
Con muchas líneas de código

37
00:02:23,479 --> 00:02:25,259
Pues si pillo un trozo

38
00:02:25,259 --> 00:02:26,060
Lo saco fuera

39
00:02:26,060 --> 00:02:26,819
Y lo llamo

40
00:02:26,819 --> 00:02:28,560
Acceso a la base de datos

41
00:02:28,560 --> 00:02:31,460
O login del cliente

42
00:02:31,460 --> 00:02:31,719
¿Vale?

43
00:02:32,060 --> 00:02:33,479
Yo cuando miro el main

44
00:02:33,479 --> 00:02:34,960
Leo allí que se llama

45
00:02:34,960 --> 00:02:36,460
Una función que tiene nombre

46
00:02:36,460 --> 00:02:37,680
Login del cliente

47
00:02:37,680 --> 00:02:39,740
O calcular no sé qué

48
00:02:39,740 --> 00:02:42,219
Y sé que esa función sola

49
00:02:42,219 --> 00:02:44,460
Independientemente de cómo esté implementada

50
00:02:44,460 --> 00:02:45,939
De cuántas líneas de código tiene

51
00:02:45,939 --> 00:02:47,539
Pues tiene esa funcionalidad

52
00:02:47,539 --> 00:02:48,479
¿Vale?

53
00:02:48,780 --> 00:02:51,180
Entonces el main se me vuelve más pequeño

54
00:02:51,180 --> 00:02:53,879
Se me vuelve más fácil de leer y de organizar

55
00:02:53,879 --> 00:02:54,340
¿Sí?

56
00:02:55,120 --> 00:02:56,080
Y además

57
00:02:56,080 --> 00:02:59,439
La cosa interesante de las funciones de los procedimientos

58
00:02:59,439 --> 00:03:01,419
Es que pueden llevar parámetros

59
00:03:01,419 --> 00:03:02,120
¿Vale?

60
00:03:02,539 --> 00:03:03,000
Entonces

61
00:03:03,000 --> 00:03:06,780
Un código que yo voy a ejecutar

62
00:03:06,780 --> 00:03:08,240
Le voy a pasar

63
00:03:08,240 --> 00:03:10,479
Un cierto parámetro, un cierto valor

64
00:03:10,479 --> 00:03:11,539
O unos valores

65
00:03:11,539 --> 00:03:15,139
Y su funcionamiento, el resultado que me dará

66
00:03:15,139 --> 00:03:17,960
Dependerá de los parámetros que yo le paso

67
00:03:17,960 --> 00:03:19,340
Para hacer un ejemplo básico

68
00:03:19,340 --> 00:03:22,419
Si yo tengo un método que se llama calcular el cuadrado

69
00:03:22,419 --> 00:03:23,280
¿Vale?

70
00:03:23,340 --> 00:03:28,439
Le pasaré como parámetro el lado del cuadrado que yo quiero calcular

71
00:03:28,439 --> 00:03:34,199
Y él me calculará el área del cuadrado del lado del número que le he pasado

72
00:03:34,199 --> 00:03:35,280
¿Vale?

73
00:03:36,259 --> 00:03:37,120
Para hacer un ejemplo

74
00:03:37,120 --> 00:03:39,740
Entonces, vamos a ver un poquito

75
00:03:39,740 --> 00:03:42,500
Qué tipo de cosas hay

76
00:03:42,500 --> 00:03:44,060
Vamos aquí

77
00:03:44,060 --> 00:03:47,120
Imaginémonos, aquí hace un ejemplo, ¿vale?

78
00:03:47,139 --> 00:03:51,719
Diciendo, vamos a ver si en un programa se repite muchas veces el mismo código, ¿vale?

79
00:03:51,800 --> 00:03:53,240
Como por ejemplo aquí

80
00:03:53,240 --> 00:04:01,520
Nosotros lo que vamos a hacer es calcular el área, el perímetro de un rectángulo varias veces

81
00:04:01,520 --> 00:04:06,900
Y cada vez cambia el tipo de rectángulo que yo tengo, ¿vale?

82
00:04:06,900 --> 00:04:09,659
Entonces aquí tengo un rectángulo de lado 3 y 4

83
00:04:09,659 --> 00:04:11,800
Y luego calculo la área, el perímetro

84
00:04:11,800 --> 00:04:14,199
Y escribo el rectángulo de lado

85
00:04:14,199 --> 00:04:15,979
Con sus lados, tiene área

86
00:04:15,979 --> 00:04:17,500
Área y perímetro

87
00:04:17,500 --> 00:04:19,439
¿Vale? Y luego hago lo mismo

88
00:04:19,439 --> 00:04:21,339
Lo único que hago es cambiar

89
00:04:21,339 --> 00:04:23,620
Los lados

90
00:04:23,620 --> 00:04:25,939
Ahora en vez de utilizar lado 3 y 4

91
00:04:25,939 --> 00:04:27,180
Utilizo lado 5 y 10

92
00:04:27,180 --> 00:04:29,459
Y luego lado 2 y 7

93
00:04:29,459 --> 00:04:32,240
¿Vale? Esto es un programa

94
00:04:32,240 --> 00:04:33,800
Algo parecido

95
00:04:33,800 --> 00:04:34,939
Hemos hecho al principio, ¿vale?

96
00:04:34,939 --> 00:04:36,000
Un programa muy sencillo

97
00:04:36,000 --> 00:04:38,680
Lo que noto es que está haciendo siempre lo mismo

98
00:04:38,680 --> 00:04:40,319
¿Vale? Entonces

99
00:04:40,319 --> 00:04:42,920
No tiene mucho sentido que yo vuelva a escribir

100
00:04:42,920 --> 00:04:43,939
Todo este código

101
00:04:43,939 --> 00:04:45,899
Si el código es el mismo

102
00:04:45,899 --> 00:04:48,060
La idea sería pillar este código de aquí

103
00:04:48,060 --> 00:04:50,740
Darle un nombre

104
00:04:50,740 --> 00:04:53,139
Y luego reutilizar

105
00:04:53,139 --> 00:04:54,259
Este código

106
00:04:54,259 --> 00:04:56,079
Utilizando una función

107
00:04:56,079 --> 00:04:58,480
O un procedimiento o lo que sea

108
00:04:58,480 --> 00:05:00,079
¿Vale? Ya luego veremos

109
00:05:00,079 --> 00:05:02,939
La diferencia entre procedimiento

110
00:05:02,939 --> 00:05:04,819
Y

111
00:05:04,819 --> 00:05:06,540
Función

112
00:05:06,540 --> 00:05:08,759
¿Vale? Entonces, por ejemplo, algo así

113
00:05:08,759 --> 00:05:13,420
Mi main se transforma en esta cosa aquí

114
00:05:13,420 --> 00:05:16,240
Yo tengo calcular el perímetro de 3, 4

115
00:05:16,240 --> 00:05:18,040
Calcular el perímetro de 5, 10

116
00:05:18,040 --> 00:05:20,139
Calcular el perímetro de 2, 6, 7

117
00:05:20,139 --> 00:05:24,740
Y esto, técnicamente, es más fácil de leer a nivel de main

118
00:05:24,740 --> 00:05:26,980
Con respecto al anterior

119
00:05:26,980 --> 00:05:29,639
Es mucho más organizado, ¿vale?

120
00:05:29,920 --> 00:05:31,519
Luego, ¿qué harán estas cosas?

121
00:05:31,639 --> 00:05:33,399
Pues si me interesa y lo quiero saber

122
00:05:33,399 --> 00:05:35,699
La voy a mirar, voy a mirar cuál es su implementación

123
00:05:35,699 --> 00:05:37,300
Ahora lo vamos a ver, ¿vale?

124
00:05:37,300 --> 00:05:40,399
Pero ya sé que esta línea de aquí

125
00:05:40,399 --> 00:05:42,279
Calcular el perímetro de 3, 4

126
00:05:42,279 --> 00:05:44,839
Me tiene que calcular el perímetro del rectángulo

127
00:05:44,839 --> 00:05:46,660
Que tiene el lado 3 y el lado 4

128
00:05:46,660 --> 00:05:48,060
¿Sí?

129
00:05:48,759 --> 00:05:49,220
¿Se entiende?

130
00:05:50,019 --> 00:05:50,860
¿Dudas hasta aquí?

131
00:05:52,699 --> 00:05:55,199
Vale, vamos a ver cómo declaro

132
00:05:55,199 --> 00:05:57,279
Cómo creo un nuevo método

133
00:05:57,279 --> 00:05:59,100
¿Vale? Por ejemplo, esto

134
00:05:59,100 --> 00:06:00,639
¿Métodos o funciones?

135
00:06:02,139 --> 00:06:05,540
En Java, funciones y procedimientos se llaman métodos

136
00:06:05,540 --> 00:06:06,100
¿Vale?

137
00:06:06,100 --> 00:06:09,259
Y están relacionados con la programación orientada a objetos

138
00:06:09,259 --> 00:06:12,060
Por lo tanto, cuando estaremos en programación orientada a objetos

139
00:06:12,060 --> 00:06:13,600
Todo esto serán métodos

140
00:06:13,600 --> 00:06:15,959
Métodos normales o métodos estáticos, ¿vale?

141
00:06:17,339 --> 00:06:21,019
En programación estructurada

142
00:06:21,019 --> 00:06:24,259
No es un método, sino es más bien funciones o procedimientos

143
00:06:24,259 --> 00:06:25,639
Que ahora veremos la diferencia, ¿vale?

144
00:06:25,660 --> 00:06:27,040
Depende de qué devuelve

145
00:06:27,040 --> 00:06:30,680
Si devuelve algo es una función, si no devuelve algo es un procedimiento, ¿vale?

146
00:06:31,079 --> 00:06:33,199
Si ahora me equivoco y uso método

147
00:06:33,199 --> 00:06:38,079
Pues por ahora lo utilizamos como sinónimo

148
00:06:38,079 --> 00:06:40,300
Al fin y al cabo el concepto es el mismo

149
00:06:40,300 --> 00:06:42,579
Es pillar un trozo de código

150
00:06:42,579 --> 00:06:44,980
Sacarlo fuera y darle un nombre

151
00:06:44,980 --> 00:06:45,839
Y parámetros

152
00:06:45,839 --> 00:06:46,600
¿Vale?

153
00:06:47,300 --> 00:06:48,519
Entonces si digo método

154
00:06:48,519 --> 00:06:50,959
Vosotros cambiadlo en vuestra cabeza

155
00:06:50,959 --> 00:06:53,220
Luego la grabación

156
00:06:53,220 --> 00:06:56,759
Pues no sé cómo cambiar la grabación

157
00:06:56,759 --> 00:06:58,079
Vale, entonces

158
00:06:58,079 --> 00:07:00,720
Este aquí es una función

159
00:07:00,720 --> 00:07:03,019
Vamos a crear una función

160
00:07:03,019 --> 00:07:06,519
Bueno, concretamente esto sería un procedimiento, ¿vale?

161
00:07:07,680 --> 00:07:11,379
Si os fijáis, estas palabras ya las hemos visto alguna vez, ¿vale?

162
00:07:11,480 --> 00:07:16,420
Porque cuando nosotros hemos hecho main, este es el método main, llamado en Java, ¿vale?

163
00:07:16,839 --> 00:07:20,379
Y es el punto de acceso a mi programa

164
00:07:20,379 --> 00:07:23,680
Y siempre nosotros poníamos delante un public static void

165
00:07:23,680 --> 00:07:26,680
¿Y qué son estas cosas? Ni idea, ¿vale?

166
00:07:26,680 --> 00:07:29,240
Hasta ahora la hemos puesto siempre así

167
00:07:29,240 --> 00:07:31,639
Y luego poníamos este string

168
00:07:31,639 --> 00:07:33,759
Paréntesis, paréntesis

169
00:07:33,759 --> 00:07:35,439
Arcs

170
00:07:35,439 --> 00:07:37,540
¿Y qué es eso? No tengo ni idea, ¿vale?

171
00:07:37,660 --> 00:07:38,699
Sí, lo sé, ¿vale?

172
00:07:38,959 --> 00:07:41,259
Pero por qué va allí, no lo sabía

173
00:07:41,259 --> 00:07:43,319
¿Sí? Ahora la idea es intentar

174
00:07:43,319 --> 00:07:45,360
Entender un poquito qué es esto

175
00:07:45,360 --> 00:07:47,279
¿Vale? Y luego crear cosas parecidas

176
00:07:47,279 --> 00:07:48,259
¿Sí?

177
00:07:51,259 --> 00:07:53,720
Voy también porque aquí hay muchas cosas

178
00:07:53,720 --> 00:07:55,019
Hay muchas cosas para entender

179
00:07:55,019 --> 00:07:57,319
Y algunas cosas son también complejas

180
00:07:57,319 --> 00:08:01,199
Por lo tanto, yo voy, por ahora, simplificando algunos temas

181
00:08:01,199 --> 00:08:03,220
Dejándolos a más para allá, ¿vale?

182
00:08:03,379 --> 00:08:04,939
Por ejemplo, el public inicial

183
00:08:04,939 --> 00:08:07,860
Public inicial no tiene mucho sentido

184
00:08:07,860 --> 00:08:12,360
Mientras que no trabajemos con objetos, clases y visibilidad de los objetos

185
00:08:12,360 --> 00:08:15,160
Por lo tanto, por ahora, nosotros este es public

186
00:08:15,160 --> 00:08:16,199
Es público

187
00:08:16,199 --> 00:08:18,399
Todos nos pueden ver y todos nos pueden utilizar

188
00:08:18,399 --> 00:08:20,019
Ya está, ¿vale?

189
00:08:20,920 --> 00:08:23,040
También sabemos que lo utilizamos en la clase

190
00:08:23,040 --> 00:08:24,560
Public clase prueba 3

191
00:08:24,560 --> 00:08:26,279
Y sabemos que si una clase es public

192
00:08:26,279 --> 00:08:27,800
O sea, si se ponga así

193
00:08:27,800 --> 00:08:30,500
Prueba 3 tiene que estar en un fichero

194
00:08:30,500 --> 00:08:32,580
Que se llama prueba3.java

195
00:08:32,580 --> 00:08:33,960
¿Sí? ¿Se acuerdan?

196
00:08:34,480 --> 00:08:36,620
Veremos en un futuro que yo puedo crear

197
00:08:36,620 --> 00:08:38,200
Clases no públicas

198
00:08:38,200 --> 00:08:40,879
Y esas pueden no estar

199
00:08:40,879 --> 00:08:42,120
En un fichero que se llama

200
00:08:42,120 --> 00:08:43,639
No sé qué punto ya

201
00:08:43,639 --> 00:08:45,679
¿Vale? Pero eso va a ser

202
00:08:45,679 --> 00:08:47,799
Static

203
00:08:47,799 --> 00:08:49,419
¿Qué es esto de static?

204
00:08:49,639 --> 00:08:52,179
También no lo podemos saber muy bien

205
00:08:52,179 --> 00:08:54,399
Sin saber el concepto de objeto

206
00:08:54,399 --> 00:08:56,059
De instancia de objeto y de clase

207
00:08:56,059 --> 00:08:59,600
¿Vale? No lo sabemos, no lo conocemos todavía, lo veremos en breve

208
00:08:59,600 --> 00:09:04,740
Por ahora simplemente sabemos que todos los métodos y funciones que vamos a crear

209
00:09:04,740 --> 00:09:06,679
Y procedimientos van a ser estáticos

210
00:09:06,679 --> 00:09:08,179
¿Vale? ¿Por qué?

211
00:09:08,960 --> 00:09:12,980
Lo tenemos que esperar un rato para entender por qué son estáticos

212
00:09:12,980 --> 00:09:14,879
¿Vale? Pero por ahora simplemente

213
00:09:14,879 --> 00:09:17,240
Como el main es estático

214
00:09:17,240 --> 00:09:19,620
¿Vale? Y no sé crear objetos

215
00:09:19,620 --> 00:09:22,299
He creado algunos objetos pero no sé muy bien qué son

216
00:09:22,299 --> 00:09:22,720
¿Vale?

217
00:09:22,720 --> 00:09:24,980
Pues entonces los métodos

218
00:09:24,980 --> 00:09:27,240
Estoy en un contexto estático

219
00:09:27,240 --> 00:09:29,500
O sea que esto es estático porque pone static

220
00:09:29,500 --> 00:09:32,659
Y entonces los métodos que puedo llamar

221
00:09:32,659 --> 00:09:34,039
Tienen que ser static también

222
00:09:34,039 --> 00:09:35,480
Por ahora sumamos así

223
00:09:35,480 --> 00:09:36,240
¿Vale?

224
00:09:37,399 --> 00:09:38,039
Perfecto

225
00:09:38,039 --> 00:09:41,019
De hecho, cuando escribís el nombre

226
00:09:41,019 --> 00:09:43,620
Si os fijáis, esto calcula área pedímetro

227
00:09:43,620 --> 00:09:45,659
Está como en cursiva

228
00:09:45,659 --> 00:09:46,480
¿Vale?

229
00:09:46,500 --> 00:09:47,940
Y esto es porque es un método estático

230
00:09:47,940 --> 00:09:49,580
Si no fuera un método estático

231
00:09:49,580 --> 00:09:50,899
No lo pondría en cursiva

232
00:09:50,899 --> 00:09:51,659
¿Vale?

233
00:09:51,659 --> 00:09:52,960
Pero bueno, por ahora

234
00:09:52,960 --> 00:09:55,019
Todos para nosotros pondremos static

235
00:09:55,019 --> 00:09:56,120
¿Vale? Fenómeno

236
00:09:56,120 --> 00:09:58,899
Tercera palabrita, esto ya nos interesa más

237
00:09:58,899 --> 00:09:59,559
Es void

238
00:09:59,559 --> 00:10:02,740
Void que en inglés quiere decir como

239
00:10:02,740 --> 00:10:04,240
Nada, vacío

240
00:10:04,240 --> 00:10:06,679
¿Vale? Es porque

241
00:10:06,679 --> 00:10:09,080
Estos métodos de aquí

242
00:10:09,080 --> 00:10:11,279
Que estamos viendo, estos procedimientos

243
00:10:11,279 --> 00:10:12,500
Concretamente que estamos viendo

244
00:10:12,500 --> 00:10:14,399
No devuelven nada

245
00:10:14,399 --> 00:10:17,159
Es decir, yo no me espero que al final

246
00:10:17,159 --> 00:10:18,100
De este trabajo

247
00:10:18,100 --> 00:10:20,779
Este método calcule algo

248
00:10:20,779 --> 00:10:22,480
Y me lo devuelva a mí

249
00:10:22,480 --> 00:10:23,960
¿A quién lo ha llamado?

250
00:10:24,379 --> 00:10:24,600
¿Vale?

251
00:10:24,980 --> 00:10:26,059
El método main

252
00:10:26,059 --> 00:10:27,299
Aquí llama

253
00:10:27,299 --> 00:10:28,019
¿Vale?

254
00:10:28,440 --> 00:10:31,440
El método calcula área, perímetro, 3 y 4

255
00:10:31,440 --> 00:10:32,899
Y no se espera

256
00:10:32,899 --> 00:10:34,779
Que este método de aquí

257
00:10:34,779 --> 00:10:36,440
Que este procedimiento

258
00:10:36,440 --> 00:10:39,559
Calcule algo y me lo devuelva

259
00:10:39,559 --> 00:10:40,340
Y me lo dé

260
00:10:40,340 --> 00:10:41,120
¿Vale?

261
00:10:41,480 --> 00:10:42,279
Hará algo

262
00:10:42,279 --> 00:10:44,960
Pero no me da el resultado

263
00:10:44,960 --> 00:10:47,240
Si me diera un resultado

264
00:10:47,240 --> 00:10:49,159
Yo podría hacer algo así

265
00:10:49,159 --> 00:10:52,159
No, aquí no lo puedo hacer

266
00:10:52,159 --> 00:10:55,639
Sí, esperad un segundo que pillo un

267
00:10:55,639 --> 00:10:57,620
Block de notas

268
00:10:57,620 --> 00:10:58,299
Para escribir

269
00:10:58,299 --> 00:11:01,539
Si

270
00:11:01,539 --> 00:11:05,159
Calcula área perímetro me diera

271
00:11:05,159 --> 00:11:07,419
Algo, yo podría esperarme

272
00:11:07,419 --> 00:11:09,399
Algo así, por ejemplo, imaginaos que

273
00:11:09,399 --> 00:11:11,379
Me espero un intero, pues podría hacer

274
00:11:11,379 --> 00:11:13,519
Int x es igual

275
00:11:13,519 --> 00:11:15,360
Es igual a

276
00:11:15,360 --> 00:11:17,179
Calcula área

277
00:11:17,179 --> 00:11:19,779
Y perímetro

278
00:11:19,779 --> 00:11:23,580
De 3 y 4

279
00:11:23,580 --> 00:11:26,299
¿Vale?

280
00:11:26,620 --> 00:11:28,539
Esta cosa de aquí sería, vale, ok

281
00:11:28,539 --> 00:11:30,240
Tú haz lo que tienes que hacer

282
00:11:30,240 --> 00:11:32,840
Al final calcularás algo

283
00:11:32,840 --> 00:11:34,419
Y este es algo

284
00:11:34,419 --> 00:11:36,100
Me lo devuelves

285
00:11:36,100 --> 00:11:38,379
Me lo das a mí, ¿vale?

286
00:11:38,679 --> 00:11:41,259
Entonces, el resultado de esta operación

287
00:11:41,259 --> 00:11:41,659
De aquí

288
00:11:41,659 --> 00:11:44,299
Lo guardas, por ejemplo, aquí dentro

289
00:11:44,299 --> 00:11:46,919
¿Sí? Y esto sería una función

290
00:11:46,919 --> 00:11:49,679
Para que esto pueda ser

291
00:11:49,679 --> 00:11:51,279
esto

292
00:11:51,279 --> 00:11:54,220
no puede ser

293
00:11:54,220 --> 00:11:55,320
void

294
00:11:55,320 --> 00:11:58,279
si esto es void

295
00:11:58,279 --> 00:11:59,980
quiere decir que no lo hace

296
00:11:59,980 --> 00:12:02,340
¿vale? no me da

297
00:12:02,340 --> 00:12:03,320
un resultado

298
00:12:03,320 --> 00:12:05,200
hace operaciones

299
00:12:05,200 --> 00:12:07,980
¿vale? pero no me devuelve

300
00:12:07,980 --> 00:12:08,740
un resultado

301
00:12:08,740 --> 00:12:11,340
¿se entiende esto?

302
00:12:12,100 --> 00:12:13,500
una función

303
00:12:13,500 --> 00:12:16,100
la diferencia que tiene con respecto al procedimiento

304
00:12:16,100 --> 00:12:17,740
es que si devuelve algo

305
00:12:17,740 --> 00:12:20,820
Es decir, una cosa como esta de aquí

306
00:12:20,820 --> 00:12:22,620
Que hemos visto ahora, que he escrito ahora

307
00:12:22,620 --> 00:12:27,059
Esta sería una función

308
00:12:27,059 --> 00:12:30,919
Porque después de haber hecho lo que sea

309
00:12:30,919 --> 00:12:31,899
No lo sé qué es

310
00:12:31,899 --> 00:12:33,980
Pues crea un entero

311
00:12:33,980 --> 00:12:36,100
Este entero me lo pasa a mí

312
00:12:36,100 --> 00:12:38,019
Que soy el que ha llamado este método

313
00:12:38,019 --> 00:12:38,620
¿Vale?

314
00:12:38,740 --> 00:12:40,080
Esto sería el main, por ejemplo

315
00:12:40,080 --> 00:12:44,159
Y este valor final se guarda dentro de x

316
00:12:44,159 --> 00:12:45,679
¿Sí?

317
00:12:45,679 --> 00:12:50,480
Podría también utilizarlo 3 más esta cosa aquí, ¿vale?

318
00:12:50,860 --> 00:13:00,980
Como este de aquí devuelve un entero, este es un int, le sumo 3 y el resultado lo pongo dentro de x, ¿vale?

319
00:13:01,100 --> 00:13:05,159
Esto sería del tipo que devuelve.

320
00:13:05,419 --> 00:13:07,220
Si devuelve un int, pues este sería un int.

321
00:13:07,779 --> 00:13:10,159
Si devuelve un boolean, pues este sería un boolean.

322
00:13:10,240 --> 00:13:11,500
Entonces esto no tendría sentido.

323
00:13:11,500 --> 00:13:13,460
Pero podría hacer

324
00:13:13,460 --> 00:13:15,039
Si esto devolviera un boolean

325
00:13:15,039 --> 00:13:16,960
Podría hacer un if

326
00:13:16,960 --> 00:13:18,740
Esta cosa de aquí

327
00:13:18,740 --> 00:13:22,450
Entonces haz algo

328
00:13:22,450 --> 00:13:24,210
Porque al final

329
00:13:24,210 --> 00:13:26,490
Después de haber hecho todo el trabajo

330
00:13:26,490 --> 00:13:28,370
Que haga esta cosa aquí, que no lo sé

331
00:13:28,370 --> 00:13:30,029
Me dará un true o un false

332
00:13:30,029 --> 00:13:31,769
¿De acuerdo?

333
00:13:32,730 --> 00:13:34,769
Si en vez es un procedimiento

334
00:13:34,769 --> 00:13:36,110
O sea que tiene void

335
00:13:36,110 --> 00:13:38,029
Esta cosa aquí no la puedo hacer

336
00:13:38,029 --> 00:13:40,090
Porque no me devuelve un valor

337
00:13:40,090 --> 00:13:41,830
Hace operaciones

338
00:13:41,830 --> 00:13:44,049
Hace lo que sea, escribe en pantalla

339
00:13:44,049 --> 00:13:45,029
Él, no lo sé

340
00:13:45,029 --> 00:13:46,629
Pero al final no me dice

341
00:13:46,629 --> 00:13:48,409
Y el valor calculado es esto

342
00:13:48,409 --> 00:13:52,549
¿Se entiende?

343
00:13:53,649 --> 00:13:54,210
¿Dudas?

344
00:13:56,409 --> 00:13:57,090
Vale, entonces

345
00:13:57,090 --> 00:13:59,210
Por ejemplo, en la que tenemos nosotros

346
00:13:59,210 --> 00:14:00,730
Como estos son void

347
00:14:00,730 --> 00:14:02,710
No puedo hacer una cosa así

348
00:14:02,710 --> 00:14:04,710
No puedo tampoco hacer

349
00:14:04,710 --> 00:14:06,149
Una cosa así

350
00:14:06,149 --> 00:14:08,590
Entre x es igual

351
00:14:08,590 --> 00:14:11,070
Oye, pero esto calcula el perímetro

352
00:14:11,070 --> 00:14:13,309
Pues esto tiene que ser un entero, un double

353
00:14:13,309 --> 00:14:18,899
Sí, pero por como está definido

354
00:14:18,899 --> 00:14:20,919
El valor que calcula

355
00:14:20,919 --> 00:14:23,220
Será él, por ejemplo, que lo escribe en pantalla

356
00:14:23,220 --> 00:14:25,600
O será él que hace lo que sea con ese valor

357
00:14:25,600 --> 00:14:27,100
Pero no te lo da a ti

358
00:14:27,100 --> 00:14:29,279
No te lo devuelve

359
00:14:29,279 --> 00:14:31,779
¿Dudas sobre esto?

360
00:14:32,899 --> 00:14:33,179
Vale

361
00:14:33,179 --> 00:14:37,600
Entonces, cuando un trozo de código con nombre

362
00:14:37,600 --> 00:14:39,220
No devuelve nada

363
00:14:39,220 --> 00:14:41,000
Se suele llamar procedimiento

364
00:14:41,000 --> 00:14:44,059
Cuando un trozo de código con nombre

365
00:14:44,059 --> 00:14:45,779
Devuelve algo

366
00:14:45,779 --> 00:14:46,940
Se suele llamar función

367
00:14:46,940 --> 00:14:49,720
Cuando un trozo de código

368
00:14:49,720 --> 00:14:51,740
Está asociado con un objeto

369
00:14:51,740 --> 00:14:53,639
Y trabaja con programación de un objeto

370
00:14:53,639 --> 00:14:54,580
Se suele llamar método

371
00:14:54,580 --> 00:14:56,039
Así simplificado

372
00:14:56,039 --> 00:14:57,679
¿Dudas?

373
00:14:58,320 --> 00:15:00,879
Y esta es la diferencia básica

374
00:15:00,879 --> 00:15:03,940
Entre función, procedimiento y método

375
00:15:03,940 --> 00:15:05,519
¿Dudas?

376
00:15:06,500 --> 00:15:07,659
En realidad en Java

377
00:15:07,659 --> 00:15:09,940
Como en Java estamos utilizando objetos siempre

378
00:15:09,940 --> 00:15:11,759
Pues todos son métodos

379
00:15:11,759 --> 00:15:12,000
¿Vale?

380
00:15:12,000 --> 00:15:16,700
Pero por ahora nosotros ignoramos la parte orientada a objetos de Java

381
00:15:16,700 --> 00:15:19,220
Y por lo tanto para nosotros son funciones

382
00:15:19,220 --> 00:15:21,759
Y si me decís que son métodos, me vale

383
00:15:21,759 --> 00:15:23,519
¿Dudas?

384
00:15:24,700 --> 00:15:25,059
¿Sigo?

385
00:15:25,820 --> 00:15:26,120
Vale

386
00:15:26,120 --> 00:15:28,580
Entonces, volvamos aquí

387
00:15:28,580 --> 00:15:30,220
Entonces tengo

388
00:15:30,220 --> 00:15:32,940
Public static, son así, por ahora

389
00:15:32,940 --> 00:15:35,740
Void, porque no devuelvo nada

390
00:15:35,740 --> 00:15:38,320
Veremos ejemplos después de cosas que devuelve

391
00:15:38,320 --> 00:15:38,720
¿Vale?

392
00:15:38,720 --> 00:15:43,399
Nombre que doy a este trozo de código, a esta función, a este procedimiento

393
00:15:43,399 --> 00:15:47,460
Y luego una lista de parámetros

394
00:15:47,460 --> 00:15:48,659
¿Vale?

395
00:15:49,059 --> 00:15:51,840
Estos son, cuando yo llamo a esta función de aquí

396
00:15:51,840 --> 00:15:54,299
Le daré una serie de valores

397
00:15:54,299 --> 00:15:56,120
Unos valores que son parámetros

398
00:15:56,120 --> 00:15:59,240
Son valores que parametrizan este procedimiento, esta función

399
00:15:59,240 --> 00:15:59,960
¿Vale?

400
00:16:00,639 --> 00:16:02,980
Entonces, ¿qué parámetros recibe?

401
00:16:02,980 --> 00:16:07,419
¿Qué necesita este trozo de código para poder funcionar?

402
00:16:07,419 --> 00:16:11,139
Para calcular el área y el perímetro, estamos hablando de rectángulos

403
00:16:11,139 --> 00:16:12,860
Pues entonces

404
00:16:12,860 --> 00:16:18,919
Vale, ahí, espera, yo no sé si está grabando o no

405
00:16:18,919 --> 00:16:19,960
Ahora tengo un problema

406
00:16:19,960 --> 00:16:23,179
Aquí pone pausar grabación

407
00:16:23,179 --> 00:16:25,080
Pongo que está grabando

408
00:16:25,080 --> 00:16:27,419
Esa es la bonita directa

409
00:16:27,419 --> 00:16:29,559
¿Lo pone para algún lado que está grabando?

410
00:16:30,419 --> 00:16:31,399
Espero que sí

411
00:16:31,399 --> 00:16:36,240
Sí, lo pone aquí, rec, vale, muy bien

412
00:16:36,240 --> 00:16:43,019
Entonces, para calcular el perímetro de un rectángulo

413
00:16:43,019 --> 00:16:44,399
Estamos trabajando en un rectángulo, ¿vale?

414
00:16:44,399 --> 00:16:48,779
Aquí a lo mejor habría sido interesante poner de rectángulo o algo por el estilo

415
00:16:48,779 --> 00:16:51,279
¿Para qué? Porque de un triángulo no sería esto, ¿vale?

416
00:16:51,279 --> 00:16:56,139
De un triángulo no necesito lado y lado, necesito otras cosas, base, altura o lo que sea

417
00:16:56,139 --> 00:16:59,720
¿Vale? Pero aquí estamos hablando de rectángulos, ¿vale?

418
00:16:59,840 --> 00:17:04,319
Por lo tanto, ¿qué necesito para calcular el área de un rectángulo y el perímetro de un rectángulo?

419
00:17:04,319 --> 00:17:07,160
Pues los lados, por lo tanto tengo estos dos parámetros

420
00:17:07,160 --> 00:17:08,440
Tengo el parámetro

421
00:17:08,440 --> 00:17:10,700
Lado 1 y lado 2

422
00:17:10,700 --> 00:17:11,500
¿Vale?

423
00:17:11,759 --> 00:17:13,599
Que son los dos lados distintos de un retangón

424
00:17:13,599 --> 00:17:15,980
Si fuera la área de un cuadrado

425
00:17:15,980 --> 00:17:19,200
El perímetro de un cuadrado

426
00:17:19,200 --> 00:17:20,579
Necesitaría un solo

427
00:17:20,579 --> 00:17:23,000
Entonces lado 2 no lo pondría

428
00:17:23,000 --> 00:17:24,539
Pondría lado, int lado

429
00:17:24,539 --> 00:17:26,900
Es más, si yo quiero que sea un double

430
00:17:26,900 --> 00:17:28,339
Pues pondría double lado 1

431
00:17:28,339 --> 00:17:29,559
Double lado 2

432
00:17:29,559 --> 00:17:32,779
Es más, si yo quiero saber también

433
00:17:32,779 --> 00:17:35,759
el color, pues pondría ahí

434
00:17:35,759 --> 00:17:37,559
int lado 1, int lado 2

435
00:17:37,559 --> 00:17:38,519
string color

436
00:17:38,519 --> 00:17:40,980
¿vale? lo que necesite

437
00:17:40,980 --> 00:17:43,279
para poder trabajar

438
00:17:43,279 --> 00:17:45,420
¿vale? entonces pienso en

439
00:17:45,420 --> 00:17:47,740
que va a hacer este procedimiento

440
00:17:47,740 --> 00:17:49,920
calcular el perímetro, vale, que necesito

441
00:17:49,920 --> 00:17:51,420
necesito lado y lado

442
00:17:51,420 --> 00:17:53,859
¿vale? ¿cuánto vale la de 1 y la de 2?

443
00:17:54,640 --> 00:17:55,359
ni idea

444
00:17:55,359 --> 00:17:57,180
¿vale?

445
00:17:57,180 --> 00:17:59,279
ahora mismo, en fase

446
00:17:59,279 --> 00:18:00,980
de creación de este

447
00:18:00,980 --> 00:18:03,119
Procedimiento, no tengo

448
00:18:03,119 --> 00:18:05,119
Idea de cuánto valga el lado 1

449
00:18:05,119 --> 00:18:06,940
Y cuánto valga el lado 2

450
00:18:06,940 --> 00:18:09,119
Son parámetros, son genéricos

451
00:18:10,119 --> 00:18:10,420
¿Vale?

452
00:18:10,859 --> 00:18:12,519
Yo ahora aquí dentro

453
00:18:12,519 --> 00:18:15,059
Los voy a utilizar como parámetros

454
00:18:15,059 --> 00:18:16,279
Como variables

455
00:18:16,279 --> 00:18:19,180
En el momento en que alguien

456
00:18:19,180 --> 00:18:21,380
Me llame, me dirá

457
00:18:21,380 --> 00:18:22,759
Cuánto vale el lado 1

458
00:18:22,759 --> 00:18:24,140
Y cuánto vale el lado 2

459
00:18:24,140 --> 00:18:28,259
¿Sí? ¿Me seguís?

460
00:18:29,059 --> 00:18:30,660
O sea, la clave de esto

461
00:18:30,660 --> 00:18:32,460
es que estoy abstraendo

462
00:18:32,460 --> 00:18:34,140
¿cuánto vale el lado 1? no lo sé

463
00:18:34,140 --> 00:18:36,700
vale el lado 1, cada vez que tengo

464
00:18:36,700 --> 00:18:38,920
que utilizar el lado 1, utilizaré el lado 1

465
00:18:38,920 --> 00:18:40,740
esta será una

466
00:18:40,740 --> 00:18:42,779
variable, una variable que existe dentro

467
00:18:42,779 --> 00:18:44,440
de mi método, dentro de mi función

468
00:18:44,440 --> 00:18:45,900
dentro de mi procedimiento

469
00:18:45,900 --> 00:18:48,200
¿vale? y que

470
00:18:48,200 --> 00:18:50,579
ahora mismo no vale nada

471
00:18:50,579 --> 00:18:52,460
en un futuro cuando

472
00:18:52,460 --> 00:18:54,859
alguien use este procedimiento

473
00:18:54,859 --> 00:18:56,380
me tendrá que decir

474
00:18:56,380 --> 00:18:58,920
cuánto vale el lado 1 y cuánto vale el lado 2

475
00:18:58,920 --> 00:19:00,460
y entonces yo aplicaré

476
00:19:00,460 --> 00:19:01,940
lo que viene aquí dentro

477
00:19:01,940 --> 00:19:03,859
utilizando los valores

478
00:19:03,859 --> 00:19:06,279
que me has dado tú en ese momento

479
00:19:06,279 --> 00:19:08,240
¿vale? que si os acordáis

480
00:19:08,240 --> 00:19:09,240
son estos

481
00:19:09,240 --> 00:19:12,240
cuando yo llamo

482
00:19:12,240 --> 00:19:14,740
calcular el perímetro de 3,4

483
00:19:14,740 --> 00:19:16,079
este 3

484
00:19:16,079 --> 00:19:18,460
se asocia al lado 1

485
00:19:18,460 --> 00:19:20,460
y este 4

486
00:19:20,460 --> 00:19:21,960
se asocia al lado 2

487
00:19:21,960 --> 00:19:24,460
entonces cuando

488
00:19:24,460 --> 00:19:26,279
aquí dentro encontraré el lado 1

489
00:19:26,279 --> 00:19:27,519
para mí es 3

490
00:19:27,519 --> 00:19:30,660
Y cuando encuentro el lado 2, para mí es 4

491
00:19:30,660 --> 00:19:35,779
Cuando después se vuelva a llamar esto con 5 y 10

492
00:19:35,779 --> 00:19:39,819
Vuelvo a hacer lo mismo, pero esta vez el lado 1 me vale 5

493
00:19:39,819 --> 00:19:41,700
Y el lado 2 me vale 10

494
00:19:41,700 --> 00:19:45,700
Por lo tanto, cuando hago esta operación de aquí, haré 5 multiplicado 10

495
00:19:45,700 --> 00:19:53,549
Estos se llaman parámetros formales

496
00:19:53,549 --> 00:19:57,710
Y estos son los parámetros actuales

497
00:19:57,710 --> 00:20:12,009
Estos parámetros formales son como la forma. No es un parámetro concreto, sino es la idea de ese parámetro. Lo vas a utilizar sin saber su valor actual, su valor real.

498
00:20:12,009 --> 00:20:24,009
En el momento en que se hace una llamada a este método de aquí o a este procedimiento, pues se tiene que instanciar los parámetros formales con valores actuales.

499
00:20:24,009 --> 00:20:33,349
En esta ejecución, el valor actual del parámetro lado 1 es 3

500
00:20:33,349 --> 00:20:37,890
Y el valor actual del parámetro lado 2 es 4

501
00:20:37,890 --> 00:20:39,710
¿Se entiende?

502
00:20:40,690 --> 00:20:41,609
¿Dudas?

503
00:20:43,049 --> 00:20:44,509
¿Y qué hago aquí dentro?

504
00:20:44,509 --> 00:20:48,329
Pues me creo int área de rectángulo es igual a lado 1 por lado 2

505
00:20:48,329 --> 00:20:51,690
Int perímetro es lado 1 por 2 más lado 2 por 2

506
00:20:51,690 --> 00:20:54,750
Y luego escribo el rectángulo de lado

507
00:20:54,750 --> 00:20:56,329
Lado 1 y lado 2

508
00:20:56,329 --> 00:20:59,609
Esto es el código que tenía antes

509
00:20:59,609 --> 00:21:00,309
¿Vale?

510
00:21:00,349 --> 00:21:02,069
El código que se repetía muchas veces

511
00:21:02,069 --> 00:21:03,829
Pues lo he copiado aquí

512
00:21:03,829 --> 00:21:06,789
Entonces cada vez que llamo

513
00:21:06,789 --> 00:21:07,809
Esta cosa de aquí

514
00:21:07,809 --> 00:21:09,589
Me ejecutará estas tres

515
00:21:09,589 --> 00:21:12,769
Funciones

516
00:21:12,769 --> 00:21:13,470
Estas tres

517
00:21:13,470 --> 00:21:15,430
Instrucciones

518
00:21:15,430 --> 00:21:18,750
Cada vez con un parámetro distinto

519
00:21:18,750 --> 00:21:20,890
Un parámetro distinto

520
00:21:20,890 --> 00:21:29,509
dudas habría podido hacer esto un poquito distinto es decir vale el

521
00:21:29,509 --> 00:21:34,069
resultado de esto aquí o sea este string de aquí lo es que aquí hay un string que

522
00:21:34,069 --> 00:21:38,430
dice el rectángulo de lado bla bla bla bla bla bla en vez de escribirlo tú

523
00:21:38,430 --> 00:21:45,529
directamente devuélveme lo entonces esto no habría sido una para un

524
00:21:45,529 --> 00:21:51,950
procedimiento habría sido una función y esto no habría escrito nada habría

525
00:21:51,950 --> 00:21:54,109
Calculado esta string de aquí

526
00:21:54,109 --> 00:21:55,910
Y luego la habría devuelta

527
00:21:55,910 --> 00:21:57,630
Aquí al

528
00:21:57,630 --> 00:21:59,769
Al main

529
00:21:59,769 --> 00:22:02,109
Que habría podido guardarla dentro de una string

530
00:22:02,109 --> 00:22:04,190
Por ejemplo, habría podido escribirla

531
00:22:04,190 --> 00:22:05,950
Él, no lo sé

532
00:22:05,950 --> 00:22:07,750
Habría utilizado esa cosa

533
00:22:07,750 --> 00:22:09,369
¿Vale? Pero no

534
00:22:09,369 --> 00:22:11,130
He querido que haga todo

535
00:22:11,130 --> 00:22:13,230
Este procedimiento

536
00:22:13,230 --> 00:22:14,250
Entonces, ¿cómo funciona?

537
00:22:14,769 --> 00:22:17,529
El main empieza, hace una llamada

538
00:22:17,529 --> 00:22:19,009
¿Vale? Hace una llamada

539
00:22:19,009 --> 00:22:21,069
Y aquí está el concepto de estructura de control

540
00:22:21,069 --> 00:22:23,730
Quiere decir que no sigo aquí debajo

541
00:22:23,730 --> 00:22:26,369
Sino que salto aquí

542
00:22:26,369 --> 00:22:31,069
Ejecuto estas tres líneas de código

543
00:22:31,069 --> 00:22:33,609
Luego vuelvo aquí

544
00:22:33,609 --> 00:22:36,069
Hay otra llamada

545
00:22:36,069 --> 00:22:37,710
Entonces vuelvo aquí

546
00:22:37,710 --> 00:22:39,730
Ejecuto estas tres líneas de código

547
00:22:39,730 --> 00:22:41,569
Pero esta vez con parámetros distintos

548
00:22:41,569 --> 00:22:42,930
Vuelvo aquí

549
00:22:42,930 --> 00:22:45,450
Otra llamada

550
00:22:45,450 --> 00:22:47,490
Vuelvo aquí, ejecuto estas tres

551
00:22:47,490 --> 00:22:49,190
Y vuelvo aquí, y acabo

552
00:22:49,190 --> 00:22:51,670
¿Dudas?

553
00:22:53,250 --> 00:22:54,250
¿Preguntas hasta aquí?

554
00:22:58,319 --> 00:22:59,880
Vale, sigamos adelante

555
00:22:59,880 --> 00:23:01,779
Procedimiento, ¿vale?

556
00:23:01,799 --> 00:23:04,859
Un procedimiento es un conjunto de instrucciones que cumplen una determinada tarea

557
00:23:04,859 --> 00:23:05,460
¿Vale?

558
00:23:05,640 --> 00:23:06,980
Entonces aquí la tarea ¿Cuál era?

559
00:23:07,119 --> 00:23:10,720
Era calcular área y perímetro

560
00:23:10,720 --> 00:23:10,980
¿Vale?

561
00:23:10,980 --> 00:23:11,980
Habría podido dividirlo

562
00:23:11,980 --> 00:23:19,920
Crear un método, una función o un procedimiento para crear el área

563
00:23:19,920 --> 00:23:22,099
y uno para calcular el perímetro

564
00:23:22,099 --> 00:23:23,720
y luego juntarlos de alguna forma

565
00:23:23,720 --> 00:23:25,660
eso depende a mi, yo tengo una tarea

566
00:23:25,660 --> 00:23:27,480
pues voy a crear toda

567
00:23:27,480 --> 00:23:29,559
voy a asociar

568
00:23:29,559 --> 00:23:31,500
todas las instrucciones necesarias

569
00:23:31,500 --> 00:23:33,779
para hacer esa determinada tarea a un nombre

570
00:23:33,779 --> 00:23:34,859
vale

571
00:23:34,859 --> 00:23:37,380
entonces luego cuando

572
00:23:37,380 --> 00:23:39,700
quiero hacer esa tarea

573
00:23:39,700 --> 00:23:41,019
pues simplemente llamo ese nombre

574
00:23:41,019 --> 00:23:43,460
con los parámetros que necesita para hacer

575
00:23:43,460 --> 00:23:45,480
esa tarea, si necesita tres parámetros

576
00:23:45,480 --> 00:23:47,440
ponde tres parámetros y si necesita cien

577
00:23:47,440 --> 00:23:48,799
parámetros pone cien parámetros

578
00:23:48,799 --> 00:23:52,059
Si necesita 100 parámetros, probablemente le daré un array

579
00:23:52,059 --> 00:23:54,579
¿Vale? Lo que haga falta

580
00:23:54,579 --> 00:23:58,700
Esta tarea puede depender de algunos valores, ¿vale?

581
00:23:58,720 --> 00:23:59,720
Llamados parámetros o no

582
00:23:59,720 --> 00:24:02,319
Como por ejemplo, calcula área de lado 1 y lado 2

583
00:24:02,319 --> 00:24:04,960
Saluda de esta cosa ahí o saluda nombre, ¿vale?

584
00:24:05,140 --> 00:24:07,839
Estos son llamadas a métodos, ¿vale?

585
00:24:08,160 --> 00:24:10,420
Calcula área, calculará una área

586
00:24:10,420 --> 00:24:12,480
Entonces necesita dos lados, por ejemplo

587
00:24:12,480 --> 00:24:15,019
Aquí hay otro método que no sé qué hace

588
00:24:15,019 --> 00:24:16,960
Saludará, dirá hola, ¿vale?

589
00:24:16,960 --> 00:24:20,700
Que si yo lo llamo saluda sin parámetros

590
00:24:20,700 --> 00:24:23,119
Como no sabe a quien tiene que ir a saludar

591
00:24:23,119 --> 00:24:24,759
Dirá hola

592
00:24:24,759 --> 00:24:25,000
¿Vale?

593
00:24:25,559 --> 00:24:29,799
Si en vez de llamo saluda y le paso un parámetro

594
00:24:29,799 --> 00:24:31,440
Que es nombre, ¿qué es nombre?

595
00:24:32,000 --> 00:24:35,420
Será una variable, una variable de tipo string por ejemplo

596
00:24:35,420 --> 00:24:37,519
Donde dentro he puesto el nombre mío, Estefano

597
00:24:37,519 --> 00:24:40,740
Pues ahora me dirá hola, Estefano

598
00:24:40,740 --> 00:24:42,259
¿Sí?

599
00:24:42,519 --> 00:24:44,660
Entonces este es el mismo método, entre comillas

600
00:24:44,660 --> 00:24:45,720
Son dos métodos distintos

601
00:24:45,720 --> 00:24:48,299
Son dos funciones distintas

602
00:24:48,299 --> 00:24:49,539
O procedimientos distintos

603
00:24:49,539 --> 00:24:51,420
Que hacen lo mismo

604
00:24:51,420 --> 00:24:53,079
Hacen la misma tarea

605
00:24:53,079 --> 00:24:54,380
Hacen la tarea de saludar

606
00:24:54,380 --> 00:24:56,099
Pero saluda sin parámetros

607
00:24:56,099 --> 00:24:57,759
Saluda genéricamente

608
00:24:57,759 --> 00:24:58,539
Hola usuario

609
00:24:58,539 --> 00:25:01,140
Y si en vez tú le has pasado

610
00:25:01,140 --> 00:25:02,400
Como se llama el usuario

611
00:25:02,400 --> 00:25:04,259
Pues te dirá hola y es tu nombre

612
00:25:04,259 --> 00:25:05,920
¿Se entiende?

613
00:25:06,680 --> 00:25:07,240
¿Dudas?

614
00:25:10,880 --> 00:25:12,220
¿Cómo se declara?

615
00:25:12,579 --> 00:25:13,660
Pues lo hemos visto

616
00:25:13,660 --> 00:25:15,440
Public static void

617
00:25:15,440 --> 00:25:17,460
Porque estamos hablando de procedimientos

618
00:25:17,460 --> 00:25:18,940
Entonces el procedimiento es void

619
00:25:18,940 --> 00:25:20,859
El nombre del procedimiento

620
00:25:20,859 --> 00:25:23,660
Y luego tipo 1, parámetro 1

621
00:25:23,660 --> 00:25:25,000
Tipo 2, parámetros 2

622
00:25:25,000 --> 00:25:26,259
Tipo 3, parámetros 3

623
00:25:26,259 --> 00:25:27,759
Cuidado, puede no tener ninguno

624
00:25:27,759 --> 00:25:32,299
Si yo hago un procedimiento que no necesita parámetros

625
00:25:32,299 --> 00:25:33,400
Pues no le pongo nada

626
00:25:33,400 --> 00:25:35,099
Abro paréntesis, cero paréntesis

627
00:25:35,099 --> 00:25:37,299
¿Dudas?

628
00:25:39,559 --> 00:25:41,559
¿Cómo se llama un procedimiento?

629
00:25:41,740 --> 00:25:42,819
Pues con el nombre

630
00:25:42,819 --> 00:25:45,599
Y luego una secuencia de valores

631
00:25:45,599 --> 00:25:48,880
Que se corresponderán con los parámetros que tengo aquí

632
00:25:48,880 --> 00:25:52,700
Si aquí tengo int, double, boolean

633
00:25:52,700 --> 00:25:57,140
Lo llamaré con un intero, coma, un booleano

634
00:25:57,140 --> 00:25:58,779
No, ¿qué era el segundo? Un double

635
00:25:58,779 --> 00:26:01,500
Segundo un double y tercero un booleano

636
00:26:01,500 --> 00:26:02,660
¿Sí?

637
00:26:02,859 --> 00:26:04,339
Tiene que ir en el mismo orden

638
00:26:04,339 --> 00:26:07,259
Si yo le he dicho int, int, boolean

639
00:26:07,259 --> 00:26:10,400
No puedo luego poner un booleano, un entero, un entero

640
00:26:10,400 --> 00:26:12,059
¿Vale? Porque se lía

641
00:26:12,059 --> 00:26:14,779
El primero tiene que ser el que me has dicho

642
00:26:14,779 --> 00:26:16,259
El segundo es el que me has dicho

643
00:26:16,259 --> 00:26:17,200
El tercero es el que me has dicho

644
00:26:17,200 --> 00:26:18,779
¿Vale? Para entendernos

645
00:26:18,779 --> 00:26:21,319
Yo aquí me espero dos int

646
00:26:21,319 --> 00:26:24,619
Si tú me llamas calcular el perímetro

647
00:26:24,619 --> 00:26:25,700
Con un int solo

648
00:26:25,700 --> 00:26:26,839
No va a funcionar

649
00:26:26,839 --> 00:26:28,299
Dice, me falta uno

650
00:26:28,299 --> 00:26:30,720
Si tú le das un boolean

651
00:26:30,720 --> 00:26:32,039
No te va a funcionar

652
00:26:32,039 --> 00:26:33,220
Dice, yo necesito un int

653
00:26:33,220 --> 00:26:35,940
¿Dudas?

654
00:26:39,089 --> 00:26:40,109
Creo que ahora vienen

655
00:26:40,109 --> 00:26:42,069
Aquí

656
00:26:42,069 --> 00:26:43,190
¿Ejemplos?

657
00:26:43,190 --> 00:26:44,809
Minúscula sería en...

658
00:26:44,809 --> 00:26:47,509
El nombre

659
00:26:47,509 --> 00:26:51,529
El nombre siempre empieza en la barra minúscula

660
00:26:51,529 --> 00:26:53,390
Se diferencian de las variables

661
00:26:53,390 --> 00:26:55,410
Los dos se ponen con minúscula

662
00:26:55,410 --> 00:26:57,690
Pero un método acaba con paréntesis

663
00:26:57,690 --> 00:26:58,910
Dentro de la variable no

664
00:26:58,910 --> 00:27:00,029
¿Vale?

665
00:27:02,769 --> 00:27:03,289
Ejemplo

666
00:27:03,289 --> 00:27:04,829
¿Vale?

667
00:27:05,250 --> 00:27:07,329
Aquí tengo mis dos métodos

668
00:27:07,329 --> 00:27:08,450
El método saluda

669
00:27:08,450 --> 00:27:11,369
Bueno, estos son procedimientos

670
00:27:11,369 --> 00:27:11,630
¿Vale?

671
00:27:13,289 --> 00:27:15,190
El método saluda que es un método

672
00:27:15,190 --> 00:27:17,329
Que no devuelve nada y dice hola a todos

673
00:27:17,329 --> 00:27:20,250
¿Por qué? Porque es genérico, no me pasa nada

674
00:27:20,250 --> 00:27:24,789
Si en vez de yo pongo saluda con un parámetro string nombre

675
00:27:24,789 --> 00:27:29,690
Lo que hace es hola y luego le pega detrás el nombre que tú me has dado

676
00:27:29,690 --> 00:27:33,069
Estas son las definiciones de los métodos

677
00:27:33,069 --> 00:27:34,809
¿Cómo se usan?

678
00:27:35,410 --> 00:27:37,049
Pues por ejemplo yo puedo llamar saluda

679
00:27:37,049 --> 00:27:40,069
Entonces saluda me llamaría este método de aquí

680
00:27:40,069 --> 00:27:43,089
El sin parámetros porque no le he puesto ningún parámetros

681
00:27:43,089 --> 00:27:45,230
Y me escribiría hola a todos

682
00:27:45,230 --> 00:27:47,549
Luego llamo saluda

683
00:27:47,549 --> 00:27:48,470
Estefano

684
00:27:48,470 --> 00:27:51,150
Y lo que me hace, me llama este de aquí

685
00:27:51,150 --> 00:27:52,490
Porque le he pasado un string

686
00:27:52,490 --> 00:27:55,150
Entonces me pondría hola, espacio, Estefano

687
00:27:55,150 --> 00:27:57,210
Y luego, fijaos aquí

688
00:27:57,210 --> 00:27:58,769
Yo creo una variable string

689
00:27:58,769 --> 00:28:00,309
Que tenga dentro Paco

690
00:28:00,309 --> 00:28:02,150
Y luego llamo saluda de n

691
00:28:02,150 --> 00:28:04,450
Como este n es un string

692
00:28:04,450 --> 00:28:05,869
Pues me llama este de aquí

693
00:28:05,869 --> 00:28:07,490
¿Vale?

694
00:28:08,109 --> 00:28:09,650
Asociaría nombre

695
00:28:09,650 --> 00:28:11,750
El parámetro formal nombre

696
00:28:11,750 --> 00:28:13,769
Con el valor actual n

697
00:28:13,769 --> 00:28:15,690
Que en verdad es una variable

698
00:28:15,690 --> 00:28:16,769
Que tiene dentro pago

699
00:28:16,769 --> 00:28:18,710
Por lo tanto ahora nombre vale pago

700
00:28:18,710 --> 00:28:20,130
Justo

701
00:28:20,130 --> 00:28:22,650
Y me diría hola pago

702
00:28:22,650 --> 00:28:25,880
¿Dudas?

703
00:28:28,980 --> 00:28:30,220
Más ejemplos

704
00:28:30,220 --> 00:28:34,519
Por ejemplo, y aquí tengo un repite saludo

705
00:28:34,519 --> 00:28:36,640
Que pilla dos parámetros

706
00:28:36,640 --> 00:28:37,799
Un nombre

707
00:28:37,799 --> 00:28:39,740
Y cuántas repeticiones

708
00:28:39,740 --> 00:28:40,980
¿Vale?

709
00:28:41,279 --> 00:28:43,500
Entonces me dice, desde igual a cero

710
00:28:43,500 --> 00:28:45,400
Y menor de repeticiones y más más

711
00:28:45,400 --> 00:28:48,079
O sea, por repeticiones veces

712
00:28:48,079 --> 00:28:52,079
Lo que haces es decir hola el nombre

713
00:28:52,079 --> 00:28:54,220
Entonces este de aquí es un método solo

714
00:28:54,220 --> 00:28:55,980
Que cuando lo llamo con Luis

715
00:28:55,980 --> 00:28:58,799
Pues me dirá hola Luis, hola Luis, hola Luis, hola Luis

716
00:28:58,799 --> 00:29:00,579
Tantas veces cuanto lo he puesto aquí

717
00:29:00,579 --> 00:29:01,420
Por ejemplo 4

718
00:29:01,420 --> 00:29:06,519
Fijaos que necesita un string y un int

719
00:29:06,519 --> 00:29:09,579
Pues yo cuando lo llamo string e int

720
00:29:09,579 --> 00:29:11,920
¿Podría ser esta una variable tipo string?

721
00:29:12,059 --> 00:29:12,220
Sí

722
00:29:12,220 --> 00:29:15,440
¿Podría ser esta una variable tipo int?

723
00:29:15,599 --> 00:29:15,819
Sí

724
00:29:15,819 --> 00:29:18,680
¿Podría ser esto de aquí el resultado de una operación?

725
00:29:18,980 --> 00:29:19,200
Sí

726
00:29:19,200 --> 00:29:21,279
¿Con qué sea un int el resultado de la operación?

727
00:29:21,559 --> 00:29:21,839
Sí

728
00:29:21,839 --> 00:29:25,880
¿Podría ser esto una posición de un array de string?

729
00:29:26,039 --> 00:29:26,279
Sí

730
00:29:26,279 --> 00:29:29,920
Todo lo que tenga tipo string puede ir aquí

731
00:29:29,920 --> 00:29:33,380
Y todo lo que tenga tipo int puede ir aquí

732
00:29:33,380 --> 00:29:36,319
Y se utilizará aquí con su valor y su valor

733
00:29:36,319 --> 00:29:37,839
¿Dudas?

734
00:29:39,099 --> 00:29:39,579
¿Preguntas?

735
00:29:46,079 --> 00:29:48,240
Se puede usar también para ordenar el código

736
00:29:48,240 --> 00:29:49,380
Hacerlo más leíble, ¿vale?

737
00:29:49,380 --> 00:29:50,920
Lo que decíamos antes

738
00:29:50,920 --> 00:29:53,059
Vale, aquí se me han colado dos puntos

739
00:29:53,059 --> 00:29:53,299
Pero

740
00:29:53,299 --> 00:29:56,059
Imaginamos que yo tengo un main

741
00:29:56,059 --> 00:29:58,660
En vez de tener todo el código allí

742
00:29:58,660 --> 00:30:00,299
Metido

743
00:30:00,299 --> 00:30:01,420
Pues tengo un método

744
00:30:01,420 --> 00:30:02,640
Inicializa el sistema

745
00:30:02,640 --> 00:30:03,839
Calcula datos

746
00:30:03,839 --> 00:30:04,740
Escribe resultados

747
00:30:04,740 --> 00:30:05,960
Esto ya sé

748
00:30:05,960 --> 00:30:08,319
Que mi main hará tres pasos

749
00:30:08,319 --> 00:30:11,599
Iniciará el sistema con lo que tiene que inicializar

750
00:30:11,599 --> 00:30:12,920
Luego después

751
00:30:12,920 --> 00:30:14,220
Calculará los datos

752
00:30:14,220 --> 00:30:16,059
Y hará las operaciones que tiene que hacer

753
00:30:16,059 --> 00:30:16,900
Y al final

754
00:30:16,900 --> 00:30:19,059
Los resultados me los escribirá de alguna forma

755
00:30:19,059 --> 00:30:21,099
¿Cómo se hacen estas tres cosas?

756
00:30:21,579 --> 00:30:24,339
Pues estarán aquí, aquí y aquí

757
00:30:24,339 --> 00:30:26,019
No lo sé, aquí le he metido comentarios

758
00:30:26,019 --> 00:30:28,299
Lo tengo que implementar

759
00:30:28,299 --> 00:30:31,319
¿Por qué esto es interesante?

760
00:30:31,680 --> 00:30:35,140
Primero porque si a mí no me interesa cómo se hacen las cosas

761
00:30:35,140 --> 00:30:38,160
Sino lo que se está haciendo, me leo solo esto

762
00:30:38,160 --> 00:30:41,059
Aquí está escrito lo que se está haciendo

763
00:30:41,059 --> 00:30:42,000
¿Cómo se hace?

764
00:30:42,500 --> 00:30:43,079
No me importa

765
00:30:43,079 --> 00:30:45,380
Otra cosa

766
00:30:45,380 --> 00:30:47,859
En términos de trabajo

767
00:30:47,859 --> 00:30:49,140
Yo podría

768
00:30:49,140 --> 00:30:51,099
Pillar distintos

769
00:30:51,099 --> 00:30:53,460
Grupos de trabajo, distintos

770
00:30:53,460 --> 00:30:55,599
Empleados y decirle, mira, oye, tú

771
00:30:55,599 --> 00:30:58,119
Te encargas de la inicialización de sistemas

772
00:30:58,119 --> 00:30:59,900
Rellena este método

773
00:30:59,900 --> 00:31:00,299
De aquí

774
00:31:00,299 --> 00:31:03,660
Otro grupo, este método de aquí

775
00:31:03,660 --> 00:31:04,839
Otro grupo, este método de aquí

776
00:31:04,839 --> 00:31:06,279
Os voy a dar las

777
00:31:06,279 --> 00:31:09,680
Especificaciones de cómo

778
00:31:09,680 --> 00:31:12,079
Qué tiene que hacer cada uno de estos

779
00:31:12,079 --> 00:31:12,619
¿Vale?

780
00:31:13,220 --> 00:31:14,619
Inicialización de sistemas tiene que

781
00:31:14,619 --> 00:31:16,140
Inicializar un array

782
00:31:16,140 --> 00:31:18,720
meter los nombres de los

783
00:31:18,720 --> 00:31:20,660
clientes, hacer no sé qué

784
00:31:20,660 --> 00:31:22,440
cuánto, vale, calcular datos

785
00:31:22,440 --> 00:31:24,480
¿qué tiene que hacer? se espera que un array

786
00:31:24,480 --> 00:31:26,420
ya esté inicializado, porque

787
00:31:26,420 --> 00:31:27,700
aquí es donde se inicializa

788
00:31:27,700 --> 00:31:30,539
y lo que hace es pillar los nombres

789
00:31:30,539 --> 00:31:32,599
de los clientes, añadirle

790
00:31:32,599 --> 00:31:34,259
un código, no sé qué, no sé cuánto

791
00:31:34,259 --> 00:31:36,319
¿y qué tiene que hacer este aquí? pues se espera

792
00:31:36,319 --> 00:31:38,380
que el proceso

793
00:31:38,380 --> 00:31:40,240
ya haya acabado, ya esté

794
00:31:40,240 --> 00:31:42,579
el resultado final y tiene que imprimir

795
00:31:42,579 --> 00:31:44,480
los resultados, vale, y en un cierto

796
00:31:44,480 --> 00:31:46,920
sentido puedo separar el trabajo entre ellos

797
00:31:46,920 --> 00:31:50,480
dudas

798
00:31:50,480 --> 00:31:52,660
fijaos que son todos

799
00:31:52,660 --> 00:31:53,740
void, son todos proceeding

800
00:31:53,740 --> 00:31:56,319
vale, entonces

801
00:31:56,319 --> 00:31:58,839
la idea

802
00:31:58,839 --> 00:32:00,299
es, por un lado

803
00:32:00,299 --> 00:32:02,539
ordenar el código y hacerlo más leíble

804
00:32:02,539 --> 00:32:04,720
y ser más fácil, por otro lado

805
00:32:04,720 --> 00:32:05,880
generalizar

806
00:32:05,880 --> 00:32:08,460
los trabajos, vale

807
00:32:08,460 --> 00:32:10,660
en vez de hacer mil veces lo mismo

808
00:32:10,660 --> 00:32:12,640
pues generalizo

809
00:32:12,640 --> 00:32:14,200
la operación que estoy haciendo

810
00:32:14,200 --> 00:32:17,440
Y pongo un método que me generaliza

811
00:32:17,440 --> 00:32:18,740
Esa operación

812
00:32:18,740 --> 00:32:20,819
Y luego llamo ese método todas las veces que quiero

813
00:32:20,819 --> 00:32:23,440
Parametrizado

814
00:32:23,440 --> 00:32:25,480
¿Dudas?

815
00:32:29,549 --> 00:32:30,589
¿Entonces qué es una función?

816
00:32:30,890 --> 00:32:31,549
Pues lo mismo

817
00:32:31,549 --> 00:32:33,549
Pero os repito que la función

818
00:32:33,549 --> 00:32:35,210
Al final de todo

819
00:32:35,210 --> 00:32:37,369
Ha calculado algo

820
00:32:37,369 --> 00:32:39,490
Ha calculado un entero, ha calculado un double

821
00:32:39,490 --> 00:32:42,369
Ha calculado un objeto, ha calculado algo

822
00:32:42,369 --> 00:32:44,130
Y esa cosa

823
00:32:44,130 --> 00:32:45,910
Me la devuelve a mí

824
00:32:45,910 --> 00:32:48,049
¿A quién? ¿A quién la he llamado?

825
00:32:48,630 --> 00:32:51,349
Si lo habéis entendido, aquí hay dos cosas

826
00:32:51,349 --> 00:32:56,769
Hay por un lado donde se declara el método, la función o el procedimiento

827
00:32:56,769 --> 00:33:02,930
Y por otro lado donde se llama ese método, función o procedimiento

828
00:33:02,930 --> 00:33:05,670
Esto es una llamada a un procedimiento

829
00:33:05,670 --> 00:33:07,930
Esta es la definición de procedimiento

830
00:33:07,930 --> 00:33:12,069
Entonces la idea es que como es un procedimiento, como es void

831
00:33:12,069 --> 00:33:14,450
No me espero que me devuelva nada

832
00:33:14,450 --> 00:33:16,009
Entonces lo llamo y ya está

833
00:33:16,009 --> 00:33:19,950
Si me esperara que esto calcula algo

834
00:33:19,950 --> 00:33:22,789
Y luego me devuelve a mí que lo estoy llamando

835
00:33:22,789 --> 00:33:26,910
Un valor, pues entonces este valor tendría que hacer algo con él

836
00:33:26,910 --> 00:33:29,970
Guardarlo en una variable, utilizarlo en un if

837
00:33:29,970 --> 00:33:34,190
Ponerlo dentro de un array, no lo sé

838
00:33:34,190 --> 00:33:36,390
¿Vale? Pero algo tendría que hacer con él

839
00:33:36,390 --> 00:33:40,250
Si no, calculo el valor del área

840
00:33:40,250 --> 00:33:43,089
Y luego este valor calculado, pues lo pierdo

841
00:33:43,089 --> 00:33:45,650
Si no lo guardo por algún lado para utilizarlo

842
00:33:45,650 --> 00:33:47,849
Pues lo pierdo, o lo imprimo directamente en pantalla

843
00:33:47,849 --> 00:33:48,730
¿Vale? Fenomenal

844
00:33:48,730 --> 00:33:50,630
O si no lo pierdo, ¿vale?

845
00:33:51,529 --> 00:33:53,230
Entonces, vamos a ver ejemplos

846
00:33:53,230 --> 00:33:57,690
Por ejemplo, estas son llamadas

847
00:33:57,690 --> 00:33:59,210
De funciones, ¿vale?

848
00:34:00,349 --> 00:34:01,869
Intarea es igual a

849
00:34:01,869 --> 00:34:03,450
Calcular área del lado 1 al lado 2

850
00:34:03,450 --> 00:34:05,710
Me espero que calcular área sea una función

851
00:34:05,710 --> 00:34:07,650
Pille el lado 1, pille el lado 2

852
00:34:07,650 --> 00:34:09,750
Haga los cálculos y el resultado

853
00:34:09,750 --> 00:34:11,070
De esto que es el área

854
00:34:11,070 --> 00:34:12,750
Me lo guardo en intarea

855
00:34:12,750 --> 00:34:16,630
A este punto puedo hacer un system.auto.println

856
00:34:16,630 --> 00:34:18,449
El área del cuadrado

857
00:34:18,449 --> 00:34:19,949
El área del rectángulo es

858
00:34:19,949 --> 00:34:21,909
Área, porque lo tengo allí

859
00:34:21,909 --> 00:34:22,349
¿Vale?

860
00:34:22,849 --> 00:34:25,230
O crea saludo de un nombre

861
00:34:25,230 --> 00:34:27,389
Entonces, antes me escribía directamente

862
00:34:27,389 --> 00:34:29,090
Hola en pantalla, pues ahora no

863
00:34:29,090 --> 00:34:31,849
Ahora me crea un string con escrito dentro

864
00:34:31,849 --> 00:34:33,889
Hola y el nombre, hola Stefano

865
00:34:33,889 --> 00:34:36,349
Y este string me lo devuelve

866
00:34:36,349 --> 00:34:37,230
A mí que lo he llamado

867
00:34:37,230 --> 00:34:40,570
Y yo me lo guardo en una variable tipo string

868
00:34:40,570 --> 00:34:44,639
Y luego lo uso

869
00:34:44,639 --> 00:34:51,699
Como se declara

870
00:34:51,699 --> 00:34:53,440
Una función

871
00:34:53,440 --> 00:34:56,059
Exactamente igual que antes un procedimiento

872
00:34:56,059 --> 00:34:57,539
La única cosa que cambia

873
00:34:57,539 --> 00:35:00,019
Es que el tipo devuelto ahora no es void

874
00:35:00,019 --> 00:35:02,559
Pero es el tipo de lo que me espero que me devuelva

875
00:35:02,559 --> 00:35:04,559
Es un cálculo que al final

876
00:35:04,559 --> 00:35:05,400
Devuelve un int

877
00:35:05,400 --> 00:35:06,559
Pues aquí pondré int

878
00:35:06,559 --> 00:35:09,000
Quiero al final me da un double

879
00:35:09,000 --> 00:35:10,119
Pues aquí pondré double

880
00:35:10,119 --> 00:35:12,679
Da un boolean, boolean, da un string, string

881
00:35:12,679 --> 00:35:17,960
Y el resto es igual, el nombre y los tipos de parámetros que necesita para trabajar

882
00:35:17,960 --> 00:35:20,860
¿Cómo se llama?

883
00:35:21,760 --> 00:35:27,000
Pues se llama igual, nombre con tipo valor, valor, valor, igual al otro

884
00:35:27,000 --> 00:35:31,840
Solo que normalmente el resultado se guarda en una variable para utilizarlo

885
00:35:31,840 --> 00:35:38,820
Si la variable es nueva, la declaro, int x es igual a lo que de esto

886
00:35:38,820 --> 00:35:40,840
Y si en vez lo había ya creado antes

887
00:35:40,840 --> 00:35:42,300
Pues puedo hacer x igual

888
00:35:42,300 --> 00:35:43,920
Lo que sea

889
00:35:43,920 --> 00:35:45,500
¿Sí?

890
00:35:45,659 --> 00:35:47,139
O lo puedo usar directamente

891
00:35:47,139 --> 00:35:48,320
¿Sí?

892
00:35:48,619 --> 00:35:49,780
Ahora le damos ejemplo

893
00:35:49,780 --> 00:35:53,840
Por ejemplo aquí

894
00:35:53,840 --> 00:35:54,480
¿Vale?

895
00:35:54,659 --> 00:35:55,179
Fijaos

896
00:35:55,179 --> 00:35:56,760
Ahora ha cambiado saluda

897
00:35:56,760 --> 00:35:58,800
Ahora ya no es un procedimiento

898
00:35:58,800 --> 00:36:00,679
Es una función porque aquí tiene string

899
00:36:00,679 --> 00:36:03,340
Me espero que al final

900
00:36:03,340 --> 00:36:05,360
Me devuelva un string

901
00:36:05,360 --> 00:36:06,699
¿Vale?

902
00:36:07,320 --> 00:36:08,400
Entonces ¿Cómo lo hago?

903
00:36:08,460 --> 00:36:09,360
Por ejemplo esto de aquí

904
00:36:09,360 --> 00:36:11,840
saluda, pilla como parámetros un nombre

905
00:36:11,840 --> 00:36:13,900
fijaos que ahora no lo escribe

906
00:36:13,900 --> 00:36:15,579
lo que crea es

907
00:36:15,579 --> 00:36:17,400
hola más nombre

908
00:36:17,400 --> 00:36:18,920
crea este string

909
00:36:18,920 --> 00:36:21,739
lo guarda dentro de la variable

910
00:36:21,739 --> 00:36:23,860
resultado que es de tipo

911
00:36:23,860 --> 00:36:24,340
string

912
00:36:24,340 --> 00:36:27,760
y luego palabra reservada

913
00:36:27,760 --> 00:36:29,860
return resultado

914
00:36:29,860 --> 00:36:31,480
esto es el concepto de

915
00:36:31,480 --> 00:36:33,360
devuelve resultado

916
00:36:33,360 --> 00:36:35,659
lo que hace esta función

917
00:36:35,659 --> 00:36:38,099
es pillar estos parámetros

918
00:36:38,099 --> 00:36:39,800
Construirme un string

919
00:36:39,800 --> 00:36:41,300
Y este string me lo devuelve

920
00:36:41,300 --> 00:36:44,340
Si yo no pongo esta cosa de aquí

921
00:36:44,340 --> 00:36:45,920
Y he puesto

922
00:36:45,920 --> 00:36:48,059
String aquí, me da un error

923
00:36:48,059 --> 00:36:49,820
Me dice, oye mira

924
00:36:49,820 --> 00:36:51,219
Tú has dicho que devuelve un string

925
00:36:51,219 --> 00:36:52,980
Pero no has hecho return de nada

926
00:36:52,980 --> 00:36:54,599
¿Vale?

927
00:36:56,389 --> 00:36:57,469
¿Y cómo lo uso?

928
00:36:57,969 --> 00:36:59,750
Por ejemplo, string saludo1

929
00:36:59,750 --> 00:37:01,670
Es igual a saludaStéfano

930
00:37:01,670 --> 00:37:03,030
¿Vale?

931
00:37:03,469 --> 00:37:05,989
Fijaos que el resultado de esta cosa de aquí

932
00:37:05,989 --> 00:37:07,389
Me lo guardo en saludo1

933
00:37:07,389 --> 00:37:11,170
O tengo una string Paco

934
00:37:11,170 --> 00:37:14,269
Tengo otro string que es saludo2

935
00:37:14,269 --> 00:37:17,309
Que es igual a saluda de esta variable de aquí

936
00:37:17,309 --> 00:37:19,210
Entonces, ¿cuánto vale saluda1?

937
00:37:23,820 --> 00:37:24,059
No

938
00:37:24,059 --> 00:37:25,980
Hola, Estefano

939
00:37:25,980 --> 00:37:27,980
¿Y cuánto vale saluda2?

940
00:37:28,659 --> 00:37:29,659
Hola, Paco

941
00:37:29,659 --> 00:37:31,360
Y luego los imprimo en pantalla

942
00:37:31,360 --> 00:37:34,760
¿Sí?

943
00:37:35,340 --> 00:37:36,460
Diferencia de antes

944
00:37:36,460 --> 00:37:38,980
Es que antes, cuando hacía saluda a Estefano

945
00:37:38,980 --> 00:37:41,559
Como procedimiento, no lo puedo guardar en una variable

946
00:37:41,559 --> 00:37:48,659
Y ahora sí, porque el resultado de este de aquí es que me devuelve a mí un valor que es un string

947
00:37:48,659 --> 00:37:50,219
¿Cómo lo sé? De esto

948
00:37:50,219 --> 00:37:57,300
¿Podría hacer int saludo1 igual a saludo a Estefano?

949
00:37:57,659 --> 00:38:01,340
No, porque el resultado de esta operación no es un int

950
00:38:01,340 --> 00:38:05,199
Es un string, entonces no lo puedo guardar en una variable int

951
00:38:05,199 --> 00:38:08,739
¿Verdad?

952
00:38:10,139 --> 00:38:10,699
¿Dudas?

953
00:38:14,579 --> 00:38:16,300
Más ejemplos

954
00:38:16,300 --> 00:38:21,090
¿Qué es esta cosa aquí?

955
00:38:29,760 --> 00:38:32,400
Es una función que se llama repiteSaludo

956
00:38:32,400 --> 00:38:37,059
Pilla como parámetros un nombre y repeticiones

957
00:38:37,059 --> 00:38:39,480
Y devuelve una string

958
00:38:39,480 --> 00:38:40,900
¿Vale?

959
00:38:41,260 --> 00:38:42,260
¿Qué hace dentro?

960
00:38:42,900 --> 00:38:44,000
Crea un string vacío

961
00:38:44,000 --> 00:38:47,199
Por repeticiones veces

962
00:38:47,199 --> 00:38:50,719
Lo que hace es concatenar al resultado

963
00:38:50,719 --> 00:38:54,159
Hola y un nombre más un espacio

964
00:38:54,159 --> 00:38:55,280
¿Vale?

965
00:38:55,280 --> 00:38:58,019
Y lo guarda otra vez en resultado

966
00:38:58,019 --> 00:39:00,639
Entonces irá pegando

967
00:39:00,639 --> 00:39:03,019
Hola y el nombre que me has pasado

968
00:39:03,019 --> 00:39:04,880
Espacio, hola y el nombre que me has pegado

969
00:39:04,880 --> 00:39:06,500
Espacio, hola y el nombre que me has pasado

970
00:39:06,500 --> 00:39:07,460
Etcétera, etcétera, etcétera

971
00:39:07,460 --> 00:39:10,659
Un cierto número de repeticiones veces

972
00:39:10,659 --> 00:39:12,280
¿Sí?

973
00:39:13,360 --> 00:39:15,099
Entonces, ¿cómo se llama esto?

974
00:39:15,440 --> 00:39:17,460
Por ejemplo, digo string saludos

975
00:39:17,460 --> 00:39:22,079
Es igual, repite saludos de Luis,4

976
00:39:22,079 --> 00:39:24,340
Entonces, ¿qué hace esto?

977
00:39:24,340 --> 00:39:26,679
Pues repite cuatro veces

978
00:39:26,679 --> 00:39:28,019
Hola Luis

979
00:39:28,019 --> 00:39:28,900
Es fácil

980
00:39:28,900 --> 00:39:31,579
Lo concatena todo

981
00:39:31,579 --> 00:39:33,039
Y no lo escribe en pantalla

982
00:39:33,039 --> 00:39:35,400
Me da esa cadena

983
00:39:35,400 --> 00:39:36,119
¿Vale?

984
00:39:36,360 --> 00:39:38,000
Y esa cadena yo la guardo

985
00:39:38,000 --> 00:39:39,400
En esta variable de aquí

986
00:39:39,400 --> 00:39:41,679
Y ahora puedo utilizar esa variable de aquí

987
00:39:41,679 --> 00:39:42,400
Como me da la gana

988
00:39:42,400 --> 00:39:43,420
Como por ejemplo

989
00:39:43,420 --> 00:39:44,400
Imprimirla en pantalla

990
00:39:44,400 --> 00:39:48,719
Duda para vosotros

991
00:39:48,719 --> 00:39:49,920
Entonces eso quiere decir

992
00:39:49,920 --> 00:39:52,099
Que una función no puede imprimir en pantalla

993
00:39:52,099 --> 00:39:56,449
Puede, tranquilamente

994
00:39:56,449 --> 00:39:59,989
La diferencia es que al final me tiene que devolver algo

995
00:39:59,989 --> 00:40:03,329
Me puede hasta devolver una cadera vacía

996
00:40:03,329 --> 00:40:04,849
Pero me tiene que devolver un string

997
00:40:04,849 --> 00:40:06,050
¿Por qué? Porque lo dice aquí

998
00:40:06,050 --> 00:40:10,030
Está claro que si hace mil cosas

999
00:40:10,030 --> 00:40:11,909
Y luego me devuelve algo inútil

1000
00:40:11,909 --> 00:40:13,670
Entonces no es una función

1001
00:40:13,670 --> 00:40:15,070
Es un procedimiento

1002
00:40:15,070 --> 00:40:17,369
Entonces aquí le pongo void y ya está

1003
00:40:17,369 --> 00:40:19,670
¿Sí o no?

1004
00:40:20,949 --> 00:40:23,570
Fijaos también que después de haberlo creado la string

1005
00:40:23,570 --> 00:40:24,769
Me lo devuelve

1006
00:40:24,769 --> 00:40:28,190
¿Vale? Necesito un return

1007
00:40:28,190 --> 00:40:30,269
Si aquí no he puesto void

1008
00:40:30,269 --> 00:40:31,769
Necesito un return

1009
00:40:31,769 --> 00:40:33,869
Porque es lo que me devuelve

1010
00:40:33,869 --> 00:40:35,250
Al final de todo el procedimiento

1011
00:40:35,250 --> 00:40:36,269
Haga lo que haga

1012
00:40:36,269 --> 00:40:37,570
Por aquí, por allá

1013
00:40:37,570 --> 00:40:39,789
Cambia cosas, escribe cosas

1014
00:40:39,789 --> 00:40:40,789
Haga lo que sea

1015
00:40:40,789 --> 00:40:42,829
Pero al final me tiene que hacer

1016
00:40:42,829 --> 00:40:47,570
Un resultado de esta función

1017
00:40:47,570 --> 00:40:48,590
Y me lo tiene que dar

1018
00:40:48,590 --> 00:40:51,190
Y el resultado tiene que coincidir en tipo

1019
00:40:51,190 --> 00:40:52,710
Con lo que he puesto aquí

1020
00:40:52,710 --> 00:40:55,269
Si tiene que devolver un string

1021
00:40:55,269 --> 00:40:56,030
Tiene que devolver un string

1022
00:40:56,030 --> 00:40:57,530
¿Dudas?

1023
00:41:02,300 --> 00:41:04,340
No, ¿esto qué es?

1024
00:41:05,119 --> 00:41:06,500
Un ejercicio

1025
00:41:06,500 --> 00:41:08,760
Otro ejemplo

1026
00:41:08,760 --> 00:41:09,199
¿Vale?

1027
00:41:10,760 --> 00:41:12,559
Entonces, por ejemplo, aquí tenemos

1028
00:41:12,559 --> 00:41:14,719
Un ejercicio

1029
00:41:14,719 --> 00:41:15,280
¿Qué dice?

1030
00:41:16,940 --> 00:41:18,780
Scanner es, es igual a un scanner

1031
00:41:18,780 --> 00:41:20,800
¿Vale? Este aquí le he detectado

1032
00:41:20,800 --> 00:41:22,739
Int lado 1

1033
00:41:22,739 --> 00:41:25,039
Es leginum

1034
00:41:25,039 --> 00:41:26,059
¿Vale?

1035
00:41:26,139 --> 00:41:28,380
esto es italiano, leenum

1036
00:41:28,380 --> 00:41:29,940
vale, de

1037
00:41:29,940 --> 00:41:32,420
darme el primer número de rectángulo

1038
00:41:32,420 --> 00:41:33,199
coma s

1039
00:41:33,199 --> 00:41:36,380
o sea, estoy llamando un método

1040
00:41:36,380 --> 00:41:37,699
¿qué es esto? ¿una función?

1041
00:41:38,199 --> 00:41:39,340
¿o un procedimiento?

1042
00:41:40,260 --> 00:41:44,320
una función, porque veis que

1043
00:41:44,320 --> 00:41:46,340
el resultado lo estoy

1044
00:41:46,340 --> 00:41:47,579
guardando dentro del lado 1

1045
00:41:47,579 --> 00:41:50,519
vale, entonces me espero que esto me devuelva

1046
00:41:50,519 --> 00:41:52,679
algo, ¿y qué parámetros

1047
00:41:52,679 --> 00:41:53,659
le estoy pasando?

1048
00:41:54,639 --> 00:41:55,840
un string

1049
00:41:55,840 --> 00:41:58,719
Y un escáner

1050
00:41:58,719 --> 00:41:59,679
¿Vale?

1051
00:42:00,019 --> 00:42:01,920
Un escáner que será este escáner de aquí

1052
00:42:01,920 --> 00:42:04,860
¿Vale? Vamos a ver que hace este legendum

1053
00:42:04,860 --> 00:42:06,119
Pues está aquí

1054
00:42:06,119 --> 00:42:08,239
Me devuelve un entero

1055
00:42:08,239 --> 00:42:10,179
Entonces me espero que al final

1056
00:42:10,179 --> 00:42:12,780
Haya un return de algo que sea un int

1057
00:42:12,780 --> 00:42:14,900
¿Cómo se llama?

1058
00:42:15,039 --> 00:42:15,619
Legendum

1059
00:42:15,619 --> 00:42:18,000
¿Qué parámetros tienes?

1060
00:42:18,619 --> 00:42:20,559
Un string que llamaré mensaje

1061
00:42:20,559 --> 00:42:23,159
Y un escáner que llamaré teclado

1062
00:42:23,159 --> 00:42:24,119
¿Vale?

1063
00:42:24,119 --> 00:42:25,360
Aquí dentro

1064
00:42:25,360 --> 00:42:27,360
Si uso teclado

1065
00:42:27,360 --> 00:42:29,360
Estoy usando este escáner

1066
00:42:29,360 --> 00:42:30,519
Y si uso MSG

1067
00:42:30,519 --> 00:42:32,159
Estoy utilizando este stringer

1068
00:42:32,159 --> 00:42:34,039
¿Qué son este stringer y este escáner?

1069
00:42:34,119 --> 00:42:34,739
No lo sé

1070
00:42:34,739 --> 00:42:38,639
Lo sabré a la hora en que tú me llames aquí

1071
00:42:38,639 --> 00:42:42,280
Entonces sabré que el mensaje es este de aquí

1072
00:42:42,280 --> 00:42:44,059
Y el escáner será este de aquí

1073
00:42:44,059 --> 00:42:44,800
¿Vale?

1074
00:42:44,800 --> 00:42:47,239
Pero no lo sé en este momento

1075
00:42:47,239 --> 00:42:50,579
Abstractamente pienso solo en MSG y teclado

1076
00:42:50,579 --> 00:42:53,800
Sí que puedo hipotizar que MSG será un mensaje

1077
00:42:53,800 --> 00:42:54,900
Por lo tanto un stringer

1078
00:42:54,900 --> 00:42:56,579
Por lo tanto lo puedo utilizar como string

1079
00:42:56,579 --> 00:42:58,480
Y que teclado será un escáner

1080
00:42:58,480 --> 00:43:00,420
Por lo tanto lo puedo utilizar como un escáner

1081
00:43:00,420 --> 00:43:01,360
¿Vale?

1082
00:43:01,960 --> 00:43:02,820
Entonces ¿Qué hago?

1083
00:43:03,539 --> 00:43:05,519
Escribo el mensaje en pantalla

1084
00:43:05,519 --> 00:43:09,800
Luego hago teclado.nextint

1085
00:43:09,800 --> 00:43:13,360
El resultado de este teclado.nextint

1086
00:43:13,360 --> 00:43:15,780
Que es como cuando nosotros hacemos can.nextint

1087
00:43:15,780 --> 00:43:18,400
Lo guardo en un entero

1088
00:43:18,400 --> 00:43:19,719
En una variable entero

1089
00:43:19,719 --> 00:43:22,420
Y esta variable aquí que es numleído

1090
00:43:22,420 --> 00:43:23,679
Es la que devuelvo

1091
00:43:23,679 --> 00:43:26,079
Sustancialmente

1092
00:43:26,079 --> 00:43:28,219
Las operaciones estas que nosotros

1093
00:43:28,219 --> 00:43:30,079
Hacíamos siempre de pido al usuario

1094
00:43:30,079 --> 00:43:32,599
Dame un número y luego después lo leo

1095
00:43:32,599 --> 00:43:34,639
Pues lo he pegado y compactado

1096
00:43:34,639 --> 00:43:35,639
En una única

1097
00:43:35,639 --> 00:43:37,800
Función

1098
00:43:37,800 --> 00:43:38,940
Que se llama leginum

1099
00:43:38,940 --> 00:43:41,760
Entonces cuando llamo leginum

1100
00:43:41,760 --> 00:43:42,880
Le pongo aquí

1101
00:43:42,880 --> 00:43:44,940
Lo que quiero pedir

1102
00:43:44,940 --> 00:43:46,739
Y donde lo voy a leer

1103
00:43:46,739 --> 00:43:48,300
Lo voy a leer desde el teclado

1104
00:43:48,300 --> 00:43:49,659
Y ya está

1105
00:43:49,659 --> 00:43:53,059
Si o no

1106
00:43:53,059 --> 00:43:56,320
Entonces, este leggiNum

1107
00:43:56,320 --> 00:43:58,500
Dame el primer número, me le dará un primer número

1108
00:43:58,500 --> 00:44:00,940
LeggiNum, dame el otro lado del rectángulo

1109
00:44:00,940 --> 00:44:02,460
Me le dará el segundo num

1110
00:44:02,460 --> 00:44:04,920
A este punto, en intarea

1111
00:44:04,920 --> 00:44:06,619
Voy a poner

1112
00:44:06,619 --> 00:44:08,079
Calcularea

1113
00:44:08,079 --> 00:44:10,519
¿Qué es calcularia?

1114
00:44:13,170 --> 00:44:14,389
Función o procedimiento

1115
00:44:14,389 --> 00:44:17,699
Función

1116
00:44:17,699 --> 00:44:18,460
¿Por qué?

1117
00:44:19,000 --> 00:44:21,800
Porque luego algo lo pongo dentro de área

1118
00:44:21,800 --> 00:44:23,300
¿Vale? Por lo tanto, probablemente

1119
00:44:23,300 --> 00:44:24,659
Tiene que ser una función

1120
00:44:24,659 --> 00:44:25,239
¿Vale?

1121
00:44:26,420 --> 00:44:28,019
¿Qué pilla como parámetros?

1122
00:44:34,170 --> 00:44:35,550
Un int y otro int

1123
00:44:35,550 --> 00:44:37,429
¿Vale? Lo veo aquí, int e int

1124
00:44:37,429 --> 00:44:38,789
¿Vale? Vamos a verlo

1125
00:44:38,789 --> 00:44:40,809
Entonces aquí tengo calcular

1126
00:44:40,809 --> 00:44:43,690
Que me pilla un int al lado uno

1127
00:44:43,690 --> 00:44:44,889
Y un int al lado dos

1128
00:44:44,889 --> 00:44:46,949
Cuidado que este nombre de aquí

1129
00:44:46,949 --> 00:44:48,909
No tiene que ser el mismo de esto de aquí

1130
00:44:48,909 --> 00:44:50,050
Pueden ser distintos

1131
00:44:50,050 --> 00:44:52,610
¿Vale? O iguales, da igual

1132
00:44:52,610 --> 00:44:55,389
Fijaos antes que yo uso S

1133
00:44:55,389 --> 00:44:57,670
Pero luego aquí dentro lo llamo teclado

1134
00:44:57,670 --> 00:44:59,650
¿Sí?

1135
00:44:59,809 --> 00:45:01,489
Pueden ser distintos, son variables

1136
00:45:01,489 --> 00:45:05,769
Calcula área, lado 1 y lado 2

1137
00:45:05,769 --> 00:45:07,530
Que son dos int, lado 1 y lado 2

1138
00:45:07,530 --> 00:45:10,309
Y que hace, returna lado 1 por lado 2

1139
00:45:10,309 --> 00:45:12,969
¿Es correcto esto?

1140
00:45:15,190 --> 00:45:16,469
Esta es una expresión

1141
00:45:16,469 --> 00:45:17,929
Lado 1 por lado 2

1142
00:45:17,929 --> 00:45:20,269
Lado 1 es un entero, lado 2 es un entero

1143
00:45:20,269 --> 00:45:21,969
Entero por entero, ¿qué me devuelve?

1144
00:45:22,869 --> 00:45:23,710
Un entero

1145
00:45:23,710 --> 00:45:25,630
Y tengo que devolver un entero

1146
00:45:25,630 --> 00:45:26,769
Pues perfecto

1147
00:45:26,769 --> 00:45:29,949
entonces devuelvo el resultado de esta operación

1148
00:45:29,949 --> 00:45:33,789
y el resultado de esta operación se guardará

1149
00:45:33,789 --> 00:45:34,650
en área

1150
00:45:34,650 --> 00:45:37,550
y ahora tengo

1151
00:45:37,550 --> 00:45:38,630
pinta bonito

1152
00:45:38,630 --> 00:45:40,670
que no es un animal

1153
00:45:40,670 --> 00:45:43,690
lado 1, lado 2, área

1154
00:45:43,690 --> 00:45:46,789
¿qué es esto?

1155
00:45:50,050 --> 00:45:52,840
es un procedimiento

1156
00:45:52,840 --> 00:45:54,820
me espero que sea un procedimiento

1157
00:45:54,820 --> 00:45:57,400
no estoy guardando nada de esto

1158
00:45:57,400 --> 00:45:59,039
Entonces probablemente es un procedimiento

1159
00:45:59,039 --> 00:46:00,000
Puede ser una función

1160
00:46:00,000 --> 00:46:02,239
Voy a mirarlo

1161
00:46:02,239 --> 00:46:04,460
Voy a mirar aquí

1162
00:46:04,460 --> 00:46:05,239
Pinta bonito

1163
00:46:05,239 --> 00:46:08,559
Pinta bonito

1164
00:46:08,559 --> 00:46:09,980
Efectivamente es void

1165
00:46:09,980 --> 00:46:12,199
Por lo tanto es un procedimiento

1166
00:46:12,199 --> 00:46:15,159
Que recibe un entero, otro entero

1167
00:46:15,159 --> 00:46:15,980
Y otro entero

1168
00:46:15,980 --> 00:46:18,559
Int B y R

1169
00:46:18,559 --> 00:46:20,519
Que si os fijáis

1170
00:46:20,519 --> 00:46:22,360
Se corresponderán con

1171
00:46:22,360 --> 00:46:23,900
Donde está pinta bonito

1172
00:46:23,900 --> 00:46:26,679
Con el lado, lado y el área

1173
00:46:26,679 --> 00:46:28,860
Y escribe

1174
00:46:28,860 --> 00:46:32,159
En un marco

1175
00:46:32,159 --> 00:46:34,380
Magnífico y muy bonito

1176
00:46:34,380 --> 00:46:34,920
¿Vale?

1177
00:46:35,559 --> 00:46:37,320
El rectángulo de lados

1178
00:46:37,320 --> 00:46:38,440
A

1179
00:46:38,440 --> 00:46:41,559
Y B

1180
00:46:41,559 --> 00:46:43,019
Lo que tú me has pasado

1181
00:46:43,019 --> 00:46:45,659
Tiene área R

1182
00:46:45,659 --> 00:46:49,340
¿Si o no?

1183
00:46:50,760 --> 00:46:52,719
Y el resultado es esta cosa aquí

1184
00:46:52,719 --> 00:46:58,619
Esta es la primera función

1185
00:46:58,619 --> 00:47:00,559
¿Vale?

1186
00:47:00,559 --> 00:47:03,340
Dame el primer lado y luego leo un número

1187
00:47:03,340 --> 00:47:05,840
Llamo otra vez la misma función

1188
00:47:05,840 --> 00:47:07,380
Pero con un mensaje distinto

1189
00:47:07,380 --> 00:47:09,099
Y dice, dame el otro lado del rectángulo

1190
00:47:09,099 --> 00:47:11,400
Y leo, hago la operación

1191
00:47:11,400 --> 00:47:13,119
No se ve nada porque no imprime nada

1192
00:47:13,119 --> 00:47:14,719
Y luego llamo pinta bonito

1193
00:47:14,719 --> 00:47:17,440
Me hace estos dos bonitos marcos

1194
00:47:17,440 --> 00:47:19,159
Y escribe el rectángulo de lado

1195
00:47:19,159 --> 00:47:21,199
4 y 6

1196
00:47:21,199 --> 00:47:22,519
Tiene área 24

1197
00:47:22,519 --> 00:47:26,199
Ahora

1198
00:47:26,199 --> 00:47:28,480
En vez de todo este código

1199
00:47:28,480 --> 00:47:30,519
En el main

1200
00:47:30,519 --> 00:47:31,639
Tengo un main

1201
00:47:31,639 --> 00:47:33,320
Mucho más

1202
00:47:33,320 --> 00:47:35,199
Leíble

1203
00:47:35,199 --> 00:47:37,059
Más escueto

1204
00:47:37,059 --> 00:47:38,880
Más sencillo

1205
00:47:38,880 --> 00:47:39,219
¿Vale?

1206
00:47:39,880 --> 00:47:42,280
Donde además entiendo lo que estoy haciendo

1207
00:47:42,280 --> 00:47:44,280
Creo un escáner, leo un número

1208
00:47:44,280 --> 00:47:45,800
Leo un número

1209
00:47:45,800 --> 00:47:47,159
Si esto fuera español

1210
00:47:47,159 --> 00:47:48,539
No entendería mejor

1211
00:47:48,539 --> 00:47:50,159
Leo un número, leo otro número

1212
00:47:50,159 --> 00:47:51,840
Calculo el área y pinto bonito

1213
00:47:51,840 --> 00:47:52,539
El resultado

1214
00:47:52,539 --> 00:47:54,840
Entiendo lo que estoy haciendo

1215
00:47:54,840 --> 00:47:56,880
¿Sí o no?

1216
00:47:58,079 --> 00:47:58,599
¿Dudas?

1217
00:48:00,840 --> 00:48:01,400
¿Preguntas?

1218
00:48:01,639 --> 00:48:10,130
Esto ya hemos dicho, parámetros formales y parámetros actuales

1219
00:48:10,130 --> 00:48:12,730
Entonces aquí yo tengo dos tipos de parámetros

1220
00:48:12,730 --> 00:48:16,969
Los verditos son parámetros formales

1221
00:48:16,969 --> 00:48:20,469
Y los azulitos son parámetros actuales

1222
00:48:20,469 --> 00:48:21,349
¿Cuál es la diferencia?

1223
00:48:21,929 --> 00:48:26,469
Los parámetros formales son los que uso abstractamente

1224
00:48:26,469 --> 00:48:31,530
Dentro de los métodos, de las funciones, de los procedimientos

1225
00:48:31,530 --> 00:48:34,949
MSG, aquí digo, escribe MSG

1226
00:48:34,949 --> 00:48:36,289
¿Cuánto vale MSG?

1227
00:48:36,650 --> 00:48:37,969
No, me da igual

1228
00:48:37,969 --> 00:48:39,889
A mí me habrán dado un string

1229
00:48:39,889 --> 00:48:42,110
Pues ese string lo imprimes en pantalla

1230
00:48:42,110 --> 00:48:43,409
Sea cual sea

1231
00:48:43,409 --> 00:48:44,190
¿Vale?

1232
00:48:44,730 --> 00:48:47,769
Es formal porque no sé su valor

1233
00:48:47,769 --> 00:48:50,070
Pero lo uso porque sé su tipo

1234
00:48:50,070 --> 00:48:51,789
Entonces, si sé su tipo

1235
00:48:51,789 --> 00:48:53,510
Sé cómo lo puedo utilizar

1236
00:48:53,510 --> 00:48:54,210
¿Vale?

1237
00:48:54,210 --> 00:48:55,170
Si es un string

1238
00:48:55,170 --> 00:48:56,550
Puedo preguntar, por ejemplo

1239
00:48:56,550 --> 00:48:57,789
¿Cuánto es largo este string?

1240
00:48:58,030 --> 00:49:00,010
Con MSG.length

1241
00:49:00,010 --> 00:49:01,269
¿Sí?

1242
00:49:01,269 --> 00:49:06,650
Puedo acceder a uno de sus carácter

1243
00:49:06,650 --> 00:49:11,170
Haciendo msg.cherat de 0

1244
00:49:11,170 --> 00:49:13,909
Por ejemplo, lo puedo utilizar como cualquier string

1245
00:49:13,909 --> 00:49:16,230
¿Cuál es efectivamente ese string? No lo sé

1246
00:49:16,230 --> 00:49:20,090
No lo sabré nunca hasta el momento en que me llamen

1247
00:49:20,090 --> 00:49:22,630
¿Sí?

1248
00:49:23,369 --> 00:49:25,650
Entonces lo uso de forma abstracta aquí

1249
00:49:25,650 --> 00:49:29,449
O aquí, ¿vale? Estos son todos parámetros formales

1250
00:49:29,449 --> 00:49:40,309
En el momento de la llamada, se hace una asociación entre el parámetro formal y su valor actual, que es esto.

1251
00:49:41,889 --> 00:49:50,610
Cuando yo hago esta llamada aquí, la primera, asigno a MSG el valor, dame el primer lado del rectángulo.

1252
00:49:50,610 --> 00:49:59,150
Y a teclado, lo que hay adentro de la variable S, que es este objeto de aquí, Scanner.

1253
00:49:59,449 --> 00:50:05,639
Entonces, en esta ejecución, en esta llamada

1254
00:50:05,639 --> 00:50:09,039
MSG vale, dame el primer lado del rectángulo

1255
00:50:09,039 --> 00:50:11,159
Y Scanner vale este objeto de aquí

1256
00:50:11,159 --> 00:50:12,340
Y ahora los uso

1257
00:50:12,340 --> 00:50:17,340
Cuando vuelvo a llamarlo, fijaos que el parámetro actual ha cambiado

1258
00:50:17,340 --> 00:50:19,860
Ahora, siempre aquí se llama MSG

1259
00:50:19,860 --> 00:50:21,440
El parámetro formal no cambia

1260
00:50:21,440 --> 00:50:25,420
Pero ahora tiene asociado este valor y no el otro

1261
00:50:25,420 --> 00:50:28,920
¿Dudas?

1262
00:50:28,920 --> 00:50:30,840
Entonces

1263
00:50:30,840 --> 00:50:32,780
Estos

1264
00:50:32,780 --> 00:50:35,480
Cuando son dentro de una

1265
00:50:35,480 --> 00:50:37,460
De una declaración

1266
00:50:37,460 --> 00:50:39,340
De una función

1267
00:50:39,340 --> 00:50:41,599
Método, procedimiento

1268
00:50:41,599 --> 00:50:43,639
Lo que sea, se llaman formales

1269
00:50:43,639 --> 00:50:45,119
Cuando en vez son

1270
00:50:45,119 --> 00:50:47,539
En la llamada, lo que se pasan

1271
00:50:47,539 --> 00:50:48,880
Son parámetros actuales

1272
00:50:48,880 --> 00:50:50,960
Que son los que, cuyo valor

1273
00:50:50,960 --> 00:50:53,400
Se asocia a los parámetros

1274
00:50:53,400 --> 00:50:55,500
Formales del método que estoy llamando

1275
00:50:55,500 --> 00:50:57,760
¿Dudas?

1276
00:51:03,500 --> 00:51:05,539
Y aquí el caveat de turno, ¿vale?

1277
00:51:05,840 --> 00:51:08,340
Funciones y procedimientos son propiedad de programación estructurada.

1278
00:51:08,500 --> 00:51:11,099
En Java se suele hablar más bien de métodos.

1279
00:51:11,500 --> 00:51:14,460
Sin embargo, el concepto de método está vinculado a la programación orientada a objetos.

1280
00:51:15,380 --> 00:51:18,119
En particular, al concepto de clase de objeto, ¿vale?

1281
00:51:18,119 --> 00:51:23,719
Por lo tanto, lo que hemos visto ahora, como es Java y Java orientado a objetos, son métodos, ¿vale?

1282
00:51:23,840 --> 00:51:29,519
Pero nosotros lo hemos llamado función y procedimientos, ¿vale?

1283
00:51:29,579 --> 00:51:32,219
Pero la idea es parecida, ¿vale?

1284
00:51:32,219 --> 00:51:33,320
Varias veces lo hemos hablado.

1285
00:51:33,320 --> 00:51:35,280
También otro caveat es que

1286
00:51:35,280 --> 00:51:38,159
Nosotros utilizamos mucho el static

1287
00:51:38,159 --> 00:51:39,820
Y no entendemos que es el static

1288
00:51:39,820 --> 00:51:42,300
Porque no entendemos la diferencia entre clase y objeto

1289
00:51:42,300 --> 00:51:43,739
¿Vale? No la saben

1290
00:51:43,739 --> 00:51:45,579
Por lo tanto, este static

1291
00:51:45,579 --> 00:51:47,300
¿Por qué está allí? Ni idea

1292
00:51:47,300 --> 00:51:49,519
Vendrá un momento en que este static

1293
00:51:49,519 --> 00:51:51,139
Desaparecerá, ¿vale?

1294
00:51:51,420 --> 00:51:52,440
Y veremos por qué

1295
00:51:52,440 --> 00:51:56,949
Y se acabó