1
00:00:00,560 --> 00:00:05,780
Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra voz, ¿vale?

2
00:00:06,559 --> 00:00:14,460
Entonces, nosotros, a nivel teórico, hemos visto las sentencias de control.

3
00:00:14,580 --> 00:00:25,140
Las sentencias de control me permiten variar, modificar el orden con que ejecuto las sentencias, los comandos de Java, ¿vale?

4
00:00:25,140 --> 00:00:34,679
La sentencia de control más fácil es la secuencial, es decir, voy uno tras otro, que es la base que hemos empezado a aprender al principio.

5
00:00:34,679 --> 00:00:43,140
Y luego hemos introducido dos tipos de estructuras de control que me permiten modificar esta secuencialidad.

6
00:00:43,420 --> 00:00:48,820
Por un lado el condicional, que me dice si tengo o no que ejecutar un determinado bloque.

7
00:00:48,820 --> 00:00:50,920
¿vale? Entonces podría, esto

8
00:00:50,920 --> 00:00:52,899
introduce la posibilidad de saltar

9
00:00:52,899 --> 00:00:54,939
un bloque de instrucciones si una

10
00:00:54,939 --> 00:00:57,100
condición es falsa o ejeutarlo

11
00:00:57,100 --> 00:00:59,060
si esta condición es verdadera

12
00:00:59,060 --> 00:01:00,880
y luego las iterativas que me

13
00:01:00,880 --> 00:01:02,799
permiten pillar un bloque de

14
00:01:02,799 --> 00:01:05,079
comandos

15
00:01:05,079 --> 00:01:06,840
y iterrar

16
00:01:06,840 --> 00:01:08,599
sobre este bloque una

17
00:01:08,599 --> 00:01:10,980
y otra vez y otra vez según

18
00:01:10,980 --> 00:01:12,640
una determinada condición

19
00:01:12,640 --> 00:01:14,900
¿vale? Hemos visto el while que me dice

20
00:01:14,900 --> 00:01:16,859
mientras esta condición es verdadera sigue

21
00:01:16,859 --> 00:01:18,500
aquí dentro atrapado en este bucle

22
00:01:18,500 --> 00:01:22,180
y cuando esta condición se vuelve falsa, sal, ¿vale?

23
00:01:22,239 --> 00:01:25,980
Entonces hemos visto que dentro del bucle necesitamos que esta condición

24
00:01:25,980 --> 00:01:31,319
se modifique en un determinado momento, porque si no siempre me quedaré atrapado en ese bucle.

25
00:01:31,719 --> 00:01:36,819
O si no, el for, que es un poquito distinto, que es cuando ya me sé el número de veces

26
00:01:36,819 --> 00:01:41,719
que tengo que hacer una determinada acción, pues entonces tengo este for.

27
00:01:41,719 --> 00:01:47,739
En particular, el for me permite también de tener de forma fácil un índice

28
00:01:47,739 --> 00:01:51,579
que varía en cada una de las

29
00:01:51,579 --> 00:01:55,239
iteraciones, entonces mi int i es igual a 0

30
00:01:55,239 --> 00:01:59,319
i menor de 10, en cada iteración este i va modificándose

31
00:01:59,319 --> 00:02:03,439
y por lo tanto lo puedo utilizar normalmente allí dentro para hacer

32
00:02:03,439 --> 00:02:06,959
algo, para buscar una posición, para

33
00:02:06,959 --> 00:02:08,860
incrementar un valor, etc.

34
00:02:11,020 --> 00:02:15,400
Los dos son idénticos, no se os olvide esto, todo lo que puedo

35
00:02:15,400 --> 00:02:20,560
hacer con un wire lo puede hacer con un for, todo lo que pueda hacer un for lo puede hacer con un wire.

36
00:02:20,560 --> 00:02:24,500
En el caso de los condicionales hemos visto el if que es el que utilizamos normalmente y luego hemos visto el

37
00:02:24,500 --> 00:02:30,479
switch. Yo puedo hacer con un if o puedo hacer un switch tranquilamente. Con el switch puede haber

38
00:02:30,479 --> 00:02:38,960
casos en que el if no lo puedo hacer. Pero bueno, es una forma más práctica cuando yo tengo que

39
00:02:38,960 --> 00:02:43,860
hacer algo en base al valor concreto de una variable. Entonces se usa el switch, si no,

40
00:02:43,860 --> 00:02:50,240
yes. Hemos hecho ejercicios, hemos probado, se nos ha quedado en esta transparencia,

41
00:02:50,240 --> 00:02:56,580
en esta diapositiva, en esta slide, no sé cómo se llama en español, pues el concepto de llamadas

42
00:02:56,580 --> 00:03:03,960
a métodos, que es la última, digamos, posibilidad que tenemos para que nuestra sentencia de control

43
00:03:03,960 --> 00:03:06,039
no sean una tras otra

44
00:03:06,039 --> 00:03:07,400
más cambien

45
00:03:07,400 --> 00:03:09,680
el flujo de ejecución

46
00:03:09,680 --> 00:03:11,259
la llamada a esa método

47
00:03:11,259 --> 00:03:14,020
la hemos visto en algunos ejercicios

48
00:03:14,020 --> 00:03:15,939
hemos hecho algunos ejemplos básicos

49
00:03:15,939 --> 00:03:17,719
hoy simplemente lo que vamos a hacer es

50
00:03:17,719 --> 00:03:20,360
darle un poco más de formalidad

51
00:03:20,360 --> 00:03:21,979
teórica pero la idea

52
00:03:21,979 --> 00:03:23,879
es pillar un trozo de código

53
00:03:23,879 --> 00:03:25,000
y darle un nombre

54
00:03:25,000 --> 00:03:28,300
yo tengo calcular área del cuadrado

55
00:03:28,300 --> 00:03:29,520
lo llamo así

56
00:03:29,520 --> 00:03:32,379
y dentro tendré todo el mecanismo

57
00:03:32,379 --> 00:03:38,439
todo el algoritmo, todas las instrucciones necesarias para calcular el área del cuadrado.

58
00:03:39,039 --> 00:03:43,139
Y al final de la ejecución de este método, haré algo.

59
00:03:43,620 --> 00:03:48,240
O lo escribo, o te devuelvo el valor, o lo guardo en una variable, no lo sé.

60
00:03:48,639 --> 00:03:50,520
Eso ya veremos qué opciones hay.

61
00:03:51,360 --> 00:03:58,360
El concepto es que cuando llamo a un método, paro la ejecución allí donde está la llamada del método,

62
00:03:58,360 --> 00:04:01,460
Me voy al bloque de código con ese nombre

63
00:04:01,460 --> 00:04:03,719
Ejecuto ese bloque de código

64
00:04:03,719 --> 00:04:05,659
Y una vez acabado ese bloque de código

65
00:04:05,659 --> 00:04:07,800
Vuelvo a donde se había llamado

66
00:04:07,800 --> 00:04:08,939
Y sigo adelante

67
00:04:08,939 --> 00:04:11,539
Entonces he hecho un salto

68
00:04:11,539 --> 00:04:14,300
Me he ido a otra parte

69
00:04:14,300 --> 00:04:15,180
De mi programa

70
00:04:15,180 --> 00:04:16,339
Y he vuelto

71
00:04:16,339 --> 00:04:19,740
Cuidado

72
00:04:19,740 --> 00:04:21,439
Lo diré ahora

73
00:04:21,439 --> 00:04:22,480
Y lo diré al final

74
00:04:22,480 --> 00:04:25,560
Nosotros ahora estamos viendo

75
00:04:25,560 --> 00:04:28,000
Los métodos o las funciones

76
00:04:28,000 --> 00:04:34,259
o los procedimientos desde una perspectiva más vieja de lo que es Java.

77
00:04:34,620 --> 00:04:37,800
O sea, no lo estamos viendo como orientado a objeto.

78
00:04:38,120 --> 00:04:40,819
Lo estamos viendo como programación estructural.

79
00:04:41,800 --> 00:04:47,360
Entonces, lo que tenemos aquí ahora es una parte de lo que podemos hacer con los métodos.

80
00:04:47,360 --> 00:04:50,040
Que por ahora, eso es lo que va.

81
00:04:50,420 --> 00:04:53,420
En un futuro, cuando veremos las clases, veremos los objetos,

82
00:04:53,420 --> 00:04:58,860
volveremos al concepto de método y lo veremos desde una perspectiva de orientada a objetos.

83
00:04:58,860 --> 00:05:03,500
Pero por ahora lo que vamos a ver es como la mitad de lo que se puede hacer.

84
00:05:07,279 --> 00:05:13,139
Nosotros para llamar un método podemos o llamar directamente al método, es lo que hemos usado

85
00:05:13,139 --> 00:05:18,620
nosotros varias veces. Hemos llamado un método, hemos llamado un bloque de código con un nombre

86
00:05:18,620 --> 00:05:20,680
y hemos llamado ese nombre, ¿vale?

87
00:05:20,740 --> 00:05:22,100
Eso quiere decir que cuando llegue allí,

88
00:05:22,600 --> 00:05:25,459
voy a este bloque, lo ejecuto y vuelvo atrás.

89
00:05:26,240 --> 00:05:30,019
Object.metodo es algo un poquito más complejo, ¿vale?

90
00:05:30,079 --> 00:05:31,040
Nosotros lo hemos utilizado.

91
00:05:31,060 --> 00:05:32,319
¿Dónde lo hemos utilizado esta cosa aquí?

92
00:05:38,000 --> 00:05:38,480
Scan.

93
00:05:39,720 --> 00:05:43,000
Nosotros hemos creado scanner, scanner es igual a new scanner.

94
00:05:43,220 --> 00:05:44,959
Ahí hemos creado un objeto scanner.

95
00:05:44,959 --> 00:05:49,060
Y luego hemos utilizado un método sobre la variable scan.

96
00:05:49,060 --> 00:05:56,680
Esto ya no... ¿Qué? No entiendo. ¿Qué es esto de un objeto? ¿Cómo que he creado un objeto? Sí, cuando

97
00:05:56,680 --> 00:06:02,199
tenéis un new habéis creado un objeto, ¿vale? Pero por ahora, si no lo entendéis, no pasa nada. Esto de

98
00:06:02,199 --> 00:06:07,300
aquí lo veremos poco o nada porque es lo que veremos en un futuro. Está aquí por ser completos.

99
00:06:07,300 --> 00:06:14,879
Y otra forma es, en vez de un objeto, clase, punto y un metodito. ¿Dónde hemos visto esto de aquí?

100
00:06:14,879 --> 00:06:21,279
math.rando

101
00:06:21,279 --> 00:06:23,899
por ejemplo, no he hecho nunca

102
00:06:23,899 --> 00:06:26,259
math x es igual a new math

103
00:06:26,259 --> 00:06:28,399
lo he llamado directamente

104
00:06:28,399 --> 00:06:29,180
sobre la clase

105
00:06:29,180 --> 00:06:32,279
estos son métodos estáticos

106
00:06:32,279 --> 00:06:34,920
estos son métodos no estáticos

107
00:06:34,920 --> 00:06:35,740
y esto depende

108
00:06:35,740 --> 00:06:38,279
depende de si lo estoy

109
00:06:38,279 --> 00:06:40,620
llamando sobre el objeto o si lo estoy llamando sobre la clase

110
00:06:40,620 --> 00:06:41,180
¿vale?

111
00:06:41,439 --> 00:06:44,639
pero todo esto es complejo y no lo entendemos

112
00:06:44,639 --> 00:06:46,100
porque nosotros no sabemos nada de

113
00:06:46,100 --> 00:06:48,540
programación de objetos, no sabemos que son los objetos

114
00:06:48,540 --> 00:06:52,180
no sabemos qué son las clases, y entonces no entendemos la diferencia entre esto.

115
00:06:52,620 --> 00:06:56,259
No hace falta. Por ahora, no lo pensamos.

116
00:06:56,560 --> 00:06:58,540
Y lo pensamos principalmente así.

117
00:07:01,120 --> 00:07:11,540
Vamos a ver qué son estas cosas. Llamadas a métodos.

118
00:07:12,500 --> 00:07:15,959
Entonces, si un programa repite muchas veces el mismo código,

119
00:07:16,139 --> 00:07:19,660
que es como lo vamos a usar nosotros en un futuro, quizás de una forma

120
00:07:19,660 --> 00:07:23,459
un poquito distinta, pero por ahora es donde nos sirve de verdad, es esto.

121
00:07:23,459 --> 00:07:26,699
Yo tengo el mismo código y se repite muchas veces, ¿vale?

122
00:07:26,699 --> 00:07:29,579
Entonces, he escrito siempre la misma cosa, ¿vale?

123
00:07:29,959 --> 00:07:35,240
El ejemplo que hace aquí, por ejemplo, aquí quiere calcular el, ¿qué es?

124
00:07:35,600 --> 00:07:39,480
La área, el perímetro de varios rectángulos, ¿sí?

125
00:07:39,819 --> 00:07:45,459
Entonces, lo que hace es establecer el primer rectángulo, calcular su área, su perímetro y escribirlo.

126
00:07:46,060 --> 00:07:49,660
Luego, el segundo rectángulo, calcular otra vez su área y su perímetro.

127
00:07:50,019 --> 00:07:52,519
Calcular el tercer rectángulo y su área y su perímetro.

128
00:07:52,519 --> 00:07:59,519
Si os fijáis, la parte de calcular y escribir es igual, es lo mismo en las tres cosas.

129
00:07:59,600 --> 00:08:03,519
La única cosa que estoy haciendo es cambiar el valor, ¿vale?

130
00:08:04,180 --> 00:08:06,199
Esto es repetir mucho el código.

131
00:08:06,699 --> 00:08:12,480
Si estoy repitiendo mucho el código, lo mejor que puedo hacer es este código, darle un nombre y llamarlo

132
00:08:12,480 --> 00:08:18,800
haz los cálculos que tienes que hacer y luego llamaré haz los cálculos, haz los cálculos, haz los cálculos.

133
00:08:18,800 --> 00:08:24,629
la ventaja que me da esto también

134
00:08:24,629 --> 00:08:26,089
es que si luego me doy cuenta

135
00:08:26,089 --> 00:08:27,790
que he hecho mal las operaciones

136
00:08:27,790 --> 00:08:29,810
o que hay una forma más eficiente

137
00:08:29,810 --> 00:08:30,829
de hacer las operaciones

138
00:08:30,829 --> 00:08:32,809
aquí las debería cambiar

139
00:08:32,809 --> 00:08:34,529
todas las veces que aparecen

140
00:08:34,529 --> 00:08:37,230
sin embargo en la otra forma

141
00:08:37,230 --> 00:08:39,210
lo cambio una vez

142
00:08:39,210 --> 00:08:41,110
en el bloque con su nombre

143
00:08:41,110 --> 00:08:43,409
y esto se aplicará todas las veces

144
00:08:43,409 --> 00:08:44,269
que he usado ese bloque

145
00:08:44,269 --> 00:08:45,690
¿se entiende?

146
00:08:49,419 --> 00:08:51,700
entonces sabíamos una cosa de este estilo

147
00:08:52,360 --> 00:08:56,679
Por un lado tengo el método main, que es el punto de acceso.

148
00:08:57,000 --> 00:08:58,100
Esto siempre se queda así.

149
00:08:59,240 --> 00:09:03,120
Y aquí lo que hago es calcular el perímetro 3, 4.

150
00:09:03,320 --> 00:09:05,379
Calcular el perímetro 5, 10.

151
00:09:05,539 --> 00:09:07,220
Calcular el perímetro 2 y 7.

152
00:09:07,539 --> 00:09:08,340
¿Y qué es esto?

153
00:09:08,440 --> 00:09:12,879
Esto es un bloque que tiene un nombre, que tiene el nombre calcular el perímetro, que es este de aquí.

154
00:09:14,440 --> 00:09:16,580
Declarado como hermano del main.

155
00:09:16,580 --> 00:09:19,960
Lo veis, hasta ahora nosotros hemos trabajado todo dentro del main.

156
00:09:19,960 --> 00:09:28,860
En realidad el main acaba en esta paréntesis de aquí abajo y por lo tanto esto es un hermano, es al mismo nivel del main.

157
00:09:29,220 --> 00:09:36,500
Y es un nuevo método. Si os fijáis, comparte public static void con el otro. Es la declaración de un método.

158
00:09:36,779 --> 00:09:43,379
Estoy definiendo un nuevo método, estoy definiendo una procedura, una función. En Java se llaman métodos.

159
00:09:43,379 --> 00:09:46,620
¿Cómo se llama este código?

160
00:09:46,960 --> 00:09:49,399
Este código se llama calcular área de perímetro

161
00:09:49,399 --> 00:09:53,879
Ahora, cuando yo declaro un método

162
00:09:53,879 --> 00:09:56,259
Y digo, se llama así, calcular área de perímetro

163
00:09:56,259 --> 00:09:58,440
Puedo parametrizarlo

164
00:09:58,440 --> 00:10:03,279
O sea, decir, oye, mira, aquí dentro voy a utilizar unos valores paramétricos

165
00:10:03,279 --> 00:10:08,379
O sea, tú me dirás cuántos valen en el momento en que llamas este trozo

166
00:10:08,379 --> 00:10:10,679
Y usaré los valores que tú me das

167
00:10:10,679 --> 00:10:16,759
¿Vale? En particular, para poder utilizar, calcular el perímetro, necesito dos valores.

168
00:10:17,360 --> 00:10:18,419
Necesito dos int.

169
00:10:19,000 --> 00:10:26,720
Cuando tú llamas este trozo de código, dentro de este trozo de código voy a utilizar un int lado 1 y un int lado 2.

170
00:10:27,100 --> 00:10:28,820
Como es un rectángulo, necesito dos lados.

171
00:10:30,360 --> 00:10:30,580
¿Sí?

172
00:10:31,320 --> 00:10:33,659
¿Cuánto vale? No lo sé.

173
00:10:34,259 --> 00:10:36,840
Estos se llaman parámetros formales.

174
00:10:37,639 --> 00:10:42,740
Es decir, yo sé que voy a necesitar lado 1 como entero y lado 2 como entero, lo sé,

175
00:10:42,740 --> 00:10:48,100
y los voy a utilizar, pero no sé cuánto valdrán hasta que tú llames,

176
00:10:48,500 --> 00:10:52,539
hasta que tú hagas la llamada de este método, hasta que tú lo uses este método.

177
00:10:53,220 --> 00:10:55,600
Esta es la definición abstracta del método.

178
00:10:56,120 --> 00:10:59,399
Te estoy diciendo, hay un trozo de código que usa estas dos variables.

179
00:10:59,879 --> 00:11:01,340
¿Cuánto valen? Lo veremos.

180
00:11:01,340 --> 00:11:05,519
Ahora, si tú me has dado estas dos variables

181
00:11:05,519 --> 00:11:08,860
Que yo no sé cuánto valen, por lo tanto le llamaré lado 1 y lado 2

182
00:11:08,860 --> 00:11:14,399
Lo que voy a hacer es que calculo la área de rectángulo como lado 1 por lado 2

183
00:11:14,399 --> 00:11:17,940
Y el perímetro como lado 1 por 2 más lado 2 por 2

184
00:11:17,940 --> 00:11:22,580
Y esto es el código que se le envía a la vez

185
00:11:22,580 --> 00:11:24,740
¿Sí?

186
00:11:28,179 --> 00:11:28,740
¿Sí?

187
00:11:28,740 --> 00:11:39,139
Y luego escribiré que el rectángulo de lado, el lado 1 y el lado 2, los dos lados que me has dado, tienen área, lo que he calculado, y perímetro, lo que he calculado.

188
00:11:41,279 --> 00:11:55,519
Ahora, cuando yo llamo este método diciéndole 3, 4, este 3 se vincula con este lado 1, este 4 se vincula con este lado 2, y entonces haré todos los cálculos con 3 y 4.

189
00:11:55,519 --> 00:12:02,299
Cuando tú vuelves a llamar el mismo código pero en vez de 3 y 4 me pasas 5 y 10

190
00:12:02,299 --> 00:12:06,179
Lo que está haciendo es vinculando el lado 1 con 5 y el lado 2 con 10

191
00:12:06,179 --> 00:12:08,700
Y haré todos esos cálculos con 5 y 10

192
00:12:08,700 --> 00:12:10,000
¿Se entiende?

193
00:12:10,980 --> 00:12:14,000
Estos se llaman parámetros actuales

194
00:12:14,000 --> 00:12:17,580
O sea lo que estoy utilizando actualmente en este momento

195
00:12:17,580 --> 00:12:19,519
Parámetros formales

196
00:12:19,519 --> 00:12:24,639
Los parámetros genéricos que no sé cuánto valdrán pero utilizo

197
00:12:24,639 --> 00:12:41,019
Yo sé que me darán estos valores, pero todavía no sé cuáles son, ¿sí? Sin embargo, los parámetros actuales son cuando voy a llamar a hacer la llamada del método, le tengo que pasar los valores que vas a utilizar en esta llamada del método.

198
00:12:41,019 --> 00:12:48,289
¿Dudas? ¿Preguntas? ¿Se entiende?

199
00:12:49,669 --> 00:12:54,110
Definición o declaración del método, llamada del método.

200
00:12:55,210 --> 00:12:59,070
Parámetros formales, parámetros actuales.

201
00:12:59,649 --> 00:13:03,769
¿Puedo yo hacer calcular el parámetro de tres punto y coma?

202
00:13:06,639 --> 00:13:13,820
No, porque este bloque de código aquí, este método, necesita dos parámetros, no uno solo.

203
00:13:13,820 --> 00:13:16,500
Si tú le pones un parámetro solo, te dice, no puedo.

204
00:13:17,779 --> 00:13:18,340
¿Sí?

205
00:13:20,059 --> 00:13:25,139
¿Puedo hacer el calcular el perímetro de 3, gato?

206
00:13:26,399 --> 00:13:31,059
No, porque este bloque de aquí necesita un entero y otro entero.

207
00:13:31,179 --> 00:13:32,519
No le puedo poner un string.

208
00:13:34,200 --> 00:13:34,620
¿Se entiende?

209
00:13:35,960 --> 00:13:36,559
¿Dudas?

210
00:13:41,909 --> 00:13:46,590
Un procedimiento es un conjunto de instrucciones que cumple una determinada tarea.

211
00:13:47,009 --> 00:13:47,250
¿Vale?

212
00:13:47,250 --> 00:13:49,210
como la que acabamos de ver ahora, ¿vale?

213
00:13:49,409 --> 00:13:50,470
Esta tarea puede

214
00:13:50,470 --> 00:13:53,289
depender de algunos valores que son

215
00:13:53,289 --> 00:13:55,029
llamados los parámetros o no,

216
00:13:55,350 --> 00:13:57,649
¿vale? Yo podría declararlo

217
00:13:57,649 --> 00:13:59,350
sin ningún parámetro.

218
00:14:00,210 --> 00:14:01,070
Entonces este es un

219
00:14:01,070 --> 00:14:02,909
bloque de código que se ejecuta

220
00:14:02,909 --> 00:14:05,230
claramente aquí dentro tendré que

221
00:14:05,230 --> 00:14:07,350
hacer algo. Calcular

222
00:14:07,350 --> 00:14:09,450
el perímetro como lo hemos pensado nosotros

223
00:14:09,450 --> 00:14:11,389
sin ponerle parámetro no tendría sentido

224
00:14:11,389 --> 00:14:12,870
porque sólo podría calcular

225
00:14:12,870 --> 00:14:15,909
el perímetro de un determinado

226
00:14:15,909 --> 00:14:17,769
Triángulo, rectángulo

227
00:14:17,769 --> 00:14:19,450
El que pongo aquí, dos y tres

228
00:14:19,450 --> 00:14:21,009
Ya está, me haría solo eso

229
00:14:21,009 --> 00:14:23,830
El parámetrizado me permite

230
00:14:23,830 --> 00:14:25,950
Hacerlo de todos los rectángulos posibles

231
00:14:25,950 --> 00:14:28,950
Pero

232
00:14:28,950 --> 00:14:31,330
Podría haber otros

233
00:14:31,330 --> 00:14:33,409
Métodos, como por ejemplo

234
00:14:33,409 --> 00:14:34,330
El método random

235
00:14:34,330 --> 00:14:38,549
¿Random pilla algún parámetro?

236
00:14:40,950 --> 00:14:41,769
No, era más

237
00:14:41,769 --> 00:14:43,789
Punto random, abierto, cerrado, paréntesis

238
00:14:43,789 --> 00:14:44,529
Cerrado, paréntesis

239
00:14:44,529 --> 00:14:46,789
Porque no me sirven los parámetros

240
00:14:46,789 --> 00:14:50,330
Porque es un número aleatorio entre 0

241
00:14:50,330 --> 00:14:52,490
y 0,99999999

242
00:14:52,490 --> 00:14:53,509
¿Vale?

243
00:14:53,610 --> 00:14:55,450
Y por eso no es paramétrico

244
00:14:55,450 --> 00:14:56,490
Es siempre así

245
00:14:56,490 --> 00:14:59,470
Es siempre un número aleatorio entre 0 y 0,9999

246
00:14:59,470 --> 00:15:00,730
No hay parámetros ahí

247
00:15:00,730 --> 00:15:02,009
¿Se entiende?

248
00:15:02,629 --> 00:15:05,429
Si quiero puedo hacerlo sin parámetros

249
00:15:05,429 --> 00:15:07,929
Si quiero puedo ponerle los parámetros

250
00:15:07,929 --> 00:15:09,830
¿Cuántos? ¿Cuánto me da la gana?

251
00:15:10,309 --> 00:15:12,669
1, 3, 97, 100, 1000

252
00:15:12,669 --> 00:15:13,750
Pues me da igual

253
00:15:13,750 --> 00:15:15,389
Los pongo allí, un entero

254
00:15:15,389 --> 00:15:16,409
Luego me das un string

255
00:15:16,409 --> 00:15:20,850
y luego me das un boolean, luego me das lo que yo quiera.

256
00:15:21,169 --> 00:15:24,110
Cuando lo llamo, lo tendré que usar con los mismos parámetros

257
00:15:24,110 --> 00:15:25,769
ordenados de esa forma.

258
00:15:30,129 --> 00:15:33,389
Ejemplo, calcular el lado 1 como el lado 2,

259
00:15:33,750 --> 00:15:35,509
saluda o saluda de nombre.

260
00:15:36,730 --> 00:15:39,850
Estas son llamadas de métodos posibles.

261
00:15:40,909 --> 00:15:44,929
Este de aquí me pillará dos variables que no sé qué son

262
00:15:44,929 --> 00:15:47,669
porque no sé qué es el lado 1 y el lado 2, probablemente enteros.

263
00:15:47,789 --> 00:15:54,230
Este de aquí no tiene ningún parámetro, y este de aquí tiene un parámetro nombre,

264
00:15:54,490 --> 00:15:58,830
que probablemente será un string, pero no lo sé porque no he visto que sea esta cosa.

265
00:16:00,330 --> 00:16:00,450
¿Sí?

266
00:16:03,690 --> 00:16:11,129
Se declara con public static void nombre, y luego la lista de parámetros como tipo del parámetro 1,

267
00:16:11,250 --> 00:16:18,070
nombre del parámetro 1, coma tipo del parámetro 2, nombre del parámetro 2, etc., etc., etc., todos los que yo quiera.

268
00:16:18,870 --> 00:16:19,429
¿Sí?

269
00:16:20,250 --> 00:16:27,350
Aquí entre paréntesis, entre llave y llave va el cuerpo del procedimiento, o sea, lo que hace el procedimiento, ¿vale?

270
00:16:27,950 --> 00:16:41,419
Para llamarlos uso el nombre del parámetro con aberta paréntesis, valor del tipo 1, valor del tipo 2, valor del tipo 3, ¿entiendes?

271
00:16:45,019 --> 00:16:46,259
Ejemplo, ¿vale?

272
00:16:46,259 --> 00:16:50,519
Tengo la videoclase encendida

273
00:16:50,519 --> 00:16:51,559
Si esto es demasiado pequeño

274
00:16:51,559 --> 00:16:53,600
Lo podéis meter en vuestra pantalla

275
00:16:53,600 --> 00:16:55,720
Este es el main

276
00:16:55,720 --> 00:16:56,779
¿Qué hace el main?

277
00:16:57,179 --> 00:16:58,659
El main llama el método saluda

278
00:16:58,659 --> 00:16:59,700
O sea que

279
00:16:59,700 --> 00:17:02,860
El flujo normal de ejecución

280
00:17:02,860 --> 00:17:04,160
Aquí se interrumpe

281
00:17:04,160 --> 00:17:06,680
Y salta hacia ese bloque

282
00:17:06,680 --> 00:17:08,259
Que se llama saluda

283
00:17:08,259 --> 00:17:09,500
Sin parámetros

284
00:17:09,500 --> 00:17:11,259
¿Dónde está saluda sin parámetros?

285
00:17:11,680 --> 00:17:12,200
Pues aquí

286
00:17:12,200 --> 00:17:13,440
¿Vale?

287
00:17:13,559 --> 00:17:15,279
Saluda sin parámetros

288
00:17:15,279 --> 00:17:25,240
Vale, fenomenal. ¿Qué tiene que hacer? Pondrá system.out.ptle hola a todos. O sea que esta cosa de aquí me hará escribir hola a todos en pantalla.

289
00:17:26,720 --> 00:17:37,000
Una vez acabado este método de aquí, volverá aquí y seguirá adelante. Y llama saluda con parámetros tson.

290
00:17:37,000 --> 00:17:39,759
Entonces esto no lo puede usar

291
00:17:39,759 --> 00:17:41,880
Porque saluda sin parámetro no es esto

292
00:17:41,880 --> 00:17:43,380
Tiene que buscar un saluda

293
00:17:43,380 --> 00:17:45,299
Que tenga como parámetro un

294
00:17:45,299 --> 00:17:49,069
¿Qué tipo tiene Estefano?

295
00:17:49,890 --> 00:17:51,009
Un string

296
00:17:51,009 --> 00:17:52,369
Pues vamos a mirarlo

297
00:17:52,369 --> 00:17:54,690
Saluda con string nombre

298
00:17:54,690 --> 00:17:57,130
¿Y qué hace? Pues escribe hola

299
00:17:57,130 --> 00:17:58,190
Y el nombre detrás

300
00:17:58,190 --> 00:18:01,930
Entonces esta cosa de aquí escribirá hola Estefano

301
00:18:01,930 --> 00:18:05,150
Acaba esto

302
00:18:05,150 --> 00:18:06,970
Vuelve aquí, sigue adelante

303
00:18:06,970 --> 00:18:08,630
Crea una variable que se llama

304
00:18:08,630 --> 00:18:16,869
llama n y que pone paco, ¿vale? Y luego llama saluda n. ¿Qué hará esto? Volverá a saltar

305
00:18:16,869 --> 00:18:24,509
a este método, porque es saluda de un string, ¿ok? Y aquí lo que hará es asociar este

306
00:18:24,509 --> 00:18:31,230
nombre con este n, y este n contiene paco, por lo tanto ahora nombre vale paco y escribirá

307
00:18:31,230 --> 00:18:48,170
o lavado. ¿Dudas? Claramente estos dos métodos son inútiles porque escriben una cosa, además me

308
00:18:48,170 --> 00:18:54,470
compensa escribir directamente si están puntuados por internet aquí. Sí. Cuando estos son más

309
00:18:54,470 --> 00:19:01,130
complejos, en vez de repetir toda esta complejidad aquí dos veces, porque si os fijáis esta parte

310
00:19:01,130 --> 00:19:05,809
aquí se usa dos veces, este método se usa dos veces, este método se usa una vez sola, en vez de

311
00:19:05,809 --> 00:19:07,630
tener que escribir este código,

312
00:19:07,750 --> 00:19:09,730
imaginaos 30 líneas de código, dos

313
00:19:09,730 --> 00:19:11,509
veces, entonces 60 líneas de código, o sea,

314
00:19:11,549 --> 00:19:13,549
ahí es detorcido, pues lo escribo una vez

315
00:19:13,549 --> 00:19:17,619
sola y desde aquí lo llamo. Otro

316
00:19:17,619 --> 00:19:18,819
ejemplo, ¿vale?

317
00:19:20,460 --> 00:19:21,500
Repite saludo

318
00:19:21,500 --> 00:19:23,259
Luis Castro, ¿vale?

319
00:19:23,819 --> 00:19:25,660
Esto es una llamada

320
00:19:25,660 --> 00:19:26,900
a un método que se llama

321
00:19:26,900 --> 00:19:29,579
repite saludo, que

322
00:19:29,579 --> 00:19:31,579
tiene un string

323
00:19:31,579 --> 00:19:32,759
y un int.

324
00:19:34,079 --> 00:19:35,599
Esto, ¿vale? Esa es la

325
00:19:35,599 --> 00:19:37,619
definición. Se llama repite saludo

326
00:19:37,619 --> 00:19:41,940
recibe un parámetro

327
00:19:41,940 --> 00:19:46,059
tipo string y un parámetro tipo int. Entonces, él asocia

328
00:19:46,059 --> 00:19:50,000
este nombre con Luis y estas repeticiones con 4.

329
00:19:50,880 --> 00:19:53,880
Y lo que hace es, desde y que va a 0 y menor

330
00:19:53,880 --> 00:19:57,819
que repeticiones y más más, escribe hola nombre. Es decir, que

331
00:19:57,819 --> 00:20:00,240
aquí cuando ejecuto este método, ¿qué hace?

332
00:20:05,740 --> 00:20:09,240
¿Qué? Hola y

333
00:20:09,240 --> 00:20:19,109
Escribe hola Luis cuatro veces. La misma línea, en línea, como está aprendiendo a

334
00:20:19,109 --> 00:20:26,789
leerme, pues en línea siguiente. ¿Sí? Entonces escribe en cuatro líneas hola Luis, hola Luis, hola Luis, hola Luis.

335
00:20:26,789 --> 00:20:39,029
¿Se entiende? ¿Dudas? Si yo hiciera repite, saludo, Estefano 27, ¿qué hace? Hola

336
00:20:39,029 --> 00:20:40,069
Estefano, ¿cuántas veces?

337
00:20:40,990 --> 00:20:41,549
27.

338
00:20:42,710 --> 00:20:43,230
¿Sí?

339
00:20:49,779 --> 00:20:52,039
Los procedimientos y los

340
00:20:52,039 --> 00:20:53,660
métodos en general, ¿eh? ¿Vale?

341
00:20:53,960 --> 00:20:55,940
Se pueden usar para ordenar el código

342
00:20:55,940 --> 00:20:58,000
y hacerlo más bonito. Para hacerlo

343
00:20:58,000 --> 00:21:00,059
más leíble.

344
00:21:00,460 --> 00:21:02,039
¿Vale? En vez de poner todo el código

345
00:21:02,039 --> 00:21:04,019
en el main, que salen 200

346
00:21:04,019 --> 00:21:06,220
páginas, líneas de código retorcido

347
00:21:06,220 --> 00:21:07,880
con cosas raras, que cuando vas a leer

348
00:21:07,880 --> 00:21:09,960
dices, no lo entiendo, tú te

349
00:21:09,960 --> 00:21:11,920
haces un buen main que dice

350
00:21:11,920 --> 00:21:14,059
inicializa el sistema, calcula

351
00:21:14,059 --> 00:21:18,720
datos escribe el resultado se entiende que está haciendo si muy bonito hace esto

352
00:21:18,720 --> 00:21:24,140
hace esto hace esto si hasta en vez de así genérico pues le pusiera nombres reales

353
00:21:24,140 --> 00:21:32,059
de recibe valores calcula áreas de rectángulo y escribe resultados sé que

354
00:21:32,059 --> 00:21:37,160
sé que está haciendo el carapaz vale entonces me puede servir para que el

355
00:21:37,160 --> 00:21:43,500
main se quede más limpio y que estos métodos de aquí en realidad sean que no

356
00:21:43,500 --> 00:21:45,980
estén en otro lado, hasta en otras clases

357
00:21:45,980 --> 00:21:48,039
veremos en el futuro, en otros ficheros

358
00:21:48,039 --> 00:21:49,740
o, cosa también más

359
00:21:49,740 --> 00:21:51,839
interesante, que una vez que yo he establecido

360
00:21:51,839 --> 00:21:53,759
que el main es esto, le digo

361
00:21:53,759 --> 00:21:56,000
hoy mira, este grupo implementa

362
00:21:56,000 --> 00:21:57,859
inicializaSistema, ese grupo

363
00:21:57,859 --> 00:21:59,960
implementa calculaDatos y este grupo

364
00:21:59,960 --> 00:22:01,720
implementa escribeResultal

365
00:22:01,720 --> 00:22:03,240
y estoy haciendo mi programa

366
00:22:03,240 --> 00:22:05,799
separado en tres grupos de trabajo

367
00:22:05,799 --> 00:22:07,299
entonces está de un tercer tiempo

368
00:22:07,299 --> 00:22:08,900
¿Sí?

369
00:22:11,460 --> 00:22:13,440
¿Y inicializaSistema? Pues hará todas

370
00:22:13,440 --> 00:22:17,200
Todas las operaciones para reiniciar el sistema, recuperar los datos,

371
00:22:17,200 --> 00:22:21,000
adquirir los datos, comprueba que los datos son correctos, etcétera, etcétera.

372
00:22:21,000 --> 00:22:25,740
Cuando lo ha hecho, asumo que el sistema está inicializado, lo que quiera decir

373
00:22:25,740 --> 00:22:28,920
el sistema está inicializado, es un ejemplo, no es un ejemplo completo.

374
00:22:29,579 --> 00:22:32,880
Luego empieza con cálculo de datos, hará todos los cálculos sobre los datos,

375
00:22:32,940 --> 00:22:36,599
asumiendo que el sistema ya está inicializado, porque ya lo ejecutaron.

376
00:22:37,259 --> 00:22:40,799
Y finalmente estará, escribe el resultado que pillará lo que se ha calculado y lo

377
00:22:40,799 --> 00:22:52,480
o en un fichero, o lo manda por internet, o... ¿sí? Estos serían los prototipos de estos métodos, ¿vale?

378
00:22:53,579 --> 00:23:00,619
El prototipo es esta cosa aquí, ¿vale? Cuando yo te digo el prototipo de un método, es si es público, privado,

379
00:23:00,759 --> 00:23:05,599
lo que sea, nosotros conocemos solo público, si es estático o no, nosotros conocemos solo el estático,

380
00:23:05,599 --> 00:23:09,200
si es void o otra cosa, y nosotros por ahora hemos usado solo void,

381
00:23:09,559 --> 00:23:11,859
cómo se llama y qué parámetros tiene.

382
00:23:12,700 --> 00:23:13,599
Ese es el prototipo.

383
00:23:14,539 --> 00:23:18,799
La línea que define este método se llama prototipo del método.

384
00:23:20,240 --> 00:23:23,880
Y si yo en vez de os digo la firma del método,

385
00:23:24,359 --> 00:23:32,119
la firma del método es su nombre con los tipos de los datos, de los parámetros.

386
00:23:32,119 --> 00:23:37,500
Es decir, que la firma de este método de aquí es saludaString.

387
00:23:39,619 --> 00:23:43,980
La firma de este método de aquí es repiteSaludoStringInt.

388
00:23:46,819 --> 00:23:51,019
Esto es saludaVoid, porque no tiene nada.

389
00:23:54,750 --> 00:23:55,349
Preguntas.

390
00:24:00,450 --> 00:24:01,430
Estos son los procedimientos.

391
00:24:02,410 --> 00:24:03,430
¿Dudas sobre los procedimientos?

392
00:24:04,769 --> 00:24:04,990
Vale.

393
00:24:06,289 --> 00:24:09,789
Estamos en el mundo de la programación estructurada.

394
00:24:09,789 --> 00:24:10,289
¿Vale?

395
00:24:10,289 --> 00:24:15,430
Entonces, en el mundo de la programación estructurada existen dos cosas distintas.

396
00:24:15,529 --> 00:24:17,390
Los procedimientos y las funciones.

397
00:24:18,130 --> 00:24:22,589
En el mundo orientado a objetos, o sea, el mundo donde estaremos nosotros, no existe esta diferencia.

398
00:24:22,710 --> 00:24:23,650
Existen métodos.

399
00:24:24,349 --> 00:24:25,789
Y estos son métodos.

400
00:24:26,009 --> 00:24:26,630
Todos son métodos.

401
00:24:26,730 --> 00:24:27,329
Java es método.

402
00:24:27,869 --> 00:24:32,450
Pero para entender la diferencia, hacemos esta división.

403
00:24:33,049 --> 00:24:34,509
Procedimientos, lo habéis entendido.

404
00:24:35,529 --> 00:24:38,609
En particular, los procedimientos son los que tienen aquí, voy.

405
00:24:38,609 --> 00:24:41,390
si allí tiene void es un procedimiento

406
00:24:41,390 --> 00:24:46,230
una función es una cosa un poquito distinta

407
00:24:46,230 --> 00:24:46,730
es

408
00:24:46,730 --> 00:24:50,230
un método, es un bloque de código

409
00:24:50,230 --> 00:24:51,990
pero yo me espero

410
00:24:51,990 --> 00:24:53,950
que al final de este bloque

411
00:24:53,950 --> 00:24:55,970
de código, después que haya hecho lo que

412
00:24:55,970 --> 00:24:57,730
tiene que hacer, él

413
00:24:57,730 --> 00:24:59,230
llegue a un resultado

414
00:24:59,230 --> 00:25:01,769
y me proporcione ese resultado

415
00:25:01,769 --> 00:25:03,890
o sea, mientras el procedimiento

416
00:25:03,890 --> 00:25:06,029
yo te llamo, tú haces tus cosas

417
00:25:06,029 --> 00:25:07,509
no me espero nada de ti

418
00:25:07,509 --> 00:25:09,309
cuando has hecho tus cosas sigo yo

419
00:25:09,309 --> 00:25:11,529
la función es

420
00:25:11,529 --> 00:25:13,589
tú haz tus cosas, pero cuando has

421
00:25:13,589 --> 00:25:15,569
acabado de hacer tus cosas, tú tendrás

422
00:25:15,569 --> 00:25:17,569
un valor calculado, sea

423
00:25:17,569 --> 00:25:19,589
lo que sea, ese valor

424
00:25:19,589 --> 00:25:21,470
me lo puedes dar a mí

425
00:25:21,470 --> 00:25:23,529
a quien te he llamado, cuando yo

426
00:25:23,529 --> 00:25:25,450
te llamo una función, puedo

427
00:25:25,450 --> 00:25:27,450
recoger ese valor final

428
00:25:27,450 --> 00:25:29,730
y traerlo a quien lo he llamado

429
00:25:29,730 --> 00:25:33,609
una función es parecida a un procedimiento

430
00:25:33,609 --> 00:25:35,690
pero sirve para obtener un determinado

431
00:25:35,690 --> 00:25:41,809
resultado que se devolverá al programa que ha llamado la función. Yo llamo la función, la función

432
00:25:41,809 --> 00:25:48,130
hace lo suyo y al final el valor final que ha calculado me lo devuelve a quien lo ha llamado

433
00:25:48,130 --> 00:26:01,750
y yo lo puedo utilizar para cerrar. Ejemplos, int área es igual a cálcula área, lado 1, lado 2.

434
00:26:02,410 --> 00:26:09,710
Yo me espero que cálcula área con lado 1 y lado 2 haga sus operaciones, por ejemplo, lado 1 por

435
00:26:09,710 --> 00:26:18,410
lado 2, obtiene un valor 37, pues este 37 quiero que me lo devuelva a mí y que lo ponga en la int area,

436
00:26:18,670 --> 00:26:27,940
o sea, en una variable que se llama area. Fijaos que con el procedimiento no lo puedo hacer. Si era

437
00:26:27,940 --> 00:26:39,559
esto, calcular el perímetro, yo no puedo hacer int x es igual a calcular el perímetro, porque esta

438
00:26:39,559 --> 00:26:48,559
cosa de aquí devuelve void es decir no devuelve nada no me espero que después de esto aquí te dé

439
00:26:48,559 --> 00:26:57,779
algo a cambio tú si lo escribes en pantalla pero lo haces tú o sea el llamante o sea el main cuando

440
00:26:57,779 --> 00:27:05,240
llama el método hace que el método haga todo es el método que escribe en pantalla pero cuando esto

441
00:27:05,240 --> 00:27:12,920
vuelve al llamante, el llamante no tiene en mano nada de lo que ha hecho el procedimiento.

442
00:27:12,920 --> 00:27:21,000
No recibe nada a cambio. El concepto de la función es que cuando yo acabo de ejecutar

443
00:27:21,000 --> 00:27:29,039
la función, ésta haya calculado este dato y este dato me lo puede devolver a mí. Y

444
00:27:29,039 --> 00:27:33,779
yo como llamante lo puedo guardar en una función, lo puedo utilizar directamente, lo puedo escribir

445
00:27:33,779 --> 00:27:35,680
en pantalla, puedo hacer lo que me da la gana con eso

446
00:27:35,680 --> 00:27:37,720
pero esto

447
00:27:37,720 --> 00:27:39,880
es un

448
00:27:39,880 --> 00:27:40,220
valor

449
00:27:40,220 --> 00:27:43,779
una vez que se ha ejecutado esta cosa

450
00:27:43,779 --> 00:27:45,299
eso vale algo

451
00:27:45,299 --> 00:27:47,000
con un tipo concreto

452
00:27:47,000 --> 00:27:48,759
¿me entiendes?

453
00:27:50,180 --> 00:27:51,859
o string de saludo es igual

454
00:27:51,859 --> 00:27:53,220
a crea saludo de nombre

455
00:27:53,220 --> 00:27:55,539
pues crea saludo de nombre, pillará

456
00:27:55,539 --> 00:27:57,779
un string, hará lo que le da la gana

457
00:27:57,779 --> 00:27:59,819
creará un string más grande con dentro

458
00:27:59,819 --> 00:28:01,619
el nombre y luego este string

459
00:28:01,619 --> 00:28:03,220
me lo devuelve a quien me ha llamado

460
00:28:03,220 --> 00:28:04,559
y yo lo puedo guardar

461
00:28:04,559 --> 00:28:06,720
dentro de una...

462
00:28:06,720 --> 00:28:08,720
Un no, pero...

463
00:28:08,720 --> 00:28:11,829
Ejemplos.

464
00:28:11,990 --> 00:28:12,730
Ah, no, declaración.

465
00:28:13,150 --> 00:28:14,049
¿Cómo se declara?

466
00:28:14,369 --> 00:28:15,650
Igual a que antes,

467
00:28:15,890 --> 00:28:16,710
lo único que cambia

468
00:28:16,710 --> 00:28:18,630
es que donde antes tenía void,

469
00:28:19,390 --> 00:28:20,930
ahora tengo el tipo

470
00:28:20,930 --> 00:28:23,349
del valor que se crea.

471
00:28:24,049 --> 00:28:25,029
O sea, yo tengo una función,

472
00:28:25,349 --> 00:28:26,210
hace lo que le da gana,

473
00:28:26,349 --> 00:28:27,230
al final, ¿qué tiene?

474
00:28:27,309 --> 00:28:27,930
¿Tiene un int?

475
00:28:28,369 --> 00:28:29,670
Pues entonces devuelve un int.

476
00:28:31,009 --> 00:28:31,809
Al final, ¿qué tiene?

477
00:28:31,869 --> 00:28:32,490
¿Tiene un string?

478
00:28:32,490 --> 00:28:33,930
Pues entonces aquí le pongo string.

479
00:28:34,529 --> 00:28:40,769
Esto es lo que me espero que esta función de aquí haga y al final obtiene este valor.

480
00:28:40,769 --> 00:28:42,269
¿Qué tipo tiene este valor final?

481
00:28:42,269 --> 00:28:55,289
Pues un string, pues entonces lo pongo aquí para que sepa quién me usa, que después de todo mi trabajo, pues yo te puedo devolver un string, o te puedo devolver un int, o te puedo devolver un float.

482
00:28:57,319 --> 00:28:58,140
¿Cómo se llama?

483
00:28:58,519 --> 00:29:00,500
Pues se llama igual que antes.

484
00:29:01,160 --> 00:29:01,519
¿Vale?

485
00:29:01,519 --> 00:29:04,339
Tipo variable, nombre variable es igual a

486
00:29:04,339 --> 00:29:06,779
Nombre, bla bla bla, esto es igual a que antes

487
00:29:06,779 --> 00:29:07,480
¿Ve?

488
00:29:08,819 --> 00:29:10,940
O declarando una variable nueva

489
00:29:10,940 --> 00:29:12,500
Para poner dentro el resultado

490
00:29:12,500 --> 00:29:14,980
O utilizando una variable

491
00:29:14,980 --> 00:29:16,160
Ya de ese tipo

492
00:29:16,160 --> 00:29:18,680
Y pillando el resultado

493
00:29:18,680 --> 00:29:19,700
¿Ve?

494
00:29:20,980 --> 00:29:21,539
Cuidado

495
00:29:21,539 --> 00:29:24,160
Yo podría no poner esto

496
00:29:24,160 --> 00:29:25,880
Si yo llamo una función

497
00:29:25,880 --> 00:29:29,160
Y ignoro lo que ha calculado

498
00:29:29,160 --> 00:29:30,640
Pues lo puedo hacer tranquilamente

499
00:29:30,640 --> 00:29:37,079
no se suele hacer, cuando yo llamo a una función, es porque quiero el resultado de esa función, ¿vale?

500
00:29:37,380 --> 00:29:49,210
Si yo quiero llamar a una función y no me interesa para nada el cálculo que hace, eso es un procedimiento.

501
00:29:50,630 --> 00:29:56,069
Si yo no voy a utilizar lo que tú calculas, pues entonces ponme void y dime no te devuelvo nada.

502
00:29:56,069 --> 00:29:57,390
Entonces se vuelve un procedimiento.

503
00:30:01,240 --> 00:30:03,319
Pruebas, ejemplos, ¿vale?

504
00:30:03,319 --> 00:30:08,839
Aquí tengo un main que dice string, saludo1 es igual a saluda a Estefan, ¿vale?

505
00:30:09,420 --> 00:30:15,859
Fijaos, saluda ahora, pilla un string, pero no lo escribe en pantalla.

506
00:30:16,920 --> 00:30:26,559
Lo que hace es, me crea un nuevo string de resultado, le pone hola y luego el nombre que ha recibido como parámetro formal aquí, ¿vale?

507
00:30:26,960 --> 00:30:31,940
Y lo que hace es devolver return el resultado calculado.

508
00:30:31,940 --> 00:30:36,500
esto es lo que me devuelve

509
00:30:36,500 --> 00:30:41,440
y que yo pondré en saludón, ¿entiendes?

510
00:30:42,539 --> 00:30:45,799
fijaos que aquí es public static string

511
00:30:45,799 --> 00:30:49,519
no void, eso quiere decir que al final tengo que devolver

512
00:30:49,519 --> 00:30:53,799
un string, sea cual sea el string

513
00:30:53,799 --> 00:30:57,299
tiene que ser un valor de tipo string, aquí calcularé un string

514
00:30:57,299 --> 00:31:01,779
y al final return string, cuidado, si yo no pongo return string

515
00:31:01,779 --> 00:31:08,380
¿Por qué se enfada? Me dice, oye, mira, tú has hecho un método que devuelve algo y no has dicho que devuelve.

516
00:31:09,640 --> 00:31:11,500
Entonces se va a enfadar si no le pongo return.

517
00:31:14,240 --> 00:31:22,059
Se va a enfadar también si yo hago algo tipo if x es mayor que cero en turner, entonces return a Stéfano y ya está.

518
00:31:22,720 --> 00:31:30,039
Porque él dice, oye, cuidado, que si x es mayor que cero esto funciona, pero si x es menor que cero no estás llegando a ningún return.

519
00:31:30,039 --> 00:31:31,680
Me tienes que cubrir

520
00:31:31,680 --> 00:31:33,000
las dos posibilidades.

521
00:31:33,759 --> 00:31:35,180
No puedo yo tener una posibilidad

522
00:31:35,180 --> 00:31:37,400
que me diga, sí, con esto de return

523
00:31:37,400 --> 00:31:38,339
y con esto no.

524
00:31:39,099 --> 00:31:41,660
Si tiene que devolver algo, tiene que devolver algo

525
00:31:41,660 --> 00:31:42,079
siempre.

526
00:31:43,859 --> 00:31:47,250
¿Entiendes? Vale.

527
00:31:48,829 --> 00:31:49,990
Más ejemplos.

528
00:31:50,210 --> 00:31:51,450
¿Vale? Entonces tengo

529
00:31:51,450 --> 00:31:53,490
string saludos es igual, repite

530
00:31:53,490 --> 00:31:55,369
saludos de Luis 4. ¿Vale?

531
00:31:55,470 --> 00:31:57,509
Esta es la misma versión de antes, pero en vez

532
00:31:57,509 --> 00:31:59,369
que como procedimiento, ¿os acordáis? El procedimiento

533
00:31:59,369 --> 00:32:00,970
lo escribía él directamente.

534
00:32:00,970 --> 00:32:03,009
en vez de aquí lo que hace es

535
00:32:03,009 --> 00:32:04,990
nombre de repeticiones

536
00:32:04,990 --> 00:32:07,670
empiezo con un resultado que es vacío

537
00:32:07,670 --> 00:32:09,829
¿vale? por cuatro veces

538
00:32:09,829 --> 00:32:11,309
por repeticiones veces

539
00:32:11,309 --> 00:32:13,109
lo que hago es resultados igual

540
00:32:13,109 --> 00:32:15,650
resultado más hola más nombre

541
00:32:15,650 --> 00:32:17,789
entonces hola Estefano y un start

542
00:32:17,789 --> 00:32:19,950
¿vale? retorno al resultado

543
00:32:19,950 --> 00:32:21,710
es decir que si yo

544
00:32:21,710 --> 00:32:23,730
hago esto y lo he imprimido por pantalla

545
00:32:23,730 --> 00:32:25,150
¿qué hace este programa?

546
00:32:37,150 --> 00:32:38,829
escribe hola Luis ¿cuántas veces?

547
00:32:39,329 --> 00:32:40,410
cuatro ¿cómo?

548
00:32:40,410 --> 00:32:49,759
una tras otra, lo veis

549
00:32:49,759 --> 00:32:51,640
no una encima de otra

550
00:32:51,640 --> 00:32:54,279
porque en cada círculo

551
00:32:54,279 --> 00:32:56,420
lo que está haciendo lo está pegando

552
00:32:56,420 --> 00:32:58,099
detrás, entonces me pone

553
00:32:58,099 --> 00:32:59,359
hola Luis, hola Luis, hola Luis

554
00:32:59,359 --> 00:33:01,980
cuatro veces pero en la misma línea

555
00:33:01,980 --> 00:33:02,720
lo veis

556
00:33:02,720 --> 00:33:05,099
si quisiera

557
00:33:05,099 --> 00:33:08,440
uno por línea, aquí en vez de un espacio

558
00:33:08,440 --> 00:33:09,940
le podría poner un barra n

559
00:33:09,940 --> 00:33:12,079
entonces me está diciendo hola Luis

560
00:33:12,079 --> 00:33:14,660
y un barra n que quiere decir vete a una nueva línea

561
00:33:14,660 --> 00:33:16,220
es un único string

562
00:33:16,220 --> 00:33:22,640
que pero me está diciendo esto en una línea, esto en otra línea, esto en otra línea. Pero así, me lo escribiría todo en la misma línea.

563
00:33:25,759 --> 00:33:33,359
Lucas, ¿entendéis la diferencia entre una función y un apreciamiento? ¿Está claro?

564
00:33:33,359 --> 00:33:49,579
Entonces, tengo un mail. Scanner S bla bla, leggi num, que pone dame el primer número de rectángulo, coma S.

565
00:33:49,579 --> 00:33:59,599
leggi num dame el lado del rectángulo coma S, pregunta ¿estos dos, leggi num,

566
00:33:59,599 --> 00:34:18,210
que son llamadas a procedimiento o a función? ¿Leggi num es un procedimiento o una función?

567
00:34:18,210 --> 00:34:28,489
¿Me espero que me devuelva algo o no? Sí, porque lo guardo dentro de algo.

568
00:34:28,489 --> 00:34:32,630
Y si espero que me devuelva algo, es una función.

569
00:34:33,329 --> 00:34:37,409
De hecho, si me voy a legendum, veis que aquí no tiene void, tiene int.

570
00:34:37,769 --> 00:34:41,510
Entonces, es una función que hace algo y al final devuelve un entero.

571
00:34:43,150 --> 00:34:43,269
¿Sí?

572
00:34:44,510 --> 00:34:46,150
Vamos a ver qué hace esta cosa aquí.

573
00:34:46,469 --> 00:34:48,949
Él recibe un string y un scanner.

574
00:34:50,650 --> 00:34:54,570
El scanner lo creo aquí y se lo paso como parámetro a este método.

575
00:34:54,570 --> 00:35:12,449
De esta forma, este tiene el teclado, tiene este método estándar y puede leer de teclado y lo usa así. Escribe el mensaje, que en mi caso será dame el primer lado del triángulo porque estará asociado con este mensaje. La segunda vez será dame el otro lado del triángulo porque estará asociado con este mensaje.

576
00:35:12,449 --> 00:35:16,690
Y luego dice, int numLeaders igual a teclado punto next int.

577
00:35:17,170 --> 00:35:19,070
¿Qué es teclado? Es un objeto escáner.

578
00:35:19,190 --> 00:35:23,989
Pero aquí no lo he definido el objeto escáner, porque lo recibo aquí.

579
00:35:25,030 --> 00:35:26,170
Es este objeto escáner.

580
00:35:26,849 --> 00:35:33,409
Objeto escáner lo creo una vez y luego te lo doy a ti para que lo uses aquí.

581
00:35:35,530 --> 00:35:37,670
¿Cuál es el parámetro formal? Esto.

582
00:35:37,670 --> 00:35:46,030
Y yo te digo, tú tendrás un escáner y lo podrás usar como se usan los escáner.

583
00:35:46,489 --> 00:35:47,949
¿Cuál es el parámetro actual?

584
00:35:48,369 --> 00:35:50,230
Este escáner creado aquí.

585
00:35:53,570 --> 00:35:55,449
Tú necesitarás un mensaje.

586
00:35:55,929 --> 00:35:56,349
¿Cuál es?

587
00:35:56,409 --> 00:35:56,889
No lo sé.

588
00:35:57,150 --> 00:35:58,650
Escribe el mensaje en pantalla.

589
00:35:59,309 --> 00:35:59,469
¿Vale?

590
00:36:00,070 --> 00:36:01,230
¿Cuál será el mensaje?

591
00:36:01,510 --> 00:36:02,550
Este mensaje.

592
00:36:03,429 --> 00:36:05,550
Parámetro actual, parámetro formal.

593
00:36:06,389 --> 00:36:06,769
¿Se entiende?

594
00:36:06,769 --> 00:36:08,869
¿Te gusta?

595
00:36:08,869 --> 00:36:21,829
se devuelve, devuelve en un leído. O sea, este de aquí, LEGINUM, es una forma distinta, más fácil,

596
00:36:21,829 --> 00:36:27,650
¿vale?, de hacer lo que hemos siempre hecho nosotros, de escribir un mensaje, de oye,

597
00:36:27,650 --> 00:36:36,179
dame un número, leer el número y escribirlo. Ahora, en vez de tener que hacer estas tres

598
00:36:36,179 --> 00:36:41,320
líneas de código para leer un código, pues tengo una línea sola que es LEGINUM con su mensaje,

599
00:36:41,320 --> 00:36:49,820
S y S. ¿Por qué? Porque me gusta aquí. Ya lo podía hacer aquí. ¿Sí? ¿Sí? ¿Vale?

600
00:36:50,519 --> 00:36:53,719
Entonces, leyes y números. Leyes y números lo que hacen es leer un número del teclado.

601
00:36:53,960 --> 00:36:57,940
Perfecto. He leído el lado 1 y el lado 2. ¿Y ahora qué hace? Dice, int área es igual

602
00:36:57,940 --> 00:37:05,179
a calcular el lado 1 y el lado 2. Pregunta para vosotros. ¿Calcular área es un procedimiento

603
00:37:05,179 --> 00:37:18,670
no funciona. ¿Quién dice procedimiento? ¿Quién dice función? ¿Quién dice no tengo

604
00:37:18,670 --> 00:37:27,559
idea? Es una función. ¿Por qué? Porque lo que hago lo guardo en algún lado y porque

605
00:37:27,559 --> 00:37:39,820
calcularia tiene aquí interno voy. Más preguntas. ¿Cuáles son los parámetros actuales de

606
00:37:39,820 --> 00:37:56,659
calcular para nuestros actuales serán lo que he leído por teclado aquí aquí

607
00:37:56,659 --> 00:38:02,960
son los formales estos los que no sé cuál será pero sé que me

608
00:38:02,960 --> 00:38:10,699
darán un lado uno o dos cuál es el la firma del método

609
00:38:10,699 --> 00:38:26,269
calcular ya lo sabe

610
00:38:26,269 --> 00:38:40,670
calcularia int, tal tal, dos int, calcularia int int, esa es su firma, ¿sí?, ¿cuál

611
00:38:40,670 --> 00:39:03,969
es la firma de leggi num?, leggi es le en italiano, leggi num string scanner, esa es

612
00:39:03,969 --> 00:39:10,969
¿Cuál es el prototipo de calcularia?

613
00:39:10,969 --> 00:39:26,159
El prototipo de calcularia es toda esta cosa aquí.

614
00:39:26,159 --> 00:39:30,159
Public static int calcularia int int.

615
00:39:30,159 --> 00:39:32,159
Ese es su prototipo.

616
00:39:32,159 --> 00:39:39,480
Entonces, he llegado aquí y he leído dos números en la apuesta en el lado uno y en el lado dos.

617
00:39:39,480 --> 00:39:43,480
Luego he llamado calcularia, pasándole lo que he leído.

618
00:39:43,480 --> 00:39:50,260
por lo tanto él me ha hecho este cálculo de aquí y lo ha devuelto por lo tanto esta cosa de aquí

619
00:39:50,260 --> 00:39:58,360
calcula área de lado uno lado dos vale este valor de aquí y lo guardo dentro de área y a este punto

620
00:39:58,360 --> 00:40:07,360
hago pinta bonito lado uno lado dos lado área sin mirar abajo me podéis decir cuál es el prototipo

621
00:40:07,360 --> 00:40:28,150
de, no miréis la pantalla, el prototipo, perdón, la firma de tinta bonito, firma de pinta bonito,

622
00:40:33,929 --> 00:40:45,630
int, int, int, que pinta bonito, retirar tres enteros, el entero A, el entero B, el entero R,

623
00:40:45,630 --> 00:40:50,630
Pero A será un lado, entero B será otro lado, R será el resultado, ¿vale?

624
00:40:50,630 --> 00:40:56,630
Y lo que hace es dibujar esto con un marquito bonito, ¿sí?

625
00:40:56,630 --> 00:41:11,010
Me hace un marquito así, pues luego escribe rectángulo de lados A y B tiene área R y luego me pone otra marquita, ¿sí?

626
00:41:11,010 --> 00:41:16,010
Pregunta, ¿pinta bonito es una función o un procedimiento?

627
00:41:16,010 --> 00:41:36,099
Procedimi. ¿Por qué? Porque se me voy de aquí. ¿Por qué? Porque cuando yo lo llamo, no guardo el resultado de ningún lado, ¿sí?

628
00:41:36,099 --> 00:41:41,099
¿Dudas? ¿Se entiende un poquito?

629
00:41:41,099 --> 00:41:48,099
Pregunta, ¿podría eroter este programa sin usar ninguno de estos tres métodos?

630
00:41:48,099 --> 00:41:53,260
Si, pillo esto, lo copio allí, pillo esto, lo copio allí, pillo esto, lo copio aquí, ya está.

631
00:41:53,920 --> 00:41:55,219
Esto lo copiaría dos veces.

632
00:42:00,139 --> 00:42:05,840
Pero el main queda mucho más bonito así, que si lo hacéis un poco más de pago con esta cosa.

633
00:42:06,320 --> 00:42:14,019
Además, si yo leo este código, porque es la primera vez que lo veo, sin mirar estos, pues puedo más o

634
00:42:14,019 --> 00:42:21,360
Tienen que entender qué está haciendo de una forma más rápida y más interesante que leyendo literalmente el código de estado.

635
00:42:22,760 --> 00:42:23,199
¿Entienden?

636
00:42:26,119 --> 00:42:28,400
Parámetros formales y parámetros actuales.

637
00:42:28,400 --> 00:42:33,400
Los parámetros formales son los que se usan dentro de la función o del procedimiento.

638
00:42:33,539 --> 00:42:38,139
No tienen un valor concreto hasta que se llame la función o el procedimiento.

639
00:42:38,760 --> 00:42:40,079
Son abstractos.

640
00:42:41,000 --> 00:42:42,099
Son estos.

641
00:42:43,260 --> 00:42:44,659
MSG y teclado.

642
00:42:44,800 --> 00:42:45,980
Lado 1 y lado 2.

643
00:42:45,980 --> 00:42:48,139
A, B y D, R. ¿Cuánto valen?

644
00:42:48,239 --> 00:42:50,039
No lo sé. Yo sé sólo que tú

645
00:42:50,039 --> 00:42:51,900
me darás un A, que es un entero,

646
00:42:51,980 --> 00:42:53,760
un B, que es un entero, un R, que es un entero.

647
00:42:54,039 --> 00:42:56,119
Y yo escribiré el rectángulo

648
00:42:56,119 --> 00:42:58,039
de lado y luego pego lo que tú me has

649
00:42:58,039 --> 00:42:59,840
dado en A y

650
00:42:59,840 --> 00:43:01,539
pego lo que me has dado en B,

651
00:43:01,920 --> 00:43:04,039
tiene área y pego lo que pones en R.

652
00:43:04,500 --> 00:43:05,940
Yo sé eso. Sé cómo

653
00:43:05,940 --> 00:43:08,099
los uso, pero no sé cuáles serán los valores

654
00:43:08,099 --> 00:43:08,739
reales.

655
00:43:10,920 --> 00:43:11,840
Sin embargo,

656
00:43:12,360 --> 00:43:13,920
los parámetros actuales son

657
00:43:13,920 --> 00:43:15,920
los valores concretos que se asignan

658
00:43:15,920 --> 00:43:20,519
los parámetros formales a la hora de llamar la función o procedimiento.

659
00:43:20,659 --> 00:43:25,539
Es decir, que cuando llamo, pinta bonito, lado 1, lado 2, lado 3, área,

660
00:43:25,980 --> 00:43:28,360
lo que estoy haciendo es, mírame que está en lado 1.

661
00:43:28,760 --> 00:43:32,579
¿Hay 3? Pues vete aquí y A vale 3.

662
00:43:32,980 --> 00:43:34,900
En esta llamada A vale 3.

663
00:43:35,420 --> 00:43:39,219
¿Lado 2 cuánto es? 7. Pues pillo 7 y lo pongo en B.

664
00:43:39,659 --> 00:43:41,500
B en esta llamada vale 7.

665
00:43:42,059 --> 00:43:43,480
Y aquí valdrá 7 por 3.

666
00:43:43,480 --> 00:44:01,489
Caveat, que en latino quiere decir cuidado, ¿sí?, funciones y procedimientos son propios

667
00:44:01,489 --> 00:44:06,730
de la programación estructurada, que es a lo que estamos nosotros más sobrenombrados.

668
00:44:06,730 --> 00:44:11,190
En Java se suele hablar más bien de métodos, sin embargo, el concepto de métodos está

669
00:44:11,190 --> 00:44:17,570
vinculado a la programación orientada a objetos, en particular al concepto de clase y objeto,

670
00:44:17,570 --> 00:44:21,090
que nosotros no sabemos nada por ahora.

671
00:44:21,090 --> 00:44:49,730
Todo esto para decir que lo que hemos visto hasta ahora es un uso impropio de Java, estamos omitiendo la parte orientada a objetos, nosotros no sabemos qué son los objetos, no sabemos cómo estamos utilizando los objetos, no sabemos cuando hacemos scan.nextInt que estamos llamando un método de un objeto y no un método estático, y no sabemos qué quiere decir estático, que estático está asociado a la clase y no estático está asociado al objeto, para nosotros parecen palabras de un idioma arcano y maléfico,

672
00:44:49,730 --> 00:44:54,269
Y no lo entenderemos hasta que veamos clases y objetos.

673
00:44:57,329 --> 00:45:00,869
Cuando llegará el momento, en un futuro lejano, como por ejemplo diciembre,

674
00:45:01,429 --> 00:45:06,269
volveremos a retomar estos conceptos y preguntaremos más en temas como

675
00:45:06,269 --> 00:45:09,230
¿qué es este static? ¿qué es este public?

676
00:45:09,969 --> 00:45:13,309
¿qué es el parámetro cuando se pasa un parámetro?

677
00:45:13,670 --> 00:45:17,070
¿qué quiere decir que se pasa por valor o se pasa por referencia?

678
00:45:17,070 --> 00:45:26,630
que es una referencia a un objeto, que es una clase, etc., etc., todos estos temas vendrán en un futuro, ¿vale?

679
00:45:26,869 --> 00:45:34,730
Esto para deciros que no es que sabéis todo de métodos, sabéis una espincelada pequeña, ¿vale?

680
00:45:41,219 --> 00:45:45,820
Bueno, hagamos un par de ejemplos, justo porque os quedan grabados, ¿vale?

681
00:45:46,719 --> 00:45:49,599
Y luego ya veremos qué hacemos.

682
00:45:59,639 --> 00:46:03,230
Ejemplo, procedimos.

683
00:46:03,489 --> 00:46:06,489
Entonces, y aquí tengo un main.

684
00:46:08,150 --> 00:46:10,090
El main es el punto de acceso.

685
00:46:10,230 --> 00:46:11,170
El main es un método.

686
00:46:12,489 --> 00:46:15,010
¿Es un procedimiento o no funciona el main?

687
00:46:26,800 --> 00:46:28,679
Es un procedimiento, porque voy.

688
00:46:31,460 --> 00:46:36,219
Cuidado, en algunos casos, como por ejemplo en C o C++,

689
00:46:36,800 --> 00:46:39,679
el método main devuelve un valor.

690
00:46:40,480 --> 00:46:42,579
Aquí también en realidad se devuelve un valor.

691
00:46:43,440 --> 00:46:44,639
Ahora déjame ver si se ve.

692
00:46:44,659 --> 00:46:49,820
Porque te dice que si te devuelve cero, un entero cero, ha ido todo bien,

693
00:46:50,380 --> 00:46:52,039
he acabado sin problemas.

694
00:46:52,519 --> 00:46:57,380
Si te devuelvo otro numerito, ese numerito representa un código de error.

695
00:46:58,059 --> 00:47:02,179
Ha pasado algo malo en la ejecución, ello ha tenido que colapsar

696
00:47:02,179 --> 00:47:07,860
y te dejo allí un numerito para que tú sepas, en base al numerito que es,

697
00:47:07,980 --> 00:47:08,699
qué ha pasado.

698
00:47:08,920 --> 00:47:10,719
Lo tienes que programar tú, no es automático.

699
00:47:10,719 --> 00:47:15,880
Pero tú tienes opciones mientras va tu código de decidir en determinado caso.

700
00:47:16,159 --> 00:47:19,820
Y si pasa esto, explota con el número 307.

701
00:47:20,280 --> 00:47:25,500
Y tú sabes que cuando explota con el número 307, el error es, no lo sé, no he podido leer el fichero.

702
00:47:26,699 --> 00:47:31,300
Y el error 409 es, tengo conexión a internet.

703
00:47:31,900 --> 00:47:33,440
Lo sabes tú que has programado.

704
00:47:34,039 --> 00:47:38,760
Pero en general, ya se puede hacer y se puede leer, pero por ahora lo dejamos.

705
00:47:38,760 --> 00:47:41,280
Asumamos que este de aquí es un profil

706
00:47:41,280 --> 00:47:41,900
¿Vale?

707
00:47:42,760 --> 00:47:45,219
¿Qué vamos a hacer? Pues vamos a

708
00:47:45,219 --> 00:47:57,119
Vamos a hacer un menú

709
00:47:57,119 --> 00:48:00,099
¿Vale? Que si te doy uno

710
00:48:00,099 --> 00:48:03,760
Me dices si un número que te doy

711
00:48:03,760 --> 00:48:04,460
Es primo o no

712
00:48:04,460 --> 00:48:08,480
Y si te doy dos

713
00:48:08,480 --> 00:48:11,579
Con uno es un programa

714
00:48:11,579 --> 00:48:13,340
Para saber si es par o impar

715
00:48:13,340 --> 00:48:15,019
Con dos

716
00:48:15,019 --> 00:48:17,000
para si es múltiplo de un número

717
00:48:17,000 --> 00:48:17,460
que te doy.

718
00:48:19,460 --> 00:48:21,199
Entonces, yo te pido

719
00:48:21,199 --> 00:48:22,420
hay un menú, ¿vale?

720
00:48:22,840 --> 00:48:24,840
Para pintar el menú, llamo

721
00:48:24,840 --> 00:48:25,960
pinta menú.

722
00:48:27,739 --> 00:48:28,739
Pinta menú

723
00:48:28,739 --> 00:48:30,639
escribe el menú

724
00:48:30,639 --> 00:48:32,480
de las opciones que yo tengo.

725
00:48:33,460 --> 00:48:35,179
¿Vale? Pregunta para vosotros.

726
00:48:35,840 --> 00:48:37,099
¿Pinta menú es

727
00:48:37,099 --> 00:48:38,860
una función

728
00:48:38,860 --> 00:48:39,880
o un procedimiento?

729
00:48:46,199 --> 00:48:46,760
Depende.

730
00:48:48,059 --> 00:48:49,539
¿Sólo pinta el menú?

731
00:48:49,539 --> 00:48:50,880
es un procedimiento

732
00:48:50,880 --> 00:48:53,380
pinta el menú

733
00:48:53,380 --> 00:48:54,860
y me pide la opción

734
00:48:54,860 --> 00:48:57,639
y te devuelve la opción que ha elegido el usuario

735
00:48:57,639 --> 00:48:59,139
sería una función

736
00:48:59,139 --> 00:49:01,480
¿cómo lo queréis?

737
00:49:02,260 --> 00:49:03,760
¿como procedimiento o como función?

738
00:49:04,260 --> 00:49:07,989
como función

739
00:49:07,989 --> 00:49:09,269
¿vale? entonces

740
00:49:09,269 --> 00:49:10,750
yo pondré aquí

741
00:49:10,750 --> 00:49:13,750
int opción elegida

742
00:49:13,750 --> 00:49:15,769
es igual a

743
00:49:15,769 --> 00:49:16,570
pinta menú

744
00:49:16,570 --> 00:49:19,789
¿ok? ahora o me lo escribo

745
00:49:19,789 --> 00:49:25,730
yo o si no aquí si vais aquí os lo dice o mira que no lo encuentro pinta menú quieres crearlo

746
00:49:25,730 --> 00:49:40,860
aquí y me crea el el o sea maestro no el prototipo es eso vale basado sobre lo que

747
00:49:40,860 --> 00:49:47,300
ha visto aquí él ha visto que lo que quieres tú es un int pues entonces te pongo un int vale y ya

748
00:49:47,300 --> 00:49:56,420
que estoy te digo mira te pongo un retorno tanto tienes que poner fijaos que si yo lo haga así y le

749
00:49:56,420 --> 00:50:02,000
digo oye a lo tú pues se me dice a vale como no lo metes en un lado asumo que esto es un

750
00:50:02,000 --> 00:50:16,010
procedimiento como voy a esta ayuda fijaos también que él te lo pone privado y que quiere decir esto

751
00:50:16,010 --> 00:50:24,349
ni idea public vale él te pone lo que él quiere y luego eres tú que si no te vale lo que ve desde

752
00:50:24,349 --> 00:50:36,449
que allí pues lo modificas vale entonces aquí el pintar menos vale y el resultado de esta de

753
00:50:36,449 --> 00:50:44,389
esta función irá en opción elegida vale entonces aquí yo tengo que hacer todo el código que me

754
00:50:44,389 --> 00:50:55,610
Pinta el menú, le pide al usuario qué opción quieres, y luego la recoja, la lea, y a ese punto esa opción me la devuelve, ¿vale?

755
00:50:55,989 --> 00:50:59,349
Entonces, quinta opción, es igual a C.

756
00:51:01,170 --> 00:51:03,710
Lo que hago es escribir el menú, CISO.

757
00:51:05,550 --> 00:51:09,849
Uno, par o impar.

758
00:51:13,380 --> 00:51:18,690
Dos, múltiplo de N.

759
00:51:18,690 --> 00:51:29,820
3, salí

760
00:51:29,820 --> 00:51:33,050
3 opciones

761
00:51:33,050 --> 00:51:35,670
¿vale? y ahora como soy

762
00:51:35,670 --> 00:51:37,730
una función, quiero preguntarle

763
00:51:37,730 --> 00:51:39,469
¿vale? ¿qué quieres hacer?

764
00:51:40,090 --> 00:51:44,139
elige, y aquí

765
00:51:44,139 --> 00:51:45,539
scanner

766
00:51:45,539 --> 00:51:48,219
scan es igual a new scanner

767
00:51:48,219 --> 00:51:50,519
de system.in

768
00:51:50,519 --> 00:51:55,079
bueno, opción

769
00:51:55,079 --> 00:51:57,880
opción es igual

770
00:51:57,880 --> 00:51:59,820
a scan.next

771
00:51:59,820 --> 00:52:06,940
y aquí

772
00:52:06,940 --> 00:52:20,960
opción. Yo pinto el menú. El menú me dice las opciones que tengo, ¿vale? Me dice de elegir, a este punto

773
00:52:20,960 --> 00:52:31,460
yo busco, leo una cosa por teclado, lo que he leído lo devuelvo. ¿A quién llegará? Aquí. Y este de aquí

774
00:52:31,460 --> 00:52:33,360
será esta opción que yo he pintado

775
00:52:33,360 --> 00:52:34,380
entonces la pondrá

776
00:52:34,380 --> 00:52:37,539
si yo

777
00:52:37,539 --> 00:52:39,460
escribo aquí opción

778
00:52:39,460 --> 00:52:46,230
elegida, pasa esto

