Saltar navegación

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

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues entonces, esto, por tanto, es lo que llamamos, venga, ahora ya sí que vemos, venga, vale, vamos. 00:00:00
Bueno, pues esto de aquí es lo que hemos llamado 00:00:22
la cabecera de la función, la cabecera. 00:00:29
Y es lo que nos da toda la información que necesitamos 00:00:33
para usar la función. 00:00:36
El interior nos da exactamente igual. 00:00:38
Aquí lo que importa no es el interior, ¿vale? 00:00:40
La cabecera nos da toda la información que necesita 00:00:44
el programador para usar la función. 00:00:47
¿Cómo llamarla? 00:00:49
qué datos tiene que pasarle para que cumpla su función 00:00:50
y si devuelve algo o no. 00:00:55
Vale, en este caso estas funciones que hemos hecho 00:01:00
no devolvían nada porque mostraron por consola 00:01:01
una información y ya está. 00:01:03
Vamos ahora a usar este valor. 00:01:05
Venga, pues vamos a probar en este proyecto de ejemplo nuestro, 00:01:09
vamos a hacer otra función distinta. 00:01:11
Esta ya, estamos hartos de que nos salude. 00:01:14
entonces, ahora vamos a hacer una función 00:01:19
que nos diga, anda, deja de saludarme 00:01:21
casi mejor 00:01:23
dime 00:01:25
cuántas vocales tiene mi nombre 00:01:26
que me apetece casi más saber eso 00:01:29
el número de vocales que tiene mi nombre 00:01:31
que no que me saludes 00:01:33
pues venga, vamos a hacer una función 00:01:34
a la que le pasamos nuestro nombre también 00:01:37
y en lugar de saludarnos 00:01:39
nos va a decir, oye, tu nombre tiene 7 vocales 00:01:41
pues ya está 00:01:43
vamos a 00:01:44
vocales 00:01:45
Venga, pues vamos a hacer otra función 00:01:47
Esto lo voy a... 00:01:51
Vamos allá 00:01:52
Da igual, lo vas a hacer igualmente 00:01:53
Venga, nombrecito 00:01:56
Contar vocales 00:02:01
Vale 00:02:04
Datos de entrada 00:02:07
Del método, de la función 00:02:10
El nombre 00:02:13
Me ha dicho, oye, pásame tu nombre y yo te cuento todas las vocales que quieras 00:02:15
Vale 00:02:18
Y aquí podríamos hacer ya el método que lo hace. 00:02:22
No, no, no, hacerlo, que lo vamos a hacer. 00:02:29
Y luego ya ver qué hacemos con el resultado. 00:02:31
Vamos a hacer ahora mismo, antes de poner aquí esta cosa que no sabemos qué poner, 00:02:33
vamos a hacer el código de la función que, string vocales, no, string nombre. 00:02:39
Dado un nombre que le pasamos, nos cuenta las vocales. 00:02:46
pues nada, esto ya en medio 00:02:49
segundo, esto es lo de siempre 00:02:52
no hay otra vez, vamos a contar 00:02:53
pues entonces un contador 00:02:55
que lo inicializo a cero 00:02:56
vale, entonces 00:02:59
el que ahora cuando tenga que hacer el código 00:03:03
de esta función, no sepa contar 00:03:05
las vocales que hay en esta variable 00:03:07
nombre, si está empezando a tener un problema 00:03:09
vale, el que no diga, ah si claro 00:03:11
es todo loco, papá, vale 00:03:13
y entonces 00:03:15
a estudiar, a pasar a estudiar 00:03:17
de dos horas a cuatro, lo que haga falta 00:03:19
bueno, no hace 00:03:21
falta, pero va, entonces vamos a 00:03:25
hacer ahora mismo rápidamente el código de esta función 00:03:27
que dado una cadena no menos cuanto las 00:03:29
vocales, un contador, pues venga, un contador 00:03:31
y ahora que tenemos que hacer, recorrer 00:03:33
nuestra cadena 00:03:36
parar 00:03:37
en cada carácter, si es 00:03:39
vocal, incremento contador 00:03:41
pues venga, para contar 00:03:43
tenemos que hacer un bucle sí o sí 00:03:45
Ese bucle 00:03:46
¿Qué paradas va a hacer? 00:03:48
Va a hacer paradas en todos y cada uno 00:03:50
De los caracteres que forman el string 00:03:52
Pues el índice mío del bucle 00:03:54
Puede ir desde igual a cero 00:03:57
Mientras si sea menor que nombre.length 00:03:59
Porque recordad que esto 00:04:02
Me devolvía el número de caracteres de una cadena 00:04:05
Y ahora 00:04:09
¿Qué tenemos que hacer? 00:04:13
Vale, pues vámonos 00:04:14
Carácter por carácter 00:04:16
de esta cadena 00:04:18
y habrá que hacer, si esto es vocal 00:04:20
si esto es vocal 00:04:25
incrementas contador 00:04:27
vale, ¿cómo podemos ver si esto es vocal? 00:04:28
desgraciadamente A, E, I o U 00:04:38
no están consecutivas 00:04:40
en la tabla ASCII, porque si estuvieran 00:04:41
consecutivas, estupendísimo, haríamos 00:04:43
si ese carácter es 00:04:45
mayor o igual que 7 00:04:48
y menor o igual que 12, estás comprendido 00:04:49
en la tabla 00:04:52
claro, pero no está 00:04:53
entonces esta condición la tenemos que hacer 00:04:55
si este carácter es igual a 00:04:57
vamos a poner solo minúsculas 00:04:59
y así uno por uno 00:05:01
y así con las cinco vocales 00:05:04
¿qué significa amai? 00:05:07
o sea, sé lo que significa 00:05:13
pero ¿qué uso le dais? 00:05:14
porque ya habíamos quedado con lo de chill 00:05:17
mi hija me ha dicho que me habéis mentido 00:05:18
que esta clase chill no significa 00:05:20
lo que me decís vosotros 00:05:22
¿qué significa para vosotros? 00:05:23
Pues mi hija dice que no 00:05:25
Dice que chill 00:05:29
Dice que chill significa de puta madre 00:05:33
¿No? 00:05:36
De puta madre 00:05:37
¿No? ¿No significa eso? 00:05:39
Alguien me engaña 00:05:42
Para mí chill 00:05:43
De toda la vida ha sido calma 00:05:51
De ahí el chill out 00:05:53
o sea que me engaña ella 00:05:54
me tiene 16 00:05:57
y si me toma el pelo 00:06:03
vale 00:06:04
pues la condición de ser vocal 00:06:24
minúscula 00:06:26
es esta 00:06:27
no tenemos, no hay nariz 00:06:29
no hay huevos, es esta, no hay otra posibilidad 00:06:32
¿vale? 00:06:34
no porque 00:06:36
eso 00:06:37
es un char, variable 00:06:38
primitiva, se compara 00:06:41
con doble igual, solo las variables 00:06:44
objeto como string se comparan 00:06:46
con equals 00:06:48
fijaos aquí que estupendo lo de tener 00:06:48
funciones, porque imaginaos que yo 00:06:52
tuviera que hacer esto varias veces 00:06:54
pues que en mi código apareciera este rollo 00:06:55
varias veces, lo dejaría horroroso 00:06:58
lo tengo metido en una función 00:07:00
está ahí metido, oculto y ya está 00:07:01
bueno, pues este es el código 00:07:04
que me cuenta 00:07:06
todas las veces 00:07:08
que hay una vocal 00:07:10
en nombre, está clarísimo, ¿no? 00:07:12
vale, una vez que este for ha terminado 00:07:14
una vez que este for ha terminado 00:07:16
ahora yo digo 00:07:19
¿qué hago con cont? 00:07:20
¿Lo muestro por consola? 00:07:22
Bueno, pues podría mostrarlo por consola 00:07:23
y tengo una versión ya de esta función 00:07:25
y en ese caso aquí pondría 00:07:27
mi void, ¿vale? 00:07:29
Aquí pondría mi void 00:07:32
y lo muestro por consola, ¿vale? 00:07:33
Podríamos probarlo y ya está. 00:07:35
Sí, para luego poder 00:07:39
llamarla y que no me dé el error, 00:07:41
efectivamente tengo que poner el static. 00:07:43
Si no pongo el static, solo la puedo usar 00:07:44
de una manera. 00:07:47
Vale, bueno, pero 00:07:49
esta versión podría no gustarnos. 00:07:51
podría no gustarnos 00:07:53
pues por algo 00:07:57
bastante habitual 00:07:58
que es, vamos a ver 00:07:59
el desarrollador que hace esta función 00:08:01
dice, oye, tú hazme una función 00:08:04
que cuente vocales, vale, vale, yo te la hago 00:08:06
y el tío ya se ha metido en mi territorio 00:08:08
y se ha empeñado 00:08:10
en que el resultado 00:08:12
va por consola 00:08:13
digo, oye, perdona, tú te estás excediendo 00:08:15
en tus funciones 00:08:18
tú dame a mí el valor 00:08:19
y yo ya decidiré si lo pongo 00:08:21
en la consola, lo pongo en una interfaz 00:08:24
gráfica, se lo paso a una variable 00:08:26
para que esa variable no se quede. 00:08:28
Entonces, 00:08:31
esta versión 00:08:32
me muestra el resultado por consola, 00:08:33
pero puede ser que yo no quiera 00:08:36
que se muestre por consola. 00:08:38
Puede ser que yo quiera ese valor 00:08:40
para hacer lo que a mí me dé la gana con él. 00:08:42
Que es una situación distinta. 00:08:45
Entonces, 00:08:47
vamos a hacer una versión en la cual 00:08:48
esta función te hace 00:08:50
la cuenta y luego te dice, y ahora te entrego 00:08:52
el valor. Y tú con ese valor 00:08:54
haz lo que quieras. Que lo quieras por 00:08:56
consola, que lo quieras en interfaz gráfica, que lo quieras en 00:08:58
no sé qué, lo querés mandar por email, haz lo que quieras 00:09:00
con él. Pero yo no te condeno 00:09:02
a mostrarlo por consola y que haya un tío 00:09:04
ahí en la consola esperando a que lo saques 00:09:06
para apuntarlo en un papel. 00:09:08
No tiene mucha operatividad eso. 00:09:10
Vale, vamos a hacer una versión 00:09:13
de contar vocales 00:09:14
versión 2. 00:09:16
versión 2 00:09:19
entonces ahora cuando hemos llegado a este punto 00:09:28
tenemos cont 00:09:30
y como terminemos ahí 00:09:32
este pobre cont 00:09:34
se pierde, en cuanto la función termine 00:09:36
ese cont como es una variable 00:09:38
local a esas llaves, pum, desaparecería 00:09:41
con lo cual esta función 00:09:43
habrá hecho la cuenta para nada 00:09:44
para que luego el valor desaparezca 00:09:46
vale, pues que va a hacer 00:09:48
antes de cerrarse y terminar 00:09:50
lo va a devolver 00:09:53
lo va a mandar para arriba, lo va a devolver 00:09:54
como resultado 00:09:56
lo va a devolver como resultado final 00:09:58
¿y cómo puede hacer eso? 00:10:00
devolverlo como resultado final, pues con una sentencia 00:10:02
que se llama retun 00:10:04
y esa sentencia retun 00:10:05
admite un único 00:10:08
parámetro 00:10:10
un valor, un único valor 00:10:11
pues cont, en nuestro caso 00:10:15
cont, ¿vale? 00:10:17
vale, ahora lo arreglamos 00:10:20
estoy muy 00:10:22
impaciente 00:10:23
vale, entonces 00:10:24
con esto decimos 00:10:26
oye, coge ese cont 00:10:28
y mándalo a quien te llamó 00:10:30
y mándalo a quien te llamó, vale, estupendo 00:10:33
ya está 00:10:35
¿qué ocurre? que si mi función 00:10:35
devuelve un valor y lo entrega 00:10:39
el tipo que devuelve 00:10:40
hay que ponerlo aquí en lugar 00:10:43
del void, porque si yo pongo 00:10:45
void, es que no devuelvo 00:10:47
nada, no hay ningún retun que devuelva valores 00:10:49
aquí ponía void, pero es que no había 00:10:51
ningún retun que devolviera nada 00:10:53
claro, aquí si hay un retun 00:10:54
que devuelve un entero, un int 00:10:57
porque cont está declarado como int 00:10:58
como cont está declarado como int devuelve un int 00:11:00
pues entonces tengo que indicarlo 00:11:02
que esta función me va a devolver un int 00:11:03
¿vale? 00:11:06
entonces ahora ya sí que deja de quejarse 00:11:08
esta función tiene un retun 00:11:11
que implica, te entrego este valor 00:11:20
a ti que me has llamado, te lo entrego 00:11:22
ahora veremos como lo recoge el otro 00:11:24
pero él lo entrega, te entrego este valor 00:11:26
a ti que me has llamado, un valor además 00:11:28
entero, porque conto es entero 00:11:30
vale, pues si hace eso 00:11:32
la cabecera 00:11:34
lo tiene que indicar, que ahí 00:11:36
va a haber un valor de entrega 00:11:38
que es de tipo entero 00:11:40
entonces tienes que poner el int 00:11:42
vale 00:11:44
si aquí devolviéramos un valor que es 00:11:45
double, pues pondríamos aquí double 00:11:48
si devolviéramos un valor que es un string 00:11:50
pondríamos ahí string, si devolviéramos un valor que es un array 00:11:52
pondríamos ahí el array 00:11:54
¿vale? pero bueno, ahora quedémonos con los casos 00:11:56
más sencillos 00:11:59
¿vale? entonces lo que va antes del nombre 00:12:00
lo que va antes, justo antes 00:12:05
siempre es 00:12:07
o un tipo de dato o void 00:12:08
no hay más alternativas 00:12:11
void es 00:12:12
no devuelvo nada, no hay return 00:12:14
y si no es 00:12:17
un tipo 00:12:18
y el tipo puede ser cualquiera 00:12:19
primitivo, objeto, cualquiera 00:12:22
¿vale? el tipo puede ser cualquiera 00:12:24
pero tiene que ser el mismo tipo del dato devuelto 00:12:27
ahí tiene que haber un tipo de dato siempre 00:12:30
¿vale? pues esta función 00:12:32
ahora 00:12:35
la verdad es que tiene un poquito más 00:12:36
tendría más sentido, claro 00:12:39
todo depende de lo que me han pedido 00:12:41
si a ti te han pedido, haz una función que lo muestre por consola 00:12:42
pues está estupendo, te lo muestra por consola 00:12:45
pero en general 00:12:47
si hablamos en general 00:12:48
siempre será más útil 00:12:50
que te entreguen el valor 00:12:52
y la aplicación decida 00:12:54
porque a esta función le puede llamar mucha gente 00:12:55
y habrá gente que a lo mejor quiera 00:12:58
que se muestre la cuenta por consola 00:13:00
fenomenal, pero habrá gente que no 00:13:02
entonces dice, mira, yo te entrego el valor 00:13:03
y tú haces con él lo que te dé la gana 00:13:05
vale, pues 00:13:07
el retorno es mejor 00:13:10
a ver, hace la función 00:13:11
más usable 00:13:14
porque no condena a que lo muestres 00:13:15
por consola, te lo entrega 00:13:18
y el programa que lo llama hace con ese valor 00:13:20
lo que quiera 00:13:22
vale, pues ahora vamos a llamarlos 00:13:22
desde el main 00:13:25
vale, pues 00:13:27
si llamamos por ejemplo 00:13:32
la primera versión, contar vocales 00:13:35
con el nombre que hemos leído 00:13:37
contar vocales, vale 00:13:41
voy a poner aquí una línea 00:13:45
para que podamos distinguir 00:13:47
la salida de esta segunda parte 00:13:49
vale, aquí en vez de 00:13:51
78 le voy a poner 00:13:55
1 para que no me muestre tantas veces 00:13:56
Bueno, la llamada a la primera versión 00:13:59
Contar vocales, yo le paso el nombre 00:14:06
La primera versión 00:14:07
Pues lo llamamos 00:14:08
Y efectivamente 00:14:10
Pepe 00:14:12
Dos 00:14:14
¿Vale? Dos vocales 00:14:15
Ahora vamos a llamar a la segunda versión 00:14:18
A la segunda versión 00:14:23
La llamamos por su nombre 00:14:29
También 00:14:31
Como a todas las funciones 00:14:37
Contar vocales, versión 2 00:14:38
y le pasamos el parámetro. 00:14:41
¿Y ahora qué pasa? 00:14:45
Yo podría llamarla así también. 00:14:47
Esa es la llamada de la primera versión. 00:14:50
Ahora, ahora. 00:14:52
Esta es la llamada de la primera versión 00:14:53
que no devuelve nada 00:14:54
y que le paso el parámetro y me lo ha mostrado por consola 00:14:56
como acabamos de comprobar. 00:14:59
La llamada de la segunda versión igual, por su nombre 00:15:00
y pasándole el parámetro. ¿Pero qué ocurre? 00:15:02
Que si yo esto lo dejo así, lo puedo dejar así, 00:15:04
esta me está entregando un valor. 00:15:07
Lo está haciendo sí o sí porque tiene un retorno. 00:15:09
Pero ese valor, tal cual me lo está entregando, 00:15:10
la máquina virtual lo está tirando a la basura. 00:15:13
Luego no vale para nada. 00:15:16
Entonces, para que ese valor lo podamos recoger en algún sitio, 00:15:20
pues lo tendremos que recoger en algún lado, 00:15:24
en alguna caja habrá que recoger ese valor. 00:15:26
¿Qué es recoger un valor en una caja? 00:15:28
Una asignación. 00:15:30
No ha sido eso de toda la vida. 00:15:31
Una asignación era mi variable, que es una caja, 00:15:33
a la que yo le doy un valor. 00:15:36
Pues esta es la misma situación. 00:15:38
contar vocales me ha entregado un valor 00:15:40
se lo tendré que asignar a alguna variable 00:15:42
porque si no se lo asigno a ninguna variable 00:15:44
a la basura que se ha ido 00:15:47
¿a qué variable? 00:15:49
pues a la que me dé la gana, tiene que ser entera 00:15:50
porque lo que me devuelve es entero 00:15:52
entonces por ejemplo, esto pues tendría sentido 00:15:53
¿vale? 00:15:57
en mi variable 00:15:59
num vocales que es entera 00:16:00
le asigno el retun de este 00:16:02
¿vale? 00:16:05
entonces la recogida del retorno 00:16:06
siempre es mediante una sentencia de asignación 00:16:09
y ese valor 00:16:12
se va a donde tú le hayas dicho 00:16:14
vale 00:16:15
ahora ya con este en un vocales 00:16:17
uno ya hace lo que le dé la gana 00:16:20
y así tiene mucho más sentido por el programa principal 00:16:21
a veces lo querrá para una cosa 00:16:24
a veces lo querrá para otra, depende de para lo que lo quieras 00:16:26
tú lo recoges 00:16:28
y luego haces con él lo que quieras 00:16:29
por ejemplo en este caso 00:16:31
podríamos, pues sí, mostrarlo por 00:16:33
por consola 00:16:36
Pero podría ser cualquier otra cosa 00:16:37
Las vocales son 00:16:40
NumVocales 00:16:41
Entonces esta primera versión 00:16:46
Nos lo va a mostrar directamente porque lo hace 00:16:49
Y luego cuando hagamos esta ejecución 00:16:51
Pues nos lo va a hacer también 00:16:53
Entonces ejecutamos esto 00:16:54
Bueno, este primer número no hacía nada 00:16:58
Pepito 00:17:00
Pues esta es la primera llamada 00:17:03
Y esta es la segunda 00:17:05
Vale, pues entonces la llamada a una función 00:17:06
Que devuelve un valor 00:17:33
hay que interpretarla como el propio 00:17:34
valor, como si fuera 00:17:36
una expresión más, el propio valor 00:17:38
y ese propio valor yo lo asigno a una 00:17:40
variable, hago lo que sea 00:17:42
podríamos haberlo pasado al system out también 00:17:44
tranquilamente 00:17:46
también y no pasa nada 00:17:48
podríamos haber hecho esto 00:17:50
¿verdad? 00:17:51
podríamos haberse lo pasado a un system out 00:17:56
porque esto ¿qué hace? 00:17:58
esto me entrega su valor 00:18:01
me entrega su valor 00:18:03
y ese mismo valor 00:18:05
ya lo coge el system out 00:18:06
aquí el valor que me entrega 00:18:08
lo coge la variable a la que se lo asigno 00:18:11
aquí el valor que me entrega 00:18:13
se lo paso al system out 00:18:16
o sea lo que importa 00:18:17
es que esta llamada 00:18:18
es como si fuera un número 00:18:19
es igual que un número 00:18:21
y que número es en particular 00:18:22
el número que hay en el return 00:18:24
luego esta llamada 00:18:26
equivale a un número entero 00:18:28
equivale al return que me han devuelto 00:18:30
para asignar a variable 00:18:32
para meterlo en un system out 00:18:34
para meter una expresión para lo que sea 00:18:35
equivale al número devuelto 00:18:37
equivale al número devuelto 00:18:39
tal cual 00:18:41
dime 00:18:42
en la primera versión no podríamos 00:18:43
no, en la primera versión 00:18:47
si yo trato de hacer por ejemplo 00:18:49
meterlo en 00:18:51
una variable 00:18:53
esta que no tiene retún 00:18:54
me va a decir el compilador 00:19:01
me va a decir 00:19:05
oye, que contar vocales no es un número 00:19:07
porque no hay ahí ningún retón que te devuelva un número 00:19:10
tiene un void 00:19:12
entonces dice, no puedo meter, no puedo asignarlo 00:19:14
ahí, no puedo 00:19:17
no puedo 00:19:17
es para que te devuelva un número 00:19:19
y ese número ya haces con él lo que quieras 00:19:24
pero esta como tenía void 00:19:27
esta no te devuelve nada, te hace código 00:19:28
te hace cosas, pero no te entrega un número 00:19:30
con lo cual si no te entrega un número 00:19:33
no puedes ni asignarlo 00:19:35
a un sitio, ni hacer nada con ello 00:19:37
¿vale? 00:19:38
a las funciones que tengan retun 00:19:40
a las funciones que tengan retun 00:19:50
tú ya usas ese número devuelto 00:19:53
como quieras, aquí por ejemplo 00:19:55
hemos asignado una variable 00:19:57
aquí lo he usado también 00:19:58
para pasárselo al system.not para que lo muestre 00:20:00
tú tienes que verlo como un número 00:20:03
como un valor entero, toda esa función tienes que verlo 00:20:04
como un valor entero, con la particularidad 00:20:06
de que ese valor entero es la cuenta 00:20:08
de las vocales de nombre 00:20:10
entonces tú cuando ves esto dices 00:20:11
ah, vale, esto es el numerito 00:20:14
de vocales que tiene nombre 00:20:16
es lo que tú ves cuando haces eso 00:20:18
y es ese número, todos los efectos 00:20:20
como este hecho por dentro ya te da exactamente igual 00:20:21
tú ves que eso es un número 00:20:24
y ese número haces con él lo que quieras 00:20:25
claro 00:20:27
cada función solo puede devolver un valor 00:20:28
si tú quieres que una función te devuelva dos datos 00:20:33
lo que puedes hacer es meterlos en un array 00:20:38
y devolver un array 00:20:40
porque un array también lo puedes devolver 00:20:42
Porque es un único dato 00:20:43
¿Vale? Solo puedes devolver 00:20:44
Un dato, ahora podemos poner un ejemplo 00:20:47
¿Vale? 00:20:49
Bueno, pues a ver 00:20:53
¿Entendido? 00:20:54
Vale, pues aquí vosotros 00:20:58
Que siempre os adelantáis 00:20:59
Y esta vez no os habéis adelantado 00:21:01
Ya, pero creía que ibas 00:21:03
Como locos a decirme 00:21:07
Entonces, ¿por qué no lo has llamado igual? 00:21:09
Porque también se distinguen 00:21:12
Porque esta tiene un void 00:21:14
y esta tiene un int 00:21:15
ya pero no, justo 00:21:16
claro, porque 00:21:19
aquí son distinguibles a la vista 00:21:23
esta devuelve un boi y esta un int 00:21:25
claro, pero yo a contar 00:21:26
vocales 2 a esta 00:21:29
si a mí me da la gana 00:21:31
la puedo llamar 00:21:33
tirando su valor a la basura 00:21:34
la puedo llamar así, nadie me obliga 00:21:36
a recoger su valor 00:21:39
si yo la llamo así y el nombre 00:21:40
fuera el mismo, la máquina virtual 00:21:43
¿cómo sabe a cuál está llamando? 00:21:45
Si a la primera o a la segunda, no puede saberlo. 00:21:47
No puede saberlo. 00:21:50
Entonces, cuando las 00:21:51
funciones se distinguen 00:21:55
solo en el tipo de retorno, 00:21:56
ahí ya sí que se tiene que llamar distinto. 00:21:59
Ya. 00:22:05
¿Seguro que no os habéis adelantado 00:22:06
ninguno por eso? 00:22:08
Muy poca fe de la clase. 00:22:09
De verdad. 00:22:11
Pues sí. Tengo poca confianza en vosotros. 00:22:15
Tengo que aumentar mi confianza. 00:22:18
Vale, vale 00:22:19
¿Qué me ha llamado este? 00:22:22
Algo me ha llamado, ¿a que sí? 00:22:27
No, no, no te ha dicho nada 00:22:28
Creía que me había llamado ilusa 00:22:31
Ilusa es una palabra del castellano 00:22:34
Significa 00:22:38
Higiénico, inocente 00:22:39
Seguro 00:22:41
Quien habla español viene 00:22:44
No, ilusa 00:22:45
A ver, perdona 00:22:49
se lo habría dicho a cualquiera 00:22:51
porque los que no sabéis castellano 00:22:53
sois todos 00:22:55
todos los menores de 25 00:22:56
aproximadamente 00:23:01
todos los que 00:23:02
no, os he llamado víctimas 00:23:07
de un sistema educativo 00:23:11
y un entorno sociocultural 00:23:12
tremendamente dañino 00:23:14
y pobre 00:23:16
y poco estimulante 00:23:18
eso 00:23:19
os he llamado víctimas de la sociedad 00:23:21
en la que os estáis criando 00:23:24
efectivamente 00:23:25
y de poca cultura del esfuerzo 00:23:28
poca curiosidad, poca capacidad 00:23:30
de concentración porque te llega todo demasiado 00:23:32
fácil, entonces 00:23:34
me pierdes la... 00:23:35
bueno, todo eso les hemos llamado de golpe 00:23:37
conclusión 00:23:39
conclusión 00:23:42
en cualquier caso no es vuestro 00:23:44
caso la falta de concentración porque ya me decís 00:23:46
que estaba clarísimo 00:23:48
que 00:23:50
las funciones no se podían llamar igual 00:23:51
aunque el tipo de dato fuera distinto 00:23:54
porque la máquina virtual no podría distinguirlas 00:23:56
si yo las llamo 00:23:58
tirando a la basura 00:24:00
el valor del otro 00:24:01
no porque la máquina 00:24:03
porque si se llaman igual 00:24:10
y yo llamo a la segunda 00:24:11
pero pasando del 00:24:14
valor de retorno, ignorándolo porque no me da 00:24:16
la gana, pues entonces 00:24:18
y se llamaran igual, estaría 00:24:20
haciendo estas dos llamadas. 00:24:22
Y siempre sería la 00:24:24
primera versión. O sea, nunca, 00:24:26
esta sería inaccesible. 00:24:28
Esta otra 00:24:30
que me devuelve el donde está por ahí arriba. 00:24:32
¿Dónde está? 00:24:34
¿Vale? 00:24:37
Entonces... 00:24:43
O devuelven datos de tipos distintos. 00:24:44
Es decir, cuando las funciones se diferencian en el tipo de datos solamente, los parámetros son iguales, 00:24:59
el nombre tiene que ser distinto, porque si no, no se van a poder distinguir a la hora de llamar. 00:25:06
Vale, el retun 00:25:11
en realidad es una sentencia que puede aparecer 00:25:20
en las funciones que devuelven void 00:25:24
el retun también puede aparecer, pero en ese caso, ¿cómo aparecería? 00:25:28
Sin parámetros, sin nada. 00:25:33
Sirve para terminar la función en ese momento. Aquí ponerlo es estúpido 00:25:35
porque es que la función va a acabar en ese momento igualmente, la función acaba cuando acaba el código 00:25:40
pero imaginaos que 00:25:44
por ejemplo, yo quiero, voy a modificar 00:25:46
ahora este contar vocales para 00:25:49
si nombre es null, no hacer nada 00:25:50
tiene mucho sentido porque 00:25:53
si nombre es null y yo 00:25:55
entro aquí, aquí me va a salir un 00:25:57
null pointer exception 00:25:59
porque si nombre es null, un null 00:26:00
no puede llamar la función 00:26:03
length porque es null, null pointer exception 00:26:05
claro 00:26:07
entonces yo podría hacer, mira voy a 00:26:08
modificar esta versión mía para que sea 00:26:10
más bonita y voy a decir, oye 00:26:13
vamos a ver si nombre es null, porque si nombre es null 00:26:14
quiero terminar en ese momento 00:26:17
y se acabó, pues entonces haríamos 00:26:18
si nombre es 00:26:21
igual a null 00:26:22
entonces aquí le pega muy bien 00:26:23
poner return 00:26:26
return es 00:26:28
la sentencia que termina 00:26:30
la función en la que 00:26:32
estás en ese momento y ya no hace más 00:26:35
que es justo 00:26:37
lo que querríamos aquí, si nombre es igual a null 00:26:39
función terminada, se acabó 00:26:41
y como esta es void 00:26:42
no ponemos nada 00:26:44
imaginaos que yo quiero devolver 00:26:46
un entero aquí, pues pondría aquí el entero 00:26:48
que fuera, pero si es void 00:26:50
no se devuelve nada 00:26:52
¿se pone el igual igual en vez del 00:26:54
equals? 00:26:56
sí, porque nombre 00:26:57
es una dirección de memoria 00:27:00
y lo que estoy mirando es que la dirección de memoria 00:27:02
sea null 00:27:04
no, es que cuando un objeto es null 00:27:05
lo que significa es que la dirección de memoria tiene null 00:27:07
entonces ahí sí que lo hago con igual igual 00:27:10
¿Vale? A ver, esto 00:27:12
Empieza a ser importante 00:27:14
Todo es importante 00:27:17
Pero 00:27:19
¿Qué pasa cuando tenemos 00:27:20
Un objeto como es el caso de string o array 00:27:23
A raíz de lo que me ha preguntado ella 00:27:25
Ya sabemos que lo que realmente 00:27:27
Tenemos es 00:27:29
Una variable que es una dirección de memoria 00:27:30
Que apunta 00:27:33
A mi objeto 00:27:37
Entonces cuando tenemos un string 00:27:38
En realidad la variable string 00:27:41
tiene la dirección, porque es un objeto 00:27:44
y a través de esa dirección 00:27:46
llegamos aquí ya a todos los caracteres, a todo eso 00:27:48
vale, pues cuando 00:27:50
escribimos esto 00:27:52
vamos a suponer que 00:27:53
esta variable se llama 00:27:56
nombre 00:28:00
vale, imaginaos que tenemos aquí mi string 00:28:03
nombre, vale 00:28:11
entonces, para ver yo 00:28:12
si nombre no tiene nada, o sea si es un objeto 00:28:14
que no existe, pues 00:28:17
¿qué ocurre cuando un objeto no existe? 00:28:18
que directamente aquí dentro 00:28:20
directamente aquí dentro 00:28:21
ya está escrito, entre comillas 00:28:23
esto, con lo cual 00:28:26
para ver si un objeto no tiene nada 00:28:28
no lo hago con equals, porque directamente 00:28:30
hago nombre 00:28:32
hay una dirección de memoria 00:28:33
claro 00:28:36
eso es un hexadecimal en realidad 00:28:37
a ver, null, la máquina virtual de java 00:28:39
lo interpreta a dirección de memoria 00:28:42
no asignada, y cuando un objeto 00:28:44
está sin inicializar 00:28:47
lo que tiene físicamente dentro es 00:28:49
hexadecimal dirección de memoria 00:28:51
no asignada, que en Java 00:28:53
por comodidad se llama null 00:28:55
entonces cuando hacemos nombre 00:28:56
igual a null, decimos, esta misma variable 00:28:59
tiene dentro null 00:29:01
porque si tiene dentro null, ¿qué significa? 00:29:02
que mi objeto no existe, eso es lo que significa 00:29:04
sale null 00:29:07
pone null escrito 00:29:09
sí, pone null escrito 00:29:11
que significa que no está asignada 00:29:12
pone null, vale 00:29:14
Pero, sin embargo, si este objeto nombre ya tuviera algo dentro, entonces yo ahora podría querer hacer otra cosa, es ver si lo que hay aquí es Pepito, entonces ahora ya no haría nombre igual a Pepito, 00:29:16
Porque yo lo que quiero es ver lo que hay aquí, esto. 00:29:44
Y para ver lo que hay aquí es con equals. 00:29:47
Pero para ver lo que hay aquí es con null. 00:29:49
Con doble igual. 00:29:51
¿Vale? 00:29:53
Entonces, por eso, para ver si un string es igual a Pepito, Juanito, 00:29:54
lo hacemos con equals, porque queremos ver lo que hay ahí. 00:29:58
Pero para ver si un objeto es null, no tiene nada, 00:30:01
lo hacemos con doble igual, 00:30:04
porque lo que queremos ver es lo que hay ahí. 00:30:05
Ver si la dirección de memoria es dirección no asignada. 00:30:07
¿Vale? 00:30:11
Y con cualquier cosa que sea objeto. 00:30:18
Pero nosotros hasta ahora 00:30:19
Cosas que son objeto han sido 00:30:20
Stream y Arrays, nada más 00:30:22
Sobre todo Stream, ¿vale? 00:30:24
Vamos a trabajar más 00:30:26
Vale 00:30:27
Lo que vamos a ver es ArrayList 00:30:28
¿Qué son ArrayList? 00:30:33
Hombre, claro, son las colecciones 00:30:34
Los ArrayList, los List, los Set, los Map 00:30:35
Las colecciones, la jerarquía de colecciones 00:30:38
De Java 00:30:41
Claro 00:30:41
Claro, lo que pasa es que todo eso son colecciones 00:30:42
De datos, ¿vale? 00:30:47
entonces son clases adicionales 00:30:48
que están construidas 00:30:50
que físicamente por dentro son un array 00:30:51
pero las funciones que tienen 00:30:53
son para tapar 00:30:56
su manejo y tú llamas al método 00:30:58
insertar y te lo hacen 00:31:00
pero están construidas por código 00:31:01
todas las colecciones 00:31:03
tendremos que verlas 00:31:05
claro 00:31:08
ArrayList lo que te hace dentro 00:31:09
es exactamente 00:31:12
lo que nosotros hemos hecho de crear uno nuevo 00:31:13
copiar y eso mismo 00:31:15
es lo que te hace bien. 00:31:18
Pero como ya te lo he hecho 00:31:21
dentro y le he puesto un numerito de función, 00:31:22
pues te vamos a la función y listo. 00:31:24
Vale, bueno. 00:31:27
Dudas. 00:31:29
Problemas. 00:31:30
Algo 00:31:33
de... 00:31:33
¿Tu existencia es un problema o es una duda? 00:31:38
Ambas. 00:31:40
A ver, una duda 00:31:42
sí que es. 00:31:44
Un problema no, hombre. 00:31:45
claro, una duda es 00:31:48
para nosotros no, para tus padres 00:31:50
igual, la cosa está más chunga 00:31:52
pero 00:31:54
uy, pues entonces tienen un problema 00:31:54
muchísimo más grande 00:32:02
bueno 00:32:03
a ver, venga 00:32:13
Venga, como nos quedan 00:32:16
9 minutos 00:32:19
Vamos a hacer... ¿Qué te pasa? 00:32:20
Ah, es que está así congelado 00:32:23
Sí, claro, justo 00:32:25
Es lo que iba a decir 00:32:28
En esos 9 minutos, pues por ejemplo, simplemente 00:32:29
Hacer este... Ah, sí, sí, sí 00:32:32
Sí 00:32:35
¡Ay! 00:32:36
Bueno, espera 00:32:38
Se me acumula el trabajo 00:32:39
Un momento 00:32:42
una función chorra 00:32:43
para que en estos 8 minutos efectivamente 00:32:46
hagáis lo que Pedro ha pedido 00:32:48
que es, vamos a asimilarlo un poco más 00:32:50
¿vale? 00:32:52
no, hombre 00:32:54
calladitos todos veis 00:32:56
vale, vamos a hacer 00:32:57
una función 00:33:02
que recibe 00:33:03
Venga, la primera chorradita que se me ha ocurrido 00:33:13
Recibe dos nombres por parámetro 00:33:21
Y te devuelve 00:33:24
El que tenga más vocales 00:33:28
¡Hala, ya está! 00:33:40
Recibe dos cadenas, dos nombres 00:33:42
y te devuelve el nombre 00:33:44
que tenga más vocales 00:33:46
esto, ya está, punto pelota 00:33:47
vale, y ahora ya, solo de cara a asimilarlo 00:33:49
sí, dime 00:33:53
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:
11
Fecha:
11 de noviembre de 2024 - 12:17
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
33′ 56″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
130.52 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid