1
00:00:00,000 --> 00:00:08,840
vale pues entonces el otro día llegamos a hacer nosotros aquí en la pizarra

2
00:00:08,840 --> 00:00:16,960
silencio hasta este ejercicio verdad y luego ya a partir de ahí os quedasteis

3
00:00:16,960 --> 00:00:21,800
vosotros pues tratando de hacer estas cosas que ahora ahora revisaremos y todo

4
00:00:21,800 --> 00:00:31,360
eso vale vamos a volver un momentito a este este que tenía su dificultad para

5
00:00:31,360 --> 00:00:36,720
usarlo como repaso para situarnos y de paso

6
00:00:37,520 --> 00:00:40,360
dar una

7
00:00:40,680 --> 00:00:46,080
herramienta adicional para programar este tipo de

8
00:00:46,160 --> 00:00:53,360
ejercicios vale vamos a volver otra vez a este pedir un número y mostrar la

9
00:00:53,360 --> 00:00:59,520
lista de todos los números inferiores a él que sean primos entonces ese ejercicio

10
00:00:59,520 --> 00:01:04,520
solicitaba un número ahora tenía que recorrer todos los inferiores a él con

11
00:01:04,520 --> 00:01:08,640
lo cual ahí ya visualizamos un primer bucle un primer bucle que va pasando por

12
00:01:08,640 --> 00:01:14,600
1 2 3 así hasta en o al revés por en en menos 1 en menos 2 así hasta un

13
00:01:14,600 --> 00:01:23,000
primer bucle y ahora con cada numerito por el que pasaba ese bucle es decir en

14
00:01:23,000 --> 00:01:27,520
cada iteración que hacía con ese numerito ver si era primo no

15
00:01:27,520 --> 00:01:32,680
luego teníamos un subproblema ver si un número es primo no es primo dentro de un

16
00:01:32,680 --> 00:01:38,400
bucle que va haciendo eso para cada número verdad situación habitual un

17
00:01:38,400 --> 00:01:42,280
programa normalmente se descomponen diferentes subproblemas que yo voy

18
00:01:42,280 --> 00:01:46,960
rellenando pues éste tenía un problema que era un bucle gordo que era ir

19
00:01:46,960 --> 00:01:51,400
recorriendo todos y cada uno de los números inferiores

20
00:01:51,400 --> 00:01:57,120
al número pedido y luego ya tenía dentro de ese bucle en cada iteración

21
00:01:57,120 --> 00:02:02,240
tenía ahora ya un subproblema que era ese número ver si era primo no verdad y

22
00:02:02,240 --> 00:02:07,120
ese ejercicio que era el 14 era este

23
00:02:08,120 --> 00:02:16,560
entonces con este bucle este primer bucle recorríamos todos los números que

24
00:02:16,560 --> 00:02:24,560
iban desde el 1 hasta el 1 menos 1 vale la variable y iba tomando esos valores

25
00:02:24,560 --> 00:02:31,760
tomando 12 vale y ahora para cada numerito y para cada numerito y dentro

26
00:02:31,760 --> 00:02:35,560
ya de esta iteración para cada numerito y pues ya teníamos que resolver ese

27
00:02:35,560 --> 00:02:41,800
subproblema ver si era primo no porque si lo era lo mostrábamos

28
00:02:42,240 --> 00:02:47,240
entonces ese subproblema respondía a este patrón

29
00:02:47,240 --> 00:02:51,920
patrón de ver si algo ocurre o no vale tenemos ya varios patrones que sabemos

30
00:02:51,920 --> 00:02:57,680
resolver varios patrones un patrón es suma de términos suma acumulativa ese

31
00:02:57,680 --> 00:03:01,400
patrón no sabemos responder el resolver tenemos que adaptarlo claro nuestra

32
00:03:01,400 --> 00:03:04,600
situación otro patrón que ya tenemos grabado en la cabeza que sabemos

33
00:03:04,600 --> 00:03:10,000
resolver contar otro patrón que cuando lo identificamos tenemos ya en la cabeza

34
00:03:10,000 --> 00:03:16,760
cómo resolverlo máximo y mínimo vale ya son tres patrones otro patrón este ver

35
00:03:16,760 --> 00:03:22,720
si algo ocurre o no pues ese patrón que es el que responde a esto ver si dado y

36
00:03:22,720 --> 00:03:28,800
es primo no es primo ese patrón de situación posible ver si algo ocurre o

37
00:03:28,800 --> 00:03:33,000
no cuando yo identifico ese patrón de situación ver si algo ocurre o no pues

38
00:03:33,000 --> 00:03:36,960
ese patrón lo podemos programar una variable booleana asumo de partida que

39
00:03:36,960 --> 00:03:42,680
es true o false lo que me interesa en función del problema concreto y ahora en

40
00:03:42,680 --> 00:03:47,680
un bucle busco un contra ejemplo en cuanto encuentro ya uno un contra

41
00:03:47,680 --> 00:03:53,280
ejemplo cambio la suposición de partida cambio la suposición de partida y ya

42
00:03:53,280 --> 00:03:57,520
está cuando he terminado ese recorrido de búsqueda de contra ejemplos ese

43
00:03:57,520 --> 00:04:04,040
boolean me dirá si lo que yo quería saber pasa o no pasa la forma de

44
00:04:04,040 --> 00:04:11,360
programar este problema ver si algo pasa o no pues justo aquí lo que teníamos

45
00:04:11,360 --> 00:04:17,720
dado un y tenemos que ver si es primo no es primo justo es ese patrón dado un y

46
00:04:17,720 --> 00:04:23,680
tengo que ver si se cumple que es primo si no se cumple pues así lo resolvemos

47
00:04:23,680 --> 00:04:28,680
asumimos de partida que es primo porque porque en cuanto ahora yo me pongo a

48
00:04:28,680 --> 00:04:33,360
recorrer son los números inferiores a él entre 2 y n menos y menos uno en este

49
00:04:33,360 --> 00:04:41,120
caso en cuanto encuentre uno que lo divide ya está contra ejemplo con lo

50
00:04:41,120 --> 00:04:44,920
cual puedo cambiar es primo a falso contra gente pues es lo que estamos

51
00:04:44,920 --> 00:04:49,560
haciendo asumo de partida que es primo y me pongo a buscar el contra ejemplo en

52
00:04:49,560 --> 00:04:53,640
el bucle que toque es que depende de la situación el contra ejemplo aquí lo

53
00:04:53,640 --> 00:04:57,000
encontraré si encuentro un divisor porque lo que tengo que averiguar es

54
00:04:57,000 --> 00:04:59,960
espinos encuentro un divisor ahí encontrar el contra ejemplo pues eso

55
00:04:59,960 --> 00:05:07,960
hacemos con este bucle recorremos todos los numeritos desde 2 hasta y menos uno

56
00:05:07,960 --> 00:05:12,800
desde 2 hasta y menos uno usando este bucle for del que ya conocemos la

57
00:05:12,800 --> 00:05:18,920
sintaxis y que nos es muy práctico para este tipo de cosas desde 2 hasta y menos

58
00:05:18,920 --> 00:05:23,480
uno y ahora en cuanto encuentro un jota que divide ahí en cuanto encuentro un

59
00:05:23,480 --> 00:05:27,000
jota que divide ahí ya está tengo contra ejemplo pues como encontré

60
00:05:27,000 --> 00:05:33,080
contra ejemplo es primo falso y ya explicamos bien el otro día porque poner

61
00:05:33,080 --> 00:05:37,120
el ls aquí no tiene sentido etcétera etcétera

62
00:05:37,120 --> 00:05:43,680
que lo tenéis todo en la grabación vale bueno pues ya está este es mi sub

63
00:05:43,680 --> 00:05:48,280
problema una vez ya resuelto mi sub problema tengo en este bullying si lo

64
00:05:48,280 --> 00:05:52,880
que quería ver se cumple o no bueno pues es lo que me faltaba si se cumple

65
00:05:52,880 --> 00:05:58,040
lo muestro y si no se cumple no y todo esto dentro del bucle de fuera

66
00:05:58,040 --> 00:06:02,360
bueno ese es el problema que el ejercicio que resolvió

67
00:06:02,360 --> 00:06:08,000
que efectivamente evidentemente cada cosa se puede hacer de muchas maneras

68
00:06:08,000 --> 00:06:13,960
poder a lo mejor uno podría haber dicho bueno voy a hacer este mismo bucle

69
00:06:13,960 --> 00:06:18,400
este mismo bucle y voy a meterle un contador que cuente los divisores

70
00:06:18,400 --> 00:06:23,720
entonces cada divisor que encuentra entre 2 y menos uno lo cuenta lo cuenta

71
00:06:23,720 --> 00:06:29,280
vale entonces una vez que el bucle ha terminado si ese contador es cero es que

72
00:06:29,280 --> 00:06:33,480
no ha encontrado ninguno entonces la condición podría ser si con es igual a

73
00:06:33,480 --> 00:06:38,160
cero vale si contes igual a cero pues ese número era primo entonces cada cosa se

74
00:06:38,160 --> 00:06:41,920
puede resolver de muchas maneras pero esto que yo he puesto aquí

75
00:06:41,920 --> 00:06:48,240
es el algoritmo genérico responde al algoritmo genérico no ha aplicado a

76
00:06:48,240 --> 00:06:54,000
esta situación en concreto sino genérico que uno utiliza cuando tiene

77
00:06:54,000 --> 00:06:59,520
esa situación ver si algo ocurre o no bullean que asume de partida que eso

78
00:06:59,520 --> 00:07:03,680
ocurre o que eso no ocurre depende de si el contra ejemplo

79
00:07:03,680 --> 00:07:08,640
en qué sentido quiero que vaya y luego ya busco contra ejemplo con que

80
00:07:08,640 --> 00:07:12,040
encuentre uno que me cambia la suposición de partida lo cambia si era

81
00:07:12,040 --> 00:07:17,800
true lo cambia falsa lo cambia y ya está bueno bueno pues nada este ejercicio es

82
00:07:17,800 --> 00:07:21,680
el que hicimos el otro día etcétera etcétera y sobre este en principio no

83
00:07:21,680 --> 00:07:29,360
había dudas no ni las hay ahora no vale bueno pues entonces aquí ya hay una

84
00:07:29,360 --> 00:07:34,400
situación que es un poco fea en este caso no es tan fea porque hombre el

85
00:07:34,400 --> 00:07:39,680
programa no es muy largo pero queda un poco feo a la vista un poco feo a la

86
00:07:39,680 --> 00:07:45,600
vista un bucle dentro de otro que no hay ningún problema esto es que es

87
00:07:45,600 --> 00:07:49,880
imprescindible hacerlo este programa no se puede hacer sin anidar un bucle

88
00:07:49,880 --> 00:07:54,880
dentro de otro porque yo tengo primero que recorrer los inferiores a nun y

89
00:07:54,880 --> 00:08:01,640
luego dentro de un buscar sus divisores mario

90
00:08:01,640 --> 00:08:08,200
vale entonces tengo que hacer lo que es impecable es que para resolver este

91
00:08:08,200 --> 00:08:11,600
ejercicio de hacer un bucle dentro de otro como lo hemos hecho

92
00:08:11,600 --> 00:08:15,960
pero una vez que está escrito el código pues esto a la vista cuando llega a otro

93
00:08:15,960 --> 00:08:19,600
que no lo ha hecho y lo tiene que entender en cuanto empieza a ver bucles

94
00:08:19,600 --> 00:08:24,760
anidados ya le cuesta entenderlo verdad ismael y

95
00:08:24,760 --> 00:08:27,320
compañero

96
00:08:28,320 --> 00:08:32,240
vale si uno que no ha hecho este código va a viene a leerlo en cuanto empieza a

97
00:08:32,240 --> 00:08:36,760
ver bucles anidados ya se puede liar entonces lo de anidar un bucle en otro

98
00:08:36,760 --> 00:08:41,000
cuando hay que hacerlo es que hay que hacerlo es que en muchas cosas para

99
00:08:41,000 --> 00:08:44,720
resolverlas es que hay que hacerlo así no hay otra sin sus problemas y que un

100
00:08:44,720 --> 00:08:49,680
bucle y está dentro de otro pues es que lo tengo que hacer vale pero simplemente

101
00:08:49,680 --> 00:08:55,000
cuando uno viene a leerlo y no lo ha hecho pues se puede liar tengo un bucle

102
00:08:55,040 --> 00:09:00,680
dentro que hace entonces este código se puede recolocar solo recolocar

103
00:09:00,680 --> 00:09:06,040
recolocar para que el problema sea más legible se puede recolocar para que sea

104
00:09:06,040 --> 00:09:09,920
más legible que luego la máquina va a ejecutar lo mismo me da igual cómo esté

105
00:09:09,920 --> 00:09:13,400
recolocado me da lo mismo la máquina va a ejecutar lo mismo

106
00:09:13,400 --> 00:09:19,560
pero el que intenta entender ese código lo va a entender mejor y esto es

107
00:09:19,560 --> 00:09:25,320
importante porque como hemos dicho otras veces la

108
00:09:25,560 --> 00:09:30,600
la bondad entre comillas de un software no es sólo que funcione bien y que la

109
00:09:30,600 --> 00:09:35,400
máquina lo ejecute de forma eficiente y que no haga ciclos de memoria necesarios

110
00:09:35,400 --> 00:09:40,080
no es sólo eso no sólo en términos computacionales en términos de que la

111
00:09:40,080 --> 00:09:44,440
máquina lo ejecute bien sino también otra parte que es importantísima y es

112
00:09:44,440 --> 00:09:48,840
que ese código se entienda para que si luego hay que cambiarle y hacerle

113
00:09:48,840 --> 00:09:53,480
modificaciones que siempre un software tiene un recorrido en el que hay que

114
00:09:53,480 --> 00:09:57,680
modificarlo pues se puede hacer y si es hay un galimatías de código ese software

115
00:09:57,680 --> 00:10:00,800
no se puede mantener y si no se puede mantener es un galimatías de código por

116
00:10:00,800 --> 00:10:04,560
muy bien que funcione si yo no le puedo incorporar ninguna modificación porque

117
00:10:04,560 --> 00:10:08,600
no entiendo nada de lo que hicieron aquí no vale para nada por eso es

118
00:10:08,600 --> 00:10:15,480
importantísimo acostumbrarse a seguir pautas de diseño de código y escritura

119
00:10:15,480 --> 00:10:19,320
de código que hagan códigos legibles aunque luego vayan a hacer lo mismo en

120
00:10:19,320 --> 00:10:22,760
la máquina se vayan a ejecutar igual pero es importante

121
00:10:22,760 --> 00:10:27,040
porque tú enseñas un código a tu jefe que es una patata de código

122
00:10:27,040 --> 00:10:33,200
y te van a dar la porra y ese día y eso mismo con un código más legible pues no

123
00:10:33,200 --> 00:10:37,200
te va a mandar la porra vale bueno pues cómo podríamos hacer este código más

124
00:10:37,200 --> 00:10:41,760
legible es decir cómo podríamos quitar el un bucle dentro del otro

125
00:10:41,760 --> 00:10:46,040
a ver poder no podemos el bucle tiene que estar ahí pero si podemos hacer una

126
00:10:46,040 --> 00:10:50,720
cosa que es recurrir a un término de programación estructurada de toda la

127
00:10:50,720 --> 00:10:55,640
vida de programación de toda la vida que sonará que es el término que se llama

128
00:10:55,640 --> 00:11:02,640
función o procedimiento el término de función o procedimiento que son casi

129
00:11:02,640 --> 00:11:08,600
sinónimos casi sinónimos función o procedimiento recoge una serie de

130
00:11:08,600 --> 00:11:13,640
instrucciones que yo pongo juntitas les doy un nombre

131
00:11:13,640 --> 00:11:18,800
y ahora ya cuando quiero ejecutar esas sentencias me limito a llamarlas por el

132
00:11:18,800 --> 00:11:23,120
nombre que les he dado entonces cuando llame a ese nombre la máquina virtual

133
00:11:23,120 --> 00:11:29,560
plaz saltará ahí y hará todo esto entonces ahora tengo como dos partes lo

134
00:11:29,560 --> 00:11:33,480
que es la función del procedimiento con el código al que le ha dado un nombre y

135
00:11:33,480 --> 00:11:37,520
ahora mi código principal que hace sus cosas y alguna vez quiero que haga esto

136
00:11:37,880 --> 00:11:43,320
pues paz lo llamo vale entonces esto sería algo así

137
00:12:02,920 --> 00:12:04,240
esto sería algo así

138
00:12:07,520 --> 00:12:09,520
y

139
00:12:26,720 --> 00:12:31,400
eso es un concepto fundamental de programación y de hecho la programación

140
00:12:31,400 --> 00:12:36,760
orientada a objetos que es el paradigma de programación de propósito general

141
00:12:37,400 --> 00:12:42,920
que se usa actualmente la orientada a objetos es una mejora de esto una mejora

142
00:12:42,920 --> 00:12:46,720
entre comillas pero es un concepto básico sin el cual no se podría

143
00:12:46,720 --> 00:12:50,680
programar porque se harían programas informables bueno pues entonces el

144
00:12:50,680 --> 00:12:54,480
concepto de función o procedimiento es este yo tengo aquí mi programa estas son

145
00:12:54,480 --> 00:12:59,440
mis sentencias vale cada línea es una sentencia tras otra para la papa sentencia

146
00:12:59,440 --> 00:13:04,000
pues mi programa puede ser interminable puede tener 50.000 sentencias eso es

147
00:13:04,000 --> 00:13:10,200
inmanejable vale pero resulta que a lo mejor estas cuatro yo necesito hacerlas

148
00:13:10,200 --> 00:13:15,120
muchas veces las hago aquí y luego resulta que estas mismas las tengo aquí

149
00:13:15,120 --> 00:13:18,920
abajo también porque luego después tengo que hacer eso y luego después

150
00:13:18,920 --> 00:13:21,560
resulta que a lo mejor vuelvo a necesitar hacerlo a lo mejor una idea de

151
00:13:21,560 --> 00:13:26,440
hacerlo vale ya no me digáis porque no lo metes en un bucle cuidado no porque

152
00:13:26,440 --> 00:13:30,640
si yo no meto en un bucle las hago todas seguidas una otra otra no hablo de esa

153
00:13:30,640 --> 00:13:37,360
idea hablo de que a lo mejor necesito hacer aquí esto por ejemplo Miguel

154
00:13:37,360 --> 00:13:41,920
necesito hacer esto una vez luego mi programa sigue anda necesito hacerlo otra vez

155
00:13:41,920 --> 00:13:46,000
aquí abajo pues te voy a poner las sentencias de nuevo mi programa sigue

156
00:13:46,000 --> 00:13:50,840
hace otras mil cosas diferentes anda esto otra vez necesito hacer pues otra

157
00:13:50,840 --> 00:13:54,440
vez esas líneas ahí abajo vale pues si lo puedo dejar así porque eso es lo que

158
00:13:54,440 --> 00:13:59,200
tiene que hacer el ordenador pero hombre vaya código más feo

159
00:13:59,200 --> 00:14:05,040
y si nosotros cogemos estas cuatro sentencias las ponemos aparte las

160
00:14:05,040 --> 00:14:10,080
ponemos aparte estas cuatro sentencias le damos un nombre el nombre que sea

161
00:14:10,080 --> 00:14:15,240
imaginaos que lo que hace esto pues es yo que sé sumar números cualquier cosa

162
00:14:15,240 --> 00:14:19,200
pues le doy un nombrecito le doy un nombre a estas cuatro líneas le doy un

163
00:14:19,200 --> 00:14:25,200
nombre y ahora cuando quiera hacerlos aquí estas cuatro líneas fuera

164
00:14:25,200 --> 00:14:28,320
y las llamo por su nombre por el nombre que yo le he dado el que a mí me ha

165
00:14:28,320 --> 00:14:32,720
dado la gana a la hay lo llamo pues entonces hombre ya el programa se me ha

166
00:14:32,720 --> 00:14:37,360
quedado un poco más ahora mi programa sigue que aquí abajo necesito volver a

167
00:14:37,360 --> 00:14:42,440
hacer esto otra vez pues bueno en lugar de poner ese código enterito vuelvo a

168
00:14:42,440 --> 00:14:47,040
llamarlo por su nombre el nombre que a mí me haya dado la

169
00:14:47,040 --> 00:14:51,160
gana darle y ahora ya el programa que se ejecuta es este eso está claro es el que

170
00:14:51,160 --> 00:14:55,560
se ejecuta eso se va ejecutando cuando la máquina virtual que ejecuta llegue

171
00:14:55,560 --> 00:15:00,840
aquí lo que hará será saltar ahí ejecutar a esto y cuando termine vuelve

172
00:15:00,840 --> 00:15:06,120
aquí y si anda que se encuentra otra vez la llamada pues vuelve a saltar aquí

173
00:15:06,120 --> 00:15:13,080
ejecuta este cuando termine vuelve aquí y así entonces la ejecución es igual lo

174
00:15:13,080 --> 00:15:17,320
que hacemos es lo mismo realidad lo que el ordenador hace es lo mismo hace esto

175
00:15:17,320 --> 00:15:20,680
luego hace esto una vez luego sigue luego hace esto una vez lo que el

176
00:15:20,680 --> 00:15:25,080
ordenador hace es lo mismo no cambia pero hombre este código queda más

177
00:15:25,080 --> 00:15:28,480
organizado porque en lugar de tener esto recogido que podrían ser mil líneas

178
00:15:28,480 --> 00:15:36,280
recogido 300 veces pues lo llama por su nombre y yo lo tengo aparte

179
00:15:36,280 --> 00:15:41,360
entonces este código queda más claro y sobre todo se oculta información que a

180
00:15:41,360 --> 00:15:45,160
lo mejor no es relevante porque el que quiere mirar este código lo que le

181
00:15:45,160 --> 00:15:49,120
interesa saber que aquí lo que se hacen es sumar números pero como este hecho

182
00:15:49,120 --> 00:15:53,000
por dentro le da exactamente igual eso está fuera me da igual como este hecho

183
00:15:53,000 --> 00:15:57,200
eso por dentro yo sé que aquí se va a llamar a un código que suma números

184
00:15:57,200 --> 00:16:01,640
entonces yo entiendo perfectamente mi programa lo entiendo es mucho más corto

185
00:16:01,640 --> 00:16:07,680
sé que aquí llamo a sumar números me da igual como este hecho y ya está

186
00:16:07,680 --> 00:16:12,600
entonces la principal ventaja que este código va a quedar más legible y la

187
00:16:12,600 --> 00:16:17,800
segunda fundamental que se puede separar el trabajo de desarrollo de programación

188
00:16:18,200 --> 00:16:22,520
a uno se le dice a un programador oye tú hazme esta parte la que suma números muy

189
00:16:22,520 --> 00:16:25,600
bien que yo ya te llamaré desde aquí cuando la tengas me da igual como la

190
00:16:25,600 --> 00:16:29,600
hagas yo me voy a limitar a llamarla pero a la bien claro vale tú vas a otra

191
00:16:29,600 --> 00:16:32,880
parte por ahí que se llame restar números que ya te llamaré yo desde aquí

192
00:16:32,880 --> 00:16:38,240
cuando lo necesite esa parte la hará otro pues se puede separar el código en

193
00:16:38,240 --> 00:16:42,200
partes mucho más fácilmente que cada uno haga su parte y luego el programa

194
00:16:42,200 --> 00:16:49,840
principal las va llamando según lo vaya necesitando que hay que hacer algún

195
00:16:49,840 --> 00:16:53,960
cambio aquí porque la forma de sumar números ha cambiado lo hace el

196
00:16:53,960 --> 00:16:58,400
programador que se ocupe de esto y este código ni lo tocamos y lo tocamos este

197
00:16:58,400 --> 00:17:04,680
está llamando a esto y aquí se incorpora el código que sea entonces se divide se

198
00:17:04,680 --> 00:17:09,760
modulariza que se llama se divide la tarea de desarrollo de un software se

199
00:17:09,760 --> 00:17:14,920
divide y entonces es mucho más eficiente el trabajo podemos separar

200
00:17:14,920 --> 00:17:19,960
entre programadores etcétera vale luego son las dos principales ventajas

201
00:17:19,960 --> 00:17:24,280
legibilidad de los programas al estar organizados así los entiendo mucho

202
00:17:24,280 --> 00:17:30,840
mejor que en otro que 100.000 líneas aquí y luego es poder separar en partes

203
00:17:30,840 --> 00:17:35,920
poder hacer partes separadas y cada uno se ocupe de una si yo toco esta esta no

204
00:17:35,920 --> 00:17:41,360
tengo ni que tocarla etcétera bueno pues este concepto este concepto es el

205
00:17:41,360 --> 00:17:45,280
que se ha llamado de toda la vida programación funciones o procedimientos

206
00:17:45,280 --> 00:17:49,960
esto sería depende del matiz del lenguaje de programación de cosas que

207
00:17:49,960 --> 00:17:55,680
nos interesa un poco lo vamos a aplicar a todo objeto esto es lo que se llamaría

208
00:17:55,680 --> 00:17:59,800
función o procedimiento

209
00:18:00,120 --> 00:18:03,120
vale en

210
00:18:03,840 --> 00:18:08,400
los que hayáis hecho grado medio yo creo que en sistemas operativos así hacéis

211
00:18:08,400 --> 00:18:13,880
programación para ser fuera en linux fuera en windows

212
00:18:13,880 --> 00:18:18,440
pues ahí está el concepto de ese de llamar a continuación procedimientos no

213
00:18:18,440 --> 00:18:24,120
alguien le suena lo que digo vale pues es lo mismo es lo mismo

214
00:18:24,280 --> 00:18:29,080
el lenguaje de ser operativo pues es en este lenguaje pero es la misma idea la

215
00:18:29,080 --> 00:18:30,640
misma

216
00:18:30,640 --> 00:18:35,840
vale en programación orientada a objetos como es java esto en realidad se llama de

217
00:18:35,840 --> 00:18:38,720
otra manera

218
00:18:38,720 --> 00:18:46,320
entonces cuando ya empecemos a ver clases y objetos ya dentro de cuando ya

219
00:18:46,320 --> 00:18:50,440
empecemos a ver clases y objetos ya nos meteremos más en este rollo de los

220
00:18:50,440 --> 00:18:56,560
métodos y todo eso ahora vamos a ver simplemente cómo sacar código a

221
00:18:56,560 --> 00:19:04,840
funciones aparte para que sea más claro vale simplemente eso pues

222
00:19:09,840 --> 00:19:12,840
vamos a aplicarlo a este ejemplito de ahí

223
00:19:21,320 --> 00:19:24,320
o

224
00:19:27,440 --> 00:19:30,440
para

225
00:19:30,440 --> 00:19:33,440
y

226
00:19:55,400 --> 00:19:59,160
vale estamos ahí bueno pues entonces qué

227
00:19:59,160 --> 00:20:04,640
parte podríamos sacar fuera a un método aparte bueno pues en este caso este

228
00:20:04,640 --> 00:20:09,760
subproblema de aquí este es un problema es el que sirve para ver si un número

229
00:20:09,760 --> 00:20:13,360
es primo no es el que sirve para ver si un número es primo no este es un

230
00:20:13,360 --> 00:20:18,480
problema que es el que hace que yo tenga y un foranidad etcétera pues es un

231
00:20:18,480 --> 00:20:23,160
problema ese trozo de código que yo lo puedo separar porque hace una cosa muy

232
00:20:23,160 --> 00:20:29,800
concreta hace una cosa muy concreta que es ver si el numerito y es primo no es

233
00:20:29,800 --> 00:20:36,440
primo ver si es primo y el resultado quedará almacenado en esa variable si

234
00:20:36,440 --> 00:20:41,520
no hemos contra si no hemos encontrado ningún divisor es primo será true pero

235
00:20:41,520 --> 00:20:45,440
si hemos encontrado algún divisor con que hayamos encontrado 1 es primo ya es

236
00:20:45,440 --> 00:20:54,800
falso este código de aquí este código resuelve el subproblema ese

237
00:20:54,800 --> 00:21:03,200
vale trabaja con y el resultado se queda almacenado aquí y luego yo ya uso ese

238
00:21:03,200 --> 00:21:07,560
resultado uso ese resultado ya lo uso para lo que yo quiera en este caso era

239
00:21:07,560 --> 00:21:11,800
para mostrar podría usar ese resultado de ser primo para sumar los primos para

240
00:21:11,800 --> 00:21:16,120
lo que yo quisiera en este caso lo estoy usando para mostrar vale pues este

241
00:21:16,120 --> 00:21:19,600
subproblema que tengo aquí podría plantearme sacarlo una función aparte

242
00:21:19,600 --> 00:21:26,240
vale y así aquí me limito a llamar bueno entonces vamos a ver cómo lo vamos a

243
00:21:26,240 --> 00:21:28,680
hacer aquí

244
00:21:29,360 --> 00:21:36,120
ejercicio 14 con función vamos a ponerlo

245
00:21:42,800 --> 00:21:48,600
ejercicio 14

246
00:21:51,800 --> 00:21:55,200
con función

247
00:21:57,160 --> 00:22:03,240
vale pues voy a copiar el otro entero para irlo éste era nuestro ejercicio

248
00:22:03,240 --> 00:22:06,240
original

249
00:22:12,600 --> 00:22:15,920
éste era nuestro ejercicio original que vamos a hacerlo ahora con una función

250
00:22:15,920 --> 00:22:21,160
aparte vale pues este código este código es el que queremos sacar aparte

251
00:22:21,160 --> 00:22:27,240
el que queremos sacar aparte y aquí nos limitamos a llamarle ya está pues venga

252
00:22:27,240 --> 00:22:32,080
entonces yo cuando ya donde ya ha acabado el main el main empieza aquí y

253
00:22:32,080 --> 00:22:36,400
acaba aquí perdón no ahí acaba ahí acaba el foro entonces cuando ya

254
00:22:36,400 --> 00:22:39,520
empieza a acumular muchas llaves es buena idea que os acostumbréis cada

255
00:22:39,520 --> 00:22:43,360
llave que cerráis poner aquí un comentario para ver qué está cerrando

256
00:22:43,360 --> 00:22:51,080
en este caso estoy cerrando este foro vale pues cuidado vale y ahora esta

257
00:22:51,080 --> 00:22:57,160
llave que me cierra esta llave me está cerrando el main

258
00:22:57,160 --> 00:23:03,760
vale pues ponemos aquí main y esta llave ya me cierra la clase

259
00:23:03,760 --> 00:23:07,120
me cierra la clase

260
00:23:10,520 --> 00:23:16,400
bueno lo pongo así porque

261
00:23:17,160 --> 00:23:21,960
vale porque cuando ya empieza a ver muchas anidamientos de y de foro etcétera

262
00:23:21,960 --> 00:23:27,000
igual ya son muchas llaves cerrándose y nos hacemos un día bueno pues el main

263
00:23:27,000 --> 00:23:30,480
se abre y se cierra aquí

264
00:23:31,680 --> 00:23:35,920
entonces dónde hago yo esa función aparte la tengo que hacer fuera del main

265
00:23:35,920 --> 00:23:40,920
fuera aquí ha parado el main es como el programa principal el programa principal

266
00:23:40,920 --> 00:23:44,600
que puede llamar a las funciones ese es el main el programa principal que

267
00:23:44,600 --> 00:23:48,800
empieza aquí y termina aquí ese es el main el programa principal ya las

268
00:23:48,800 --> 00:23:53,640
funciones las pongo aparte luego las pongo fuera del main vale

269
00:23:53,640 --> 00:23:58,680
pues por ejemplo esta función que vamos a sacar fuera para que le tenemos que

270
00:23:58,680 --> 00:24:02,760
dar un nombre lo más explicativo posible para que luego el que vea la clase

271
00:24:02,760 --> 00:24:07,680
principal el main entienda lo que está haciendo igual que las variables las

272
00:24:07,680 --> 00:24:10,440
variables aunque tengan un nombre muy largo da igual lo importante es que

273
00:24:10,440 --> 00:24:15,080
tengan un nombre que explique lo que tienen dentro pues los las funciones

274
00:24:15,080 --> 00:24:19,840
igual me da igual que tenga un nombre larguísimo de hecho cuando uno utiliza

275
00:24:19,840 --> 00:24:24,480
clases de por ahí o sea funciones de por ahí de librería ve que los métodos

276
00:24:24,480 --> 00:24:28,040
tienen nombres enormes porque lo importante es que se entienda esa

277
00:24:28,040 --> 00:24:32,120
función que hace estoy usando función método procedimiento

278
00:24:32,120 --> 00:24:37,760
indistintamente e intentar usar función por ahora sólo se termina vale pues

279
00:24:37,760 --> 00:24:45,920
entonces primero vamos a hacer aquí función para ver si un número es primo

280
00:24:45,920 --> 00:24:48,120
no

281
00:24:50,600 --> 00:24:57,160
vale porque el código que yo voy a sacar es un código que vale para ver si un

282
00:24:57,160 --> 00:25:04,120
número es primo no es primo vale para eso pues entonces vamos a darle un

283
00:25:04,120 --> 00:25:09,880
nombre por ejemplo es prima ese es el nombre que le vamos a dar

284
00:25:09,880 --> 00:25:16,480
el nombre de las funciones puede empezar con mayúscula minúscula pero de nuevo

285
00:25:16,480 --> 00:25:22,000
para seguir todos pautas homogéneas de programación y entender los códigos

286
00:25:22,000 --> 00:25:30,440
unos de otros se siguen siempre estos estas pautas y es que las variables

287
00:25:30,440 --> 00:25:34,920
empiezan con nombres en minúscula letras en minúscula y las funciones

288
00:25:34,920 --> 00:25:40,760
también con letras en minúscula que es lo que empieza con letra en mayúscula

289
00:25:40,760 --> 00:25:45,720
los nombres de las clases luego más adelante cuando vemos objetos y

290
00:25:45,720 --> 00:25:49,560
tendremos porque sólo clarifica que es obligatorio no no es obligatorio esto

291
00:25:49,560 --> 00:25:54,120
puede empezar por minúscula esto puede empezar por mayúscula pero si yo no

292
00:25:54,120 --> 00:25:59,480
sigo los criterios asumidos entre todos los programadores del mundo pues me

293
00:25:59,480 --> 00:26:03,560
estoy poniendo trabas a mí mismo porque no van a entender los demás las cosas

294
00:26:03,560 --> 00:26:07,680
vale cuando hay programas grandes si yo veo un identificador que empieza con

295
00:26:07,680 --> 00:26:12,120
minúscula digo uy esto un nombre de clase no va a ser seguro seguro que es

296
00:26:12,120 --> 00:26:17,040
variable de función entonces ya ayudas un poco entonces sigamos eso que hemos

297
00:26:17,040 --> 00:26:24,160
asumido todos que deberíamos seguir y una de esas pautas es que los nombres de

298
00:26:24,160 --> 00:26:27,640
las funciones con las excepciones que veros más adelante empiecen con

299
00:26:27,640 --> 00:26:32,640
minúscula va a llegar un nombrecito vale pero qué más cosas tengo que poner en

300
00:26:32,640 --> 00:26:38,960
java pues en java tengo que poner aquí unos paréntesis después

301
00:26:38,960 --> 00:26:45,720
que ahora indicaremos para qué aquí va entre llaves el código el código que yo

302
00:26:45,720 --> 00:26:50,480
voy a meter y aquí antes del es primo tiene que haber algo que también y

303
00:26:50,480 --> 00:26:56,760
veremos lo que es entonces una función tendrá el nombrecito este el que a mí me

304
00:26:56,760 --> 00:27:02,520
dé la gana lo más explicativo posible de lo que hace ese código

305
00:27:02,520 --> 00:27:08,160
unos paréntesis que pueden tener cosas dentro o no o pueden no tenerlas ya lo

306
00:27:08,160 --> 00:27:15,360
ahora lo vemos y aquí algo que tiene que existir ya veremos el que vale y aquí

307
00:27:15,400 --> 00:27:22,600
dentro el código de lo que hace así es como se declara esa función vale pues

308
00:27:22,600 --> 00:27:28,000
vamos a meterle primero el código luego ya lo quitamos del mail vamos a meterle

309
00:27:28,000 --> 00:27:33,760
primero el código yo quería que esta función hiciera esto vale pues le voy a

310
00:27:33,760 --> 00:27:36,360
pasar esto

311
00:27:36,360 --> 00:27:40,360
esto es lo que yo quiero que haga

312
00:27:40,760 --> 00:27:43,360
vale

313
00:27:44,200 --> 00:27:49,880
vale y aquí nos surgen preguntas vale esta parte es la más con lo que vamos a

314
00:27:49,880 --> 00:27:53,280
explicar ahora que son estas interrogaciones y estas es lo más

315
00:27:53,280 --> 00:27:57,640
complicado de entender pero ahora después haciendo unos cuantos ejemplos pues la

316
00:27:57,640 --> 00:28:01,280
idea es que vaya quedando más o menos claro vamos a ver vamos a pensar o sea

317
00:28:01,280 --> 00:28:07,040
este código de aquí con quién tiene que trabajar cuál va a ser su entrada pues

318
00:28:07,040 --> 00:28:11,080
su entrada es el numerito y que yo quiero ver si es primo no verdad porque

319
00:28:11,080 --> 00:28:16,400
yo cuando llame a esta función la voy a llamar para que trabaje con este

320
00:28:16,400 --> 00:28:22,760
numerito y con este numerito para que trabaje con este numerito y entonces

321
00:28:22,760 --> 00:28:27,880
este código trabaja con este numerito y es con su su dato de partida con el que

322
00:28:27,880 --> 00:28:32,680
tiene que trabajar su dato de partida bueno pues este dato de partida es el

323
00:28:32,680 --> 00:28:35,920
que yo le tengo que poner estos paréntesis decirle a ver cuál es el

324
00:28:35,920 --> 00:28:40,480
dato con el que tú vas a trabajar pues ahí tengo que declararlo como si fuera

325
00:28:40,480 --> 00:28:44,520
una variable normal y corriente pues yo voy a trabajar de partida con un número

326
00:28:44,520 --> 00:28:52,520
entero que se llama y lo declaró como cualquier otra variable

327
00:28:52,520 --> 00:28:58,240
vale entonces esto significa esta función es primo va a trabajar con este

328
00:28:58,240 --> 00:29:05,760
dato de entrada que yo le paso con este dato de entrada haciendo cosas en este

329
00:29:05,760 --> 00:29:10,960
caso esta función como dato de entrada sólo tiene este porque el jota lo

330
00:29:10,960 --> 00:29:17,400
declara aquí dentro y lo usa solamente para ver para pasar por los divisores

331
00:29:17,400 --> 00:29:20,560
pero no es un dato de entrada el dato de entrada es el número del que yo quiero

332
00:29:20,560 --> 00:29:29,240
averiguar si es primo no vale pues el dato de entrada lo pongo aquí ahora

333
00:29:29,240 --> 00:29:33,800
después veremos ejemplos podría tener más datos de entrada a lo mejor podría

334
00:29:33,800 --> 00:29:36,840
ser una función que trabajará con dos números para ver si no es múltiplo de

335
00:29:36,840 --> 00:29:41,160
otro lo que fuera esta sólo tiene un dato de entrada que es el numerito y que

336
00:29:41,160 --> 00:29:46,840
tenemos que ver si es primo no pues venga se lo pasamos ahí y ahí lo que

337
00:29:46,840 --> 00:29:49,800
hay que poner repito es como si estuviéramos declarando lo hay que

338
00:29:49,800 --> 00:29:53,200
poner el tipo y el nombre de ese dato de entrada exactamente igual que si lo

339
00:29:53,200 --> 00:29:59,120
estuviéramos declarando esto significa a la función es primo cuando la llamemos

340
00:29:59,120 --> 00:30:05,680
pásale un número entero es lo que significa eso pásale un número entero

341
00:30:05,680 --> 00:30:10,800
vale pues ya tenemos esta parte y nos queda esta para completar la función

342
00:30:10,840 --> 00:30:20,400
esta parte cuál es esta función normalmente tendrá un resultado en este

343
00:30:20,400 --> 00:30:26,560
caso el resultado cuál es vale el resultado es este boolean porque es lo

344
00:30:26,560 --> 00:30:30,480
que a mí me interesa aquí porque es el que luego yo voy a usar este boolean es

345
00:30:30,480 --> 00:30:34,520
el que luego yo voy a usar luego el resultado de este código el resultado

346
00:30:34,520 --> 00:30:38,920
interesante es ese boolean es el que yo quiero entregar

347
00:30:38,920 --> 00:30:43,800
fuera y decir oye ya he hecho lo que me has pedido con este y que me has dado y

348
00:30:43,800 --> 00:30:48,120
te devuelvo este boolean para que trabajes con él entonces el resultado

349
00:30:48,120 --> 00:30:52,480
de la función es ese boolean bueno pues entonces una vez que la función ha hecho

350
00:30:52,480 --> 00:30:57,920
lo que tenga que hacer tengo que decir oye devuélveme ese resultado y eso lo

351
00:30:57,920 --> 00:31:01,840
haremos con la palabra retún y lo que yo quiera devolver que será una variable

352
00:31:01,840 --> 00:31:09,480
siempre pues esto yo he trabajado con esto con el dato de entrada y y esta

353
00:31:09,480 --> 00:31:14,520
variable boolean es la que le interesa al que me llama desde fuera es la que le

354
00:31:14,520 --> 00:31:20,680
interesa es la que le interesa le interesa esa variable pues este método

355
00:31:20,680 --> 00:31:26,920
devolverá esa variable y qué es lo que se pone aquí aquí se pone simplemente

356
00:31:26,920 --> 00:31:31,680
el tipo de dato de la variable que devuelvo el tipo de dato nada más

357
00:31:31,680 --> 00:31:35,160
entonces qué variable devuelvo yo devuelvo esta que es boolean pues aquí

358
00:31:35,160 --> 00:31:37,800
pongo boolean

359
00:31:38,400 --> 00:31:43,200
vale aquí pongo boolean

360
00:31:44,160 --> 00:31:48,520
pero esta es una función ya correctamente declarada

361
00:31:48,520 --> 00:31:54,480
tiene un código trabaja con un dato de entrada que es

362
00:31:55,080 --> 00:32:00,520
este con lo cual yo tengo que ponerlo aquí con el tipo de dato que sea hace

363
00:32:00,520 --> 00:32:06,280
lo que sea y devuelve una variable como resultado devuelve una variable como

364
00:32:06,280 --> 00:32:10,440
resultado la que me interese en función de la función que estoy haciendo a mí me

365
00:32:10,440 --> 00:32:14,200
interesa devolver este boolean porque es el que usamos aquí

366
00:32:14,200 --> 00:32:20,280
la que me interese pues lo devuelvo con retún y pongo aquí el tipo de dato de

367
00:32:20,280 --> 00:32:25,280
esta variable ahora hacemos más ejemplos de funciones para

368
00:32:25,280 --> 00:32:28,600
entender un poco mejor eso

369
00:32:31,160 --> 00:32:35,600
y ya está esta función ya está hecha ahora mi problema es llamarla mi problema es

370
00:32:35,600 --> 00:32:39,880
llamarla entonces la función una función puede

371
00:32:39,880 --> 00:32:42,840
tener dentro todo el código que a mí me dé la gana todo lo que yo quiera

372
00:32:42,840 --> 00:32:46,920
200.000 líneas todo lo que yo necesite para hacer lo que tenga que hacer todo

373
00:32:46,920 --> 00:32:51,280
lo que yo necesite y puede declarar variables dentro de hecho aquí está

374
00:32:51,280 --> 00:32:55,720
declarado ésta de aquí ha declarado la injota puede declarar cosas dentro se

375
00:32:55,720 --> 00:33:00,760
las necesita puede declarar entonces una función trabajará con las cosas que

376
00:33:00,760 --> 00:33:06,280
declara dentro para trabajar como aquí la jota este y también trabajará con el

377
00:33:06,280 --> 00:33:12,760
dato de entrada trabaja con todo eso con el dato de entrada y las cosas que se

378
00:33:12,760 --> 00:33:17,120
declaren ya dentro para operar y con eso puede hacer un código de toda la

379
00:33:17,120 --> 00:33:24,680
inyección falta vale y luego devolverá un valor de volver a un valor

380
00:33:25,360 --> 00:33:31,840
bueno pues ahora está ahora ahora como llamo yo a esta función

381
00:33:31,840 --> 00:33:36,760
vale pues esta función mi idea la quiero llamar desde aquí

382
00:33:36,760 --> 00:33:40,320
todo esto ya no hace falta que yo lo haga y puedo llamar a esta función

383
00:33:40,760 --> 00:33:46,080
entonces como llamo yo a esta función pues la llamo por su nombre su nombre es

384
00:33:46,080 --> 00:33:52,040
primo pues la llamo por su nombre pero claro entre paréntesis tengo que pasarle

385
00:33:52,040 --> 00:33:57,560
tengo que pasarle el número entero con el que yo quiero que trabaje porque esta

386
00:33:57,560 --> 00:34:01,280
función me dice oye tú puedes llamarme cuando quieras cuando quieras pero

387
00:34:01,280 --> 00:34:05,160
cuando me llames tienes que pasarme un número entero eso sí que es

388
00:34:05,160 --> 00:34:09,800
impepinable tienes que pasar un número entero y yo te diré a través del

389
00:34:09,800 --> 00:34:14,040
boolean que devuelvo si es primo no es lo que nos está obligando esta función

390
00:34:14,040 --> 00:34:18,200
a que cuando la llamemos le pasemos un entero eso es obligatorio

391
00:34:18,200 --> 00:34:23,640
vale entonces nosotros podríamos llamar a esta función si nos diera la gana

392
00:34:23,640 --> 00:34:29,480
pasándole 6 y sería una llamada correcta porque 6 es un número entero

393
00:34:29,480 --> 00:34:34,040
es una llamada correcta vale podría valer lo que pasa es que yo no

394
00:34:34,040 --> 00:34:39,000
quiero ver si es primo 6 quiero ver si es primo quien el y eso es lo que yo

395
00:34:39,000 --> 00:34:42,160
quiero ver quiero ver si es primo el y pues entonces no le pasaré 6 le pasaré

396
00:34:42,160 --> 00:34:46,760
y pero yo esa función la puedo llamar ahora ya siempre que me dé la gana

397
00:34:46,760 --> 00:34:51,160
siempre que yo quiera pasándole un entero que quiero ver yo ahora si es

398
00:34:51,160 --> 00:34:59,000
primo 528 529 pues es primo 529 después puedo reutilizar esa función cuando me

399
00:34:59,000 --> 00:35:03,560
dé a mí la gana para ver si un número es primo no en cualquier parte del código

400
00:35:03,560 --> 00:35:07,560
que me dé la gana la puedo llamar siempre y cuando le pase un número

401
00:35:07,560 --> 00:35:10,480
entero que es lo único a lo que me obliga a esta función a pasarle un

402
00:35:10,480 --> 00:35:16,280
entero porque así lo hemos declarado en este caso yo la voy a usar para ver si

403
00:35:16,280 --> 00:35:20,880
es entero este numerito y bueno pues entonces le pasaré y no le pasaré 300

404
00:35:20,880 --> 00:35:29,960
ni 420 ni nada le pasaré y vale pero claro es primo me devuelve algo me

405
00:35:29,960 --> 00:35:34,560
devuelve un boolean esto es como cuando llamamos al scan next y next sin es una

406
00:35:34,560 --> 00:35:37,240
función también a la que estamos llamando el personaje hemos hecho

407
00:35:37,240 --> 00:35:41,280
nosotros y estamos llamando a next y en un montón de veces estamos llamando a

408
00:35:41,280 --> 00:35:46,600
esta función en realidad y qué es lo que hace esta función está en particular nos

409
00:35:46,600 --> 00:35:51,040
devuelve un numerito bueno pues la nuestra que hemos hecho nos devuelve un

410
00:35:51,040 --> 00:35:55,320
boolean pues habrá que guardar ese boolean en algún sitio verdad habrá que

411
00:35:55,320 --> 00:35:59,800
guardar en algún sitio bueno pues lo vamos a guardar en esta variable por

412
00:35:59,800 --> 00:36:05,640
ejemplo ya está esta función que yo he llamado aquí ahora quitamos el rojo

413
00:36:05,640 --> 00:36:13,560
este esta función que yo he llamado me calcula si es primo el número entero que

414
00:36:13,560 --> 00:36:18,840
yo le pase en este caso le quiero pasar y el valor que me devuelve que es un

415
00:36:18,840 --> 00:36:22,680
boolean el valor que me devuelve que es un boolean tendremos que asignarse a una

416
00:36:22,680 --> 00:36:28,800
variable boolean igual que next in que también es una función el entero que me

417
00:36:28,800 --> 00:36:36,080
devuelve se lo paso a un a una variable entera pues es lo mismo la única

418
00:36:36,080 --> 00:36:41,480
diferencia es que esta función no la hemos hecho nosotros esta función

419
00:36:41,480 --> 00:36:48,320
es esta es esta es una función que devuelve un entero

420
00:36:48,320 --> 00:36:51,640
y este entero no lo hemos hecho nosotros está ya hecha afortunadamente esta

421
00:36:51,640 --> 00:36:57,880
función devuelve un entero y ese entero nosotros lo guardamos aquí

422
00:36:57,920 --> 00:37:02,720
pues nuestra función está devuelve un boolean y ese boolean lo guardamos en un

423
00:37:02,720 --> 00:37:05,600
boolean el que a mí me dé la gana no hace falta que le llame igual que aquí

424
00:37:05,600 --> 00:37:09,120
no hace falta que lo llame igual que aquí me da lo mismo como lo llame lo

425
00:37:09,120 --> 00:37:12,360
único que importa es que ese boolean lo tengo que guardar en algún sitio

426
00:37:12,360 --> 00:37:15,920
vale pues ya está entonces este código me ha quedado más corto llamo a esta

427
00:37:15,920 --> 00:37:21,000
función y llamo a esto vale porque me sale esa cosita roja

428
00:37:21,000 --> 00:37:24,160
me sale esa cosita roja porque como lo estoy llamando desde un main que es

429
00:37:24,200 --> 00:37:30,000
static tenemos que poner aquí está esto no es imposible que lo entendamos

430
00:37:30,000 --> 00:37:37,640
ahora porque necesitamos conocer más cosas pero ahora mismo simplemente que

431
00:37:37,640 --> 00:37:43,320
quedaos con que si yo declaro funciones fuera del main fuera del main para

432
00:37:43,320 --> 00:37:51,280
llamarlas en el main tengo que poner el static delante ya está vale entonces

433
00:37:51,280 --> 00:37:55,680
ponéis el static delante el tipo de dato que devuelve el nombre de la

434
00:37:55,680 --> 00:38:02,680
función el dato de entrada y lo que sea que haga y ahora ya la llamamos

435
00:38:02,680 --> 00:38:06,720
veis ya se me ha quitado el rojo que ahora resulta que quiero yo ver si es

436
00:38:06,720 --> 00:38:11,520
prima ahora imaginaos que mi programa sigue por aquí y ahora quiero ver si es

437
00:38:11,520 --> 00:38:14,920
primo pues

438
00:38:16,040 --> 00:38:21,120
pues este número por ejemplo quiero ver si es primo

439
00:38:21,280 --> 00:38:36,880
el número 3567 quiero ver si es primo este número porque me apetece ahora de

440
00:38:36,880 --> 00:38:40,960
repente mi programa sigue y ha hecho este bucle de aquí y ahora quiero ver

441
00:38:40,960 --> 00:38:44,560
si es primo este número pues en lugar de volver a repetir el código como lo

442
00:38:44,560 --> 00:38:48,440
tengo metido en una función magnífico como tengo una función la vuelvo a

443
00:38:48,440 --> 00:38:54,240
llamar pero ahora esta función trabajará con este número entero y me

444
00:38:54,240 --> 00:39:00,280
devuelve el resultado aquí vale y ahora yo ya aquí haré lo que sea si primo

445
00:39:00,280 --> 00:39:04,320
pues entonces puede decir pues

446
00:39:06,440 --> 00:39:13,480
pues yo que se 3567 es primo

447
00:39:13,480 --> 00:39:17,840
que mi programa sigue tiene 10.000 líneas y luego vuelvo a necesitar ver si

448
00:39:17,840 --> 00:39:22,840
el número es primo pues estupendo otra vez vuelvo a llamar a la función otra

449
00:39:22,840 --> 00:39:27,080
vez vuelvo a llamarla como primo ya está declarado no la

450
00:39:27,080 --> 00:39:30,960
puedo traer de nuevo claro a la otra vez la vuelvo a llamar este no va a ser

451
00:39:30,960 --> 00:39:36,360
primo obviamente por ejemplo yo que sé entonces al haber metido esto en una

452
00:39:36,360 --> 00:39:41,040
función al haberlo metido cada vez que quiera saber si un número es primo la

453
00:39:41,040 --> 00:39:46,160
llamo pasándole ese número entero y sabiendo que además esa función me va

454
00:39:46,160 --> 00:39:50,080
a devolver un boolean que yo guardaré en un boolean porque si no lo guardo en un

455
00:39:50,080 --> 00:39:53,640
boolean lo pierdo lo tiro a la basura lo guardaré en un boolean y con ese boolean

456
00:39:53,640 --> 00:39:58,720
ya le lo que quiera entonces no sólo ha quedado el código más claro me ha

457
00:39:58,720 --> 00:40:02,120
quedado esta línea y esta el que lo entienda dice a vale que estás haciendo

458
00:40:02,120 --> 00:40:07,080
con cada y antes el que veía este código veía un for y ese for podía no

459
00:40:07,080 --> 00:40:11,160
entenderlo ahora el que ve este código ve la llamada a una función es primo

460
00:40:11,160 --> 00:40:13,840
entonces el que ve este código dice a estupendo lo que estás haciendo es ver

461
00:40:13,840 --> 00:40:18,640
si es primo o no es primo lo ve a la primera y en una sola línea antes veía un for

462
00:40:18,640 --> 00:40:22,880
que no sabía ni lo que estaba haciendo ahora ve una llamada que la entiende

463
00:40:22,880 --> 00:40:28,360
mejor vale entonces si ejecutamos ahora esto

464
00:40:28,360 --> 00:40:35,400
primero nos pide el enterito este pues 6 venga y los que le hemos metido ha dado

465
00:40:35,400 --> 00:40:39,600
la casualidad de que ninguno de los dos que hemos metido era primo

466
00:40:40,600 --> 00:40:44,600
perdón

467
00:40:45,600 --> 00:40:49,600
le habéis puesto la estática aquí delante

468
00:40:49,600 --> 00:40:54,760
y le habéis pasado un número entero y lo habéis guardado en un

469
00:40:56,160 --> 00:41:00,720
lo habéis escrito bien seguro habéis puesto aquí un número entero el y el

470
00:41:00,720 --> 00:41:04,040
que sea un entero pero a ver qué error os dice aquí lo importante es que leáis

471
00:41:04,040 --> 00:41:09,880
lo que os dice si te da un error tendrá una información que información

472
00:41:09,880 --> 00:41:12,280
te dice

473
00:41:15,480 --> 00:41:18,440
la variable

474
00:41:18,640 --> 00:41:22,040
bueno pues entonces vete a la variable es primo de tu código porque la tendrás

475
00:41:22,040 --> 00:41:24,920
declarada dos veces

476
00:41:28,080 --> 00:41:32,280
claro no no pero no no es por eso porque esto está dentro de estas llaves va

477
00:41:32,280 --> 00:41:37,480
aparte eso no en tu mismo código este de aquí la tendrás declarada

478
00:41:37,480 --> 00:41:41,040
esta variable la tendrás declarada dentro de este mismo código más arriba

479
00:41:41,040 --> 00:41:45,200
o en algún otro sitio si te dice que es primo está de cada dos veces es que

480
00:41:45,200 --> 00:41:50,080
bullion es primo lo tienes dos veces en el mismo

481
00:41:50,080 --> 00:41:52,080
y

482
00:41:56,320 --> 00:42:03,200
a ver no lo que he quitado es el bullion de aquí por aquí ya estaba declarada

483
00:42:03,200 --> 00:42:09,400
claro vale venga pues vamos a parar aquí