779
00:52:46,230 --> 00:52:49,840
me ha escrito el menú

780
00:52:49,840 --> 00:52:52,019
me dice elige, está funcionando

781
00:52:52,019 --> 00:52:54,159
pero está parado, yo le pongo 3

782
00:52:54,159 --> 00:52:55,219
y me dice

783
00:52:55,219 --> 00:52:56,420
a 3

784
00:52:56,420 --> 00:52:59,360
fijaos

785
00:52:59,360 --> 00:53:11,380
soy pinta menú

786
00:53:11,380 --> 00:53:22,400
pinta menú

787
00:53:22,400 --> 00:53:23,739
ha acabado

788
00:53:23,739 --> 00:53:32,480
esto lo está escribiendo el método

789
00:53:32,480 --> 00:53:34,280
ha escrito todo esto

790
00:53:34,280 --> 00:53:35,760
no ha acabado todavía

791
00:53:35,760 --> 00:53:37,239
le pongo 3

792
00:53:37,239 --> 00:53:40,519
acaba y esto lo escribe

793
00:53:40,519 --> 00:53:43,019
el main

794
00:53:43,019 --> 00:53:44,219
¿lo veis?

795
00:53:44,940 --> 00:53:46,239
pregunta para vosotros

796
00:53:46,239 --> 00:53:48,400
¿por qué esto no lo escribe aquí abajo?

797
00:53:55,730 --> 00:53:57,210
porque cuando llega

798
00:53:57,210 --> 00:53:59,550
a return se ha acabado

799
00:53:59,550 --> 00:54:01,289
return es

800
00:54:01,289 --> 00:54:02,929
he acabado

801
00:54:02,929 --> 00:54:04,809
vuelve a quien me ha llamado

802
00:54:04,809 --> 00:54:12,730
retorna, devuelve, vuelve a donde estabas antes. Entonces todo lo que está después de return es

803
00:54:12,730 --> 00:54:20,829
inalcanzable. Se lo dice. Unreachable code. Código inalcanzable. Código inalcanzable. No puede llegar

804
00:54:20,829 --> 00:54:30,960
aquí porque esto me bloquea antes. Por eso lo he apostado. Bueno, lo borro porque... ¿Os gusta?

805
00:54:30,960 --> 00:54:55,599
Si le pongo "-7", pero debería decir, no me vale, y pedirte otra cosa. Pregunta, ¿quién no debería mirar esta cosa?

806
00:54:55,599 --> 00:55:05,380
O sea, ¿es el Main que tiene que mirar que esta opción elegida esté bien, o es el mismo Pintamenu

807
00:55:05,380 --> 00:55:07,800
que debería mirar si esta opción

808
00:55:07,800 --> 00:55:08,280
está bien.

809
00:55:10,920 --> 00:55:11,900
No lo sé.

810
00:55:12,599 --> 00:55:13,559
Las dos son opciones

811
00:55:13,559 --> 00:55:14,920
válidas. ¿Vale?

812
00:55:15,159 --> 00:55:17,420
En un caso, aquí esto

813
00:55:17,420 --> 00:55:19,079
lo debería meter en un while

814
00:55:19,079 --> 00:55:21,099
que mientras, mirad,

815
00:55:27,960 --> 00:55:29,760
asumo que esto valga menos uno.

816
00:55:31,119 --> 00:55:31,739
Un valor

817
00:55:31,739 --> 00:55:32,800
que no es válido.

818
00:55:32,800 --> 00:55:34,079
Y te digo que

819
00:55:34,079 --> 00:55:36,659
opción

820
00:55:36,659 --> 00:55:38,679
elegida

821
00:55:38,679 --> 00:55:42,420
sea menor que cero

822
00:55:42,420 --> 00:55:43,800
menor que 1

823
00:55:43,800 --> 00:55:45,159
y

824
00:55:45,159 --> 00:55:48,860
opción elegida

825
00:55:48,860 --> 00:55:52,820
sea mayor que 3

826
00:55:52,820 --> 00:55:54,679
o sea una opción no

827
00:55:54,679 --> 00:55:58,139
válida, entra aquí

828
00:55:58,139 --> 00:55:59,659
dentro y pinta el menú

829
00:55:59,659 --> 00:56:03,780
él lo que hará es, vale, muy bien

830
00:56:03,780 --> 00:56:05,559
entra aquí dentro, como vale

831
00:56:05,559 --> 00:56:07,440
menos 1 al principio, entro y

832
00:56:07,440 --> 00:56:09,440
llamo el menú, si tú me das un

833
00:56:09,440 --> 00:56:10,880
valor que no es

834
00:56:10,880 --> 00:56:13,300
él volverá a escribir el pinta menú

835
00:56:13,300 --> 00:56:28,610
porque lo vuelve a llamar

836
00:56:28,610 --> 00:56:29,409
¿Y qué es un número?

837
00:56:31,329 --> 00:56:38,429
Mientras que sea menor que 1 o mayor que 3, o sea, un valor no válido, quédate allí dentro.

838
00:56:38,929 --> 00:56:39,210
No i.

839
00:56:40,469 --> 00:56:46,030
Porque ningún número será nunca menor que 1 y a la vez mayor que 3.

840
00:56:46,389 --> 00:56:48,889
¿Cuál es un número que es menor que 1 y mayor que 3?

841
00:56:50,349 --> 00:56:51,090
No existe.

842
00:56:51,710 --> 00:56:51,909
¿Vale?

843
00:56:51,989 --> 00:56:52,670
Que te me he equivocado.

844
00:56:53,949 --> 00:56:54,210
Vale.

845
00:56:54,510 --> 00:56:55,769
¿Y vosotros por qué no lo habéis dicho?

846
00:56:55,769 --> 00:56:58,670
entonces dice, ah si, dame un número

847
00:56:58,670 --> 00:57:00,730
elige, y te digo, menos 8

848
00:57:00,730 --> 00:57:01,469
y él dice

849
00:57:01,469 --> 00:57:03,230
otra vez el menú

850
00:57:03,230 --> 00:57:07,739
hasta que elija

851
00:57:07,739 --> 00:57:09,039
2

852
00:57:09,039 --> 00:57:13,920
esto lo he hecho

853
00:57:13,920 --> 00:57:15,900
aquí, en el main

854
00:57:15,900 --> 00:57:18,679
es una opción, otra opción

855
00:57:18,679 --> 00:57:20,800
es no hacerlo en el main y hacerlo aquí

856
00:57:20,800 --> 00:57:21,159
aquí dentro

857
00:57:21,159 --> 00:57:22,880
¿lo creéis?

858
00:57:25,139 --> 00:57:26,800
yo aquí podría hacer

859
00:57:26,800 --> 00:57:28,420
también, no, voy a hacer

860
00:57:28,420 --> 00:57:53,500
Entonces esta es una opción y esta es otra opción. Entonces si lo quiero delegar al pinta menú

861
00:58:03,860 --> 00:58:17,019
y controla. Si elijo esta opción de aquí, llamo pinta menú. Nada más, pinta menú es tonto,

862
00:58:17,019 --> 00:58:23,019
entre comillas, solo pinta y recibe una cosa, no controla nada. Si en vez uso esta otra opción,

863
00:58:23,019 --> 00:58:29,179
pues uso pinta menú y controla, que es otro método que además de pintar el menú y leer,

864
00:58:29,179 --> 00:58:52,400
ahora controla si está bien o no. Entonces, dile opción sea menor que 0 o opción mayor que 3,

865
00:58:53,480 --> 00:59:39,920
Podría añadir aquí un if, esta misma cosa de aquí, opción no válida, no me gusta

866
00:59:39,920 --> 00:59:50,639
mucho esto porque esta vez estoy comprobando la misma cosa dos veces. Entonces si hago

867
00:59:50,639 --> 01:00:01,679
menos 5, mi reducción no vale. Una opción para evitar que haga dos veces esto. Hago

868
01:00:01,679 --> 01:00:39,820
esta cosa de aquí. Entonces una vez lo hago siempre. Y leo la primera. Si tú me has dado

869
01:00:39,820 --> 01:00:46,420
un valor que no es válido entonces entraré aquí te diré opción no válida y te lo vuelvo a pedir

870
01:00:46,420 --> 01:00:52,079
y ahora entro en este bucle que mientras que tú me lo digas mal pues siempre me quedaré aquí vale

871
01:00:52,079 --> 01:00:58,000
sin embargo si en un determinado momento me das una que es buena o me la das al primero una opción

872
01:00:58,000 --> 01:01:49,219
buena me salto todo esto y salgo pero he escrito dos veces esto y ahí ahora tengo pinta menú que

873
01:01:49,219 --> 01:01:51,280
lo que me hace escribir esto y leer

874
01:01:51,280 --> 01:01:53,639
y cosas por el estilo, me devuelve la opción

875
01:01:53,639 --> 01:01:55,719
si la opción es correcta

876
01:01:55,719 --> 01:01:57,179
entonces salgo directamente

877
01:01:57,179 --> 01:01:59,340
si la opción no es correcta, escribo opción

878
01:01:59,340 --> 01:02:01,039
no valida y vuelvo a llamar pinta menú

879
01:02:01,039 --> 01:02:08,070
de esta forma, si ahora

880
01:02:08,070 --> 01:02:10,210
tengo que modificar el menú

881
01:02:10,210 --> 01:02:12,650
en vez de tener que modificarlo dos veces

882
01:02:12,650 --> 01:02:14,449
porque lo había escrito dos veces, pues solo

883
01:02:14,449 --> 01:02:16,070
modifico aquí y ya está

884
01:02:16,070 --> 01:02:21,269
y fijaos que ahora yo estoy llamando

885
01:02:21,269 --> 01:02:22,849
desde el main un método

886
01:02:22,849 --> 01:02:24,869
y este método salta aquí

887
01:02:24,869 --> 01:02:26,530
que empieza a llamar esta cosa aquí

888
01:02:26,530 --> 01:02:28,949
y aquí llama otro método que salta aquí

889
01:02:28,949 --> 01:02:30,849
y esto ejecuta todo esto

890
01:02:30,849 --> 01:02:33,010
al final devuelve la opción, vuelve aquí

891
01:02:33,010 --> 01:02:35,269
que es quien ha llamado

892
01:02:35,269 --> 01:02:36,670
lo pone aquí

893
01:02:36,670 --> 01:02:38,889
y cuando llega aquí, quien lo devuelve

894
01:02:38,889 --> 01:02:39,630
vuelve al main

895
01:02:39,630 --> 01:02:42,670
del main salta un método

896
01:02:42,670 --> 01:02:44,809
del método salta otro método, de este método vuelve

897
01:02:44,809 --> 01:02:46,230
el primer método y cosa por esto

898
01:02:46,230 --> 01:02:56,059
empiezo con el método main

899
01:02:56,059 --> 01:03:00,590
el método main llama

900
01:03:00,590 --> 01:03:02,750
el pinta

901
01:03:02,750 --> 01:03:03,570
y controla

902
01:03:03,570 --> 01:03:06,889
el método Pinta y Controla

903
01:03:06,889 --> 01:03:08,750
llama el método

904
01:03:08,750 --> 01:03:10,150
Pinta

905
01:03:10,150 --> 01:03:15,050
cuando el método Pinta acaba

906
01:03:15,050 --> 01:03:17,369
vuelvo al Pinta y Controla

907
01:03:17,369 --> 01:03:18,849
cuando el Pinta y Controla

908
01:03:18,849 --> 01:03:20,469
acaba, vuelvo al Main

909
01:03:20,469 --> 01:03:25,519
Main

910
01:03:25,519 --> 01:03:28,179
pongo por encima Pinta y Controla

911
01:03:28,179 --> 01:03:29,679
pongo por encima el Pinta

912
01:03:29,679 --> 01:03:31,099
quito el Pinta

913
01:03:31,099 --> 01:03:34,460
imaginamos que me equivoco

914
01:03:34,460 --> 01:03:36,440
Main, Pinta y Controla

915
01:03:36,440 --> 01:03:42,199
pongo por encima pinta, vuelvo a pinta de controla, se da cuenta que está mal, vuelve a llamar el pinta,

916
01:03:42,199 --> 01:03:54,400
quito el pinta, quito esto. Siempre vuelvo al último método llamado, no vuelvo directamente al main.

917
01:03:54,400 --> 01:04:02,139
¿Lo veis? Esta cosa de aquí, de que meto una cosa, una cosa encima, una cosa encima,

918
01:04:02,139 --> 01:04:10,500
y quito solo la última, se llama una pila.

919
01:04:11,760 --> 01:04:13,920
Y la estudiaremos en el segundo trimestre.

920
01:04:13,920 --> 01:04:27,780
Esta es hasta llamado last in, first out.

921
01:04:28,800 --> 01:04:34,039
El último que ha llegado es el primero que quito.

922
01:04:38,429 --> 01:04:43,489
Contrapuesto a fifo, first in, first out,

923
01:04:43,489 --> 01:04:52,250
que es la cola que hacemos nosotros a correos. El primero que ha llegado bien atendido es el

924
01:04:52,250 --> 01:04:57,170
primero que quito y ha llegado este el segundo que quito. Primo que ha llegado es el primero que quito.

925
01:04:58,650 --> 01:05:10,579
Leaf o 50. Lo estudiaste. Más. Entonces con este de aquí hemos hecho nuestro control. Nosotros

926
01:05:10,579 --> 01:05:12,360
llamamos pinta y controla

927
01:05:12,360 --> 01:05:14,599
controla, hace un

928
01:05:14,599 --> 01:05:16,179
pinta menú, el pinta menú

929
01:05:16,179 --> 01:05:18,760
recoge una opción, si la opción

930
01:05:18,760 --> 01:05:20,760
funciona, he acabado

931
01:05:20,760 --> 01:05:21,960
si la opción no funciona

932
01:05:21,960 --> 01:05:24,500
no es válida, entro aquí dentro

933
01:05:24,500 --> 01:05:26,619
le diré opción no válida y volveré a repetir

934
01:05:26,619 --> 01:05:28,199
esto hasta que me dé una opción válida

935
01:05:28,199 --> 01:05:29,980
cuando estoy aquí

936
01:05:29,980 --> 01:05:34,510
puedo asumir

937
01:05:34,510 --> 01:05:36,769
tranquilamente que

938
01:05:36,769 --> 01:05:39,050
opción elegida es un número entre

939
01:05:39,050 --> 01:05:46,460
entre 1 y 3

940
01:05:46,460 --> 01:05:48,380
Decidlo

941
01:05:48,380 --> 01:05:50,960
Lo siento murmurarlo, pero no lo decís

942
01:05:50,960 --> 01:05:52,260
¿Por qué?

943
01:05:52,380 --> 01:05:54,059
Porque si no es un número entre 1 y 3

944
01:05:54,059 --> 01:05:55,980
Me quedaré estancado aquí dentro

945
01:05:55,980 --> 01:05:57,699
En este círculo aquí de pedir cosas

946
01:05:57,699 --> 01:06:00,119
¿Vale? Entonces, ahora yo tengo

947
01:06:00,119 --> 01:06:01,940
Opción elegida y sé que opción elegida

948
01:06:01,940 --> 01:06:03,679
Es un número que vale 1, 2 o 3

949
01:06:03,679 --> 01:06:05,860
Y tengo que hacer algo

950
01:06:05,860 --> 01:06:07,539
En base a esa cosa. ¿Y qué hago?

951
01:06:13,920 --> 01:06:14,400
Fitch

952
01:06:14,400 --> 01:06:18,590
Opción elegida

953
01:06:18,590 --> 01:06:22,559
Y tengo varias opciones

954
01:06:22,559 --> 01:06:24,059
Casi

955
01:06:24,059 --> 01:06:53,170
1, 2 puntos, casi, bueno ponemos el break que luego me lo miro, pre-apro, pongámoslo bonito que luego me lo miro, pre-apro, casi, 2 y casi 3, digamos que habría podido dejar que pillara cualquier número y poner aquí un default, ¿vale?

956
01:06:53,170 --> 01:07:00,289
pero ahora como estoy mezclando la opción elegida con opción no válida, caos, ¿vale?

957
01:07:00,730 --> 01:07:04,750
Tengo solo estas tres opciones, caso 1, caso 2 y caso 3.

958
01:07:06,840 --> 01:07:12,900
Entonces, esto se enfada porque lo he escrito mal.

959
01:07:17,579 --> 01:07:27,460
En caso 1 lo que quiero hacer es, hemos dicho paro en paro, ¿vale?

960
01:07:27,460 --> 01:07:32,699
Entonces, llamaré el método par o impar.

961
01:07:36,019 --> 01:07:36,940
¿Qué es esto?

962
01:07:39,159 --> 01:07:41,119
Función o procedimiento.

963
01:07:49,099 --> 01:07:51,340
Procedimiento, porque no lo guardo en ningún lado.

964
01:07:52,420 --> 01:07:57,199
Él hará ahora el programita para hacer el par o impar.

965
01:07:58,119 --> 01:08:02,650
Que lo escribiré aquí, en este método de aquí.

966
01:08:04,230 --> 01:08:09,349
Esto será el metodito que me pillará un número y me dirá si es par o impar.

967
01:08:09,349 --> 01:08:19,050
todo aquí. Si en vez es casi 2, lo que tengo que hacer es múltiplo de n.

968
01:08:19,649 --> 01:08:28,720
Entonces llamaré el método múltiplo n, que estará aquí.

969
01:08:30,380 --> 01:08:36,439
Y si no, si eso, adiós. Y sale.

970
01:08:36,439 --> 01:08:48,409
dudas? Implementamos estos dos métodos que son muy fáciles, vale? Este de aquí,

971
01:08:48,409 --> 01:09:11,760
scannerScan es igual a newScannerDeSystem.int, si eso, dame un número, int num es igual a

972
01:09:11,760 --> 01:09:56,279
scan.exe si num módulo dos es cero, si eso num es par, es impar. Ya lo había importado.

973
01:09:56,279 --> 01:10:01,180
Porque ya lo había utilizado aquí, ¿dónde estaba? Aquí, aquí. Entonces ya lo había

974
01:10:01,180 --> 01:10:07,619
importada aquí. Pero se importa, fíjate, antes de la clase. Entonces, en toda la clase está importante.

975
01:10:10,560 --> 01:10:23,609
Y la segunda opción empieza, que es este de aquí, de múltiplo a n. Es lo mismo, pero pido dos números.

976
01:10:26,369 --> 01:10:44,170
Dame m, no, n. Y luego yo hago esto.

977
01:10:46,409 --> 01:10:55,270
¿es múltiplo de n o no es múltiplo de n?

978
01:11:03,510 --> 01:11:03,689
Sí.

979
01:11:04,470 --> 01:11:08,069
Entonces ahora yo tengo un método,

980
01:11:08,430 --> 01:11:12,350
un procedimiento que lo que hace es calcular si es par o impar

981
01:11:12,350 --> 01:11:20,210
y un otro procedimiento que es calcular si un número es múltiplo de n o no.

982
01:11:23,329 --> 01:11:24,750
Entonces ahora tengo mi programa.

983
01:11:25,750 --> 01:11:38,020
Lanzo mi programa. ¿Qué quieres hacer? Pues el 66, pues opción no válida. El menos 7, opción no válida.

984
01:11:38,020 --> 01:11:43,199
Pues dame un par o impar. Vale, dame un número. 8. Pues 8 es par. Y acabado.

985
01:11:45,800 --> 01:11:57,789
Lanzo. Quiero múltiplo de n. Me dice dame un número 88. Dame n 5. Pues 88 no es múltiplo de 5.

986
01:11:57,789 --> 01:12:02,000
y se ha acabado, lanzo esto

987
01:12:02,000 --> 01:12:03,380
y digo, ¿qué quieres hacer? salir

988
01:12:03,380 --> 01:12:07,699
pues, adiós

989
01:12:07,699 --> 01:12:09,300
ahora

990
01:12:09,300 --> 01:12:12,319
para completar

991
01:12:12,319 --> 01:12:13,279
y definir esto

992
01:12:13,279 --> 01:12:16,159
esta cosa de aquí

993
01:12:16,159 --> 01:12:21,859
la quiero hacer

994
01:12:21,859 --> 01:12:26,079
mientras

995
01:12:26,079 --> 01:12:32,100
mejor, esta cosa de aquí

996
01:12:32,100 --> 01:12:33,760
la quiero hacer mientras

997
01:12:33,760 --> 01:13:06,310
si, mientras

998
01:13:06,310 --> 01:13:08,189
tú no hayas elegido la opción

999
01:13:08,189 --> 01:13:09,270
tres, que es salir

1000
01:13:09,270 --> 01:13:11,550
me quedo allí

1001
01:13:11,550 --> 01:13:13,510
y te pide otra vez el menú

1002
01:13:13,510 --> 01:13:15,689
te pongo el menú, tú eliges

1003
01:13:15,689 --> 01:13:17,829
crear el menú, 1, 2, entras

1004
01:13:17,829 --> 01:13:19,930
en 1, haces par en par, entras en 2

1005
01:13:19,930 --> 01:13:21,770
haces múltiplo par y vuelves aquí

1006
01:13:21,770 --> 01:13:23,989
otra vez, porque has elegido

1007
01:13:23,989 --> 01:13:25,689
1, 2, entonces lo vuelves a hacer

1008
01:13:25,689 --> 01:13:27,409
y me pides otra vez el menú

1009
01:13:27,409 --> 01:13:29,630
y así, así, así, todas las veces que me valga

1010
01:13:29,630 --> 01:13:31,689
hasta que tú me digas 3, que es salir

1011
01:13:31,689 --> 01:13:33,869
y entonces entrará aquí dentro

1012
01:13:33,869 --> 01:13:35,670
escribirá a ellos y saldrá

1013
01:13:35,670 --> 01:13:48,789
aquí hay algo raro

1014
01:13:48,789 --> 01:13:51,409
hay una paréntesis que no me

1015
01:13:51,409 --> 01:13:52,130
gusta

1016
01:13:52,130 --> 01:14:07,920
a play entonces y aquí me puede equivocar me puede equivocar ahora digo paro en par

1017
01:14:07,920 --> 01:14:16,479
pues le digo 88 es parte y vuelve al menú porque como la opción que elegido yo no es

1018
01:14:16,479 --> 01:14:38,180
tres, ha vuelto a pedirme el menú. Y ahora le digo, ¿me das otra vez para impar? Siete, pues es impar. Y vuelve al menú. Le digo, órame un múltiplo. Pues cinco es múltiplo de tres, pues no es múltiplo. Y vuelve al menú. Hasta que yo le diga salir. Entonces me dice adiós y acaba.

1019
01:14:38,180 --> 01:14:56,760
fijaos que mi main se ha quedado bastante limpio vale de que oye mira mientras la opción no sea

1020
01:14:56,760 --> 01:15:07,239
3 pues elige pinta y controla pinta menú y controla mira la opción elegida si es 1 2 o 3

1021
01:15:07,239 --> 01:15:09,039
en base a esto hace una cosa u otra

1022
01:15:09,039 --> 01:15:10,060
y vuelve arriba

1023
01:15:10,060 --> 01:15:13,659
todo lo que es el cálculo puro

1024
01:15:13,659 --> 01:15:15,539
lo he delegado

1025
01:15:15,539 --> 01:15:17,319
a otras funciones

1026
01:15:17,319 --> 01:15:18,500
o a otros métodos

1027
01:15:18,500 --> 01:15:21,779
podría haber hecho todo esto

1028
01:15:21,779 --> 01:15:23,020
sin ningún método

1029
01:15:23,020 --> 01:15:26,079
pero me había metido todo este código

1030
01:15:26,079 --> 01:15:27,939
de aquí, ahora estaría dentro del main

1031
01:15:27,939 --> 01:15:29,960
entonces el main sería mucho menos

1032
01:15:29,960 --> 01:15:30,319
libre

1033
01:15:30,319 --> 01:15:35,409
y por ahora

1034
01:15:35,409 --> 01:15:39,279
nosotros los métodos

1035
01:15:39,279 --> 01:15:41,239
O las funciones y procedimientos

1036
01:15:41,239 --> 01:15:43,079
Nos sirven más o menos para hacer

1037
01:15:43,079 --> 01:15:44,779
Más estructurado, más bonito

1038
01:15:44,779 --> 01:15:46,079
Nuestro código

1039
01:15:46,079 --> 01:15:48,640
Por poco más

1040
01:15:48,640 --> 01:15:51,119
Más reutilizable

1041
01:15:51,119 --> 01:15:52,500
Más bonito

1042
01:15:52,500 --> 01:15:54,600
Más organizado

1043
01:15:54,600 --> 01:15:56,920
Esto es lo que nos sirve para eso

1044
01:15:56,920 --> 01:15:59,079
Tened en cuenta que ahora yo tengo

1045
01:15:59,079 --> 01:15:59,920
Este método de aquí

1046
01:15:59,920 --> 01:16:02,479
Si mañana

1047
01:16:02,479 --> 01:16:04,539
Quiero hacer en otro lado

1048
01:16:04,539 --> 01:16:07,380
Un trozo de código

1049
01:16:07,380 --> 01:16:08,260
Que lo que haga es

1050
01:16:08,260 --> 01:16:10,239
ver si se hace múltiplo, no, no

1051
01:16:10,239 --> 01:16:12,300
pues pillo esto, lo copio allí y lo tengo

1052
01:16:12,300 --> 01:16:16,579
está organizado en funcionalidades

1053
01:16:16,579 --> 01:16:18,300
estructurado

1054
01:16:18,300 --> 01:16:19,619
funcionado

1055
01:16:19,619 --> 01:16:24,109
no oigo

1056
01:16:24,109 --> 01:16:29,229
no oigo vuestro compañero

1057
01:16:29,229 --> 01:16:30,010
ah, perdón

1058
01:16:30,010 --> 01:16:32,210
el cálculo que tenéis ahí en el link

1059
01:16:32,210 --> 01:16:33,930
¿está bien?

1060
01:16:35,069 --> 01:16:35,670
¿listo?

1061
01:16:36,670 --> 01:16:41,699
no, está mal, sí, ahora está bien

1062
01:16:41,699 --> 01:16:43,279
¿no está bien?

1063
01:16:43,279 --> 01:16:44,460
visitado, por ahí.

1064
01:16:46,140 --> 01:16:49,670
Sí. Vale.