Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 6-11-23 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 6 de noviembre de 2023 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

vale pues entonces el otro día llegamos a hacer nosotros aquí en la pizarra 00:00:00
silencio hasta este ejercicio verdad y luego ya a partir de ahí os quedasteis 00:00:08
vosotros pues tratando de hacer estas cosas que ahora ahora revisaremos y todo 00:00:16
eso vale vamos a volver un momentito a este este que tenía su dificultad para 00:00:21
usarlo como repaso para situarnos y de paso 00:00:31
dar una 00:00:37
herramienta adicional para programar este tipo de 00:00:40
ejercicios vale vamos a volver otra vez a este pedir un número y mostrar la 00:00:46
lista de todos los números inferiores a él que sean primos entonces ese ejercicio 00:00:53
solicitaba un número ahora tenía que recorrer todos los inferiores a él con 00:00:59
lo cual ahí ya visualizamos un primer bucle un primer bucle que va pasando por 00:01:04
1 2 3 así hasta en o al revés por en en menos 1 en menos 2 así hasta un 00:01:08
primer bucle y ahora con cada numerito por el que pasaba ese bucle es decir en 00:01:14
cada iteración que hacía con ese numerito ver si era primo no 00:01:23
luego teníamos un subproblema ver si un número es primo no es primo dentro de un 00:01:27
bucle que va haciendo eso para cada número verdad situación habitual un 00:01:32
programa normalmente se descomponen diferentes subproblemas que yo voy 00:01:38
rellenando pues éste tenía un problema que era un bucle gordo que era ir 00:01:42
recorriendo todos y cada uno de los números inferiores 00:01:46
al número pedido y luego ya tenía dentro de ese bucle en cada iteración 00:01:51
tenía ahora ya un subproblema que era ese número ver si era primo no verdad y 00:01:57
ese ejercicio que era el 14 era este 00:02:02
entonces con este bucle este primer bucle recorríamos todos los números que 00:02:08
iban desde el 1 hasta el 1 menos 1 vale la variable y iba tomando esos valores 00:02:16
tomando 12 vale y ahora para cada numerito y para cada numerito y dentro 00:02:24
ya de esta iteración para cada numerito y pues ya teníamos que resolver ese 00:02:31
subproblema ver si era primo no porque si lo era lo mostrábamos 00:02:35
entonces ese subproblema respondía a este patrón 00:02:42
patrón de ver si algo ocurre o no vale tenemos ya varios patrones que sabemos 00:02:47
resolver varios patrones un patrón es suma de términos suma acumulativa ese 00:02:51
patrón no sabemos responder el resolver tenemos que adaptarlo claro nuestra 00:02:57
situación otro patrón que ya tenemos grabado en la cabeza que sabemos 00:03:01
resolver contar otro patrón que cuando lo identificamos tenemos ya en la cabeza 00:03:04
cómo resolverlo máximo y mínimo vale ya son tres patrones otro patrón este ver 00:03:10
si algo ocurre o no pues ese patrón que es el que responde a esto ver si dado y 00:03:16
es primo no es primo ese patrón de situación posible ver si algo ocurre o 00:03:22
no cuando yo identifico ese patrón de situación ver si algo ocurre o no pues 00:03:28
ese patrón lo podemos programar una variable booleana asumo de partida que 00:03:33
es true o false lo que me interesa en función del problema concreto y ahora en 00:03:36
un bucle busco un contra ejemplo en cuanto encuentro ya uno un contra 00:03:42
ejemplo cambio la suposición de partida cambio la suposición de partida y ya 00:03:47
está cuando he terminado ese recorrido de búsqueda de contra ejemplos ese 00:03:53
boolean me dirá si lo que yo quería saber pasa o no pasa la forma de 00:03:57
programar este problema ver si algo pasa o no pues justo aquí lo que teníamos 00:04:04
dado un y tenemos que ver si es primo no es primo justo es ese patrón dado un y 00:04:11
tengo que ver si se cumple que es primo si no se cumple pues así lo resolvemos 00:04:17
asumimos de partida que es primo porque porque en cuanto ahora yo me pongo a 00:04:23
recorrer son los números inferiores a él entre 2 y n menos y menos uno en este 00:04:28
caso en cuanto encuentre uno que lo divide ya está contra ejemplo con lo 00:04:33
cual puedo cambiar es primo a falso contra gente pues es lo que estamos 00:04:41
haciendo asumo de partida que es primo y me pongo a buscar el contra ejemplo en 00:04:44
el bucle que toque es que depende de la situación el contra ejemplo aquí lo 00:04:49
encontraré si encuentro un divisor porque lo que tengo que averiguar es 00:04:53
espinos encuentro un divisor ahí encontrar el contra ejemplo pues eso 00:04:57
hacemos con este bucle recorremos todos los numeritos desde 2 hasta y menos uno 00:04:59
desde 2 hasta y menos uno usando este bucle for del que ya conocemos la 00:05:07
sintaxis y que nos es muy práctico para este tipo de cosas desde 2 hasta y menos 00:05:12
uno y ahora en cuanto encuentro un jota que divide ahí en cuanto encuentro un 00:05:18
jota que divide ahí ya está tengo contra ejemplo pues como encontré 00:05:23
contra ejemplo es primo falso y ya explicamos bien el otro día porque poner 00:05:27
el ls aquí no tiene sentido etcétera etcétera 00:05:33
que lo tenéis todo en la grabación vale bueno pues ya está este es mi sub 00:05:37
problema una vez ya resuelto mi sub problema tengo en este bullying si lo 00:05:43
que quería ver se cumple o no bueno pues es lo que me faltaba si se cumple 00:05:48
lo muestro y si no se cumple no y todo esto dentro del bucle de fuera 00:05:52
bueno ese es el problema que el ejercicio que resolvió 00:05:58
que efectivamente evidentemente cada cosa se puede hacer de muchas maneras 00:06:02
poder a lo mejor uno podría haber dicho bueno voy a hacer este mismo bucle 00:06:08
este mismo bucle y voy a meterle un contador que cuente los divisores 00:06:13
entonces cada divisor que encuentra entre 2 y menos uno lo cuenta lo cuenta 00:06:18
vale entonces una vez que el bucle ha terminado si ese contador es cero es que 00:06:23
no ha encontrado ninguno entonces la condición podría ser si con es igual a 00:06:29
cero vale si contes igual a cero pues ese número era primo entonces cada cosa se 00:06:33
puede resolver de muchas maneras pero esto que yo he puesto aquí 00:06:38
es el algoritmo genérico responde al algoritmo genérico no ha aplicado a 00:06:41
esta situación en concreto sino genérico que uno utiliza cuando tiene 00:06:48
esa situación ver si algo ocurre o no bullean que asume de partida que eso 00:06:54
ocurre o que eso no ocurre depende de si el contra ejemplo 00:06:59
en qué sentido quiero que vaya y luego ya busco contra ejemplo con que 00:07:03
encuentre uno que me cambia la suposición de partida lo cambia si era 00:07:08
true lo cambia falsa lo cambia y ya está bueno bueno pues nada este ejercicio es 00:07:12
el que hicimos el otro día etcétera etcétera y sobre este en principio no 00:07:17
había dudas no ni las hay ahora no vale bueno pues entonces aquí ya hay una 00:07:21
situación que es un poco fea en este caso no es tan fea porque hombre el 00:07:29
programa no es muy largo pero queda un poco feo a la vista un poco feo a la 00:07:34
vista un bucle dentro de otro que no hay ningún problema esto es que es 00:07:39
imprescindible hacerlo este programa no se puede hacer sin anidar un bucle 00:07:45
dentro de otro porque yo tengo primero que recorrer los inferiores a nun y 00:07:49
luego dentro de un buscar sus divisores mario 00:07:54
vale entonces tengo que hacer lo que es impecable es que para resolver este 00:08:01
ejercicio de hacer un bucle dentro de otro como lo hemos hecho 00:08:08
pero una vez que está escrito el código pues esto a la vista cuando llega a otro 00:08:11
que no lo ha hecho y lo tiene que entender en cuanto empieza a ver bucles 00:08:15
anidados ya le cuesta entenderlo verdad ismael y 00:08:19
compañero 00:08:24
vale si uno que no ha hecho este código va a viene a leerlo en cuanto empieza a 00:08:28
ver bucles anidados ya se puede liar entonces lo de anidar un bucle en otro 00:08:32
cuando hay que hacerlo es que hay que hacerlo es que en muchas cosas para 00:08:36
resolverlas es que hay que hacerlo así no hay otra sin sus problemas y que un 00:08:41
bucle y está dentro de otro pues es que lo tengo que hacer vale pero simplemente 00:08:44
cuando uno viene a leerlo y no lo ha hecho pues se puede liar tengo un bucle 00:08:49
dentro que hace entonces este código se puede recolocar solo recolocar 00:08:55
recolocar para que el problema sea más legible se puede recolocar para que sea 00:09:00
más legible que luego la máquina va a ejecutar lo mismo me da igual cómo esté 00:09:06
recolocado me da lo mismo la máquina va a ejecutar lo mismo 00:09:09
pero el que intenta entender ese código lo va a entender mejor y esto es 00:09:13
importante porque como hemos dicho otras veces la 00:09:19
la bondad entre comillas de un software no es sólo que funcione bien y que la 00:09:25
máquina lo ejecute de forma eficiente y que no haga ciclos de memoria necesarios 00:09:30
no es sólo eso no sólo en términos computacionales en términos de que la 00:09:35
máquina lo ejecute bien sino también otra parte que es importantísima y es 00:09:40
que ese código se entienda para que si luego hay que cambiarle y hacerle 00:09:44
modificaciones que siempre un software tiene un recorrido en el que hay que 00:09:48
modificarlo pues se puede hacer y si es hay un galimatías de código ese software 00:09:53
no se puede mantener y si no se puede mantener es un galimatías de código por 00:09:57
muy bien que funcione si yo no le puedo incorporar ninguna modificación porque 00:10:00
no entiendo nada de lo que hicieron aquí no vale para nada por eso es 00:10:04
importantísimo acostumbrarse a seguir pautas de diseño de código y escritura 00:10:08
de código que hagan códigos legibles aunque luego vayan a hacer lo mismo en 00:10:15
la máquina se vayan a ejecutar igual pero es importante 00:10:19
porque tú enseñas un código a tu jefe que es una patata de código 00:10:22
y te van a dar la porra y ese día y eso mismo con un código más legible pues no 00:10:27
te va a mandar la porra vale bueno pues cómo podríamos hacer este código más 00:10:33
legible es decir cómo podríamos quitar el un bucle dentro del otro 00:10:37
a ver poder no podemos el bucle tiene que estar ahí pero si podemos hacer una 00:10:41
cosa que es recurrir a un término de programación estructurada de toda la 00:10:46
vida de programación de toda la vida que sonará que es el término que se llama 00:10:50
función o procedimiento el término de función o procedimiento que son casi 00:10:55
sinónimos casi sinónimos función o procedimiento recoge una serie de 00:11:02
instrucciones que yo pongo juntitas les doy un nombre 00:11:08
y ahora ya cuando quiero ejecutar esas sentencias me limito a llamarlas por el 00:11:13
nombre que les he dado entonces cuando llame a ese nombre la máquina virtual 00:11:18
plaz saltará ahí y hará todo esto entonces ahora tengo como dos partes lo 00:11:23
que es la función del procedimiento con el código al que le ha dado un nombre y 00:11:29
ahora mi código principal que hace sus cosas y alguna vez quiero que haga esto 00:11:33
pues paz lo llamo vale entonces esto sería algo así 00:11:37
esto sería algo así 00:12:02
eso es un concepto fundamental de programación y de hecho la programación 00:12:26
orientada a objetos que es el paradigma de programación de propósito general 00:12:31
que se usa actualmente la orientada a objetos es una mejora de esto una mejora 00:12:37
entre comillas pero es un concepto básico sin el cual no se podría 00:12:42
programar porque se harían programas informables bueno pues entonces el 00:12:46
concepto de función o procedimiento es este yo tengo aquí mi programa estas son 00:12:50
mis sentencias vale cada línea es una sentencia tras otra para la papa sentencia 00:12:54
pues mi programa puede ser interminable puede tener 50.000 sentencias eso es 00:12:59
inmanejable vale pero resulta que a lo mejor estas cuatro yo necesito hacerlas 00:13:04
muchas veces las hago aquí y luego resulta que estas mismas las tengo aquí 00:13:10
abajo también porque luego después tengo que hacer eso y luego después 00:13:15
resulta que a lo mejor vuelvo a necesitar hacerlo a lo mejor una idea de 00:13:18
hacerlo vale ya no me digáis porque no lo metes en un bucle cuidado no porque 00:13:21
si yo no meto en un bucle las hago todas seguidas una otra otra no hablo de esa 00:13:26
idea hablo de que a lo mejor necesito hacer aquí esto por ejemplo Miguel 00:13:30
necesito hacer esto una vez luego mi programa sigue anda necesito hacerlo otra vez 00:13:37
aquí abajo pues te voy a poner las sentencias de nuevo mi programa sigue 00:13:41
hace otras mil cosas diferentes anda esto otra vez necesito hacer pues otra 00:13:46
vez esas líneas ahí abajo vale pues si lo puedo dejar así porque eso es lo que 00:13:50
tiene que hacer el ordenador pero hombre vaya código más feo 00:13:54
y si nosotros cogemos estas cuatro sentencias las ponemos aparte las 00:13:59
ponemos aparte estas cuatro sentencias le damos un nombre el nombre que sea 00:14:05
imaginaos que lo que hace esto pues es yo que sé sumar números cualquier cosa 00:14:10
pues le doy un nombrecito le doy un nombre a estas cuatro líneas le doy un 00:14:15
nombre y ahora cuando quiera hacerlos aquí estas cuatro líneas fuera 00:14:19
y las llamo por su nombre por el nombre que yo le he dado el que a mí me ha 00:14:25
dado la gana a la hay lo llamo pues entonces hombre ya el programa se me ha 00:14:28
quedado un poco más ahora mi programa sigue que aquí abajo necesito volver a 00:14:32
hacer esto otra vez pues bueno en lugar de poner ese código enterito vuelvo a 00:14:37
llamarlo por su nombre el nombre que a mí me haya dado la 00:14:42
gana darle y ahora ya el programa que se ejecuta es este eso está claro es el que 00:14:47
se ejecuta eso se va ejecutando cuando la máquina virtual que ejecuta llegue 00:14:51
aquí lo que hará será saltar ahí ejecutar a esto y cuando termine vuelve 00:14:55
aquí y si anda que se encuentra otra vez la llamada pues vuelve a saltar aquí 00:15:00
ejecuta este cuando termine vuelve aquí y así entonces la ejecución es igual lo 00:15:06
que hacemos es lo mismo realidad lo que el ordenador hace es lo mismo hace esto 00:15:13
luego hace esto una vez luego sigue luego hace esto una vez lo que el 00:15:17
ordenador hace es lo mismo no cambia pero hombre este código queda más 00:15:20
organizado porque en lugar de tener esto recogido que podrían ser mil líneas 00:15:25
recogido 300 veces pues lo llama por su nombre y yo lo tengo aparte 00:15:28
entonces este código queda más claro y sobre todo se oculta información que a 00:15:36
lo mejor no es relevante porque el que quiere mirar este código lo que le 00:15:41
interesa saber que aquí lo que se hacen es sumar números pero como este hecho 00:15:45
por dentro le da exactamente igual eso está fuera me da igual como este hecho 00:15:49
eso por dentro yo sé que aquí se va a llamar a un código que suma números 00:15:53
entonces yo entiendo perfectamente mi programa lo entiendo es mucho más corto 00:15:57
sé que aquí llamo a sumar números me da igual como este hecho y ya está 00:16:01
entonces la principal ventaja que este código va a quedar más legible y la 00:16:07
segunda fundamental que se puede separar el trabajo de desarrollo de programación 00:16:12
a uno se le dice a un programador oye tú hazme esta parte la que suma números muy 00:16:18
bien que yo ya te llamaré desde aquí cuando la tengas me da igual como la 00:16:22
hagas yo me voy a limitar a llamarla pero a la bien claro vale tú vas a otra 00:16:25
parte por ahí que se llame restar números que ya te llamaré yo desde aquí 00:16:29
cuando lo necesite esa parte la hará otro pues se puede separar el código en 00:16:32
partes mucho más fácilmente que cada uno haga su parte y luego el programa 00:16:38
principal las va llamando según lo vaya necesitando que hay que hacer algún 00:16:42
cambio aquí porque la forma de sumar números ha cambiado lo hace el 00:16:49
programador que se ocupe de esto y este código ni lo tocamos y lo tocamos este 00:16:53
está llamando a esto y aquí se incorpora el código que sea entonces se divide se 00:16:58
modulariza que se llama se divide la tarea de desarrollo de un software se 00:17:04
divide y entonces es mucho más eficiente el trabajo podemos separar 00:17:09
entre programadores etcétera vale luego son las dos principales ventajas 00:17:14
legibilidad de los programas al estar organizados así los entiendo mucho 00:17:19
mejor que en otro que 100.000 líneas aquí y luego es poder separar en partes 00:17:24
poder hacer partes separadas y cada uno se ocupe de una si yo toco esta esta no 00:17:30
tengo ni que tocarla etcétera bueno pues este concepto este concepto es el 00:17:35
que se ha llamado de toda la vida programación funciones o procedimientos 00:17:41
esto sería depende del matiz del lenguaje de programación de cosas que 00:17:45
nos interesa un poco lo vamos a aplicar a todo objeto esto es lo que se llamaría 00:17:49
función o procedimiento 00:17:55
vale en 00:18:00
los que hayáis hecho grado medio yo creo que en sistemas operativos así hacéis 00:18:03
programación para ser fuera en linux fuera en windows 00:18:08
pues ahí está el concepto de ese de llamar a continuación procedimientos no 00:18:13
alguien le suena lo que digo vale pues es lo mismo es lo mismo 00:18:18
el lenguaje de ser operativo pues es en este lenguaje pero es la misma idea la 00:18:24
misma 00:18:29
vale en programación orientada a objetos como es java esto en realidad se llama de 00:18:30
otra manera 00:18:35
entonces cuando ya empecemos a ver clases y objetos ya dentro de cuando ya 00:18:38
empecemos a ver clases y objetos ya nos meteremos más en este rollo de los 00:18:46
métodos y todo eso ahora vamos a ver simplemente cómo sacar código a 00:18:50
funciones aparte para que sea más claro vale simplemente eso pues 00:18:56
vamos a aplicarlo a este ejemplito de ahí 00:19:09
para 00:19:27
vale estamos ahí bueno pues entonces qué 00:19:55
parte podríamos sacar fuera a un método aparte bueno pues en este caso este 00:19:59
subproblema de aquí este es un problema es el que sirve para ver si un número 00:20:04
es primo no es el que sirve para ver si un número es primo no este es un 00:20:09
problema que es el que hace que yo tenga y un foranidad etcétera pues es un 00:20:13
problema ese trozo de código que yo lo puedo separar porque hace una cosa muy 00:20:18
concreta hace una cosa muy concreta que es ver si el numerito y es primo no es 00:20:23
primo ver si es primo y el resultado quedará almacenado en esa variable si 00:20:29
no hemos contra si no hemos encontrado ningún divisor es primo será true pero 00:20:36
si hemos encontrado algún divisor con que hayamos encontrado 1 es primo ya es 00:20:41
falso este código de aquí este código resuelve el subproblema ese 00:20:45
vale trabaja con y el resultado se queda almacenado aquí y luego yo ya uso ese 00:20:54
resultado uso ese resultado ya lo uso para lo que yo quiera en este caso era 00:21:03
para mostrar podría usar ese resultado de ser primo para sumar los primos para 00:21:07
lo que yo quisiera en este caso lo estoy usando para mostrar vale pues este 00:21:11
subproblema que tengo aquí podría plantearme sacarlo una función aparte 00:21:16
vale y así aquí me limito a llamar bueno entonces vamos a ver cómo lo vamos a 00:21:19
hacer aquí 00:21:26
ejercicio 14 con función vamos a ponerlo 00:21:29
ejercicio 14 00:21:42
con función 00:21:51
vale pues voy a copiar el otro entero para irlo éste era nuestro ejercicio 00:21:57
original 00:22:03
éste era nuestro ejercicio original que vamos a hacerlo ahora con una función 00:22:12
aparte vale pues este código este código es el que queremos sacar aparte 00:22:15
el que queremos sacar aparte y aquí nos limitamos a llamarle ya está pues venga 00:22:21
entonces yo cuando ya donde ya ha acabado el main el main empieza aquí y 00:22:27
acaba aquí perdón no ahí acaba ahí acaba el foro entonces cuando ya 00:22:32
empieza a acumular muchas llaves es buena idea que os acostumbréis cada 00:22:36
llave que cerráis poner aquí un comentario para ver qué está cerrando 00:22:39
en este caso estoy cerrando este foro vale pues cuidado vale y ahora esta 00:22:43
llave que me cierra esta llave me está cerrando el main 00:22:51
vale pues ponemos aquí main y esta llave ya me cierra la clase 00:22:57
me cierra la clase 00:23:03
bueno lo pongo así porque 00:23:10
vale porque cuando ya empieza a ver muchas anidamientos de y de foro etcétera 00:23:17
igual ya son muchas llaves cerrándose y nos hacemos un día bueno pues el main 00:23:21
se abre y se cierra aquí 00:23:27
entonces dónde hago yo esa función aparte la tengo que hacer fuera del main 00:23:31
fuera aquí ha parado el main es como el programa principal el programa principal 00:23:35
que puede llamar a las funciones ese es el main el programa principal que 00:23:40
empieza aquí y termina aquí ese es el main el programa principal ya las 00:23:44
funciones las pongo aparte luego las pongo fuera del main vale 00:23:48
pues por ejemplo esta función que vamos a sacar fuera para que le tenemos que 00:23:53
dar un nombre lo más explicativo posible para que luego el que vea la clase 00:23:58
principal el main entienda lo que está haciendo igual que las variables las 00:24:02
variables aunque tengan un nombre muy largo da igual lo importante es que 00:24:07
tengan un nombre que explique lo que tienen dentro pues los las funciones 00:24:10
igual me da igual que tenga un nombre larguísimo de hecho cuando uno utiliza 00:24:15
clases de por ahí o sea funciones de por ahí de librería ve que los métodos 00:24:19
tienen nombres enormes porque lo importante es que se entienda esa 00:24:24
función que hace estoy usando función método procedimiento 00:24:28
indistintamente e intentar usar función por ahora sólo se termina vale pues 00:24:32
entonces primero vamos a hacer aquí función para ver si un número es primo 00:24:37
vale porque el código que yo voy a sacar es un código que vale para ver si un 00:24:50
número es primo no es primo vale para eso pues entonces vamos a darle un 00:24:57
nombre por ejemplo es prima ese es el nombre que le vamos a dar 00:25:04
el nombre de las funciones puede empezar con mayúscula minúscula pero de nuevo 00:25:09
para seguir todos pautas homogéneas de programación y entender los códigos 00:25:16
unos de otros se siguen siempre estos estas pautas y es que las variables 00:25:22
empiezan con nombres en minúscula letras en minúscula y las funciones 00:25:30
también con letras en minúscula que es lo que empieza con letra en mayúscula 00:25:34
los nombres de las clases luego más adelante cuando vemos objetos y 00:25:40
tendremos porque sólo clarifica que es obligatorio no no es obligatorio esto 00:25:45
puede empezar por minúscula esto puede empezar por mayúscula pero si yo no 00:25:49
sigo los criterios asumidos entre todos los programadores del mundo pues me 00:25:54
estoy poniendo trabas a mí mismo porque no van a entender los demás las cosas 00:25:59
vale cuando hay programas grandes si yo veo un identificador que empieza con 00:26:03
minúscula digo uy esto un nombre de clase no va a ser seguro seguro que es 00:26:07
variable de función entonces ya ayudas un poco entonces sigamos eso que hemos 00:26:12
asumido todos que deberíamos seguir y una de esas pautas es que los nombres de 00:26:17
las funciones con las excepciones que veros más adelante empiecen con 00:26:24
minúscula va a llegar un nombrecito vale pero qué más cosas tengo que poner en 00:26:27
java pues en java tengo que poner aquí unos paréntesis después 00:26:32
que ahora indicaremos para qué aquí va entre llaves el código el código que yo 00:26:38
voy a meter y aquí antes del es primo tiene que haber algo que también y 00:26:45
veremos lo que es entonces una función tendrá el nombrecito este el que a mí me 00:26:50
dé la gana lo más explicativo posible de lo que hace ese código 00:26:56
unos paréntesis que pueden tener cosas dentro o no o pueden no tenerlas ya lo 00:27:02
ahora lo vemos y aquí algo que tiene que existir ya veremos el que vale y aquí 00:27:08
dentro el código de lo que hace así es como se declara esa función vale pues 00:27:15
vamos a meterle primero el código luego ya lo quitamos del mail vamos a meterle 00:27:22
primero el código yo quería que esta función hiciera esto vale pues le voy a 00:27:28
pasar esto 00:27:33
esto es lo que yo quiero que haga 00:27:36
vale 00:27:40
vale y aquí nos surgen preguntas vale esta parte es la más con lo que vamos a 00:27:44
explicar ahora que son estas interrogaciones y estas es lo más 00:27:49
complicado de entender pero ahora después haciendo unos cuantos ejemplos pues la 00:27:53
idea es que vaya quedando más o menos claro vamos a ver vamos a pensar o sea 00:27:57
este código de aquí con quién tiene que trabajar cuál va a ser su entrada pues 00:28:01
su entrada es el numerito y que yo quiero ver si es primo no verdad porque 00:28:07
yo cuando llame a esta función la voy a llamar para que trabaje con este 00:28:11
numerito y con este numerito para que trabaje con este numerito y entonces 00:28:16
este código trabaja con este numerito y es con su su dato de partida con el que 00:28:22
tiene que trabajar su dato de partida bueno pues este dato de partida es el 00:28:27
que yo le tengo que poner estos paréntesis decirle a ver cuál es el 00:28:32
dato con el que tú vas a trabajar pues ahí tengo que declararlo como si fuera 00:28:35
una variable normal y corriente pues yo voy a trabajar de partida con un número 00:28:40
entero que se llama y lo declaró como cualquier otra variable 00:28:44
vale entonces esto significa esta función es primo va a trabajar con este 00:28:52
dato de entrada que yo le paso con este dato de entrada haciendo cosas en este 00:28:58
caso esta función como dato de entrada sólo tiene este porque el jota lo 00:29:05
declara aquí dentro y lo usa solamente para ver para pasar por los divisores 00:29:10
pero no es un dato de entrada el dato de entrada es el número del que yo quiero 00:29:17
averiguar si es primo no vale pues el dato de entrada lo pongo aquí ahora 00:29:20
después veremos ejemplos podría tener más datos de entrada a lo mejor podría 00:29:29
ser una función que trabajará con dos números para ver si no es múltiplo de 00:29:33
otro lo que fuera esta sólo tiene un dato de entrada que es el numerito y que 00:29:36
tenemos que ver si es primo no pues venga se lo pasamos ahí y ahí lo que 00:29:41
hay que poner repito es como si estuviéramos declarando lo hay que 00:29:46
poner el tipo y el nombre de ese dato de entrada exactamente igual que si lo 00:29:49
estuviéramos declarando esto significa a la función es primo cuando la llamemos 00:29:53
pásale un número entero es lo que significa eso pásale un número entero 00:29:59
vale pues ya tenemos esta parte y nos queda esta para completar la función 00:30:05
esta parte cuál es esta función normalmente tendrá un resultado en este 00:30:10
caso el resultado cuál es vale el resultado es este boolean porque es lo 00:30:20
que a mí me interesa aquí porque es el que luego yo voy a usar este boolean es 00:30:26
el que luego yo voy a usar luego el resultado de este código el resultado 00:30:30
interesante es ese boolean es el que yo quiero entregar 00:30:34
fuera y decir oye ya he hecho lo que me has pedido con este y que me has dado y 00:30:38
te devuelvo este boolean para que trabajes con él entonces el resultado 00:30:43
de la función es ese boolean bueno pues entonces una vez que la función ha hecho 00:30:48
lo que tenga que hacer tengo que decir oye devuélveme ese resultado y eso lo 00:30:52
haremos con la palabra retún y lo que yo quiera devolver que será una variable 00:30:57
siempre pues esto yo he trabajado con esto con el dato de entrada y y esta 00:31:01
variable boolean es la que le interesa al que me llama desde fuera es la que le 00:31:09
interesa es la que le interesa le interesa esa variable pues este método 00:31:14
devolverá esa variable y qué es lo que se pone aquí aquí se pone simplemente 00:31:20
el tipo de dato de la variable que devuelvo el tipo de dato nada más 00:31:26
entonces qué variable devuelvo yo devuelvo esta que es boolean pues aquí 00:31:31
pongo boolean 00:31:35
vale aquí pongo boolean 00:31:38
pero esta es una función ya correctamente declarada 00:31:44
tiene un código trabaja con un dato de entrada que es 00:31:48
este con lo cual yo tengo que ponerlo aquí con el tipo de dato que sea hace 00:31:55
lo que sea y devuelve una variable como resultado devuelve una variable como 00:32:00
resultado la que me interese en función de la función que estoy haciendo a mí me 00:32:06
interesa devolver este boolean porque es el que usamos aquí 00:32:10
la que me interese pues lo devuelvo con retún y pongo aquí el tipo de dato de 00:32:14
esta variable ahora hacemos más ejemplos de funciones para 00:32:20
entender un poco mejor eso 00:32:25
y ya está esta función ya está hecha ahora mi problema es llamarla mi problema es 00:32:31
llamarla entonces la función una función puede 00:32:35
tener dentro todo el código que a mí me dé la gana todo lo que yo quiera 00:32:39
200.000 líneas todo lo que yo necesite para hacer lo que tenga que hacer todo 00:32:42
lo que yo necesite y puede declarar variables dentro de hecho aquí está 00:32:46
declarado ésta de aquí ha declarado la injota puede declarar cosas dentro se 00:32:51
las necesita puede declarar entonces una función trabajará con las cosas que 00:32:55
declara dentro para trabajar como aquí la jota este y también trabajará con el 00:33:00
dato de entrada trabaja con todo eso con el dato de entrada y las cosas que se 00:33:06
declaren ya dentro para operar y con eso puede hacer un código de toda la 00:33:12
inyección falta vale y luego devolverá un valor de volver a un valor 00:33:17
bueno pues ahora está ahora ahora como llamo yo a esta función 00:33:25
vale pues esta función mi idea la quiero llamar desde aquí 00:33:31
todo esto ya no hace falta que yo lo haga y puedo llamar a esta función 00:33:36
entonces como llamo yo a esta función pues la llamo por su nombre su nombre es 00:33:40
primo pues la llamo por su nombre pero claro entre paréntesis tengo que pasarle 00:33:46
tengo que pasarle el número entero con el que yo quiero que trabaje porque esta 00:33:52
función me dice oye tú puedes llamarme cuando quieras cuando quieras pero 00:33:57
cuando me llames tienes que pasarme un número entero eso sí que es 00:34:01
impepinable tienes que pasar un número entero y yo te diré a través del 00:34:05
boolean que devuelvo si es primo no es lo que nos está obligando esta función 00:34:09
a que cuando la llamemos le pasemos un entero eso es obligatorio 00:34:14
vale entonces nosotros podríamos llamar a esta función si nos diera la gana 00:34:18
pasándole 6 y sería una llamada correcta porque 6 es un número entero 00:34:23
es una llamada correcta vale podría valer lo que pasa es que yo no 00:34:29
quiero ver si es primo 6 quiero ver si es primo quien el y eso es lo que yo 00:34:34
quiero ver quiero ver si es primo el y pues entonces no le pasaré 6 le pasaré 00:34:39
y pero yo esa función la puedo llamar ahora ya siempre que me dé la gana 00:34:42
siempre que yo quiera pasándole un entero que quiero ver yo ahora si es 00:34:46
primo 528 529 pues es primo 529 después puedo reutilizar esa función cuando me 00:34:51
dé a mí la gana para ver si un número es primo no en cualquier parte del código 00:34:59
que me dé la gana la puedo llamar siempre y cuando le pase un número 00:35:03
entero que es lo único a lo que me obliga a esta función a pasarle un 00:35:07
entero porque así lo hemos declarado en este caso yo la voy a usar para ver si 00:35:10
es entero este numerito y bueno pues entonces le pasaré y no le pasaré 300 00:35:16
ni 420 ni nada le pasaré y vale pero claro es primo me devuelve algo me 00:35:20
devuelve un boolean esto es como cuando llamamos al scan next y next sin es una 00:35:29
función también a la que estamos llamando el personaje hemos hecho 00:35:34
nosotros y estamos llamando a next y en un montón de veces estamos llamando a 00:35:37
esta función en realidad y qué es lo que hace esta función está en particular nos 00:35:41
devuelve un numerito bueno pues la nuestra que hemos hecho nos devuelve un 00:35:46
boolean pues habrá que guardar ese boolean en algún sitio verdad habrá que 00:35:51
guardar en algún sitio bueno pues lo vamos a guardar en esta variable por 00:35:55
ejemplo ya está esta función que yo he llamado aquí ahora quitamos el rojo 00:35:59
este esta función que yo he llamado me calcula si es primo el número entero que 00:36:05
yo le pase en este caso le quiero pasar y el valor que me devuelve que es un 00:36:13
boolean el valor que me devuelve que es un boolean tendremos que asignarse a una 00:36:18
variable boolean igual que next in que también es una función el entero que me 00:36:22
devuelve se lo paso a un a una variable entera pues es lo mismo la única 00:36:28
diferencia es que esta función no la hemos hecho nosotros esta función 00:36:36
es esta es esta es una función que devuelve un entero 00:36:41
y este entero no lo hemos hecho nosotros está ya hecha afortunadamente esta 00:36:48
función devuelve un entero y ese entero nosotros lo guardamos aquí 00:36:51
pues nuestra función está devuelve un boolean y ese boolean lo guardamos en un 00:36:57
boolean el que a mí me dé la gana no hace falta que le llame igual que aquí 00:37:02
no hace falta que lo llame igual que aquí me da lo mismo como lo llame lo 00:37:05
único que importa es que ese boolean lo tengo que guardar en algún sitio 00:37:09
vale pues ya está entonces este código me ha quedado más corto llamo a esta 00:37:12
función y llamo a esto vale porque me sale esa cosita roja 00:37:15
me sale esa cosita roja porque como lo estoy llamando desde un main que es 00:37:21
static tenemos que poner aquí está esto no es imposible que lo entendamos 00:37:24
ahora porque necesitamos conocer más cosas pero ahora mismo simplemente que 00:37:30
quedaos con que si yo declaro funciones fuera del main fuera del main para 00:37:37
llamarlas en el main tengo que poner el static delante ya está vale entonces 00:37:43
ponéis el static delante el tipo de dato que devuelve el nombre de la 00:37:51
función el dato de entrada y lo que sea que haga y ahora ya la llamamos 00:37:55
veis ya se me ha quitado el rojo que ahora resulta que quiero yo ver si es 00:38:02
prima ahora imaginaos que mi programa sigue por aquí y ahora quiero ver si es 00:38:06
primo pues 00:38:11
pues este número por ejemplo quiero ver si es primo 00:38:16
el número 3567 quiero ver si es primo este número porque me apetece ahora de 00:38:21
repente mi programa sigue y ha hecho este bucle de aquí y ahora quiero ver 00:38:36
si es primo este número pues en lugar de volver a repetir el código como lo 00:38:40
tengo metido en una función magnífico como tengo una función la vuelvo a 00:38:44
llamar pero ahora esta función trabajará con este número entero y me 00:38:48
devuelve el resultado aquí vale y ahora yo ya aquí haré lo que sea si primo 00:38:54
pues entonces puede decir pues 00:39:00
pues yo que se 3567 es primo 00:39:06
que mi programa sigue tiene 10.000 líneas y luego vuelvo a necesitar ver si 00:39:13
el número es primo pues estupendo otra vez vuelvo a llamar a la función otra 00:39:17
vez vuelvo a llamarla como primo ya está declarado no la 00:39:22
puedo traer de nuevo claro a la otra vez la vuelvo a llamar este no va a ser 00:39:27
primo obviamente por ejemplo yo que sé entonces al haber metido esto en una 00:39:30
función al haberlo metido cada vez que quiera saber si un número es primo la 00:39:36
llamo pasándole ese número entero y sabiendo que además esa función me va 00:39:41
a devolver un boolean que yo guardaré en un boolean porque si no lo guardo en un 00:39:46
boolean lo pierdo lo tiro a la basura lo guardaré en un boolean y con ese boolean 00:39:50
ya le lo que quiera entonces no sólo ha quedado el código más claro me ha 00:39:53
quedado esta línea y esta el que lo entienda dice a vale que estás haciendo 00:39:58
con cada y antes el que veía este código veía un for y ese for podía no 00:40:02
entenderlo ahora el que ve este código ve la llamada a una función es primo 00:40:07
entonces el que ve este código dice a estupendo lo que estás haciendo es ver 00:40:11
si es primo o no es primo lo ve a la primera y en una sola línea antes veía un for 00:40:13
que no sabía ni lo que estaba haciendo ahora ve una llamada que la entiende 00:40:18
mejor vale entonces si ejecutamos ahora esto 00:40:22
primero nos pide el enterito este pues 6 venga y los que le hemos metido ha dado 00:40:28
la casualidad de que ninguno de los dos que hemos metido era primo 00:40:35
perdón 00:40:40
le habéis puesto la estática aquí delante 00:40:45
y le habéis pasado un número entero y lo habéis guardado en un 00:40:49
lo habéis escrito bien seguro habéis puesto aquí un número entero el y el 00:40:56
que sea un entero pero a ver qué error os dice aquí lo importante es que leáis 00:41:00
lo que os dice si te da un error tendrá una información que información 00:41:04
te dice 00:41:09
la variable 00:41:15
bueno pues entonces vete a la variable es primo de tu código porque la tendrás 00:41:18
declarada dos veces 00:41:22
claro no no pero no no es por eso porque esto está dentro de estas llaves va 00:41:28
aparte eso no en tu mismo código este de aquí la tendrás declarada 00:41:32
esta variable la tendrás declarada dentro de este mismo código más arriba 00:41:37
o en algún otro sitio si te dice que es primo está de cada dos veces es que 00:41:41
bullion es primo lo tienes dos veces en el mismo 00:41:45
a ver no lo que he quitado es el bullion de aquí por aquí ya estaba declarada 00:41:56
claro vale venga pues vamos a parar aquí 00:42:03
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
6 de noviembre de 2023 - 11:58
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
802.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid