Saltar navegación

20241107 ProgrEstruct-Funciones_2 - 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.

22 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, vamos incorporando poco a poco. 00:00:00
Bueno, pues entonces, repito, la función. 00:00:02
Nombre el más explicativo que uno pueda. 00:00:07
Paréntesis obligatorios. 00:00:10
En este caso, los vamos a dejar vacíos. 00:00:13
Ya incorporaremos que si los ponemos con algo dentro, 00:00:17
pues para qué nos sirve, para qué podemos utilizarlos, 00:00:21
por qué están ahí, para qué nos sirven. 00:00:23
Y algo aquí antes hay que poner. 00:00:25
Entonces, si la función no construye ningún valor que entrega el programa 00:00:27
Ya veremos cómo podría construir ese valor, entregarlo y cómo usarlo 00:00:34
Si no lo hace, se pone void, obligatorio, ¿vale? 00:00:38
Sería el caso de lo que vamos a hacer aquí 00:00:44
Porque aquí va a pedir un nombre y va a saludar 00:00:45
Luego no hace nada de devolver al programa principal ni nada 00:00:48
Entonces pondríamos void 00:00:51
¿Vale? Pues esto de aquí es lo que se llama la firma o la cabecera de la función 00:00:52
esta es su firma, su cabecera 00:00:57
porque el programador que luego está viendo 00:00:59
esto, el código de dentro 00:01:02
ya le da igual, lo que le va a importar 00:01:04
es, ah, esta función hace 00:01:06
esto, más o menos, el nombre 00:01:08
ya le da una información, hace esto 00:01:10
y me va a devolver esto 00:01:12
y necesita esto, ya veremos 00:01:14
cuando pongamos ahí cosas 00:01:16
bueno, pues ahora 00:01:17
este mismo código 00:01:18
yo lo meto aquí 00:01:21
dentro, ala, y ya tengo 00:01:24
una función que 00:01:29
me pide un nombre y me saluda 00:01:30
por mi nombre, ya está 00:01:33
y la tengo perfectamente declarada 00:01:34
esa función 00:01:36
¿vale? como veis 00:01:37
va con sus llaves, luego abre un bloque 00:01:40
nuevo y el main 00:01:43
se ha quedado vacío 00:01:45
claro, en este caso 00:01:47
y como veis el main es una función también 00:01:48
el main que lo hemos estado usando 00:01:51
hasta ahora es una función, tiene su nombrecito 00:01:53
que es main 00:01:55
tiene su void 00:01:56
y tiene estas dos cosas, estas tres cosas que todavía no entendemos, 00:01:58
este public static y esto de aquí. 00:02:04
Entonces, esta función, lo que pasa es que es una función un poco especial, 00:02:09
es la única función especial de todas las funciones que uno puede meter en una aplicación. 00:02:15
¿Y por qué es especial? 00:02:22
porque a esta función no la llamamos nosotros desde ningún sitio 00:02:23
como a saludar, a saludar sí la llamaremos desde donde queramos 00:02:28
a main no, a main quién la llama 00:02:31
main está para que la llame la máquina virtual 00:02:33
es decir, cuando una aplicación 00:02:36
cuando arrancamos una aplicación, Java, la arrancamos 00:02:38
toma, arrancamos la aplicación 00:02:41
la máquina virtual se pone a buscar entre los millones de funciones 00:02:43
la que se llame main 00:02:47
Con lo cual solo puede haber una 00:02:49
Que se llame main en una aplicación 00:02:52
Solo puede haber una 00:02:54
Y la máquina virtual la busca entre todas 00:02:55
¿Esta se llama main? Pues esta 00:02:57
Luego la función main es el punto de arranque 00:02:59
De la aplicación 00:03:02
La aplicación siempre arranca desde la primera línea 00:03:03
De la función main 00:03:06
Y luego ya a partir de aquí 00:03:07
Empiezan a pasar las cosas que hayamos puesto 00:03:09
Algunas de ellas pueden ser de hecho 00:03:12
Llamar a otra 00:03:14
Sí, llamar a otra y a muchas más 00:03:15
y el resto de funciones 00:03:18
que no son main, ya por tanto 00:03:20
son llamadas desde aquí 00:03:22
pero la main 00:03:23
no es llamada por código 00:03:26
no hay ningún sitio en el que pongamos main 00:03:27
la main es la que 00:03:29
llama la máquina virtual 00:03:32
cuando una aplicación arranca 00:03:34
pero su sintaxis es la misma 00:03:35
su sintaxis es igual, tiene un nombre 00:03:38
que tiene que ser main obligatoriamente 00:03:40
para que la máquina virtual la encuentre 00:03:42
tiene el void porque no devuelve 00:03:43
nada a quien la llama 00:03:46
Es que no la llama nadie 00:03:48
Entonces tiene void obligatoriamente 00:03:49
Y tiene esto de aquí 00:03:51
Que ya entenderemos en breve lo que es 00:03:53
Y esto de aquí que también lo entenderemos 00:03:55
Pero es una función más, con su llave que se abre y se cierra 00:03:57
¿Vale? 00:03:59
Bueno, pues entonces 00:04:02
Ahora aquí en main podemos hacer lo que nos dé la gana 00:04:03
Un montón de nuestro código 00:04:05
Lo que sea 00:04:08
Claro 00:04:08
Y aquí mi aplicación está haciendo cosas 00:04:10
Y de repente yo necesito 00:04:15
Saludar, necesito saludar 00:04:17
Pues porque soy así de amable 00:04:19
Y si lo saludo 00:04:22
Pues entonces 00:04:24
Como necesito saludar 00:04:26
¿Para qué voy a poner el código de saludar una y otra vez? 00:04:27
¿Para qué voy a ponerlo? 00:04:30
Llamo a la función 00:04:32
¿Y cómo se llama una función? 00:04:33
Pues como a todo el mundo 00:04:36
Por su nombre 00:04:38
¿Perdón? 00:04:39
No podrías utilizar esa función 00:04:41
¿Cómo que no podrías? 00:04:43
No, el orden da igual 00:04:44
El orden en el que estén las funciones da igual 00:04:49
La podría haber declarado aquí arriba 00:04:52
En lugar de estar aquí 00:04:53
La puedo poner aquí 00:04:55
Me da lo mismo 00:05:00
En plan, siempre que esté por encima del main 00:05:01
No, por debajo, me da lo mismo 00:05:05
Es decir, el main es una función más 00:05:07
Y el resto de funciones 00:05:10
Me da igual que estén arriba, que estén debajo 00:05:12
Me da lo mismo 00:05:14
Habrá un montón de funciones 00:05:14
La máquina virtual buscará la main y es la única que busca y lo arranca. 00:05:17
Y el main ya llama a las que toquen, a las que toquen llamar. 00:05:24
Vale, pues entonces, nosotros ahora necesitamos saludar. 00:05:29
Pues no tenemos que poner el código entero porque tenemos una función que lo hace, pues la llamamos por su nombre. 00:05:33
Y como su nombre es saludar, yo pongo saludar. 00:05:39
Pero es obligatorio que ponga los paréntesis también. 00:05:42
los paréntesis los tengo que poner sí o sí 00:05:45
y cierro el punto y coma 00:05:48
y algo más que ahora, ¿vale? 00:05:50
entonces se me está quejando 00:05:52
¿vale? se me está 00:05:53
quejando porque estoy llamando 00:05:56
no, no, no, porque no tengo 00:05:58
nada dentro, no, por una cosa que 00:06:00
desgraciadamente no podemos 00:06:01
entender, pero la podemos, la tenemos que 00:06:04
poner ahora a capón 00:06:06
eso, se me está quejando 00:06:07
¿por qué? porque a saludar 00:06:10
la estoy llamando desde esta función 00:06:12
y esta función tiene un static delante. 00:06:13
Entonces, aunque ahora no entendemos 00:06:18
qué significa static, 00:06:20
si una función tiene un static delante, 00:06:21
solo puede llamar a funciones 00:06:24
que también tengan un static delante. 00:06:27
Solo. 00:06:29
Entonces, mi saludar no tiene un static delante. 00:06:30
Bueno, vamos a ponérselo. 00:06:34
Se lo ponemos. 00:06:37
Y ahora ya, vale, ya te deja. 00:06:38
Te dice, ah, vale, ya te deja. 00:06:40
Entonces, lo del static 00:06:41
No entendemos muy bien qué significa 00:06:44
Pero lo único que nos tenemos que quedar ahora es 00:06:45
Que el main, el static delante 00:06:48
Es obligatorio 00:06:51
Yo del main no puedo cambiar nada 00:06:52
Ya lo dijimos al principio 00:06:54
El public tiene que estar, el static tiene que estar 00:06:55
El void, el nombre main 00:06:58
No puedo cambiar el nombre 00:06:59
Esto, no lo puedo cambiar 00:07:00
Bueno, a ver, en realidad puedo poner esto 00:07:03
Es la única variación que puedo hacer 00:07:05
Que no entendemos lo que significa, pero da igual 00:07:07
Significa lo mismo, sí 00:07:09
significa lo mismo 00:07:11
es otra forma de poner eso 00:07:12
entonces, un segundo 00:07:14
del main yo no puedo cambiar nada 00:07:15
porque si no la máquina virtual 00:07:18
no va a encontrar a ese método cuando arranque 00:07:20
porque lo va a buscar con su nombrecito completo 00:07:22
y su cabecera completa, entonces del main no puedo cambiar nada 00:07:24
luego el static no lo puedo cambiar 00:07:27
¿vale? eso por un lado 00:07:29
y ahora la segunda parte con la que nos quedamos 00:07:30
aunque no la entendamos 00:07:33
si una función tiene static delante 00:07:34
solo puede llamar 00:07:36
a funciones que también lo tengan 00:07:38
solo, vale, pues entonces 00:07:40
pongámosle el static delante 00:07:43
para poder llamarla desde main 00:07:45
¿eso implica algo dentro de saludar? 00:07:46
sí, implica cosas, pero ahora mismo no nos molesta 00:07:49
nada, ahora mismo no nos molesta 00:07:51
entonces 00:07:53
ahora mismo vamos a dejarlo así, el static 00:07:54
de ponerlo o no ponerlo no hay ninguna diferencia 00:07:57
no hay ninguna diferencia, entonces ya que el main 00:07:59
nos lo pide porque 00:08:01
tiene un static delante, pongámoselo 00:08:02
porque ahora mismo con todo lo que estamos 00:08:05
haciendo nosotros no hay ninguna diferencia 00:08:07
entre ponerlo o no ponerlo no hay ninguna 00:08:08
Se te abre ahí un mundo de 00:08:10
Vale 00:08:14
Bueno, pues ya está, ya tenemos a 00:08:15
Ya está, ya hemos sacado el código dentro de 00:08:18
Pues venga 00:08:20
Y ahora ya efectivamente ejecutamos esto 00:08:21
Arrancamos programa, nos pide el nombrecito 00:08:23
Y nos saluda 00:08:31
Vale 00:08:32
Vale, luego 00:08:34
Recopilando 00:08:44
La función 00:08:46
La función es un código metido entre llaves 00:08:48
Eso es una función 00:08:50
¿Dónde va? Dentro de una clase 00:08:51
Esto es una clase, aunque no entendamos lo que es ahora 00:08:55
Es decir, dentro de las llaves de una clase 00:08:59
Ahí va, esta clase se abre con sus llaves aquí 00:09:01
Y se cierra aquí 00:09:04
Pues dentro de una clase va la función 00:09:06
Efectivamente, dentro de esta clase ahora tengo dos 00:09:08
Esta, que va ahí dentro 00:09:11
Y la main que va ahí dentro 00:09:13
Tengo dos, podría tener muchas más 00:09:15
Luego una función es un código 00:09:18
entre llaves 00:09:20
que va dentro de una clase 00:09:22
esa función recibe un nombre 00:09:23
lo más explicativo posible 00:09:25
y su sintaxis 00:09:27
implica que obligatoriamente 00:09:30
yo pongo unos paréntesis después 00:09:32
y algo delante 00:09:34
que es 00:09:36
el tipo del dato que esa 00:09:38
función devuelve 00:09:40
si no devuelve nada, void 00:09:41
vale, y tercera 00:09:44
cosa con la que nos quedamos por ahora 00:09:46
ahora mismo nosotros solamente 00:09:48
estamos trabajando con una clase 00:09:50
con un main y ya está, porque no tenemos 00:09:52
diferentes clases, no las tenemos 00:09:54
pues como main tiene el static 00:09:55
delante, yo tengo que poner 00:09:58
a todas las funciones que llame desde aquí 00:10:00
para que el compilador me deje 00:10:02
tengo que ponerle también el static delante 00:10:04
y ya está, y tú ibas a preguntar algo 00:10:06
Cristian 00:10:08
te aburres acaso 00:10:09
no, no, me entro hambre 00:10:14
falta oxígeno 00:10:15
por ende 00:10:16
no se puede tener funciones 00:10:19
con el mismo nombre 00:10:21
sí, y eso es 00:10:24
puedes tener funciones con el mismo nombre 00:10:25
que se llaman sobrecargadas 00:10:27
pero se tienen que distinguir en algo 00:10:30
en lo que hay adentro de los paréntesis 00:10:31
porque como dijiste que en main 00:10:33
solo puede haber un main 00:10:35
claro, claro, solamente puede haber 00:10:37
si tú haces una función main 00:10:40
y aquí pones otra cosa 00:10:42
ya es distinta 00:10:44
entonces no sería esa 00:10:46
Lo que no puedes es tener dos funciones 00:10:47
Con el mismo nombre 00:10:50
Y lo mismo entre los paréntesis 00:10:51
Porque entonces son indistinguibles para la máquina virtual 00:10:53
Pero si cambias lo que hay en los paréntesis 00:10:56
Ya son distinguibles 00:10:58
¿Vale? Por ejemplo 00:10:59
Vamos a seguir jugando con esto 00:11:00
Vamos a hacer otra versión de saludar 00:11:03
¿Vale? Y así aprovechamos para ver 00:11:05
Qué es lo que 00:11:07
Qué significa lo que hay aquí dentro 00:11:09
¿Vale? Bueno, lo que hemos hecho hasta aquí está claro 00:11:11
¿No? 00:11:13
vale, entonces yo puedo 00:11:14
llamar a saludar todas las veces que me dé la gana 00:11:16
y desde cualquier lado, puedo 00:11:18
estarme ahí llamando a saludar siempre que lo necesite 00:11:20
entonces esa es la principal ventaja que 00:11:22
vemos, que no tenemos que repetir ese código 00:11:24
cada vez que queramos usarlo, porque aquí son 00:11:26
tres líneas, pero si fueran 50 líneas 00:11:28
¿para qué voy a andar repitiendo 50 líneas? 00:11:30
llamo al método, a la función 00:11:32
llamo a la función y ya está, vale 00:11:33
en Java, estos se llaman métodos 00:11:36
vale, lo que pasa es que como 00:11:38
eso es una nomenclatura de pronunciamiento de objetos 00:11:39
ahora mismo estoy llamándolo a funciones 00:11:41
porque eso suena más 00:11:44
pero su nombre real en realidad serían 00:11:45
métodos, pero bueno, lo voy a seguir llamando funciones 00:11:48
mientras no veamos 00:11:50
planificación de entrada de objetos 00:11:52
vale, entonces la ventaja 00:11:53
está clara, que yo lo llamo cuando quiera y no tengo que repetir 00:11:56
el código una y otra vez 00:11:58
bueno, pues venga, vamos a seguir 00:11:59
incorporando cosas 00:12:02
y estos paréntesis 00:12:03
aquí, ¿para qué me sirven? 00:12:06
bueno, esta función 00:12:09
nuestra saludar 00:12:10
es autónoma 00:12:11
no necesita de nadie en la vida 00:12:13
se lo guisa y se lo come todo 00:12:15
pide el nombre, lo muestra por consola 00:12:17
es absolutamente autónoma 00:12:20
vale, pero puede ser que yo necesite 00:12:21
o me interese una función 00:12:24
que trabaje con unos datos que yo le paso 00:12:25
con unos datos concretos 00:12:28
es decir, que en lugar de solicitarlos 00:12:30
ella por consola, en lugar de solicitarlos 00:12:32
le digo, no, no, yo te los paso 00:12:34
y tú trabaja con esos datos 00:12:35
sería otra forma de plantearlos 00:12:37
¿no? 00:12:39
Bueno, pues cuando le pasamos datos a una función para que trabaje con ellos, esos datos que le pasamos se los tenemos que indicar en esos paréntesis. 00:12:40
vale, entonces por ejemplo 00:12:51
vamos a hacer una versión 2 00:12:54
de saludar, aquí abajo 00:12:56
en la cual 00:12:58
en lugar de encargarle a la función 00:13:00
que pide el nombre 00:13:02
vamos a pasárselo nosotros, decimos 00:13:03
oye, saluda a este 00:13:06
y yo te paso a quien tienes que saludar 00:13:07
y tú le saludas, entonces es una función 00:13:09
distinta, porque va a hacer otra cosa 00:13:12
vale, entonces 00:13:14
vamos a hacer ahora una función distinta 00:13:16
a la que 00:13:18
pasamos 00:13:23
un nombre 00:13:24
y saluda a ese nombre 00:13:26
el nombre tiene que estar declarado en el main 00:13:28
ahora lo vemos 00:13:33
por ahora la función se hace 00:13:35
trabaja de forma independiente y el desarrollador 00:13:37
la hace y le da lo mismo el main 00:13:39
luego ya el main tendrá que 00:13:41
ahora ya sí saber cómo está hecha la función 00:13:43
para poder llamarla 00:13:46
pero lo primero que haces es la función 00:13:46
yo voy a hacer una función a la que 00:13:49
le paso un nombre 00:13:51
y saluda a ese nombre 00:13:53
Ese es un trabajo autónomo, independiente 00:13:55
Lo hace un desarrollador por libre 00:13:58
Ahora ya los main que la quieran llamar 00:13:59
Ya que la llamen como puedan y quieran 00:14:02
Y deban 00:14:04
Pero yo mi trabajo es independiente 00:14:05
Función que recibe un nombre y saluda ese nombre 00:14:07
Vale, pues vamos a llamarla 00:14:09
De otra forma distinta 00:14:12
Aunque luego veremos que aunque la llame igual no va a pasar nada 00:14:13
Porque cambian los parámetros 00:14:16
Pero vamos a olvidarnos por ahora 00:14:18
Vamos a llamarla de una manera distinta 00:14:19
Vamos a saludar 00:14:21
Versión 2 00:14:24
Vale, esta sigue 00:14:27
Teniendo el void 00:14:30
Porque no construye nada ni nos devuelve nada 00:14:32
Lo muestra por consola 00:14:35
Lo muestra por consola 00:14:36
Entonces, y static porque la vamos a llamar 00:14:39
Desde el main 00:14:41
Vale, pero aquí ya 00:14:42
Pasan cosas 00:14:45
Que aquí ya el programador que hace esto 00:14:46
Dice, espérate 00:14:49
Que esta función mía va a recibir un dato 00:14:50
Uno 00:14:53
Vale, pues entonces pensamos 00:14:54
¿Qué dato va a ser? 00:14:57
Un nombre, luego ¿Qué tipo de dato es? 00:14:58
Lo primero que tenemos que pensar 00:15:02
Es el tipo de dato que voy a recibir 00:15:03
Un nombre, luego un string 00:15:06
Bueno, pues entonces aquí 00:15:08
Ponemos lo que pondríamos 00:15:10
Como si declaráramos una variable string 00:15:11
Lo mismo 00:15:13
String y 00:15:14
Un nombre de variable, el que a mí me dé la gana 00:15:17
Entonces 00:15:19
¿Con esto qué estoy diciendo? 00:15:21
que a esta función 00:15:23
cuando se la llame, que todavía 00:15:25
no se la está llamando, ahora mismo 00:15:27
estamos diciendo lo que va a hacer 00:15:29
cuando sea llamada. 00:15:31
Sí, luego, claro, 00:15:33
cuando la llamemos ya veremos qué le pones. 00:15:35
Aquí lo que estamos diciendo es, oye, 00:15:37
cuando alguien llame a esta función 00:15:39
me va a tener que pasar como dato 00:15:41
un string. 00:15:43
Eso es lo que estamos diciendo. 00:15:45
Luego esta función recibe un dato que es 00:15:47
un string y lo indicamos de esta 00:15:49
manera. 00:15:51
Y podría recibir muchos más datos. 00:15:53
Las funciones pueden recibir todos los datos que uno quiera. 00:15:55
Los pongo separados por comas. 00:15:57
Sí, luego cuando se llame hay que... 00:16:00
Por ejemplo, si a esta función quisiéramos pasarle, luego lo hacemos en otra, 00:16:02
un nombre y un número entero para que haga algo, para que te salude siete veces, por ejemplo, 00:16:07
pues le podríamos hacer esto. 00:16:13
Luego hacemos esa otra versión. 00:16:17
Entonces esta función recibe dos datos. 00:16:19
una cadena, un string 00:16:23
y un número entero. 00:16:24
Pero en este caso vamos a hacer 00:16:27
una función que recibe 00:16:28
solo un dato, una cadena. 00:16:30
Entonces ahora esta función 00:16:35
hará todo lo que tenga 00:16:37
que hacer y además de trabajar con 00:16:39
sus propias variables, las que se declare ella 00:16:40
adentro, con lo que pida por consola, 00:16:42
con lo que sea que le haga falta, 00:16:45
además de eso puede trabajar 00:16:47
directamente con este dato. 00:16:48
Sin necesidad de declararlo de nuevo ni nada, 00:16:50
porque ya está declarado ahí. 00:16:52
Entonces, esta función, ¿qué es lo que haría? 00:16:54
Pues en este caso, como lo único que va a hacer es saludar, 00:16:56
pues haría hola 00:16:59
y aquí 00:17:00
pondría esto. 00:17:02
Y ya está. Entonces, la función 00:17:06
ya puede 00:17:10
trabajar directamente 00:17:12
con 00:17:13
el dato que le estamos pasando. No tiene que 00:17:15
declararlo de nuevo ni nada porque esto 00:17:18
ya es una declaración. 00:17:20
Si ahora ejecutas esta clase, 00:17:21
solo te va a ejecutar lo del mail, ¿no? 00:17:23
Lo de fuera está afuera y... 00:17:25
No, no, no, claro. 00:17:26
Lo único que se ejecuta es lo que haya en el main. 00:17:26
Luego ya el main llamará lo que desea. 00:17:29
¿Estas funciones? 00:17:31
Sí. 00:17:39
Lo puedes empaquetar en un Jara e importarlo. 00:17:41
También lo haremos, ¿vale? 00:17:44
Vale, pues el dato de entrada, 00:17:54
el dato de entrada, 00:17:56
esto es lo que se llama parámetro, ¿vale? 00:17:58
Vale, luego esta función tiene un parámetro, 00:18:01
que es una cadena, un string. 00:18:10
Tiene un parámetro, 00:18:11
pero podría tener varios, ¿vale? 00:18:12
Luego los parámetros son los datos de entrada que le pasamos a la función y tenemos que declarar su tipo aquí, ¿vale? Luego repito, aquí no estamos ejecutando nada, no estamos haciendo nada, aquí estamos haciendo una declaración de cuando esta función sea llamada, ¿qué es lo que va a hacer? 00:18:15
Pues aquí estamos diciendo 00:18:34
Oye, cuando esta función sea llamada 00:18:37
Va a recibir un dato de cadena 00:18:39
Ese dato lo va a concatenar con hola 00:18:42
Lo va a mostrar 00:18:46
Eso es lo que estamos diciendo 00:18:46
Lo que va a hacer esta función cuando sea llamada 00:18:48
Y esta en particular 00:18:50
Va a recibir un parámetro 00:18:52
Y yo aquí a ese parámetro 00:18:54
Le llamo como me dé la gana 00:18:57
Claro 00:18:58
Le llamo como me dé la gana 00:19:00
Lo único que tengo que poner bien y acordarme 00:19:01
es de poner el tipo de dato 00:19:04
correcto, poner el tipo de dato correcto 00:19:07
stream 00:19:09
vale, entonces ahora vamos a saludar 00:19:09
con esta segunda función 00:19:13
vale, pues entonces 00:19:14
nos vamos a nuestro main, si quisiéramos 00:19:17
usar esta segunda función 00:19:19
aquí ya hay que pasarle el nombre 00:19:20
pues entonces aquí 00:19:22
vamos a leer el nombre desde el main, porque eso lo tenemos 00:19:24
que pasar 00:19:30
si es lo que iba a hacer, llamarlo de otra manera 00:19:31
para que quedara claro que no tiene que llamarse igual. 00:19:40
Vale, arrancamos programa. 00:19:43
Aquí hemos llamado a saludar una vez. 00:19:45
Y ahora vamos a introduzca un nombrecito. 00:19:48
Vamos a guardar el nombre que nos han introducido. 00:19:59
Vale, y ahora queremos que nos saluden a este nombre. 00:20:08
Queremos que nos saluden a este nombre. 00:20:12
Tenemos una función que lo hace. 00:20:14
tenemos una función a la que si yo le paso 00:20:15
un parámetro cadena 00:20:17
un parámetro nombre, nos lo hace 00:20:19
pues vamos a llamarla 00:20:21
a una función como la llamamos, como siempre 00:20:22
con su nombre, saludar 00:20:25
versión 2 00:20:27
y ahora, ahora ya 00:20:28
sí que si yo le paso 00:20:31
los paréntesis vacíos, el compilador me va a decir 00:20:33
eh, que saludar 00:20:35
necesita obligatoriamente 00:20:37
que le pases un dato de entrada 00:20:39
y que sea cadena, es lo que te está diciendo 00:20:41
porque está aquí declarado 00:20:43
necesita un dato de entrada que sea cadena 00:20:44
tienes que pasárselo 00:20:47
el propio compilador te lo dice 00:20:48
claro, si tú 00:20:54
compilaras esto con la consola 00:20:58
ya sabéis que ese mensaje es el que te saldría a la consola 00:21:00
entonces claro, la máquina, el compilador 00:21:03
cuando ve que tú llamas aquí a saludar V2 00:21:05
se va a buscar saludar V2 00:21:08
ve que tiene esto y te dice 00:21:10
te dice, oye, que saludo al v2, tiene ahí 00:21:13
un string. Entonces 00:21:15
te dice, oye, perdona, pero le tienes 00:21:17
que pasar ahí ya un 00:21:19
valor concreto. Entonces, ahí 00:21:21
ya es el momento, aquí ya estamos ejecutando. 00:21:23
No es como aquí, que aquí estamos 00:21:25
declarando que es lo que esa función va a ser cuando 00:21:27
se la llame, pero nadie la ha llamado, no hay nada 00:21:29
ejecutándose. Cuando ya se están 00:21:30
ejecutando cosas, es a partir de aquí. 00:21:33
Aquí ya sí se están ejecutando. 00:21:35
Claro, pues aquí 00:21:38
hay que darle ya un valor 00:21:38
concreto para ese parámetro. 00:21:41
¿Cuál? El que nos dé la gana. 00:21:43
Yo le podría pasar esto, y estupendo, 00:21:45
saludaría a este, porque es un string. 00:21:47
Le podría pasar esto. 00:21:50
Yo ya le paso un valor concreto, el que quiera, 00:21:52
siempre y cuando sea un string. 00:21:55
En la llamada ya pasamos un valor concreto, 00:22:01
porque ya estamos ejecutando. 00:22:03
Entonces, ese valor, repito, puede ser cualquiera. 00:22:12
La única restricción es que tiene que ser un dato string, 00:22:16
porque aquí la función te dice, 00:22:20
oye string, pásame lo que quieras 00:22:22
el nombre que te dé la gana 00:22:25
pero tiene que ser 00:22:27
string, y como veis 00:22:28
si yo se lo paso en una variable 00:22:32
como veis, esta variable 00:22:33
se puede llamar como le dé la gana 00:22:36
no se tiene por qué 00:22:37
llamar, perdón, como yo 00:22:40
le he dado aquí 00:22:42
porque esto y el main no se hablan 00:22:42
ni se miran, esta función va por libre 00:22:46
esta función lo que dice es 00:22:48
tú pásame un string 00:22:49
yo le voy a llamar 00:22:51
nom para mí, para mí se va a llamar 00:22:54
nom para luego aquí ya trabajar con él 00:22:56
pero tú pásame el string que te dé la gana 00:22:58
tú pásame el string que te dé la gana 00:23:00
yo le llamaré nom para aquí 00:23:02
ya operar y hacer con él lo que quiera 00:23:04
y tú le pasas el string que te dé la gana 00:23:05
en una variable 00:23:08
directamente, lo que quieras 00:23:10
con que sea un string es suficiente 00:23:12
y ahora ya esta función 00:23:13
pues trabajará con este string 00:23:15
que le hemos pasado 00:23:18
cuando saltamos aquí, cuando la máquina virtual 00:23:19
salta aquí, ese string 00:23:22
que hemos pasado 00:23:24
recibe ese nombre 00:23:25
y ya 00:23:28
aquí, pues, ese string 00:23:29
que hemos pasado con ese nombre 00:23:32
ya se trabajará con él como sea 00:23:33
vale 00:23:35
si, ahora sí 00:23:40
ahora este main que hemos hecho 00:23:46
llama a este y luego llama a la otra 00:23:47
entonces 00:23:48
Claro 00:23:49
O la gente introduzca su nombre 00:23:55
Es que no se declara en ambas 00:23:58
Porque como veis está en bloques distintos 00:24:02
Claro 00:24:05
Este es un bloque 00:24:06
Este string solo es visible 00:24:07
Este string nombre solo es visible 00:24:10
En este bloque, solo existe aquí dentro 00:24:12
Claro, solo existe ahí 00:24:14
Y cuando esta función 00:24:16
Termina 00:24:18
es decir, cuando saludar ha terminado 00:24:19
ahí no hay ningún string nombre 00:24:21
ni hay nada, todo esto está enmascarado 00:24:23
aquí dentro, todo esto está enmascarado 00:24:25
luego aquí yo he podido declarar un string nombre 00:24:27
tranquilamente, porque estoy fuera 00:24:30
del ámbito de esta función 00:24:32
claro, es que aunque lo devolviera 00:24:33
tú lo guardas en donde quieras 00:24:39
entonces cuando tú llamas a la función ya te ha sido 00:24:41
el ámbito de la función y ahí manda 00:24:43
las variables de la función y luego 00:24:45
los parámetros, cuando hemos saltado aquí 00:24:47
en saludar, hemos saltado aquí 00:24:49
durante el tiempo que esto 00:24:51
se está ejecutando, ahí solamente 00:24:53
es visible, solo es visible 00:24:55
lo que esté declarado aquí dentro 00:24:57
y lo que hemos pasado por parámetros 00:24:59
y hemos pasado algo, ya no hay nada 00:25:01
más visible, del programa principal no hay nada 00:25:03
es decir, no es como exactamente 00:25:05
como el caso de los for, porque 00:25:07
en los for tú el bloque lo tenías 00:25:09
dentro del main, luego desde dentro 00:25:11
del for podías acceder a las variables 00:25:13
que estaban en el main, desde el main 00:25:15
no a las del for, claro, porque eran internas 00:25:17
pero desde el for sí, pero aquí no 00:25:19
es que aquí son bloques absolutamente 00:25:20
independientes, entonces desde dentro 00:25:23
de este código, tú no 00:25:25
tienes acceso a ninguna de las 00:25:27
variables que están declaradas en el main, a ninguna 00:25:29
y desde dentro 00:25:31
del main no tienes acceso a ninguna 00:25:33
de las variables que están aquí dentro, a ninguna 00:25:35
¿cuál es la comunicación 00:25:37
entre el main y la función? 00:25:39
exclusivamente esta 00:25:41
los parámetros, si tú necesitas 00:25:42
que compartan información, se la tienes que pasar 00:25:45
por parámetro 00:25:47
como hemos hecho aquí 00:25:48
yo necesito que este método 00:25:50
trabaje con el nombre que he leído 00:25:52
aquí, lo necesito 00:25:54
se lo tengo que pasar por parámetro 00:25:55
porque desde aquí nunca jamás voy a poder 00:25:57
acceder a esta variable 00:26:00
del main, porque es una función 00:26:01
aparte, son independientes, no tienen nada que ver 00:26:04
entonces si quiero que una 00:26:05
función tenga algo del main 00:26:08
para trabajar, se lo tengo que pasar 00:26:09
por aquí 00:26:12
mediante el paso de parámetros, lo tengo que pasar 00:26:13
por ahí, como ha sido el caso. 00:26:16
¿Vale? Bueno, pues 00:26:18
esto es muy importante realmente, 00:26:21
entender esto. Es 00:26:23
fundamental. ¿Vale? 00:26:25
Es, efectivamente. Entonces, 00:26:30
aquí tengo dos funciones distintas, dos funciones 00:26:32
fundamentalmente distintas. 00:26:34
Podría, de hecho, 00:26:36
darles el mismo nombre si me da la 00:26:38
gana, porque 00:26:40
ya son distintas 00:26:42
por el parámetro que reciben. 00:26:43
Es decir, si yo 00:26:47
a esta le cambio el nombre 00:26:48
y la llamo así 00:26:49
como veis el compilador 00:26:51
no se queja, no me dice, uy has repetido 00:26:53
saludar, encanta de la vida 00:26:55
no se queja 00:26:57
yo la tendría que llamar aquí con su nombre 00:27:00
claro, entonces aquí uno me podría decir 00:27:02
uy, estás llamando a la misma 00:27:05
no estamos llamando a la misma 00:27:08
aquí la máquina virtual cuando llega 00:27:10
dice, a ver, estás llamando a una función 00:27:13
saludar 00:27:15
que no quiere parámetros 00:27:16
pues no hay ninguna duda, tiene que ser la primera 00:27:18
no hay ninguna duda, tiene que ser esta 00:27:21
sin embargo, cuando 00:27:23
luego la máquina virtual llega aquí abajo 00:27:25
dice, a ver, ahora me estás llamando a una 00:27:27
función que quiere un 00:27:29
string, voy a buscar 00:27:31
ah, pues es esta, porque esta es la que quiere un string 00:27:32
luego no hay duda, este 00:27:35
saludar y este saludar son distintos 00:27:37
se han podido 00:27:39
distinguir por esto 00:27:41
si no, no se podrían distinguir 00:27:43
vale, pues esto es lo que 00:27:45
se llama sobrecarga 00:27:47
de funciones. Sobrecarga significa 00:27:49
a un único nombre, sobrecargarlo 00:27:51
dándole muchas funciones. 00:27:53
Vale, aquí saludar 00:27:56
esta sobrecargada, porque 00:27:57
puede hacer esto, si no le das parámetro. 00:27:59
Puede hacer esto a otros, le das parámetro. 00:28:02
Son dos funciones distintas. 00:28:04
¿Se intenta evitar o se hace? 00:28:05
No, no, no, no, no. Se hace. 00:28:07
Es totalmente correcto. 00:28:09
Perfectamente correcto, porque tú una misma funcionalidad 00:28:10
puedes querer hacerla 00:28:13
de diferentes maneras en función de datos 00:28:15
de entrada, entonces ahí lo natural es 00:28:17
que la llames igual, para que quede claro 00:28:19
que estás haciendo lo mismo, pero diferentes versiones 00:28:21
entonces se hace continuamente 00:28:23
toda la arquitectura de clases de Java 00:28:25
está sobrecargada precisamente para que quede más clara 00:28:26
todas las clases de la máquina virtual 00:28:29
todo, claro 00:28:31
cuando tú lees del teclado 00:28:32
por ejemplo 00:28:35
claro, por ejemplo 00:28:35
en System.out.println 00:28:41
nosotros la hemos usado así 00:28:42
y la hemos usado así. 00:28:44
¿Vale? 00:28:48
Y las dos nos ha dejado. 00:28:48
Entonces son dos println distintos. 00:28:51
Aquí cuando llamamos a println estamos llamando 00:28:53
a una función en realidad. Son distintas. 00:28:54
Aquí la máquina virtual dice, ah, me estás 00:28:57
llamando al que necesita un string. 00:28:59
Vale, pues yo voy al println 00:29:01
y le doy un string, lo cojo, muestro. 00:29:03
Ah, aquí me estás llamando al que no necesita. 00:29:05
Estos son dos funciones distintas. 00:29:07
¿Vale? 00:29:10
Pero como se 00:29:11
llaman igual, nos facilita a nosotros 00:29:13
la tarea, porque la llamamos igual 00:29:15
la llamamos igual y ya está 00:29:16
si no hubiera la opción de sobrecarga 00:29:18
habría 200.000 nombres diferentes 00:29:20
de funciones y sería un rollo 00:29:23
entonces la sobrecarga 00:29:24
nos facilita las cosas, no tenemos que 00:29:27
buscar un nombre diferente para cada versión 00:29:28
¿vale? 00:29:31
vale, y 00:29:35
si ahora quisiéramos, voy a hacer una 00:29:38
función que me salude porque 00:29:40
las veces que a mí me dé la gana 00:29:42
las veces que yo quiera, quiero que me salude 00:29:44
las veces que yo le diga, oye, me vas a saludar 00:29:46
27 veces 00:29:48
venga, pues otra versión más de saludar 00:29:49
otra versión más de saludar 00:29:52
claro 00:29:55
pero ahora, esta versión 00:29:56
de saludar, veis 00:29:59
aquí si yo le pongo el mismo parámetro 00:30:01
me va a decir, oye, no puedes 00:30:02
perdona, tienes dos funciones iguales 00:30:04
aquí sí que no le gusta, porque tienes dos funciones 00:30:06
iguales, le digo, oye 00:30:08
no, pero es que es otra 00:30:11
quiero que me saludes por el nombre 00:30:12
que yo te diga y quiero 00:30:14
que me saludes las veces 00:30:16
que yo te diga, pues necesito 00:30:18
un parámetro adicional, quiero que me saludes las que 00:30:20
yo te diga, pues entonces necesitamos 00:30:22
dos parámetros separados por comas 00:30:24
cada uno con su tipo de datos 00:30:26
ahora ya 00:30:27
pues bueno, ahora ya uno hace la 00:30:29
función como le dé la gana 00:30:32
¿vale? esta función es 00:30:33
otra versión 00:30:42
que nos saluda 00:30:42
Todas las veces que 00:30:46
Nosotros queramos 00:30:47
Tiene dos datos de entrada 00:30:49
Y como veis la función se hace por libres 00:30:51
Independientemente del main 00:30:53
La función tiene unos requisitos 00:30:54
Función que haces 00:30:56
Pues tú haces la función y ya está 00:30:57
Y luego ya el main la usará 00:31:00
Vale, pues ya tenemos esta otra versión 00:31:03
Venga, pues vamos a decirle ahora 00:31:06
Que nos salude 00:31:09
27 veces 00:31:10
Pues venga, ya está 00:31:12
Ahora ya nos va a saludar 27 veces 00:31:17
Entonces, como veis 00:31:22
En el momento de la llamada 00:31:25
Tenemos que pasar tantos datos de entrada 00:31:26
Como la función tenga declarados 00:31:30
Entonces, como necesita un string y un int 00:31:32
Yo le tengo que pasar un string y un int 00:31:37
¿Vale? Un string y un int 00:31:40
Y ahí ya sí que le paso los valores concretos 00:31:44
Pasamos los valores concretos 00:31:49
Los que sean 00:31:52
En el momento de la llamada 00:31:53
En el momento de la ejecución 00:31:55
Pasamos los valores concretos que necesita 00:31:56
Pero también si ponemos rollo 00:31:59
En escáner 00:32:01
Podríamos definir el número de veces 00:32:02
Claro, yo podría 00:32:04
Lo he puesto como ejemplo 00:32:05
De que en el momento de la llamada 00:32:08
Tú le pasas un valor concreto 00:32:09
Que ese valor sea que lo has leído 00:32:11
Y lo has guardado en una variable 00:32:13
Pues claro, eso ya da igual 00:32:14
Vale, imagínate 00:32:18
bueno, en lugar de eso 00:32:20
está en la variable n, yo lo he leído por teclado 00:32:22
pues da igual 00:32:25
da igual lo que le pases, lo que importa 00:32:26
es que tú le pases ya 00:32:29
un número entero, ¿de dónde ha venido 00:32:31
ese número entero? ya dependerá del main, de lo que tú quieras hacer 00:32:33
dependerá de como tú quieras 00:32:35
pero lo que importa es que 00:32:37
en el momento de llamarla hay que pasarle 00:32:38
un número entero, tal cual 00:32:41
¿vale? 00:32:42
vale, pues ya está 00:32:51
nos ha saludado las 78 veces 00:32:52
vale 00:32:54
si yo llamo a una función 00:33:01
pasándole parámetros para los cuales no está diseñada 00:33:03
se quejaría 00:33:06
¿verdad? 00:33:07
por ejemplo si yo hago esto 00:33:09
si yo hago esto 00:33:11
y le paso por ejemplo dos string 00:33:26
pues aquí el compilador me diría 00:33:28
oye 00:33:37
me he ido a buscar una versión de saludar 00:33:38
que recibe un string 00:33:41
y recibe otro string 00:33:42
Y no la he encontrado 00:33:44
Me dice, oye, perdona, que esta versión no existe 00:33:46
Existe una versión que recibe 00:33:48
Un único string 00:33:51
Vale, esa existe 00:33:52
Existe una que no recibe nada 00:33:53
Existe una que recibe un string y un número 00:33:55
Pero una que reciba un string 00:33:58
Y un string, esa no existe 00:34:00
No existe, entonces aquí el compilador 00:34:02
Dice, oye, que no, que esta función 00:34:08
No existe 00:34:10
luego 00:34:11
la lista de parámetros 00:34:15
tiene que casar 00:34:18
en tipo y en orden 00:34:20
con los que están declarados 00:34:21
aquí por ejemplo, yo no le podría pasar 00:34:23
n, nombre 00:34:26
no, porque la función 00:34:28
está declarada para que primero 00:34:32
reciba el string y luego reciba 00:34:34
el entero 00:34:36
el lenguaje podría ser de otra manera y decir 00:34:36
me has dado un entero y un nombre, me da igual en que orden 00:34:40
bueno, asumo que ese entero es el nombre, podría ser de otra manera 00:34:42
no, pero Java es muy 00:34:44
estricto, a diferencia 00:34:46
de Python, por ejemplo, es muy estricto 00:34:49
si cada uno se usa 00:34:50
para una cosa distinta, tiene sentido 00:34:52
si usas varios del mismo tipo 00:34:54
¿cómo sabría distinguirlo? 00:34:56
entonces, tienen que pasarse, tienen que 00:34:58
coincidir en 00:35:00
tipo de dato y en orden 00:35:02
¿se puede poner 00:35:05
una descripción para que te salte ahí 00:35:06
en plan, el orden que tienes que usarlo? 00:35:08
tú puedes comentarlo 00:35:11
bueno, tú puedes hacer aquí 00:35:12
un comentario de javadoc 00:35:15
claro, y ya está 00:35:16
pero luego el comentario este de javadoc te salta 00:35:18
cuando vas a usar esa función 00:35:22
ese comentario de javadoc 00:35:23
te salta cuando tú das aquí 00:35:25
todo lo que tú hayas escrito ahí te salta 00:35:28
vale 00:35:30
vale 00:35:31
bueno, tienes que haber generado el javadoc 00:35:40
es como se documenta las clases 00:35:44
bueno, tienes que haberlo generado 00:35:47
pero vamos, sí, se salta ahí 00:35:48
de todas maneras, si no 00:35:50
él siempre te va a decir 00:35:51
el compilador siempre te va a decir, oye yo me espero 00:35:53
string, string, te va a decir eso sí 00:35:56
para decirle, este string es para una cosa 00:35:58
y este es el segundo string 00:35:59
todo eso hay que documentarlo, para explicarte cada cosa 00:36:00
eso con Javadoc 00:36:03
claro, pues Javadoc, tienes que documentarlo 00:36:04
si no, eso es lo más a lo que llega al compilador 00:36:09
vale 00:36:12
si vamos a una empresa y hacemos un programa 00:36:12
tenemos que documentarlo 00:36:14
sí, claro 00:36:15
en realidad documentalo mal 00:36:17
para que te tengan que llamar a ti siempre 00:36:20
siempre tienes que 00:36:21
no, no arriesgues 00:36:24
documentalo 00:36:25
peor para ellos 00:36:27
explícaselo a ellos cuando te estén dando el finiquito 00:36:30
no, a ver 00:36:38
porque es imprescindible 00:36:39
exacto 00:36:41
no se lo supongan así 00:36:44
No, es que no funcionan así las cosas 00:36:45
¿Y si se lo documento en chino? 00:36:48
¿Y ninguno sabe chino? 00:36:50
No funciona así 00:36:51
ChatGPT sabe chino 00:36:52
Bueno 00:36:54
Había otro 00:36:56
¿Eso quién te lo ha dicho? 00:37:01
Internet es muy de fiar 00:37:05
Bueno 00:37:06
Entendido 00:37:08
Clarísimo clarinete 00:37:11
Pues nada, continuamos después del recreo. 00:37:15
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:
22
Fecha:
11 de noviembre de 2024 - 12:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
37′ 22″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
159.79 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid