Saltar navegación

20241108 ProgrEstruct-Funciones_4 - 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 11 de noviembre de 2024 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues entonces, esto es lo primero que se nos ocurrió sobre la marcha, ¿vale? 00:00:00
Lo primero que se nos ocurrió sobre la marcha, pues para consolidarlo de ayer, algo facilito. 00:00:08
Entonces, esto, imagino que lo hicisteis, devuelve la que tenga más vocales. 00:00:12
Pues nada, pondríais el nombre, cualquiera, y ahora, una vez decidido el nombre, uno ya se plantea parámetros de entrada si es que los hay, 00:00:17
Valor de retorno si es que lo hay 00:00:27
Y luego ya el código 00:00:29
Parámetros de entrada 00:00:30
Dos nombres, dos cadenas 00:00:32
Pues dos, string 00:00:34
No voy a separar por comas y ya está 00:00:37
No voy a poner string cat1 y cat2 00:00:44
No, no, no, no 00:00:46
Aquí no puedes hacerlo como cuando haces una declaración 00:00:47
Tienes que separarlo por comas 00:00:51
Dime 00:00:52
Yo lo que he hecho ha sido dos funciones separadas 00:00:53
Se puede hacer también así 00:00:55
Dos funciones separadas, ¿para qué? 00:00:56
O sea, he hecho dos funciones 00:01:01
y una función que agrupa las dos funciones. 00:01:03
O sea, una función 00:01:05
que cuenta las vocales. 00:01:06
Otra que cuenta las vocales y otra que llama 00:01:09
esas dos. 00:01:11
Bueno, son funciones igualmente. 00:01:13
Vale. 00:01:15
Bueno, has hecho funciones y has llamado 00:01:17
funciones y pues ya está. 00:01:19
Y las ha comparado dentro del link con el link. 00:01:20
Sí. Bueno, vale. 00:01:23
Pero bueno, has hecho funciones, que es lo que había que hacer. 00:01:24
Vale. 00:01:27
Esta recibe 00:01:29
dos cadenas. A ver, 00:01:30
bueno, lo importante y lo segundo 00:01:32
importante es que se haga lo que a uno se le pide 00:01:34
porque tú puedes ir a tu trabajo 00:01:36
te piden una, oye, hazme esta 00:01:38
aplicación para no sé qué 00:01:40
oye, la que te he hecho te funciona, sí, pero 00:01:41
no me has hecho la que te he pedido 00:01:44
entonces es importante adaptarse a los requisitos 00:01:45
a ver, ¿alguna de las funciones que me has hecho recibe 00:01:48
dos nombres? 00:01:54
entonces no te he hecho lo que te piden 00:01:57
porque yo te he pedido una función que reciba 00:01:58
dos nombres 00:02:00
entonces me has hecho dos funciones 00:02:01
el resultado final de la aplicación 00:02:03
usando esas funciones en este caso es el mismo 00:02:06
pero aquí en este caso y de cara al examen 00:02:08
que ahora mismo es lo que 00:02:10
nos importa 00:02:11
si yo te pido una función 00:02:13
que reciba estos 00:02:16
parámetros y devuelva, me tienes que hacer 00:02:18
una función que haga eso 00:02:20
entonces esta función 00:02:21
recibe dos nombres 00:02:24
pues dos stream 00:02:25
y efectivamente 00:02:27
no, así no lo podéis 00:02:29
poner. Cuando nosotros declaramos dos 00:02:33
strings en un programa, sí que lo podemos 00:02:35
separados por comas y no pasa nada. 00:02:37
Aquí no, ¿vale? Aquí en la 00:02:39
lista de parámetros 00:02:41
hay que poner los parámetros 00:02:42
uno por uno separados por comas. 00:02:44
Si el tipo de dato se repite, pues el tipo de dato se repite. 00:02:47
¿Y qué te devuelve? 00:02:50
Te devuelve la 00:02:51
cadena o el nombre, bueno, como 00:02:53
lo he llamado nombre enunciado, vamos a poner 00:02:55
nombre. Te devuelve la 00:02:57
cadena o el nombre que tenga más vocales. 00:03:01
Con lo cual, ¿qué es lo que te devuelve? 00:03:03
Una cadena también. 00:03:05
También te devuelve una cadena. 00:03:07
Pues como también te devuelve una cadena, string. 00:03:11
¿Vale? 00:03:15
Entonces, la firma, la cabecera, como lo queréis llamar de la función, es esta. 00:03:18
Nombre, parámetros de entrada separados por comas si los hay y valor de retorno. 00:03:24
Y ahora ya uno aquí pues hace su código y todo lo que haga falta. 00:03:29
Entonces, esta función en particular 00:03:33
Como la vamos a llamar desde main 00:03:36
Esta en particular 00:03:38
Y main tiene el static delante 00:03:39
Pues ya sabemos que tenemos que poner el static delante 00:03:42
Aunque ahora simplemente 00:03:44
Obedezcamos como 00:03:46
Siervos 00:03:48
Pero llega el momento en que seamos libres 00:03:49
Y ya no tengamos que obedecer como siervos 00:03:52
Sino que lo pongamos si queremos 00:03:54
Ponerlo y nos interesa 00:03:56
Pero aquí tenemos que ponerlo 00:03:57
Porque main tiene static 00:04:00
pues solamente puede llamar a funciones 00:04:01
que tengan static 00:04:03
pues lo ponemos, vale 00:04:04
y aquí ahora ya el programador 00:04:07
pues podría hacer lo que fuera 00:04:09
y en un caso real 00:04:10
pues uno se deja así esta 00:04:13
función y dice, vale, a mí el programador 00:04:15
Pepito ya me dará esta 00:04:17
función alguna vez, ya me la dará 00:04:19
pero yo no me paro, yo puedo seguir mi aplicación 00:04:20
y yo puedo aquí ya en mi main 00:04:23
llamarla y todo eso 00:04:25
no me va a devolver nada en ese momento 00:04:26
pero mi código puede seguir en realidad 00:04:29
Y ya cuando esa persona tenga esta función 00:04:31
Yo la incorporo 00:04:34
Pero yo no tengo por qué ocuparme de ella 00:04:35
Yo puedo seguir aquí programando 00:04:36
Sin errores de compilación y sin nada 00:04:38
En mi main 00:04:39
Puedo estar haciendo aquí cosas 00:04:41
Puedo llamar a esa función 00:04:43
Y guardar en un resultado 00:04:44
Puedo usarla para comparar dos nombres 00:04:48
Y puedo seguir aquí trabajando 00:04:57
y hago mis cosas 00:05:01
lo que pasa es que estaré todavía en fase de desarrollo 00:05:02
y el resultado no será real 00:05:05
porque result 00:05:07
esta función está sin hacer 00:05:09
result me va a devolver un null 00:05:11
me va a devolver un null 00:05:15
pero yo en última instancia puedo seguir 00:05:16
aquí desarrollando y puedo seguir haciendo cosas 00:05:19
y ya llegará un momento en que esa función tenga algo 00:05:21
cuando el que se encargue de hacerla la haga 00:05:23
y ya está, entonces son trabajos 00:05:25
que se independizan 00:05:27
entonces el que se encarga de hacerla 00:05:28
lo mismo 00:05:31
Lo único que necesita es esto 00:05:32
La cabecera 00:05:34
Saber qué tiene que darle por parámetro 00:05:36
Saber qué sale y programar 00:05:38
No necesita saber ni en qué momento la van a llamar 00:05:40
Ni cuándo, ni para qué 00:05:42
Eso le da exactamente igual 00:05:44
Lo único que necesita saber es esto 00:05:45
Qué va a hacer la función 00:05:47
Vale, pues entonces 00:05:47
Ahora ya programar esto 00:05:50
Pues nada, contamos las vocales de una 00:05:52
Contamos las vocales de otra 00:05:54
Y lo hacemos 00:05:55
Entonces en este caso nuestro 00:05:56
Concreto, qué suerte 00:06:00
porque tenemos una función 00:06:01
ya hecha 00:06:04
que cuenta las vocales de un nombre 00:06:06
entonces 00:06:08
¿para qué repetir 00:06:10
el código aquí otra vez? 00:06:12
ya tengo yo una función que las cuenta 00:06:13
que es justo lo que quiero hacer 00:06:15
quiero contar las vocales de nombre 1 00:06:17
quiero contar las vocales de nombre 2 00:06:19
cuando las tenga quiero ver cuál de las dos tiene más 00:06:21
si nombre 1 tiene más 00:06:24
devuelvo nombre 1 00:06:25
si no devuelvo nombre 2 00:06:26
todo ese código tendría que hacerlo 00:06:28
Pero, repito, como alguien ha hecho la función contar vocales 00:06:30
Pues, magnífico 00:06:35
Vamos a ver las vocales de la primera 00:06:37
Lo voy a poner separadito en variables 00:06:41
Aunque, pues para eso tenemos una función 00:06:42
Que se llamaba contar vocales 00:06:45
A la que le pasa 00:06:48
Porque había dos versiones 00:06:50
Ah, sí, porque la última es la que nos interesa 00:06:54
Teníamos contar vocales versión 2 00:06:56
Que ya me devuelve el numerito 00:06:59
Que ya me devuelve el numerito 00:07:01
Contar vocales, versión 2 00:07:03
De nombre 1 00:07:05
Pues estupendo, que suerte 00:07:07
Que suerte que tengo esta función 00:07:12
Que ya me lo hace, me cuenta las vocales de un nombre 00:07:14
Luego la puedo llamar siempre que me haga falta 00:07:16
Entonces 00:07:19
Primera cosa 00:07:22
Que buscaba con este ejemplo 00:07:23
Pues que a una función yo la puedo llamar 00:07:25
Desde cualquier sitio donde tenga que escribir código 00:07:27
Y ese sitio puede ser mi propio main 00:07:30
Como hemos hecho aquí 00:07:32
mi propio main, yo he necesitado hacer algo 00:07:32
que me lo hace una función y lo he llamado 00:07:35
desde mi propio main, pero puede ser 00:07:36
que también quiera yo hacer eso 00:07:39
desde otra función, porque me interese 00:07:41
pues magnífico 00:07:43
yo llamo a esa función desde donde quiera 00:07:44
desde la función 00:07:47
main, que es una función también 00:07:49
aunque sea especial, desde otra función 00:07:51
desde donde yo quiera, siempre que necesite hacer eso 00:07:53
pues en este caso necesito hacerlo 00:07:55
aquí, pues magnífico 00:07:57
y necesito hacerlo otra vez más 00:07:58
Pues estupendo 00:08:00
Ahora ya sí que puedo seguir haciendo mi función 00:08:11
Que es 00:08:13
Si v1 00:08:14
Es mayor que v2 00:08:15
Entonces 00:08:19
Return 00:08:21
Nombre1 00:08:24
Else return 00:08:26
Nombre2 00:08:33
Y ya está 00:08:38
Esta función se ha apoyado en la llamada esta 00:08:40
La ha necesitado llamar dos veces 00:08:44
para contar las de nombre 1, ¿vale? 00:08:46
Yo he llamado a la función pasándole el dato que me interesaba. 00:08:49
Aquí en este caso me interesaba nombre 1, pues ala. 00:08:53
Aquí le he llamado pasándole el dato que me interesaba. 00:08:56
Aquí me interesaba nombre 2, pues ala. 00:08:58
Cuando ya tengo el resultado de estas dos llamadas 00:09:01
guardado en una variable, 00:09:03
pues comparo para ver cuál es el valor de retorno, 00:09:06
el string de retorno, si nombre 1 o nombre 2, ¿vale? 00:09:09
en esta función en particular 00:09:14
claro, habría que especificar 00:09:22
un poco más, porque me diríais 00:09:25
uy, eso 00:09:26
si tienen el mismo número de vocales 00:09:28
pues claro 00:09:31
en este caso devolvería el nombre 2 00:09:33
entonces ahí tendríamos que preguntarle 00:09:35
al que nos la ha pedido, decirle, oye 00:09:37
si tiene el mismo número de vocales 00:09:38
¿cuál quieres que devuelva? 00:09:41
entonces él te puede decir, pues cualquiera de las dos 00:09:43
o no, o si tiene el mismo 00:09:45
número de vocales, pues devuélveme nul 00:09:47
por ejemplo 00:09:49
en función de para lo que la quiera 00:09:50
esa persona, esa función 00:09:53
pues a lo mejor te puede decir, si tiene el mismo número de vocales 00:09:55
devuélveme un string 00:09:57
a lo mejor que ponga, tienen el mismo 00:09:59
no sé, que te lo especifiquen 00:10:01
entonces claro 00:10:02
lo normal es que una función venga 00:10:04
acompañada de una buena documentación 00:10:07
delante 00:10:09
para especificar 00:10:10
qué significa el valor de retorno 00:10:12
qué significa, porque hay veces 00:10:15
que está claro, claro, aquí uno lee esto y dice 00:10:17
contar vocales, hombre pues tiene toda la pinta 00:10:19
que si a un método que se llama contar vocales 00:10:22
yo le paso una cadena, pues me devuelve el número 00:10:25
de vocales, más o menos lo puedo deducir 00:10:28
porque si me devuelvo un número entiendo que es eso 00:10:31
pero aquí pueden dar más dudas y si tienen el mismo 00:10:32
¿cuál me devuelve? la primera, la segunda, porque son cadenas distintas 00:10:36
entonces habría una confusión, yo podría creer que la primera 00:10:40
tiene más y la verdad es que tiene la misma 00:10:43
que la otra, entonces no siempre 00:10:45
la cabecera especifica 00:10:48
completamente el funcionamiento, es imposible 00:10:51
no puedo deducir yo todos los detalles 00:10:53
del funcionamiento, todos 00:10:55
solo con el nombre, los parámetros 00:10:56
el resultado 00:10:59
bueno pues para eso lo mejor es 00:11:00
hacerle una buena documentación 00:11:02
y la documentación de 00:11:04
javadoc 00:11:10
se hace, son comentarios 00:11:10
especiales 00:11:14
que empiezan en lugar de 00:11:15
con la barra y un único asterisco 00:11:18
empiezan con la barra 00:11:20
y dos asteriscos, empiezan así 00:11:22
y además 00:11:24
si tú sigues 00:11:26
un formato concreto 00:11:30
tú sigues un formato, pues luego 00:11:31
a partir de estos comentarios 00:11:34
usando la herramienta Javadoc puedes 00:11:35
crear unas páginas 00:11:38
HTML que te documentan todo muy bien 00:11:39
creo que al principio lo mencionamos 00:11:42
pero vamos a volver a revisarlo 00:11:44
por ejemplo, aquí esto me ha hecho 00:11:46
una magia, ¿no? 00:11:48
yo le he hecho la barra y dos asteriscos 00:11:48
y le he dado al enter 00:11:52
y el eclipse es muy listo 00:11:53
porque al ver que yo he hecho la barra 00:11:55
y dos asteriscos dice, ah, que quieres hacer 00:11:58
comentario javadoc, entonces es muy listo 00:11:59
entonces en cuanto yo le he hecho el enter, él ya me ha creado 00:12:01
todo esto 00:12:04
y me ha creado todo esto mirando 00:12:04
la cabecera de la función que quiero documentar 00:12:08
y me ha dicho, vale 00:12:10
esta función tiene dos parámetros 00:12:12
nombre1 y nombre2 00:12:14
y tiene una vuelta, return 00:12:15
Vale, entonces me ha dicho 00:12:17
Ahora tú aquí añade lo que quieras 00:12:19
Entonces lo normal es que añadieramos 00:12:20
El primer nombre 00:12:23
O lo que 00:12:25
Sea que signifique ese parámetro 00:12:28
El segundo nombre 00:12:31
Y aquí es donde ponemos todo el rollo 00:12:35
¿Qué devuelve? 00:12:37
Devuelve 00:12:38
El nombre con más vocales 00:12:39
Y aquí es donde especificamos 00:12:44
Si tienen el mismo 00:12:46
devuelve 00:12:48
null, por ejemplo. 00:12:58
Lo que decidamos, lo que acordemos 00:13:02
con la persona que os lo ha pedido. 00:13:03
Si tienen el mismo número de vocales, devuelve null. 00:13:04
Y podemos poner más cosas, más lo que queramos. 00:13:07
Entonces, 00:13:11
si cambiamos el código 00:13:12
de la función 00:13:15
para que ya haga esto 00:13:19
que hemos dicho, 00:13:20
pues entonces, si cambiamos 00:13:23
el código de la función para que haga eso, 00:13:24
Pues entonces tendríamos que poner 00:13:26
El save 00:13:29
Mayor que V1 00:13:35
Entonces ahora sí, return nombre 2 00:13:36
Y ahora ya en el else 00:13:38
Ahora sí, return null 00:13:42
Que stream puede tener null 00:13:44
Porque es un objeto 00:13:46
Vale, entonces este código que hemos puesto 00:13:47
Ahora, ¿no? Si V1 es mayor que V2, la primera 00:13:50
Si no, la segunda 00:13:52
Y si tienen el mismo, devuelve null 00:13:53
Entonces este código que hemos hecho 00:13:56
ya si hace exactamente lo que hemos documentado 00:13:58
entonces ahora ya 00:14:00
la persona que usa esta función 00:14:03
solo necesita 00:14:05
la cabecera 00:14:06
para saber como llamarlo y todo eso 00:14:08
y esta documentación para entender 00:14:11
bien exactamente que hace la función 00:14:13
y con eso ya decidir si le interesa 00:14:15
si hace lo que quiere, si no hace lo que quiere, si la usa 00:14:17
y todo eso 00:14:19
entonces si estos comentarios javado que están 00:14:20
pues hechos bien 00:14:24
con esto de aquí que indica 00:14:26
cada parámetro de entrada 00:14:28
esto que indica el valor de retorno 00:14:30
hay más posibilidades, pues un throw 00:14:32
parece la excepción, historias raras que 00:14:34
veremos 00:14:36
pues uno podría 00:14:37
si ya tiene un montón de funciones documentadas 00:14:40
con javadoc, tiene un montón de funciones 00:14:43
ya podría decir, mira, voy a generar ya 00:14:44
mi documentación 00:14:46
y ya la cuelgo 00:14:47
la pongo en un servidor y ya quien use 00:14:50
estas funciones, pues ya entra ahí 00:14:52
y lo mira, y ya sabe si esa función 00:14:54
le vale, no le vale y ya está 00:14:56
y no tiene que entrar al código a mirarlo 00:14:58
¿por qué? porque el código no lo distribuimos 00:15:00
nosotros cuando distribuimos 00:15:03
una librería de funciones como esta 00:15:04
distribuimos ya el compilado 00:15:06
el .class 00:15:08
el código fuente no lo distribuimos 00:15:09
el .class 00:15:12
entonces el que vaya a usar esas funciones 00:15:13
no tiene acceso a esto de dentro 00:15:16
entonces la única manera que tiene de ver 00:15:18
si esa función le interesa para meterla 00:15:20
en su código 00:15:22
es la cabecera y la documentación 00:15:23
javado, entonces por eso distribuimos 00:15:26
las funciones compiladas 00:15:29
ya veremos como, toda la librería 00:15:32
de funciones metida en un hard, distribuimos 00:15:33
eso, ya compiladas 00:15:35
y el javadoc, para que el que 00:15:37
descargue esas 00:15:39
esas funciones 00:15:41
sepa si la interesa o no 00:15:44
entonces ese javadoc, pues desde la consola 00:15:45
con javadoc es muy fácil generarlo 00:15:48
y si tenemos un eclipse, pues también lo podemos 00:15:49
generar con project 00:15:52
generar javadoc 00:15:53
y aquí ya le decimos 00:15:56
Venga, ¿de qué clase quieres generar 00:15:57
Javadoc? ¿De qué paquete? 00:15:59
Del único que tenemos, de funciones 00:16:01
De paquete, pues venga 00:16:03
¿Dónde lo quieres 00:16:05
Meter? Pues 00:16:07
Lo vamos a poner en el escritorio 00:16:09
Para 00:16:11
Encontrarlo ahora rápido 00:16:12
Lo ponemos 00:16:15
En el escritorio 00:16:17
Doc, por ejemplo 00:16:19
Bueno, yo creo que me creará el 1 00:16:23
No creo que me meta todos los HTML así a lo bestia 00:16:33
Supongo que no 00:16:36
Así que lo pongo en el escritorio directamente 00:16:37
Pero bueno, porque me dice que no existe 00:16:39
Estoy en el escritorio mío, ¿no? 00:16:42
Debería dejar 00:16:48
Crear una carpeta 00:16:49
Precisamente no te la he creado 00:16:51
Ah, ahora sí me ha dejado, no sé antes qué estaba haciendo 00:16:53
No, no, estaba de igual 00:16:55
Bueno, en el escritorio, pues espera 00:16:56
Entonces ahora ya sí que le voy a poner una carpeta por si acaso 00:16:59
Vale, doc 00:17:01
Next, todo por defecto 00:17:03
Porque no nos interesan los detalles 00:17:06
Next, finish 00:17:07
Sobrescribe todo lo que haya si hubiera algo 00:17:09
Bla, bla, bla 00:17:11
Warning, warning, warning 00:17:13
Me parece que hay apuntes 00:17:15
Relajaos 00:17:18
Warning 00:17:20
Uy, no comment, que peligro 00:17:23
Bueno, da igual 00:17:25
Generating, generating, generating 00:17:26
Vale, pues vamos 00:17:30
Entonces, Doc, ¿dónde está? Aquí 00:17:31
Doc 00:17:33
Todas estas pedazos de páginas 00:17:36
Se ha generado solo para una clase 00:17:38
Que he documentado 00:17:40
Y dentro de esa clase un único método 00:17:41
Vale, el punto de partida index, como ya sabéis 00:17:42
Arrancamos index y aquí tenemos 00:17:45
Toda, ejemplo funciones 00:17:48
Vamos a ver que tiene ejemplo funciones 00:17:49
Que me he descargado ese hard de un lado 00:17:51
Pues que tiene, ah pues mira 00:17:52
Tiene un método que se llama ejemplo funciones 00:17:54
Sí, pero no lo ha generado bien porque 00:18:01
Tendría que 00:18:03
Haberme sacado el 00:18:06
Ejemplo de funciones 00:18:12
¿Dónde está? 00:18:17
¿Cómo se llama este proyecto? 00:18:21
Ejemplo clase funciones 00:18:22
Ejemplo clase funciones 00:18:24
Aquí está 00:18:33
Vale 00:18:34
Ejemplo clase funciones 00:18:35
No sé por qué tontería no me lo habrá generado bien 00:18:39
A ver 00:18:43
Que me dice aquí 00:18:44
Building index para todas las clases 00:18:45
Vale, vale, no hay comentarios 00:18:49
Vale 00:18:58
Ah, vale, vale, vale, porque no eran públicos 00:18:59
Y le he marcado que me documentara solo los públicos 00:19:02
Vale, vale, vale, vamos a volver a generarlo 00:19:04
Vale, debe ser por eso 00:19:06
Vale, proyecto lo vamos a generar 00:19:08
Que esto es muy rápido 00:19:10
Vale, entonces veis 00:19:11
aquí está marcado public 00:19:16
solo los métodos que tengan el public 00:19:18
delante y el que yo he hecho 00:19:20
esa función que yo he hecho no tenía el public delante 00:19:22
esto ya lo entenderemos más 00:19:24
entonces le voy a poner todos, todos 00:19:26
aquí, vale 00:19:27
generado 00:19:30
y ahora volvemos a 00:19:34
sí, bueno 00:19:36
me meto en ejemplo funciones 00:19:38
y ahora ya sí, vale 00:19:42
ahora me ha documentado todo lo que tengo 00:19:43
y en particular el método 00:19:45
Que yo había documentado 00:19:47
Que era el de más vocales 00:19:49
Este ya sí que tiene documentación 00:19:51
El primer nombre, el segundo 00:19:53
Devuelve el nombre con más vocales 00:19:55
Entonces me lo deja ahí todo muy bonito 00:19:57
Antes no más, ¿vale? 00:19:58
Entonces esto es 00:20:01
Si uno se acostumbra a todos los métodos 00:20:02
Y todas las cosas que haga con documentación 00:20:05
Luego, pa, le da al botoncito 00:20:07
Y tiene ya un sitio web 00:20:08
Bueno, para subir a un sitio web 00:20:09
Con toda la documentación 00:20:11
Y el que quiera, pues ya, mira aquí 00:20:12
Bueno, pues entonces todo este rollo venía 00:20:15
Por lo de las funciones 00:20:18
Pues venga 00:20:19
Vale, más funciones 00:20:20
Ahora, muchos de los códigos que hemos hecho 00:20:23
Nosotros, de los vídeos que hemos hecho 00:20:26
Pues contar cuántos primos hay 00:20:27
No sé qué hemos dicho, hay pues 00:20:30
Un contador, cada número que me va llegando 00:20:31
Tengo que mirar si es primo o no 00:20:34
Entonces, para ver si es primo 00:20:35
De nuevo teníamos que hacer otro código 00:20:37
Hubiera sido todo mucho más bonito si hubiéramos dicho 00:20:39
Ah, vale, por ejemplo, ser primo 00:20:41
lo voy a meter en un método 00:20:43
aparte, y ahora ya en mi programa 00:20:45
lo único que hago es, leo los números 00:20:47
y llamo al método a ver si es primo o no 00:20:49
pues venga, por ejemplo 00:20:51
vamos a hacer ahora 00:20:53
antes de hacer ya ejercicio más 00:20:55
¿puedes crear una clase 00:20:57
solo para funciones? 00:20:59
claro, y luego lo que pasa 00:21:00
es que la forma de llamarla no sería como 00:21:03
lo estamos llamando aquí, porque aquí la estamos llamando 00:21:05
por su nombre 00:21:07
sin más 00:21:09
habría que poner el paquete donde está 00:21:10
habría que más que el paquete la clase claro cuando ya programamos en diferentes clases vale 00:21:12
o sea esto que estamos haciendo aquí de llamarlo así con más vocales en lo que está haciendo es 00:21:19
como no le estás diciendo dónde está asumo que estás aquí y te pone por defecto el nombre de 00:21:24
tu clase ejemplo funciones es decir realmente yo debería llamarla así con el nombre de la clase 00:21:32
en la que está pero si yo no pongo nada él asume que por defecto entonces la busquen esa clase 00:21:46
vale entonces yo aquí en este caso como en este caso como solo trabajamos con una clase no estoy 00:21:52
poniendo nada, porque lo que nos interesa ahora mismo 00:21:59
es sobre todo ver 00:22:01
cómo se pasan parámetros a una función 00:22:03
y cómo se recoge el valor de retorno 00:22:05
pues venga 00:22:07
claro, de hecho, lo primero que vamos a 00:22:08
hacer cuando ya 00:22:17
podamos hacerlo en clases separadas e importar el 00:22:18
JAR y todo eso, es crearnos nosotros 00:22:21
nuestras propias funciones 00:22:23
de librería para leer del teclado 00:22:25
así no tenemos que estar todo el rato 00:22:27
con el escáner, con no sé qué, una función de librería 00:22:28
que sea leer número entero y ya está 00:22:31
y me despreocupo de tener que hacer el escáner 00:22:33
cada vez, del next line si hay un salto 00:22:35
de líneas y no sé qué 00:22:37
nos hacemos leer entero, y cuando tenga que leer entero 00:22:38
pongo leer entero y ya está 00:22:41
que si puedo, ¿qué? 00:22:42
abusar de funciones 00:22:46
puedo abusar de cualquiera 00:22:47
hombre, a ver 00:22:48
eso es un tema de diseño, tú cuando tienes que hacer 00:22:53
una aplicación, haces un diseño 00:22:55
y ese diseño significa 00:22:57
cómo voy a distribuir el código 00:22:59
entonces tú, claro, cuanto más 00:23:01
separado esté el código, mejor 00:23:03
hombre, sin pasarse, que haya 200.000 funciones 00:23:05
de una línea cada una, tampoco 00:23:07
pero sí, cuanto más modular sea mejor 00:23:08
¿vale? 00:23:11
¿en futuros exámenes? 00:23:13
¿en algún otro? 00:23:17
ya veremos 00:23:22
en futuros exámenes 00:23:23
no, no, no, a ver 00:23:24
es que lo que pase en el futuro no lo sabe 00:23:27
nadie, me refiero que 00:23:29
tú tranquilo 00:23:31
pues ya está, pues sigue tranquilo 00:23:32
vale 00:23:35
es que dependerá de la situación 00:23:38
ya iremos viendo 00:23:42
a mí déjame 00:23:43
a mí mínteme 00:23:48
dime que sí 00:23:51
y yo con eso me quedo tranquilo 00:23:52
vale 00:23:54
bueno, pues venga 00:23:57
ahora me vais a hacer, por ejemplo 00:23:58
hemos hecho 00:24:00
funciones que contaban 00:24:01
números primos, lo que fuera, pues venga 00:24:05
siguiente función, vamos a hacer 00:24:07
una 00:24:09
o vais a hacer una función 00:24:09
que 00:24:12
devuelve, que indica 00:24:15
dicho de alguna manera, si 00:24:22
un número entero 00:24:24
o no primo 00:24:29
¿vale? 00:24:32
eso es lo que tiene que hacer la función 00:24:35
esto que está aquí escrito 00:24:36
eso 00:24:40
entonces 00:24:44
si ponemos la cabecera 00:24:47
exprimo 00:24:49
pues la cabecera 00:24:51
uno le pone el nombre 00:24:53
que más le guste, en este caso está claro 00:24:56
el valor de entrada 00:24:58
un número entero 00:25:00
y el valor de retorno 00:25:01
en este caso, ¿cuál pondríais? 00:25:04
eso 00:25:06
muy bien 00:25:11
o sea la función me tiene que decir 00:25:13
sí o no 00:25:15
es lo que me tiene que decir la función 00:25:16
sí o no 00:25:18
si algo pasa o no pasa 00:25:19
no es que me tenga que volver un número 00:25:21
una cadena 00:25:22
me tiene que decir si algo pasa o no pasa 00:25:23
vale pues boolean 00:25:25
y ahora ya 00:25:26
esta función 00:25:28
ya hará lo que sea con este número 00:25:30
vale 00:25:32
entonces 00:25:33
en este caso 00:25:35
pues esta función 00:25:37
Tendrá como parámetro 00:25:38
Un número entero 00:25:40
Y que devuelve 00:25:44
Pues devuelve 00:25:46
True si es primo 00:25:50
False si no 00:25:56
Por ejemplo 00:25:58
Pues esta sería la documentación 00:26:00
Vale, pues venga 00:26:02
Venga, hace de este código 00:26:04
De aquí a las 11 00:26:08
Que luego lo vamos a usar en otra función 00:26:10
¿Cuánto tiempo tenemos? 00:26:12
Pues de aquí a las 11 00:26:19
Por ejemplo 00:26:20
Gracias. 00:26:20
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
13
Fecha:
11 de noviembre de 2024 - 12:18
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 22″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
119.43 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid