Saltar navegación

Prog2223 funciones y procedimientos - 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 18 de noviembre de 2022 por Stefano C.

38 visualizaciones

Más información Transcripción

Descargar la transcripción

A ver, voy a grabar esta clase, por lo tanto si preguntáis algo o habláis mientras hay esta grabación 00:00:00
es porque me dais vuestro consentimiento a hablar y grabaros, ¿vale? 00:00:08
Si no, levantáis la mano y lo paro y bla bla bla bla, ya lo hemos dicho varias veces. 00:00:12
Vale, entonces, hoy vamos a ver, esta parte de aquí en realidad es una extensión, 00:00:20
una parte extra con respecto a lo que hemos visto de estructuras de control, ¿vale? 00:00:28
Esto de aquí lo podríamos ver como una estructura de control. ¿Os acordáis la estructura de 00:00:34
control que hemos visto nosotros? Los condicionales, los iterativos, for, while, if, lo que hacían 00:00:39
era cambiar un poco el normal flujo de ejecución de un programa, ¿no? Ya llegaba un momento 00:00:44
Y allí tomaba una decisión 00:00:52
Si era verdadera o condición 00:00:54
Hacía una serie de instrucciones 00:00:56
Si no era verdadera esa condición 00:01:00
Hacía otra cosa, ¿vale? 00:01:03
O hacía una serie de instrucciones 00:01:05
Y cuando llegaba al final de estas instrucciones 00:01:07
Volvía al principio si una condición era verdadera 00:01:09
Entonces en vez de tener 00:01:12
Como hacíamos los ejercicios cuando estábamos al principio de curso 00:01:13
Hacer una instrucción tras otra, tras otra, tras otra 00:01:18
Y seguir hasta el final 00:01:21
Pues cambiaba un poquito la secuencia 00:01:22
Volvía atrás o cosa por esto 00:01:26
Las funciones o procedimientos tienen una función parecida en un cierto sentido 00:01:28
En el sentido que llega un momento en que puedo pillar un trozo de código 00:01:34
Una parte de mi programa 00:01:41
Sacarlo del main 00:01:43
Que hasta ahora nosotros siempre hemos trabajado y solo hemos utilizado el main 00:01:45
Y darle un nombre, para que si yo quiero utilizar esta función, utilizar este trozo de código 00:01:49
Pueda referirme, pueda referenciar este trozo de código con su nombre 00:01:59
¿Para qué me sirve esto? Para muchas cosas 00:02:04
En particular, para ser básico, como la primera cosa digamos más sencilla para entender 00:02:08
Es para organizar código 00:02:16
En vez de tener todo el código 00:02:17
Dentro del main 00:02:19
Entonces se me vuelve complejo 00:02:20
Con muchas líneas de código 00:02:22
Pues si pillo un trozo 00:02:23
Lo saco fuera 00:02:25
Y lo llamo 00:02:26
Acceso a la base de datos 00:02:26
O login del cliente 00:02:28
¿Vale? 00:02:31
Yo cuando miro el main 00:02:32
Leo allí que se llama 00:02:33
Una función que tiene nombre 00:02:34
Login del cliente 00:02:36
O calcular no sé qué 00:02:37
Y sé que esa función sola 00:02:39
Independientemente de cómo esté implementada 00:02:42
De cuántas líneas de código tiene 00:02:44
Pues tiene esa funcionalidad 00:02:45
¿Vale? 00:02:47
Entonces el main se me vuelve más pequeño 00:02:48
Se me vuelve más fácil de leer y de organizar 00:02:51
¿Sí? 00:02:53
Y además 00:02:55
La cosa interesante de las funciones de los procedimientos 00:02:56
Es que pueden llevar parámetros 00:02:59
¿Vale? 00:03:01
Entonces 00:03:02
Un código que yo voy a ejecutar 00:03:03
Le voy a pasar 00:03:06
Un cierto parámetro, un cierto valor 00:03:08
O unos valores 00:03:10
Y su funcionamiento, el resultado que me dará 00:03:11
Dependerá de los parámetros que yo le paso 00:03:15
Para hacer un ejemplo básico 00:03:17
Si yo tengo un método que se llama calcular el cuadrado 00:03:19
¿Vale? 00:03:22
Le pasaré como parámetro el lado del cuadrado que yo quiero calcular 00:03:23
Y él me calculará el área del cuadrado del lado del número que le he pasado 00:03:28
¿Vale? 00:03:34
Para hacer un ejemplo 00:03:36
Entonces, vamos a ver un poquito 00:03:37
Qué tipo de cosas hay 00:03:39
Vamos aquí 00:03:42
Imaginémonos, aquí hace un ejemplo, ¿vale? 00:03:44
Diciendo, vamos a ver si en un programa se repite muchas veces el mismo código, ¿vale? 00:03:47
Como por ejemplo aquí 00:03:51
Nosotros lo que vamos a hacer es calcular el área, el perímetro de un rectángulo varias veces 00:03:53
Y cada vez cambia el tipo de rectángulo que yo tengo, ¿vale? 00:04:01
Entonces aquí tengo un rectángulo de lado 3 y 4 00:04:06
Y luego calculo la área, el perímetro 00:04:09
Y escribo el rectángulo de lado 00:04:11
Con sus lados, tiene área 00:04:14
Área y perímetro 00:04:15
¿Vale? Y luego hago lo mismo 00:04:17
Lo único que hago es cambiar 00:04:19
Los lados 00:04:21
Ahora en vez de utilizar lado 3 y 4 00:04:23
Utilizo lado 5 y 10 00:04:25
Y luego lado 2 y 7 00:04:27
¿Vale? Esto es un programa 00:04:29
Algo parecido 00:04:32
Hemos hecho al principio, ¿vale? 00:04:33
Un programa muy sencillo 00:04:34
Lo que noto es que está haciendo siempre lo mismo 00:04:36
¿Vale? Entonces 00:04:38
No tiene mucho sentido que yo vuelva a escribir 00:04:40
Todo este código 00:04:42
Si el código es el mismo 00:04:43
La idea sería pillar este código de aquí 00:04:45
Darle un nombre 00:04:48
Y luego reutilizar 00:04:50
Este código 00:04:53
Utilizando una función 00:04:54
O un procedimiento o lo que sea 00:04:56
¿Vale? Ya luego veremos 00:04:58
La diferencia entre procedimiento 00:05:00
Función 00:05:04
¿Vale? Entonces, por ejemplo, algo así 00:05:06
Mi main se transforma en esta cosa aquí 00:05:08
Yo tengo calcular el perímetro de 3, 4 00:05:13
Calcular el perímetro de 5, 10 00:05:16
Calcular el perímetro de 2, 6, 7 00:05:18
Y esto, técnicamente, es más fácil de leer a nivel de main 00:05:20
Con respecto al anterior 00:05:24
Es mucho más organizado, ¿vale? 00:05:26
Luego, ¿qué harán estas cosas? 00:05:29
Pues si me interesa y lo quiero saber 00:05:31
La voy a mirar, voy a mirar cuál es su implementación 00:05:33
Ahora lo vamos a ver, ¿vale? 00:05:35
Pero ya sé que esta línea de aquí 00:05:37
Calcular el perímetro de 3, 4 00:05:40
Me tiene que calcular el perímetro del rectángulo 00:05:42
Que tiene el lado 3 y el lado 4 00:05:44
¿Sí? 00:05:46
¿Se entiende? 00:05:48
¿Dudas hasta aquí? 00:05:50
Vale, vamos a ver cómo declaro 00:05:52
Cómo creo un nuevo método 00:05:55
¿Vale? Por ejemplo, esto 00:05:57
¿Métodos o funciones? 00:05:59
En Java, funciones y procedimientos se llaman métodos 00:06:02
¿Vale? 00:06:05
Y están relacionados con la programación orientada a objetos 00:06:06
Por lo tanto, cuando estaremos en programación orientada a objetos 00:06:09
Todo esto serán métodos 00:06:12
Métodos normales o métodos estáticos, ¿vale? 00:06:13
En programación estructurada 00:06:17
No es un método, sino es más bien funciones o procedimientos 00:06:21
Que ahora veremos la diferencia, ¿vale? 00:06:24
Depende de qué devuelve 00:06:25
Si devuelve algo es una función, si no devuelve algo es un procedimiento, ¿vale? 00:06:27
Si ahora me equivoco y uso método 00:06:31
Pues por ahora lo utilizamos como sinónimo 00:06:33
Al fin y al cabo el concepto es el mismo 00:06:38
Es pillar un trozo de código 00:06:40
Sacarlo fuera y darle un nombre 00:06:42
Y parámetros 00:06:44
¿Vale? 00:06:45
Entonces si digo método 00:06:47
Vosotros cambiadlo en vuestra cabeza 00:06:48
Luego la grabación 00:06:50
Pues no sé cómo cambiar la grabación 00:06:53
Vale, entonces 00:06:56
Este aquí es una función 00:06:58
Vamos a crear una función 00:07:00
Bueno, concretamente esto sería un procedimiento, ¿vale? 00:07:03
Si os fijáis, estas palabras ya las hemos visto alguna vez, ¿vale? 00:07:07
Porque cuando nosotros hemos hecho main, este es el método main, llamado en Java, ¿vale? 00:07:11
Y es el punto de acceso a mi programa 00:07:16
Y siempre nosotros poníamos delante un public static void 00:07:20
¿Y qué son estas cosas? Ni idea, ¿vale? 00:07:23
Hasta ahora la hemos puesto siempre así 00:07:26
Y luego poníamos este string 00:07:29
Paréntesis, paréntesis 00:07:31
Arcs 00:07:33
¿Y qué es eso? No tengo ni idea, ¿vale? 00:07:35
Sí, lo sé, ¿vale? 00:07:37
Pero por qué va allí, no lo sabía 00:07:38
¿Sí? Ahora la idea es intentar 00:07:41
Entender un poquito qué es esto 00:07:43
¿Vale? Y luego crear cosas parecidas 00:07:45
¿Sí? 00:07:47
Voy también porque aquí hay muchas cosas 00:07:51
Hay muchas cosas para entender 00:07:53
Y algunas cosas son también complejas 00:07:55
Por lo tanto, yo voy, por ahora, simplificando algunos temas 00:07:57
Dejándolos a más para allá, ¿vale? 00:08:01
Por ejemplo, el public inicial 00:08:03
Public inicial no tiene mucho sentido 00:08:04
Mientras que no trabajemos con objetos, clases y visibilidad de los objetos 00:08:07
Por lo tanto, por ahora, nosotros este es public 00:08:12
Es público 00:08:15
Todos nos pueden ver y todos nos pueden utilizar 00:08:16
Ya está, ¿vale? 00:08:18
También sabemos que lo utilizamos en la clase 00:08:20
Public clase prueba 3 00:08:23
Y sabemos que si una clase es public 00:08:24
O sea, si se ponga así 00:08:26
Prueba 3 tiene que estar en un fichero 00:08:27
Que se llama prueba3.java 00:08:30
¿Sí? ¿Se acuerdan? 00:08:32
Veremos en un futuro que yo puedo crear 00:08:34
Clases no públicas 00:08:36
Y esas pueden no estar 00:08:38
En un fichero que se llama 00:08:40
No sé qué punto ya 00:08:42
¿Vale? Pero eso va a ser 00:08:43
Static 00:08:45
¿Qué es esto de static? 00:08:47
También no lo podemos saber muy bien 00:08:49
Sin saber el concepto de objeto 00:08:52
De instancia de objeto y de clase 00:08:54
¿Vale? No lo sabemos, no lo conocemos todavía, lo veremos en breve 00:08:56
Por ahora simplemente sabemos que todos los métodos y funciones que vamos a crear 00:08:59
Y procedimientos van a ser estáticos 00:09:04
¿Vale? ¿Por qué? 00:09:06
Lo tenemos que esperar un rato para entender por qué son estáticos 00:09:08
¿Vale? Pero por ahora simplemente 00:09:12
Como el main es estático 00:09:14
¿Vale? Y no sé crear objetos 00:09:17
He creado algunos objetos pero no sé muy bien qué son 00:09:19
¿Vale? 00:09:22
Pues entonces los métodos 00:09:22
Estoy en un contexto estático 00:09:24
O sea que esto es estático porque pone static 00:09:27
Y entonces los métodos que puedo llamar 00:09:29
Tienen que ser static también 00:09:32
Por ahora sumamos así 00:09:34
¿Vale? 00:09:35
Perfecto 00:09:37
De hecho, cuando escribís el nombre 00:09:38
Si os fijáis, esto calcula área pedímetro 00:09:41
Está como en cursiva 00:09:43
¿Vale? 00:09:45
Y esto es porque es un método estático 00:09:46
Si no fuera un método estático 00:09:47
No lo pondría en cursiva 00:09:49
¿Vale? 00:09:50
Pero bueno, por ahora 00:09:51
Todos para nosotros pondremos static 00:09:52
¿Vale? Fenómeno 00:09:55
Tercera palabrita, esto ya nos interesa más 00:09:56
Es void 00:09:58
Void que en inglés quiere decir como 00:09:59
Nada, vacío 00:10:02
¿Vale? Es porque 00:10:04
Estos métodos de aquí 00:10:06
Que estamos viendo, estos procedimientos 00:10:09
Concretamente que estamos viendo 00:10:11
No devuelven nada 00:10:12
Es decir, yo no me espero que al final 00:10:14
De este trabajo 00:10:17
Este método calcule algo 00:10:18
Y me lo devuelva a mí 00:10:20
¿A quién lo ha llamado? 00:10:22
¿Vale? 00:10:24
El método main 00:10:24
Aquí llama 00:10:26
¿Vale? 00:10:27
El método calcula área, perímetro, 3 y 4 00:10:28
Y no se espera 00:10:31
Que este método de aquí 00:10:32
Que este procedimiento 00:10:34
Calcule algo y me lo devuelva 00:10:36
Y me lo dé 00:10:39
¿Vale? 00:10:40
Hará algo 00:10:41
Pero no me da el resultado 00:10:42
Si me diera un resultado 00:10:44
Yo podría hacer algo así 00:10:47
No, aquí no lo puedo hacer 00:10:49
Sí, esperad un segundo que pillo un 00:10:52
Block de notas 00:10:55
Para escribir 00:10:57
Calcula área perímetro me diera 00:11:01
Algo, yo podría esperarme 00:11:05
Algo así, por ejemplo, imaginaos que 00:11:07
Me espero un intero, pues podría hacer 00:11:09
Int x es igual 00:11:11
Es igual a 00:11:13
Calcula área 00:11:15
Y perímetro 00:11:17
De 3 y 4 00:11:19
¿Vale? 00:11:23
Esta cosa de aquí sería, vale, ok 00:11:26
Tú haz lo que tienes que hacer 00:11:28
Al final calcularás algo 00:11:30
Y este es algo 00:11:32
Me lo devuelves 00:11:34
Me lo das a mí, ¿vale? 00:11:36
Entonces, el resultado de esta operación 00:11:38
De aquí 00:11:41
Lo guardas, por ejemplo, aquí dentro 00:11:41
¿Sí? Y esto sería una función 00:11:44
Para que esto pueda ser 00:11:46
esto 00:11:49
no puede ser 00:11:51
void 00:11:54
si esto es void 00:11:55
quiere decir que no lo hace 00:11:58
¿vale? no me da 00:11:59
un resultado 00:12:02
hace operaciones 00:12:03
¿vale? pero no me devuelve 00:12:05
un resultado 00:12:07
¿se entiende esto? 00:12:08
una función 00:12:12
la diferencia que tiene con respecto al procedimiento 00:12:13
es que si devuelve algo 00:12:16
Es decir, una cosa como esta de aquí 00:12:17
Que hemos visto ahora, que he escrito ahora 00:12:20
Esta sería una función 00:12:22
Porque después de haber hecho lo que sea 00:12:27
No lo sé qué es 00:12:30
Pues crea un entero 00:12:31
Este entero me lo pasa a mí 00:12:33
Que soy el que ha llamado este método 00:12:36
¿Vale? 00:12:38
Esto sería el main, por ejemplo 00:12:38
Y este valor final se guarda dentro de x 00:12:40
¿Sí? 00:12:44
Podría también utilizarlo 3 más esta cosa aquí, ¿vale? 00:12:45
Como este de aquí devuelve un entero, este es un int, le sumo 3 y el resultado lo pongo dentro de x, ¿vale? 00:12:50
Esto sería del tipo que devuelve. 00:13:01
Si devuelve un int, pues este sería un int. 00:13:05
Si devuelve un boolean, pues este sería un boolean. 00:13:07
Entonces esto no tendría sentido. 00:13:10
Pero podría hacer 00:13:11
Si esto devolviera un boolean 00:13:13
Podría hacer un if 00:13:15
Esta cosa de aquí 00:13:16
Entonces haz algo 00:13:18
Porque al final 00:13:22
Después de haber hecho todo el trabajo 00:13:24
Que haga esta cosa aquí, que no lo sé 00:13:26
Me dará un true o un false 00:13:28
¿De acuerdo? 00:13:30
Si en vez es un procedimiento 00:13:32
O sea que tiene void 00:13:34
Esta cosa aquí no la puedo hacer 00:13:36
Porque no me devuelve un valor 00:13:38
Hace operaciones 00:13:40
Hace lo que sea, escribe en pantalla 00:13:41
Él, no lo sé 00:13:44
Pero al final no me dice 00:13:45
Y el valor calculado es esto 00:13:46
¿Se entiende? 00:13:48
¿Dudas? 00:13:53
Vale, entonces 00:13:56
Por ejemplo, en la que tenemos nosotros 00:13:57
Como estos son void 00:13:59
No puedo hacer una cosa así 00:14:00
No puedo tampoco hacer 00:14:02
Una cosa así 00:14:04
Entre x es igual 00:14:06
Oye, pero esto calcula el perímetro 00:14:08
Pues esto tiene que ser un entero, un double 00:14:11
Sí, pero por como está definido 00:14:13
El valor que calcula 00:14:18
Será él, por ejemplo, que lo escribe en pantalla 00:14:20
O será él que hace lo que sea con ese valor 00:14:23
Pero no te lo da a ti 00:14:25
No te lo devuelve 00:14:27
¿Dudas sobre esto? 00:14:29
Vale 00:14:32
Entonces, cuando un trozo de código con nombre 00:14:33
No devuelve nada 00:14:37
Se suele llamar procedimiento 00:14:39
Cuando un trozo de código con nombre 00:14:41
Devuelve algo 00:14:44
Se suele llamar función 00:14:45
Cuando un trozo de código 00:14:46
Está asociado con un objeto 00:14:49
Y trabaja con programación de un objeto 00:14:51
Se suele llamar método 00:14:53
Así simplificado 00:14:54
¿Dudas? 00:14:56
Y esta es la diferencia básica 00:14:58
Entre función, procedimiento y método 00:15:00
¿Dudas? 00:15:03
En realidad en Java 00:15:06
Como en Java estamos utilizando objetos siempre 00:15:07
Pues todos son métodos 00:15:09
¿Vale? 00:15:11
Pero por ahora nosotros ignoramos la parte orientada a objetos de Java 00:15:12
Y por lo tanto para nosotros son funciones 00:15:16
Y si me decís que son métodos, me vale 00:15:19
¿Dudas? 00:15:21
¿Sigo? 00:15:24
Vale 00:15:25
Entonces, volvamos aquí 00:15:26
Entonces tengo 00:15:28
Public static, son así, por ahora 00:15:30
Void, porque no devuelvo nada 00:15:32
Veremos ejemplos después de cosas que devuelve 00:15:35
¿Vale? 00:15:38
Nombre que doy a este trozo de código, a esta función, a este procedimiento 00:15:38
Y luego una lista de parámetros 00:15:43
¿Vale? 00:15:47
Estos son, cuando yo llamo a esta función de aquí 00:15:49
Le daré una serie de valores 00:15:51
Unos valores que son parámetros 00:15:54
Son valores que parametrizan este procedimiento, esta función 00:15:56
¿Vale? 00:15:59
Entonces, ¿qué parámetros recibe? 00:16:00
¿Qué necesita este trozo de código para poder funcionar? 00:16:02
Para calcular el área y el perímetro, estamos hablando de rectángulos 00:16:07
Pues entonces 00:16:11
Vale, ahí, espera, yo no sé si está grabando o no 00:16:12
Ahora tengo un problema 00:16:18
Aquí pone pausar grabación 00:16:19
Pongo que está grabando 00:16:23
Esa es la bonita directa 00:16:25
¿Lo pone para algún lado que está grabando? 00:16:27
Espero que sí 00:16:30
Sí, lo pone aquí, rec, vale, muy bien 00:16:31
Entonces, para calcular el perímetro de un rectángulo 00:16:36
Estamos trabajando en un rectángulo, ¿vale? 00:16:43
Aquí a lo mejor habría sido interesante poner de rectángulo o algo por el estilo 00:16:44
¿Para qué? Porque de un triángulo no sería esto, ¿vale? 00:16:48
De un triángulo no necesito lado y lado, necesito otras cosas, base, altura o lo que sea 00:16:51
¿Vale? Pero aquí estamos hablando de rectángulos, ¿vale? 00:16:56
Por lo tanto, ¿qué necesito para calcular el área de un rectángulo y el perímetro de un rectángulo? 00:16:59
Pues los lados, por lo tanto tengo estos dos parámetros 00:17:04
Tengo el parámetro 00:17:07
Lado 1 y lado 2 00:17:08
¿Vale? 00:17:10
Que son los dos lados distintos de un retangón 00:17:11
Si fuera la área de un cuadrado 00:17:13
El perímetro de un cuadrado 00:17:15
Necesitaría un solo 00:17:19
Entonces lado 2 no lo pondría 00:17:20
Pondría lado, int lado 00:17:23
Es más, si yo quiero que sea un double 00:17:24
Pues pondría double lado 1 00:17:26
Double lado 2 00:17:28
Es más, si yo quiero saber también 00:17:29
el color, pues pondría ahí 00:17:32
int lado 1, int lado 2 00:17:35
string color 00:17:37
¿vale? lo que necesite 00:17:38
para poder trabajar 00:17:40
¿vale? entonces pienso en 00:17:43
que va a hacer este procedimiento 00:17:45
calcular el perímetro, vale, que necesito 00:17:47
necesito lado y lado 00:17:49
¿vale? ¿cuánto vale la de 1 y la de 2? 00:17:51
ni idea 00:17:54
¿vale? 00:17:55
ahora mismo, en fase 00:17:57
de creación de este 00:17:59
Procedimiento, no tengo 00:18:00
Idea de cuánto valga el lado 1 00:18:03
Y cuánto valga el lado 2 00:18:05
Son parámetros, son genéricos 00:18:06
¿Vale? 00:18:10
Yo ahora aquí dentro 00:18:10
Los voy a utilizar como parámetros 00:18:12
Como variables 00:18:15
En el momento en que alguien 00:18:16
Me llame, me dirá 00:18:19
Cuánto vale el lado 1 00:18:21
Y cuánto vale el lado 2 00:18:22
¿Sí? ¿Me seguís? 00:18:24
O sea, la clave de esto 00:18:29
es que estoy abstraendo 00:18:30
¿cuánto vale el lado 1? no lo sé 00:18:32
vale el lado 1, cada vez que tengo 00:18:34
que utilizar el lado 1, utilizaré el lado 1 00:18:36
esta será una 00:18:38
variable, una variable que existe dentro 00:18:40
de mi método, dentro de mi función 00:18:42
dentro de mi procedimiento 00:18:44
¿vale? y que 00:18:45
ahora mismo no vale nada 00:18:48
en un futuro cuando 00:18:50
alguien use este procedimiento 00:18:52
me tendrá que decir 00:18:54
cuánto vale el lado 1 y cuánto vale el lado 2 00:18:56
y entonces yo aplicaré 00:18:58
lo que viene aquí dentro 00:19:00
utilizando los valores 00:19:01
que me has dado tú en ese momento 00:19:03
¿vale? que si os acordáis 00:19:06
son estos 00:19:08
cuando yo llamo 00:19:09
calcular el perímetro de 3,4 00:19:12
este 3 00:19:14
se asocia al lado 1 00:19:16
y este 4 00:19:18
se asocia al lado 2 00:19:20
entonces cuando 00:19:21
aquí dentro encontraré el lado 1 00:19:24
para mí es 3 00:19:26
Y cuando encuentro el lado 2, para mí es 4 00:19:27
Cuando después se vuelva a llamar esto con 5 y 10 00:19:30
Vuelvo a hacer lo mismo, pero esta vez el lado 1 me vale 5 00:19:35
Y el lado 2 me vale 10 00:19:39
Por lo tanto, cuando hago esta operación de aquí, haré 5 multiplicado 10 00:19:41
Estos se llaman parámetros formales 00:19:45
Y estos son los parámetros actuales 00:19:53
Estos parámetros formales son como la forma. No es un parámetro concreto, sino es la idea de ese parámetro. Lo vas a utilizar sin saber su valor actual, su valor real. 00:19:57
En el momento en que se hace una llamada a este método de aquí o a este procedimiento, pues se tiene que instanciar los parámetros formales con valores actuales. 00:20:12
En esta ejecución, el valor actual del parámetro lado 1 es 3 00:20:24
Y el valor actual del parámetro lado 2 es 4 00:20:33
¿Se entiende? 00:20:37
¿Dudas? 00:20:40
¿Y qué hago aquí dentro? 00:20:43
Pues me creo int área de rectángulo es igual a lado 1 por lado 2 00:20:44
Int perímetro es lado 1 por 2 más lado 2 por 2 00:20:48
Y luego escribo el rectángulo de lado 00:20:51
Lado 1 y lado 2 00:20:54
Esto es el código que tenía antes 00:20:56
¿Vale? 00:20:59
El código que se repetía muchas veces 00:21:00
Pues lo he copiado aquí 00:21:02
Entonces cada vez que llamo 00:21:03
Esta cosa de aquí 00:21:06
Me ejecutará estas tres 00:21:07
Funciones 00:21:09
Estas tres 00:21:12
Instrucciones 00:21:13
Cada vez con un parámetro distinto 00:21:15
Un parámetro distinto 00:21:18
dudas habría podido hacer esto un poquito distinto es decir vale el 00:21:20
resultado de esto aquí o sea este string de aquí lo es que aquí hay un string que 00:21:29
dice el rectángulo de lado bla bla bla bla bla bla en vez de escribirlo tú 00:21:34
directamente devuélveme lo entonces esto no habría sido una para un 00:21:38
procedimiento habría sido una función y esto no habría escrito nada habría 00:21:45
Calculado esta string de aquí 00:21:51
Y luego la habría devuelta 00:21:54
Aquí al 00:21:55
Al main 00:21:57
Que habría podido guardarla dentro de una string 00:21:59
Por ejemplo, habría podido escribirla 00:22:02
Él, no lo sé 00:22:04
Habría utilizado esa cosa 00:22:05
¿Vale? Pero no 00:22:07
He querido que haga todo 00:22:09
Este procedimiento 00:22:11
Entonces, ¿cómo funciona? 00:22:13
El main empieza, hace una llamada 00:22:14
¿Vale? Hace una llamada 00:22:17
Y aquí está el concepto de estructura de control 00:22:19
Quiere decir que no sigo aquí debajo 00:22:21
Sino que salto aquí 00:22:23
Ejecuto estas tres líneas de código 00:22:26
Luego vuelvo aquí 00:22:31
Hay otra llamada 00:22:33
Entonces vuelvo aquí 00:22:36
Ejecuto estas tres líneas de código 00:22:37
Pero esta vez con parámetros distintos 00:22:39
Vuelvo aquí 00:22:41
Otra llamada 00:22:42
Vuelvo aquí, ejecuto estas tres 00:22:45
Y vuelvo aquí, y acabo 00:22:47
¿Dudas? 00:22:49
¿Preguntas hasta aquí? 00:22:53
Vale, sigamos adelante 00:22:58
Procedimiento, ¿vale? 00:22:59
Un procedimiento es un conjunto de instrucciones que cumplen una determinada tarea 00:23:01
¿Vale? 00:23:04
Entonces aquí la tarea ¿Cuál era? 00:23:05
Era calcular área y perímetro 00:23:07
¿Vale? 00:23:10
Habría podido dividirlo 00:23:10
Crear un método, una función o un procedimiento para crear el área 00:23:11
y uno para calcular el perímetro 00:23:19
y luego juntarlos de alguna forma 00:23:22
eso depende a mi, yo tengo una tarea 00:23:23
pues voy a crear toda 00:23:25
voy a asociar 00:23:27
todas las instrucciones necesarias 00:23:29
para hacer esa determinada tarea a un nombre 00:23:31
vale 00:23:33
entonces luego cuando 00:23:34
quiero hacer esa tarea 00:23:37
pues simplemente llamo ese nombre 00:23:39
con los parámetros que necesita para hacer 00:23:41
esa tarea, si necesita tres parámetros 00:23:43
ponde tres parámetros y si necesita cien 00:23:45
parámetros pone cien parámetros 00:23:47
Si necesita 100 parámetros, probablemente le daré un array 00:23:48
¿Vale? Lo que haga falta 00:23:52
Esta tarea puede depender de algunos valores, ¿vale? 00:23:54
Llamados parámetros o no 00:23:58
Como por ejemplo, calcula área de lado 1 y lado 2 00:23:59
Saluda de esta cosa ahí o saluda nombre, ¿vale? 00:24:02
Estos son llamadas a métodos, ¿vale? 00:24:05
Calcula área, calculará una área 00:24:08
Entonces necesita dos lados, por ejemplo 00:24:10
Aquí hay otro método que no sé qué hace 00:24:12
Saludará, dirá hola, ¿vale? 00:24:15
Que si yo lo llamo saluda sin parámetros 00:24:16
Como no sabe a quien tiene que ir a saludar 00:24:20
Dirá hola 00:24:23
¿Vale? 00:24:24
Si en vez de llamo saluda y le paso un parámetro 00:24:25
Que es nombre, ¿qué es nombre? 00:24:29
Será una variable, una variable de tipo string por ejemplo 00:24:32
Donde dentro he puesto el nombre mío, Estefano 00:24:35
Pues ahora me dirá hola, Estefano 00:24:37
¿Sí? 00:24:40
Entonces este es el mismo método, entre comillas 00:24:42
Son dos métodos distintos 00:24:44
Son dos funciones distintas 00:24:45
O procedimientos distintos 00:24:48
Que hacen lo mismo 00:24:49
Hacen la misma tarea 00:24:51
Hacen la tarea de saludar 00:24:53
Pero saluda sin parámetros 00:24:54
Saluda genéricamente 00:24:56
Hola usuario 00:24:57
Y si en vez tú le has pasado 00:24:58
Como se llama el usuario 00:25:01
Pues te dirá hola y es tu nombre 00:25:02
¿Se entiende? 00:25:04
¿Dudas? 00:25:06
¿Cómo se declara? 00:25:10
Pues lo hemos visto 00:25:12
Public static void 00:25:13
Porque estamos hablando de procedimientos 00:25:15
Entonces el procedimiento es void 00:25:17
El nombre del procedimiento 00:25:18
Y luego tipo 1, parámetro 1 00:25:20
Tipo 2, parámetros 2 00:25:23
Tipo 3, parámetros 3 00:25:25
Cuidado, puede no tener ninguno 00:25:26
Si yo hago un procedimiento que no necesita parámetros 00:25:27
Pues no le pongo nada 00:25:32
Abro paréntesis, cero paréntesis 00:25:33
¿Dudas? 00:25:35
¿Cómo se llama un procedimiento? 00:25:39
Pues con el nombre 00:25:41
Y luego una secuencia de valores 00:25:42
Que se corresponderán con los parámetros que tengo aquí 00:25:45
Si aquí tengo int, double, boolean 00:25:48
Lo llamaré con un intero, coma, un booleano 00:25:52
No, ¿qué era el segundo? Un double 00:25:57
Segundo un double y tercero un booleano 00:25:58
¿Sí? 00:26:01
Tiene que ir en el mismo orden 00:26:02
Si yo le he dicho int, int, boolean 00:26:04
No puedo luego poner un booleano, un entero, un entero 00:26:07
¿Vale? Porque se lía 00:26:10
El primero tiene que ser el que me has dicho 00:26:12
El segundo es el que me has dicho 00:26:14
El tercero es el que me has dicho 00:26:16
¿Vale? Para entendernos 00:26:17
Yo aquí me espero dos int 00:26:18
Si tú me llamas calcular el perímetro 00:26:21
Con un int solo 00:26:24
No va a funcionar 00:26:25
Dice, me falta uno 00:26:26
Si tú le das un boolean 00:26:28
No te va a funcionar 00:26:30
Dice, yo necesito un int 00:26:32
¿Dudas? 00:26:33
Creo que ahora vienen 00:26:39
Aquí 00:26:40
¿Ejemplos? 00:26:42
Minúscula sería en... 00:26:43
El nombre 00:26:44
El nombre siempre empieza en la barra minúscula 00:26:47
Se diferencian de las variables 00:26:51
Los dos se ponen con minúscula 00:26:53
Pero un método acaba con paréntesis 00:26:55
Dentro de la variable no 00:26:57
¿Vale? 00:26:58
Ejemplo 00:27:02
¿Vale? 00:27:03
Aquí tengo mis dos métodos 00:27:05
El método saluda 00:27:07
Bueno, estos son procedimientos 00:27:08
¿Vale? 00:27:11
El método saluda que es un método 00:27:13
Que no devuelve nada y dice hola a todos 00:27:15
¿Por qué? Porque es genérico, no me pasa nada 00:27:17
Si en vez de yo pongo saluda con un parámetro string nombre 00:27:20
Lo que hace es hola y luego le pega detrás el nombre que tú me has dado 00:27:24
Estas son las definiciones de los métodos 00:27:29
¿Cómo se usan? 00:27:33
Pues por ejemplo yo puedo llamar saluda 00:27:35
Entonces saluda me llamaría este método de aquí 00:27:37
El sin parámetros porque no le he puesto ningún parámetros 00:27:40
Y me escribiría hola a todos 00:27:43
Luego llamo saluda 00:27:45
Estefano 00:27:47
Y lo que me hace, me llama este de aquí 00:27:48
Porque le he pasado un string 00:27:51
Entonces me pondría hola, espacio, Estefano 00:27:52
Y luego, fijaos aquí 00:27:55
Yo creo una variable string 00:27:57
Que tenga dentro Paco 00:27:58
Y luego llamo saluda de n 00:28:00
Como este n es un string 00:28:02
Pues me llama este de aquí 00:28:04
¿Vale? 00:28:05
Asociaría nombre 00:28:08
El parámetro formal nombre 00:28:09
Con el valor actual n 00:28:11
Que en verdad es una variable 00:28:13
Que tiene dentro pago 00:28:15
Por lo tanto ahora nombre vale pago 00:28:16
Justo 00:28:18
Y me diría hola pago 00:28:20
¿Dudas? 00:28:22
Más ejemplos 00:28:28
Por ejemplo, y aquí tengo un repite saludo 00:28:30
Que pilla dos parámetros 00:28:34
Un nombre 00:28:36
Y cuántas repeticiones 00:28:37
¿Vale? 00:28:39
Entonces me dice, desde igual a cero 00:28:41
Y menor de repeticiones y más más 00:28:43
O sea, por repeticiones veces 00:28:45
Lo que haces es decir hola el nombre 00:28:48
Entonces este de aquí es un método solo 00:28:52
Que cuando lo llamo con Luis 00:28:54
Pues me dirá hola Luis, hola Luis, hola Luis, hola Luis 00:28:55
Tantas veces cuanto lo he puesto aquí 00:28:58
Por ejemplo 4 00:29:00
Fijaos que necesita un string y un int 00:29:01
Pues yo cuando lo llamo string e int 00:29:06
¿Podría ser esta una variable tipo string? 00:29:09
Sí 00:29:12
¿Podría ser esta una variable tipo int? 00:29:12
Sí 00:29:15
¿Podría ser esto de aquí el resultado de una operación? 00:29:15
Sí 00:29:18
¿Con qué sea un int el resultado de la operación? 00:29:19
Sí 00:29:21
¿Podría ser esto una posición de un array de string? 00:29:21
Sí 00:29:26
Todo lo que tenga tipo string puede ir aquí 00:29:26
Y todo lo que tenga tipo int puede ir aquí 00:29:29
Y se utilizará aquí con su valor y su valor 00:29:33
¿Dudas? 00:29:36
¿Preguntas? 00:29:39
Se puede usar también para ordenar el código 00:29:46
Hacerlo más leíble, ¿vale? 00:29:48
Lo que decíamos antes 00:29:49
Vale, aquí se me han colado dos puntos 00:29:50
Pero 00:29:53
Imaginamos que yo tengo un main 00:29:53
En vez de tener todo el código allí 00:29:56
Metido 00:29:58
Pues tengo un método 00:30:00
Inicializa el sistema 00:30:01
Calcula datos 00:30:02
Escribe resultados 00:30:03
Esto ya sé 00:30:04
Que mi main hará tres pasos 00:30:05
Iniciará el sistema con lo que tiene que inicializar 00:30:08
Luego después 00:30:11
Calculará los datos 00:30:12
Y hará las operaciones que tiene que hacer 00:30:14
Y al final 00:30:16
Los resultados me los escribirá de alguna forma 00:30:16
¿Cómo se hacen estas tres cosas? 00:30:19
Pues estarán aquí, aquí y aquí 00:30:21
No lo sé, aquí le he metido comentarios 00:30:24
Lo tengo que implementar 00:30:26
¿Por qué esto es interesante? 00:30:28
Primero porque si a mí no me interesa cómo se hacen las cosas 00:30:31
Sino lo que se está haciendo, me leo solo esto 00:30:35
Aquí está escrito lo que se está haciendo 00:30:38
¿Cómo se hace? 00:30:41
No me importa 00:30:42
Otra cosa 00:30:43
En términos de trabajo 00:30:45
Yo podría 00:30:47
Pillar distintos 00:30:49
Grupos de trabajo, distintos 00:30:51
Empleados y decirle, mira, oye, tú 00:30:53
Te encargas de la inicialización de sistemas 00:30:55
Rellena este método 00:30:58
De aquí 00:30:59
Otro grupo, este método de aquí 00:31:00
Otro grupo, este método de aquí 00:31:03
Os voy a dar las 00:31:04
Especificaciones de cómo 00:31:06
Qué tiene que hacer cada uno de estos 00:31:09
¿Vale? 00:31:12
Inicialización de sistemas tiene que 00:31:13
Inicializar un array 00:31:14
meter los nombres de los 00:31:16
clientes, hacer no sé qué 00:31:18
cuánto, vale, calcular datos 00:31:20
¿qué tiene que hacer? se espera que un array 00:31:22
ya esté inicializado, porque 00:31:24
aquí es donde se inicializa 00:31:26
y lo que hace es pillar los nombres 00:31:27
de los clientes, añadirle 00:31:30
un código, no sé qué, no sé cuánto 00:31:32
¿y qué tiene que hacer este aquí? pues se espera 00:31:34
que el proceso 00:31:36
ya haya acabado, ya esté 00:31:38
el resultado final y tiene que imprimir 00:31:40
los resultados, vale, y en un cierto 00:31:42
sentido puedo separar el trabajo entre ellos 00:31:44
dudas 00:31:46
fijaos que son todos 00:31:50
void, son todos proceeding 00:31:52
vale, entonces 00:31:53
la idea 00:31:56
es, por un lado 00:31:58
ordenar el código y hacerlo más leíble 00:32:00
y ser más fácil, por otro lado 00:32:02
generalizar 00:32:04
los trabajos, vale 00:32:05
en vez de hacer mil veces lo mismo 00:32:08
pues generalizo 00:32:10
la operación que estoy haciendo 00:32:12
Y pongo un método que me generaliza 00:32:14
Esa operación 00:32:17
Y luego llamo ese método todas las veces que quiero 00:32:18
Parametrizado 00:32:20
¿Dudas? 00:32:23
¿Entonces qué es una función? 00:32:29
Pues lo mismo 00:32:30
Pero os repito que la función 00:32:31
Al final de todo 00:32:33
Ha calculado algo 00:32:35
Ha calculado un entero, ha calculado un double 00:32:37
Ha calculado un objeto, ha calculado algo 00:32:39
Y esa cosa 00:32:42
Me la devuelve a mí 00:32:44
¿A quién? ¿A quién la he llamado? 00:32:45
Si lo habéis entendido, aquí hay dos cosas 00:32:48
Hay por un lado donde se declara el método, la función o el procedimiento 00:32:51
Y por otro lado donde se llama ese método, función o procedimiento 00:32:56
Esto es una llamada a un procedimiento 00:33:02
Esta es la definición de procedimiento 00:33:05
Entonces la idea es que como es un procedimiento, como es void 00:33:07
No me espero que me devuelva nada 00:33:12
Entonces lo llamo y ya está 00:33:14
Si me esperara que esto calcula algo 00:33:16
Y luego me devuelve a mí que lo estoy llamando 00:33:19
Un valor, pues entonces este valor tendría que hacer algo con él 00:33:22
Guardarlo en una variable, utilizarlo en un if 00:33:26
Ponerlo dentro de un array, no lo sé 00:33:29
¿Vale? Pero algo tendría que hacer con él 00:33:34
Si no, calculo el valor del área 00:33:36
Y luego este valor calculado, pues lo pierdo 00:33:40
Si no lo guardo por algún lado para utilizarlo 00:33:43
Pues lo pierdo, o lo imprimo directamente en pantalla 00:33:45
¿Vale? Fenomenal 00:33:47
O si no lo pierdo, ¿vale? 00:33:48
Entonces, vamos a ver ejemplos 00:33:51
Por ejemplo, estas son llamadas 00:33:53
De funciones, ¿vale? 00:33:57
Intarea es igual a 00:34:00
Calcular área del lado 1 al lado 2 00:34:01
Me espero que calcular área sea una función 00:34:03
Pille el lado 1, pille el lado 2 00:34:05
Haga los cálculos y el resultado 00:34:07
De esto que es el área 00:34:09
Me lo guardo en intarea 00:34:11
A este punto puedo hacer un system.auto.println 00:34:12
El área del cuadrado 00:34:16
El área del rectángulo es 00:34:18
Área, porque lo tengo allí 00:34:19
¿Vale? 00:34:21
O crea saludo de un nombre 00:34:22
Entonces, antes me escribía directamente 00:34:25
Hola en pantalla, pues ahora no 00:34:27
Ahora me crea un string con escrito dentro 00:34:29
Hola y el nombre, hola Stefano 00:34:31
Y este string me lo devuelve 00:34:33
A mí que lo he llamado 00:34:36
Y yo me lo guardo en una variable tipo string 00:34:37
Y luego lo uso 00:34:40
Como se declara 00:34:44
Una función 00:34:51
Exactamente igual que antes un procedimiento 00:34:53
La única cosa que cambia 00:34:56
Es que el tipo devuelto ahora no es void 00:34:57
Pero es el tipo de lo que me espero que me devuelva 00:35:00
Es un cálculo que al final 00:35:02
Devuelve un int 00:35:04
Pues aquí pondré int 00:35:05
Quiero al final me da un double 00:35:06
Pues aquí pondré double 00:35:09
Da un boolean, boolean, da un string, string 00:35:10
Y el resto es igual, el nombre y los tipos de parámetros que necesita para trabajar 00:35:12
¿Cómo se llama? 00:35:17
Pues se llama igual, nombre con tipo valor, valor, valor, igual al otro 00:35:21
Solo que normalmente el resultado se guarda en una variable para utilizarlo 00:35:27
Si la variable es nueva, la declaro, int x es igual a lo que de esto 00:35:31
Y si en vez lo había ya creado antes 00:35:38
Pues puedo hacer x igual 00:35:40
Lo que sea 00:35:42
¿Sí? 00:35:43
O lo puedo usar directamente 00:35:45
¿Sí? 00:35:47
Ahora le damos ejemplo 00:35:48
Por ejemplo aquí 00:35:49
¿Vale? 00:35:53
Fijaos 00:35:54
Ahora ha cambiado saluda 00:35:55
Ahora ya no es un procedimiento 00:35:56
Es una función porque aquí tiene string 00:35:58
Me espero que al final 00:36:00
Me devuelva un string 00:36:03
¿Vale? 00:36:05
Entonces ¿Cómo lo hago? 00:36:07
Por ejemplo esto de aquí 00:36:08
saluda, pilla como parámetros un nombre 00:36:09
fijaos que ahora no lo escribe 00:36:11
lo que crea es 00:36:13
hola más nombre 00:36:15
crea este string 00:36:17
lo guarda dentro de la variable 00:36:18
resultado que es de tipo 00:36:21
string 00:36:23
y luego palabra reservada 00:36:24
return resultado 00:36:27
esto es el concepto de 00:36:29
devuelve resultado 00:36:31
lo que hace esta función 00:36:33
es pillar estos parámetros 00:36:35
Construirme un string 00:36:38
Y este string me lo devuelve 00:36:39
Si yo no pongo esta cosa de aquí 00:36:41
Y he puesto 00:36:44
String aquí, me da un error 00:36:45
Me dice, oye mira 00:36:48
Tú has dicho que devuelve un string 00:36:49
Pero no has hecho return de nada 00:36:51
¿Vale? 00:36:52
¿Y cómo lo uso? 00:36:56
Por ejemplo, string saludo1 00:36:57
Es igual a saludaStéfano 00:36:59
¿Vale? 00:37:01
Fijaos que el resultado de esta cosa de aquí 00:37:03
Me lo guardo en saludo1 00:37:05
O tengo una string Paco 00:37:07
Tengo otro string que es saludo2 00:37:11
Que es igual a saluda de esta variable de aquí 00:37:14
Entonces, ¿cuánto vale saluda1? 00:37:17
Hola, Estefano 00:37:24
¿Y cuánto vale saluda2? 00:37:25
Hola, Paco 00:37:28
Y luego los imprimo en pantalla 00:37:29
¿Sí? 00:37:31
Diferencia de antes 00:37:35
Es que antes, cuando hacía saluda a Estefano 00:37:36
Como procedimiento, no lo puedo guardar en una variable 00:37:38
Y ahora sí, porque el resultado de este de aquí es que me devuelve a mí un valor que es un string 00:37:41
¿Cómo lo sé? De esto 00:37:48
¿Podría hacer int saludo1 igual a saludo a Estefano? 00:37:50
No, porque el resultado de esta operación no es un int 00:37:57
Es un string, entonces no lo puedo guardar en una variable int 00:38:01
¿Verdad? 00:38:05
¿Dudas? 00:38:10
Más ejemplos 00:38:14
¿Qué es esta cosa aquí? 00:38:16
Es una función que se llama repiteSaludo 00:38:29
Pilla como parámetros un nombre y repeticiones 00:38:32
Y devuelve una string 00:38:37
¿Vale? 00:38:39
¿Qué hace dentro? 00:38:41
Crea un string vacío 00:38:42
Por repeticiones veces 00:38:44
Lo que hace es concatenar al resultado 00:38:47
Hola y un nombre más un espacio 00:38:50
¿Vale? 00:38:54
Y lo guarda otra vez en resultado 00:38:55
Entonces irá pegando 00:38:58
Hola y el nombre que me has pasado 00:39:00
Espacio, hola y el nombre que me has pegado 00:39:03
Espacio, hola y el nombre que me has pasado 00:39:04
Etcétera, etcétera, etcétera 00:39:06
Un cierto número de repeticiones veces 00:39:07
¿Sí? 00:39:10
Entonces, ¿cómo se llama esto? 00:39:13
Por ejemplo, digo string saludos 00:39:15
Es igual, repite saludos de Luis,4 00:39:17
Entonces, ¿qué hace esto? 00:39:22
Pues repite cuatro veces 00:39:24
Hola Luis 00:39:26
Es fácil 00:39:28
Lo concatena todo 00:39:28
Y no lo escribe en pantalla 00:39:31
Me da esa cadena 00:39:33
¿Vale? 00:39:35
Y esa cadena yo la guardo 00:39:36
En esta variable de aquí 00:39:38
Y ahora puedo utilizar esa variable de aquí 00:39:39
Como me da la gana 00:39:41
Como por ejemplo 00:39:42
Imprimirla en pantalla 00:39:43
Duda para vosotros 00:39:44
Entonces eso quiere decir 00:39:48
Que una función no puede imprimir en pantalla 00:39:49
Puede, tranquilamente 00:39:52
La diferencia es que al final me tiene que devolver algo 00:39:56
Me puede hasta devolver una cadera vacía 00:39:59
Pero me tiene que devolver un string 00:40:03
¿Por qué? Porque lo dice aquí 00:40:04
Está claro que si hace mil cosas 00:40:06
Y luego me devuelve algo inútil 00:40:10
Entonces no es una función 00:40:11
Es un procedimiento 00:40:13
Entonces aquí le pongo void y ya está 00:40:15
¿Sí o no? 00:40:17
Fijaos también que después de haberlo creado la string 00:40:20
Me lo devuelve 00:40:23
¿Vale? Necesito un return 00:40:24
Si aquí no he puesto void 00:40:28
Necesito un return 00:40:30
Porque es lo que me devuelve 00:40:31
Al final de todo el procedimiento 00:40:33
Haga lo que haga 00:40:35
Por aquí, por allá 00:40:36
Cambia cosas, escribe cosas 00:40:37
Haga lo que sea 00:40:39
Pero al final me tiene que hacer 00:40:40
Un resultado de esta función 00:40:42
Y me lo tiene que dar 00:40:47
Y el resultado tiene que coincidir en tipo 00:40:48
Con lo que he puesto aquí 00:40:51
Si tiene que devolver un string 00:40:52
Tiene que devolver un string 00:40:55
¿Dudas? 00:40:56
No, ¿esto qué es? 00:41:02
Un ejercicio 00:41:05
Otro ejemplo 00:41:06
¿Vale? 00:41:08
Entonces, por ejemplo, aquí tenemos 00:41:10
Un ejercicio 00:41:12
¿Qué dice? 00:41:14
Scanner es, es igual a un scanner 00:41:16
¿Vale? Este aquí le he detectado 00:41:18
Int lado 1 00:41:20
Es leginum 00:41:22
¿Vale? 00:41:25
esto es italiano, leenum 00:41:26
vale, de 00:41:28
darme el primer número de rectángulo 00:41:29
coma s 00:41:32
o sea, estoy llamando un método 00:41:33
¿qué es esto? ¿una función? 00:41:36
¿o un procedimiento? 00:41:38
una función, porque veis que 00:41:40
el resultado lo estoy 00:41:44
guardando dentro del lado 1 00:41:46
vale, entonces me espero que esto me devuelva 00:41:47
algo, ¿y qué parámetros 00:41:50
le estoy pasando? 00:41:52
un string 00:41:54
Y un escáner 00:41:55
¿Vale? 00:41:58
Un escáner que será este escáner de aquí 00:42:00
¿Vale? Vamos a ver que hace este legendum 00:42:01
Pues está aquí 00:42:04
Me devuelve un entero 00:42:06
Entonces me espero que al final 00:42:08
Haya un return de algo que sea un int 00:42:10
¿Cómo se llama? 00:42:12
Legendum 00:42:15
¿Qué parámetros tienes? 00:42:15
Un string que llamaré mensaje 00:42:18
Y un escáner que llamaré teclado 00:42:20
¿Vale? 00:42:23
Aquí dentro 00:42:24
Si uso teclado 00:42:25
Estoy usando este escáner 00:42:27
Y si uso MSG 00:42:29
Estoy utilizando este stringer 00:42:30
¿Qué son este stringer y este escáner? 00:42:32
No lo sé 00:42:34
Lo sabré a la hora en que tú me llames aquí 00:42:34
Entonces sabré que el mensaje es este de aquí 00:42:38
Y el escáner será este de aquí 00:42:42
¿Vale? 00:42:44
Pero no lo sé en este momento 00:42:44
Abstractamente pienso solo en MSG y teclado 00:42:47
Sí que puedo hipotizar que MSG será un mensaje 00:42:50
Por lo tanto un stringer 00:42:53
Por lo tanto lo puedo utilizar como string 00:42:54
Y que teclado será un escáner 00:42:56
Por lo tanto lo puedo utilizar como un escáner 00:42:58
¿Vale? 00:43:00
Entonces ¿Qué hago? 00:43:01
Escribo el mensaje en pantalla 00:43:03
Luego hago teclado.nextint 00:43:05
El resultado de este teclado.nextint 00:43:09
Que es como cuando nosotros hacemos can.nextint 00:43:13
Lo guardo en un entero 00:43:15
En una variable entero 00:43:18
Y esta variable aquí que es numleído 00:43:19
Es la que devuelvo 00:43:22
Sustancialmente 00:43:23
Las operaciones estas que nosotros 00:43:26
Hacíamos siempre de pido al usuario 00:43:28
Dame un número y luego después lo leo 00:43:30
Pues lo he pegado y compactado 00:43:32
En una única 00:43:34
Función 00:43:35
Que se llama leginum 00:43:37
Entonces cuando llamo leginum 00:43:38
Le pongo aquí 00:43:41
Lo que quiero pedir 00:43:42
Y donde lo voy a leer 00:43:44
Lo voy a leer desde el teclado 00:43:46
Y ya está 00:43:48
Si o no 00:43:49
Entonces, este leggiNum 00:43:53
Dame el primer número, me le dará un primer número 00:43:56
LeggiNum, dame el otro lado del rectángulo 00:43:58
Me le dará el segundo num 00:44:00
A este punto, en intarea 00:44:02
Voy a poner 00:44:04
Calcularea 00:44:06
¿Qué es calcularia? 00:44:08
Función o procedimiento 00:44:13
Función 00:44:14
¿Por qué? 00:44:17
Porque luego algo lo pongo dentro de área 00:44:19
¿Vale? Por lo tanto, probablemente 00:44:21
Tiene que ser una función 00:44:23
¿Vale? 00:44:24
¿Qué pilla como parámetros? 00:44:26
Un int y otro int 00:44:34
¿Vale? Lo veo aquí, int e int 00:44:35
¿Vale? Vamos a verlo 00:44:37
Entonces aquí tengo calcular 00:44:38
Que me pilla un int al lado uno 00:44:40
Y un int al lado dos 00:44:43
Cuidado que este nombre de aquí 00:44:44
No tiene que ser el mismo de esto de aquí 00:44:46
Pueden ser distintos 00:44:48
¿Vale? O iguales, da igual 00:44:50
Fijaos antes que yo uso S 00:44:52
Pero luego aquí dentro lo llamo teclado 00:44:55
¿Sí? 00:44:57
Pueden ser distintos, son variables 00:44:59
Calcula área, lado 1 y lado 2 00:45:01
Que son dos int, lado 1 y lado 2 00:45:05
Y que hace, returna lado 1 por lado 2 00:45:07
¿Es correcto esto? 00:45:10
Esta es una expresión 00:45:15
Lado 1 por lado 2 00:45:16
Lado 1 es un entero, lado 2 es un entero 00:45:17
Entero por entero, ¿qué me devuelve? 00:45:20
Un entero 00:45:22
Y tengo que devolver un entero 00:45:23
Pues perfecto 00:45:25
entonces devuelvo el resultado de esta operación 00:45:26
y el resultado de esta operación se guardará 00:45:29
en área 00:45:33
y ahora tengo 00:45:34
pinta bonito 00:45:37
que no es un animal 00:45:38
lado 1, lado 2, área 00:45:40
¿qué es esto? 00:45:43
es un procedimiento 00:45:50
me espero que sea un procedimiento 00:45:52
no estoy guardando nada de esto 00:45:54
Entonces probablemente es un procedimiento 00:45:57
Puede ser una función 00:45:59
Voy a mirarlo 00:46:00
Voy a mirar aquí 00:46:02
Pinta bonito 00:46:04
Pinta bonito 00:46:05
Efectivamente es void 00:46:08
Por lo tanto es un procedimiento 00:46:09
Que recibe un entero, otro entero 00:46:12
Y otro entero 00:46:15
Int B y R 00:46:15
Que si os fijáis 00:46:18
Se corresponderán con 00:46:20
Donde está pinta bonito 00:46:22
Con el lado, lado y el área 00:46:23
Y escribe 00:46:26
En un marco 00:46:28
Magnífico y muy bonito 00:46:32
¿Vale? 00:46:34
El rectángulo de lados 00:46:35
Y B 00:46:38
Lo que tú me has pasado 00:46:41
Tiene área R 00:46:43
¿Si o no? 00:46:45
Y el resultado es esta cosa aquí 00:46:50
Esta es la primera función 00:46:52
¿Vale? 00:46:58
Dame el primer lado y luego leo un número 00:47:00
Llamo otra vez la misma función 00:47:03
Pero con un mensaje distinto 00:47:05
Y dice, dame el otro lado del rectángulo 00:47:07
Y leo, hago la operación 00:47:09
No se ve nada porque no imprime nada 00:47:11
Y luego llamo pinta bonito 00:47:13
Me hace estos dos bonitos marcos 00:47:14
Y escribe el rectángulo de lado 00:47:17
4 y 6 00:47:19
Tiene área 24 00:47:21
Ahora 00:47:22
En vez de todo este código 00:47:26
En el main 00:47:28
Tengo un main 00:47:30
Mucho más 00:47:31
Leíble 00:47:33
Más escueto 00:47:35
Más sencillo 00:47:37
¿Vale? 00:47:38
Donde además entiendo lo que estoy haciendo 00:47:39
Creo un escáner, leo un número 00:47:42
Leo un número 00:47:44
Si esto fuera español 00:47:45
No entendería mejor 00:47:47
Leo un número, leo otro número 00:47:48
Calculo el área y pinto bonito 00:47:50
El resultado 00:47:51
Entiendo lo que estoy haciendo 00:47:52
¿Sí o no? 00:47:54
¿Dudas? 00:47:58
¿Preguntas? 00:48:00
Esto ya hemos dicho, parámetros formales y parámetros actuales 00:48:01
Entonces aquí yo tengo dos tipos de parámetros 00:48:10
Los verditos son parámetros formales 00:48:12
Y los azulitos son parámetros actuales 00:48:16
¿Cuál es la diferencia? 00:48:20
Los parámetros formales son los que uso abstractamente 00:48:21
Dentro de los métodos, de las funciones, de los procedimientos 00:48:26
MSG, aquí digo, escribe MSG 00:48:31
¿Cuánto vale MSG? 00:48:34
No, me da igual 00:48:36
A mí me habrán dado un string 00:48:37
Pues ese string lo imprimes en pantalla 00:48:39
Sea cual sea 00:48:42
¿Vale? 00:48:43
Es formal porque no sé su valor 00:48:44
Pero lo uso porque sé su tipo 00:48:47
Entonces, si sé su tipo 00:48:50
Sé cómo lo puedo utilizar 00:48:51
¿Vale? 00:48:53
Si es un string 00:48:54
Puedo preguntar, por ejemplo 00:48:55
¿Cuánto es largo este string? 00:48:56
Con MSG.length 00:48:58
¿Sí? 00:49:00
Puedo acceder a uno de sus carácter 00:49:01
Haciendo msg.cherat de 0 00:49:06
Por ejemplo, lo puedo utilizar como cualquier string 00:49:11
¿Cuál es efectivamente ese string? No lo sé 00:49:13
No lo sabré nunca hasta el momento en que me llamen 00:49:16
¿Sí? 00:49:20
Entonces lo uso de forma abstracta aquí 00:49:23
O aquí, ¿vale? Estos son todos parámetros formales 00:49:25
En el momento de la llamada, se hace una asociación entre el parámetro formal y su valor actual, que es esto. 00:49:29
Cuando yo hago esta llamada aquí, la primera, asigno a MSG el valor, dame el primer lado del rectángulo. 00:49:41
Y a teclado, lo que hay adentro de la variable S, que es este objeto de aquí, Scanner. 00:49:50
Entonces, en esta ejecución, en esta llamada 00:49:59
MSG vale, dame el primer lado del rectángulo 00:50:05
Y Scanner vale este objeto de aquí 00:50:09
Y ahora los uso 00:50:11
Cuando vuelvo a llamarlo, fijaos que el parámetro actual ha cambiado 00:50:12
Ahora, siempre aquí se llama MSG 00:50:17
El parámetro formal no cambia 00:50:19
Pero ahora tiene asociado este valor y no el otro 00:50:21
¿Dudas? 00:50:25
Entonces 00:50:28
Estos 00:50:30
Cuando son dentro de una 00:50:32
De una declaración 00:50:35
De una función 00:50:37
Método, procedimiento 00:50:39
Lo que sea, se llaman formales 00:50:41
Cuando en vez son 00:50:43
En la llamada, lo que se pasan 00:50:45
Son parámetros actuales 00:50:47
Que son los que, cuyo valor 00:50:48
Se asocia a los parámetros 00:50:50
Formales del método que estoy llamando 00:50:53
¿Dudas? 00:50:55
Y aquí el caveat de turno, ¿vale? 00:51:03
Funciones y procedimientos son propiedad de programación estructurada. 00:51:05
En Java se suele hablar más bien de métodos. 00:51:08
Sin embargo, el concepto de método está vinculado a la programación orientada a objetos. 00:51:11
En particular, al concepto de clase de objeto, ¿vale? 00:51:15
Por lo tanto, lo que hemos visto ahora, como es Java y Java orientado a objetos, son métodos, ¿vale? 00:51:18
Pero nosotros lo hemos llamado función y procedimientos, ¿vale? 00:51:23
Pero la idea es parecida, ¿vale? 00:51:29
Varias veces lo hemos hablado. 00:51:32
También otro caveat es que 00:51:33
Nosotros utilizamos mucho el static 00:51:35
Y no entendemos que es el static 00:51:38
Porque no entendemos la diferencia entre clase y objeto 00:51:39
¿Vale? No la saben 00:51:42
Por lo tanto, este static 00:51:43
¿Por qué está allí? Ni idea 00:51:45
Vendrá un momento en que este static 00:51:47
Desaparecerá, ¿vale? 00:51:49
Y veremos por qué 00:51:51
Y se acabó 00:51:52
Idioma/s:
es
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
38
Fecha:
18 de noviembre de 2022 - 13:36
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
52′
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
201.74 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid