Saltar navegación

20241107Procedimientos y funciones - 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 7 de noviembre de 2024 por Stefano C.

22 visualizaciones

Más información Transcripción

Descargar la transcripción

voy a grabar esta clase por lo tanto si habláis o decís algo me autorizáis a grabar vuestra voz 00:00:02
vamos a empezar aquí nosotros hace tiempo en episodios anteriores habíamos empezado a ver 00:00:07
cómo podremos controlar el flujo de ejecución de un programa vale los primeros ejercicios cuando 00:00:15
éramos niños en septiembre os acordáis que hacíamos eran un paso tras otro de imprime 00:00:23
esto en pantalla, haz 3 más 7, ahora imprime 3 más 7 00:00:30
en pantalla, y era siempre así. Luego hemos crecido en el mundo del Java 00:00:34
y de la programación, y hemos empezado a ver cosas que pueden alterar 00:00:38
la secuencialidad de la ejecución de las instrucciones 00:00:43
es decir, el if, por ejemplo, que me dice, oye mira, este bloque 00:00:47
lo ejecutas si y solo si una condición es verdadera, si no 00:00:50
te lo saltas, y el while, que es decir, que cuando entras en un while, este 00:00:54
bloque lo puedes repetir una diez millón de veces no lo sabemos vale y el for 00:00:58
también que sirve para otros casos pero más o menos es parecido entonces todas 00:01:03
estas cosas alteran el normal flujo de programación que es secuencial una 00:01:08
instrucción traslado el último la última forma entre comillas para 00:01:14
alterar el flujo de información es la llamada 00:01:21
funciones o la llamada procedimientos 00:01:26
esto es 00:01:28
sustancialmente, y lo hemos hecho 00:01:32
un ejemplo el otro día 00:01:34
aquí en un ejercicio 00:01:36
saqué fuera 00:01:38
es pillar un trozo de código 00:01:39
sacarlo fuera 00:01:42
del main y llamarlo 00:01:44
de algún modo 00:01:46
es como una variable 00:01:47
en un cierto sentido 00:01:50
es dar un nombre a un trozo 00:01:52
de memoria para que yo cuando quiera acceder a ese trozo de memoria pueda usar ese nombre 00:01:54
crear un método o una función en un cierto sentido 00:01:58
es como dar un nombre a un bloque de texto, a una secuencia 00:02:02
de instrucciones y decir que cada vez que quiero hacer esa secuencia 00:02:06
de instrucciones, pues lo que hago es llamar ese nombre 00:02:10
entonces, una forma 00:02:14
sencilla de utilizar las funciones o procedimientos es 00:02:18
Pues imaginaos un código como este de aquí, donde yo voy a calcular lados, áreas de un rectángulo y perímetros de un rectángulo. 00:02:21
Entonces aquí voy a calcular el perímetro de un rectángulo que es 3 por 4, por lo tanto tengo este código. 00:02:33
El lado 1 vale 3, el lado 2 vale 4, el área del rectángulo es lado 1 por lado 2, el perímetro del rectángulo es lado 1 por 2 más lado 2 por 2. 00:02:42
Vale, fenomenal. Y escribo el rectángulo es este de aquí. 00:02:50
Ahora quiero cambiar de rectángulo y hacerlo otra vez 00:02:53
Pues tengo que pillar todo este código y volver a repetirlo 00:02:56
Cambiando que esta vez es 5 y 10 y luego hacer la suma 00:02:59
Ahora lo hago otra vez, pues con 2 y 7 y hago lo mismo 00:03:03
Imaginaos que por alguna razón del multiverso me haya equivocado 00:03:09
Y que esta fórmula aquí esté equivocada 00:03:13
Como esto lo he hecho tres veces 00:03:17
tendré que ir a buscar las veces que he hecho esta operación, modificarla en cada una 00:03:19
y poner la nueva fórmula, una fórmula más eficiente o lo que sea 00:03:25
esto suele ser feo, cuando en un programa se repite mucho un mismo código 00:03:29
a lo mejor con parámetros distintos, esto no lo niego 00:03:37
pero que al fin y al cabo el procedimiento que se está haciendo 00:03:40
la secuencia de instrucciones que se está haciendo, las operaciones que se están haciendo 00:03:43
son siempre las mismas, no compensa escribirlo varias veces 00:03:46
¿vale? por cuestión que el código aumenta 00:03:50
en tamaño, por cuestión en que si encuentro una forma mejor de hacerla 00:03:55
la tengo que cambiar en varios sitios, por cuestión que si tengo un error o descubro 00:03:58
un problema de seguridad en ese código, tengo que ir a buscar 00:04:03
en todo mi sistema donde he usado 00:04:06
esas operaciones y volver a cambiarlas 00:04:11
Entonces lo que se suele hacer es crear un método externo, una función externa 00:04:14
Este aquí es un procedimiento en concreto 00:04:25
A la que se le da un nombre, por ejemplo calcular área perímetro 00:04:27
Al que se le da unos parámetros, ahora veremos bien que son estas cosas aquí 00:04:32
Y aquí dentro es donde pongo el código que antes estaba repetido 00:04:37
Entonces, lo que he hecho aquí 00:04:41
Fijaos que esta de aquí es un hermano del main 00:04:44
O sea que esta llave aquí está cerrando el método main 00:04:47
Y como hermano del main, como al mismo nivel del main 00:04:53
Siempre dentro la declaración de public class 00:04:58
Pero fuera del main 00:05:01
Declaro un nuevo método 00:05:02
¿Cómo se declara un método? 00:05:05
Public, por ahora vamos a public y luego esto lo veremos en un futuro 00:05:06
Static, ¿qué es esto? 00:05:09
Pues es lo que nos permite hacer funciones y procedimientos como si fuéramos en un mundo de programación estructurada 00:05:11
Es lo que nos permite olvidarnos que en realidad deberíamos trabajar con objetos 00:05:25
Si yo excluyo el static, estoy en el mundo de los objetos 00:05:31
Con el static es una forma 00:05:37
Fea 00:05:39
Y poco elegante 00:05:42
De olvidarme que 00:05:44
Hay objetos de por medio 00:05:45
Como por ahora objetos no los sabemos 00:05:47
Pues entonces ponemos static 00:05:49
Y nos olvidamos que lo hemos puesto aquí 00:05:51
Fijaos que también vuestro método main 00:05:53
Estático y esto será siempre así 00:05:55
No cambiará nunca, el punto de acceso 00:05:57
De mi programa siempre será static 00:05:59
Pero este de aquí también 00:06:01
Tiene que ser static, el por qué tiene que ser 00:06:03
static lo entenderemos cuando veremos los 00:06:05
objetos y cuando luego veremos los 00:06:07
objetos empezaremos a trabajar sobre 00:06:09
cuando pongo static y cuando no 00:06:11
¿vale? por ahora siempre 00:06:12
esto 00:06:14
en 10 minutos entenderemos que es 00:06:16
este void, este es el 00:06:19
nombre que doy a 00:06:21
este trozo de código por aquí 00:06:23
y luego a continuación 00:06:24
digo que este código trabajará 00:06:27
con una serie de parámetros 00:06:29
¿vale? aquí dentro habrá dos 00:06:30
variables que desde el primer momento 00:06:33
hasta si no la estoy declarando, existirán, porque cuando alguien va a utilizar este código, lo que hará es asignar a este lado 1 y a este lado 2 unos valores concretos 00:06:35
y entonces para mí aquí dentro, lado 1 y lado 2, valdrán algo. Fijaos que aquí no los he todavía instanciados, pero cuando luego usaré esta función, 00:06:50
Cuando llamaré esta función, este procedimiento 00:07:00
Pues estos ya estarán inicializados a algún valor concreto 00:07:03
Y ahora veremos cómo, ¿vale? 00:07:09
Entonces, lo que yo sé es que independientemente que tú me des lado 1 y lado 2 00:07:10
Sean lo que sean los valores 00:07:14
Sé que el área será lado 1 por lado 2 00:07:15
Que el perímetro será lado 1 por 2 más lado 2 por 2 00:07:19
Y que luego tendrás que imprimir en pantalla el resultado 00:07:22
Que era el mismo que antes 00:07:26
El área de rectángulo, el perímetro de rectángulo 00:07:28
y los lados que se utilizan, ¿vale? 00:07:30
Ahora, esto es la declaración del método. 00:07:32
¿Qué hace el método? La implementación, ¿vale? 00:07:35
Declaración del método, implementación del método. 00:07:37
Lo que hace este método. 00:07:40
¿Cómo lo llamo? 00:07:42
Pues desde el main, por ejemplo, 00:07:44
puedo hacer referencia a calcular área y perímetro 00:07:47
y pasarle aquí dos valores. 00:07:50
¿Por qué le paso dos valores? 00:07:52
Porque calcular área y perímetro requiere dos int. 00:07:53
Como he puesto int e int, 00:07:57
Pues aquí se llamará poniéndole un valor int y otro valor int 00:07:58
Esto será la asociación 00:08:02
O sea, en esta llamada de este método 00:08:04
Lado 1 valdrá 3 y lado 2 valdrá 4 00:08:07
Entonces yo haré todas estas operaciones pensando en 3 y 4 00:08:10
3 y 4 00:08:15
La segunda vez que lo llamo 00:08:16
Lo estoy llamando con parámetros distintos 00:08:19
Esta vez es 5 y 10 00:08:21
Por lo tanto, ahora haré una asociación 00:08:24
Entre que el lado 1 vale 5 y el lado 2 vale 10 00:08:26
Y aquí utilizaré 5 y 10 00:08:29
¿Se entiende? 00:08:31
Entonces, esto es el mismo ejercicio 00:08:35
Esto es el mismo 00:08:38
Funciones, procedimientos, procedimientos 00:08:43
Es el mismo código que tenía antes 00:08:52
Es lo mismo, hace lo mismo 00:08:57
Escribirá los datos y los cálculos de estos tres rectángulos 00:08:58
Solo que en vez de tener un main donde se repite mucho 00:09:03
Que es largo, no sé cuántas líneas de código y cosas por el estilo 00:09:07
He organizado mejor el código 00:09:10
Ahora mi main son tres líneas de código 00:09:14
Se entiende mejor 00:09:17
Si he utilizado nombres que tienen sentido 00:09:18
Se entiende que se está haciendo 00:09:22
Y es como una abstracción 00:09:24
Y aquí te estoy diciendo, calcular el perímetro 00:09:25
Tú no sabes cómo se hace esto 00:09:27
Pero sabes lo que hace 00:09:29
Aquí se calculará el área, el perímetro 00:09:31
De estos dos 00:09:34
¿Se entiende? 00:09:36
Esto me permite que si mañana 00:09:39
Encuentro una forma más eficiente de hacerla 00:09:41
La tengo que cambiar aquí 00:09:43
Y en automático se ha cambiado 00:09:44
En todas las veces que he llamado 00:09:46
Esto me permite que si aquí había un error 00:09:47
Lo corrijo aquí y se ha corregido en todo mi programa 00:09:50
Esto me permite que mañana 00:09:53
Yo diga a ellos 00:09:55
Mirad, en vuestro trabajo 00:09:56
Que tenéis que hacer el main 00:09:58
podéis utilizar este método, ¿vale? que funcionará 00:09:59
correctamente y a otro equipo de trabajo decir, mira, vosotros tendréis 00:10:03
que desarrollar un método que se llama así, que recibe 00:10:07
estos parámetros y que tiene que dar como resultado esta cosa de aquí 00:10:11
y yo estoy trabajando, ellos que están haciendo 00:10:15
un programa, un sistema que trabaja de geometría en general y voy 00:10:18
dando a vosotros todos los métodos para rectángulo 00:10:23
A vosotros los métodos para el círculo 00:10:27
A vosotros los métodos para el triángulo 00:10:29
Y estoy paralelizando el desarrollo de este sistema 00:10:30
Entonces, ¿qué es un procedimiento? 00:10:33
Un procedimiento es un conjunto de instrucciones 00:10:45
Que cumple una determinada tarea 00:10:47
Esta tarea puede depender de algunos valores 00:10:49
Que se llaman parámetros o no 00:10:51
Por ejemplo, calcular área 00:10:53
Para calcular el área necesito un lado y otro lado 00:10:56
Pues paso los dos lados 00:10:59
Y esto de aquí hará algo 00:11:01
Pero podría ser un método que es saluda 00:11:03
Sin ningún parámetro 00:11:06
Y esto te dirá hola 00:11:07
O saluda con un nombre 00:11:10
Entonces me han pasado como parámetro un nombre 00:11:12
Y el nombre se tendrá dentro Estefano 00:11:15
Y eso dirá hola Estefano 00:11:17
Nadie me dice cuantos parámetros tengo que poner 00:11:19
Puedo poner los parámetros que me da la gana 00:11:25
Pondré los parámetros necesarios y suficientes 00:11:27
Para que este procedimiento haga lo que tiene que hacer 00:11:30
Si es el cálculo de un cuadrado 00:11:33
Pues a lo mejor con un lado solo me calcula el área 00:11:36
Ningún problema 00:11:38
Si en vez es un rectángulo necesitaré dos lados 00:11:39
Si es un triángulo necesitaré base de altura, etc. 00:11:42
Tened en cuenta que yo aquí he usado 5 y 10 o 3 y 4 00:11:48
Nadie me prohíbe aquí en vez de 3 utilizar una variable 00:11:54
Si aquí tengo int lado es igual a 7 00:11:57
Y luego aquí uso lado 00:12:00
Pues le estaré pasando 7 00:12:01
O una expresión 00:12:03
Aquí podría poner 3 por 7 00:12:04
O podría poner todo lo que hemos usado hasta ahora 00:12:06
Que luego se resuelva en un int 00:12:09
Lo puedo poner aquí como parámetro 00:12:11
Y luego será asociado con esta variable 00:12:13
¿Se entiende? 00:12:15
Vale 00:12:22
Entonces, ¿cómo se declara un procedimiento? 00:12:22
Un procedimiento se declara con public static void, esto es importante, void que quiere decir vacío, que quiere decir nada, ¿vale? Lo que está haciendo, me está diciendo que este procedimiento hace cosas, pero no genera ningún valor final que me tiene que entregar. 00:12:27
entregar. Y asumo que esto hará sus cosas 00:12:47
y cuando acaban sus cosas vuelvo a quien lo ha llamado 00:12:50
y allí me paro. No me espero que 00:12:54
desde las operaciones que hace esto haya un valor final, 00:12:58
un string final, un algo que me tiene 00:13:02
que devolver como operación que ha hecho. 00:13:06
No me espero que al final me diga, oye, este int es 7, toma el 7. 00:13:10
O que cuando aquí lo he hecho, aquí este imprime directamente en pantalla el resultado. No me espero que esta string de aquí se me devuelva a quien ha llamado para decir, oye, mira, esto es lo que he hecho y he creado esta string. Toma esta string y ahora haz tú lo que quieras. Pues no, ¿vale? 00:13:15
Cuando es un procedimiento, el procedimiento hace su tarea, hace lo que tiene que hacer y yo no me espero nada devuelto, no me espero que él lo que ha hecho me lo entregue, ¿sí? Es la diferencia entre procedimiento y función. 00:13:36
Cuando veremos la función, yo me espero que la función al final de su tarea me devuelva algo, me dé algo, un entero, un booleano, un string o un array. 00:13:52
Tú haz lo tuyo y al final has creado un producto y este producto me lo das a mí. 00:14:03
Sin embargo, cuando es procedimiento, tú haces lo tuyo y yo no me espero de recibir nada desde ti. 00:14:08
En un cierto sentido sí, podría no olvidarme, pero no me gusta. 00:14:14
en el sentido que tú puedes hasta no olvidarlo 00:14:33
tú puedes hacer operaciones y cambios 00:14:35
que luego verás desde el main 00:14:37
pero no te esperas 00:14:39
que cuando tú haces calcular 00:14:42
el perímetro, no esperas 00:14:43
que esto lo tengas que guardar 00:14:45
en alguna variable, porque esto no 00:14:47
genera nada, no genera 00:14:49
un int, no genera 00:14:51
a lo mejor te escribe un int en otra variable 00:14:53
a lo mejor en un futuro 00:14:56
te pilla un objeto y te lo modifica 00:14:58
entonces ese objeto luego lo puedes ver 00:14:59
desde el main y verás las modificaciones 00:15:01
que ha hecho, pero no te esperas 00:15:03
que recibas algo a cambio 00:15:06
o sea, yo podría hacer 00:15:07
un cálculo área 00:15:09
que calcule el área y la escriba en pantalla 00:15:10
o podría hacer un cálculo área 00:15:13
que cuando ha calculado el área 00:15:15
me devuelva ese valor 00:15:17
y que yo con ese valor haga lo que me dé la gana 00:15:19
lo ponga en un array, lo escriba en pantalla 00:15:21
lo sume con otra cosa 00:15:23
pues cuando es un procedimiento 00:15:25
ese valor no se me devuelve 00:15:27
No me espero que este señor sea una expresión 00:15:29
¿Cuánto vale calcular el perímetro de 3 y 4? 00:15:34
Nada 00:15:38
Porque no es una expresión 00:15:39
Es una operación 00:15:41
Y cuando se ha acabado 00:15:43
No devuelve nada 00:15:44
Devuelve void 00:15:46
Devuelve vacío 00:15:47
No devuelve nada 00:15:50
Sin embargo no funciona 00:15:51
Ahora veremos devuelve algo 00:15:53
Y volveremos a ver esto 00:15:54
¿Sí? 00:15:57
Después de public static void pongo el nombre 00:15:59
Nombres de métodos de funciones siempre empiezan por minúsculas 00:16:05
Y luego se usa el estándar Java 00:16:10
Si son varias palabras, cada palabra siguiente es en mayúsculas 00:16:12
Y luego empiezo una lista de un tipo con su nombre 00:16:16
Coma, tipo, con nombre, coma, tipo, con nombre, coma, tipo, con nombre 00:16:22
Y estos serán los parámetros que se usan. Sería esto. Int lado 1, int lado 2. Esto pilla dos parámetros. El parámetro lado 1 que es un entero, el parámetro lado 2 que es otro entero. 00:16:27
esto quiere decir que dentro del cuerpo de este método 00:16:49
yo tendré mágicamente este lado 1 y el lado 2 00:16:54
y los podré utilizar, lo puedo imprimir en pantalla, lo puedo sumar 00:16:57
lo puedo multiplicar, puedo hacer lo que me da la gana con este lado 1 y el lado 2 00:17:00
¿cuánto valen? no lo sé 00:17:03
no lo sabré hasta que me llamen 00:17:05
cuando llamarán este procedimiento 00:17:09
allí estarán forzados, como este procedimiento recibe dos int 00:17:12
a poner dos int aquí 00:17:16
Y estos dos ints harán operaciones llamadas bind 00:17:17
Serán enlazados con lado 1 con 3 00:17:21
Y lado 2 con 4 en esta llamada 00:17:25
O lado 1 con 5 y lado 2 con 10 en esta llamada 00:17:28
O sea que como esto es un bloque 00:17:31
Estos lado 1 y lado 2 existen aquí 00:17:34
Yo no puedo desde el main decir 00:17:38
Y ahora imprímeme lado 1 00:17:40
Porque aquí no existe lado 1 00:17:41
esta es como se declara 00:17:43
como se llama un método 00:17:52
simplemente con su nombre 00:17:54
abierta paréntesis 00:17:56
y un valor que tiene que ser 00:17:58
del tipo 1 00:18:00
coma un valor que tiene que ser del tipo 2 00:18:01
etc, etc, etc 00:18:04
si aquí había puesto string nombre 00:18:06
coma entidad 00:18:08
pues esto se llamará con su nombre 00:18:10
y luego un string 00:18:12
coma 00:18:14
un int 00:18:15
que representarán respectivamente 00:18:17
su nombre y su edad 00:18:19
¿Dudas? 00:18:21
Ejemplos 00:18:25
Tengo este main 00:18:26
¿Vale? 00:18:29
Y este main 00:18:31
No sé si se ve el problema que no puedo hacer mucho zoom 00:18:32
porque luego en los vídeos sale mal, me han dicho 00:18:37
Entonces 00:18:39
Este main lo que hace es 00:18:40
llamar unos métodos 00:18:43
Fijaos que cuando los métodos son estáticos 00:18:44
aparecen como en 00:18:47
cursiva, ¿vale? veremos que cuando 00:18:49
no son estáticos no aparecen en cursiva 00:18:52
pero esto lo veremos más adelante, por ahora cada vez que 00:18:54
llamo un método me debería aparecer en cursiva 00:18:56
si no me aparece en cursiva probablemente 00:18:58
he hecho algo malo, como por ejemplo 00:19:00
no haber puesto estática aquí, ¿vale? 00:19:01
entonces, ¿qué hace este main? 00:19:04
primero saluda, ¿qué quiere decir? 00:19:05
me voy a ver cómo está el método 00:19:08
de saluda, el método de saluda no pilla ningún 00:19:10
parámetro, por lo tanto aquí no le pongo ningún 00:19:12
parámetro, ¿sí? y lo que 00:19:14
hace el método de saluda es decir 00:19:16
Hola a todos, escribe en pantalla 00:19:17
Hola a todos, ¿me devuelve algo? 00:19:19
¿Me da algo a cambio? No 00:19:21
Se pierde, se acaba y se acabó 00:19:23
¿Sí? 00:19:26
Y luego llama el método 00:19:28
Saluda, Estefan 00:19:29
Pasándole como parámetro 00:19:31
Un elemento 00:19:33
Un parámetro que es de tipo 00:19:36
String 00:19:37
Ahora llegamos 00:19:39
Sí 00:19:44
Saluda, saluda es el mismo nombre 00:19:46
Ahora llegamos 00:19:48
¿Vale? ¿Qué hace saluda? Saluda me da un parámetro, parámetro string, ¿vale? Entonces, string nombre, lo que hace aquí dentro es que nombre será asociado a Estefano, por lo tanto me escribirá, hola Estefano. 00:19:52
Y aquí me preguntaban, ¿saluda y saluda es el mismo nombre? 00:20:07
No es confuso eso, para nada 00:20:13
Porque esto se llamará cuando saluda no tiene parámetros 00:20:15
Y esto se llamará cuando saluda tiene un parámetro de tipo string 00:20:19
Por lo tanto, el ordenador sabe siempre cuál de los dos métodos llamar 00:20:24
Lo que no puedo hacer es ahora declarar otro public static void de saluda 00:20:30
con parámetro string apellido 00:20:36
porque entonces cuando yo te digo 00:20:38
saluda a Estefano, tú no sabes 00:20:42
si llamar saluda con string 00:20:44
o saluda con string 00:20:46
serían lo mismo, ¿se entiende? 00:20:48
eso no se puede hacer 00:20:51
lo que tiene que ser 00:20:52
único es la firma 00:20:54
del método 00:20:56
la firma del método es su nombre 00:20:57
seguido de los tipos 00:21:00
de su parámetro 00:21:02
la firma de este método es saluda void 00:21:03
que es distinto de saluda string 00:21:06
perfecto, lo puedo hacer 00:21:09
sería distinto de saluda string string 00:21:11
que sería distinto de saluda int 00:21:14
que sería distinto de saluda int string string 00:21:16
no puedo hacer dos métodos 00:21:19
declarar dos veces un método con el mismo nombre 00:21:22
y los mismos tipos de parámetros 00:21:25
dos que tengan la firma saluda string y saluda string 00:21:27
sería ambiguo, sería no determinista 00:21:32
y por lo tanto cuando me dan un saluda con un string no sabría si utilizar 00:21:36
esto o este otro, y esto al ordenador no le gusta, el ordenador en cada 00:21:40
momento quiere saber que va a hacer 00:21:44
cuando lo llama, no lo puedes hacer, te da un error 00:21:46
aquí lo que hace es que este es void 00:21:51
y este es string, por lo tanto sabe 00:21:56
cuál utilizar. Si pusiera otro aquí 00:22:00
poniendo string apellido y luego 00:22:02
hola apellido, pues me daría 00:22:04
un error. Me diría, esta cosa aquí ya existe. 00:22:06
Ahora lo hacemos cuando hacemos lo propio. 00:22:09
¿Ya te he contestado? 00:22:11
Vale. Ah, bueno. 00:22:13
Luego creo una variable string 00:22:18
que pongo dentro Paco y llamo 00:22:20
saludaN. ¿Qué hará este 00:22:22
saludaN? 00:22:24
Hola Paco. 00:22:26
¿Paco qué es? 00:22:30
Vale. Entonces 00:22:33
Cuando hago saluda y le paso un string 00:22:34
Él asociará este nombre 00:22:36
Con el contenido de end 00:22:38
Que es paco 00:22:40
Por lo tanto me ejecutará esto 00:22:43
Donde nombre vale paco 00:22:45
Cuando llegue aquí y dice hola 00:22:47
Paco 00:22:48
Make sense? 00:22:50
Dudas? 00:22:52
Cuando acabo la parte teórica 00:22:55
Luego hacemos pruebas 00:22:57
Y volvemos sobre estas cosas 00:22:58
Otro ejemplo 00:23:01
Vale, tengo un main que dice, repite saludo, Luis, coma, cuatro. 00:23:03
¿Cuántos parámetros pilla esto? 00:23:08
Dos. ¿Qué tipo de parámetros pilla? 00:23:10
String e int. 00:23:14
¿Cuál es la firma de este método? 00:23:16
Repite saludo, string, int. 00:23:21
La firma es su nombre con los tipos de los parámetros. 00:23:26
Declaro este método, que es public static void. 00:23:31
Nombre 00:23:35
Y luego tengo un string 00:23:36
O sea, el nombre del método 00:23:38
Del procedimiento 00:23:39
String 00:23:41
Nombre 00:23:42
Coma 00:23:43
Int 00:23:44
Repetición 00:23:44
Y ahora digo que 00:23:45
For int 00:23:47
Igual a cero 00:23:47
Y menor que repeticiones 00:23:48
Y más más 00:23:49
String.out.tln 00:23:50
Hola 00:23:52
Más nombre 00:23:52
¿Qué hace esta cosa aquí? 00:23:53
¿Qué hace este programa si lo lanzo? 00:23:55
Escribe cuatro veces 00:24:00
Porque hace cuatro repeticiones 00:24:01
¿Vale? 00:24:03
Un for de cero a menor que repeticiones lo hará cuatro veces, en que me escribe hola y el nombre. 00:24:04
O sea, hola Luis. 00:24:11
Si yo hiciera repite saludo de, entre comillas, Estefano, coma, sesenta, ¿qué haría? 00:24:16
Hola Estefano, sesenta veces. 00:24:25
Si yo hiciera string n es igual a cocodrilo, entre comillas. 00:24:27
Y luego hago repite saludos de n, coma, tres, ¿qué haría? 00:24:32
N,3 00:24:38
O la cocodrilo tres veces 00:24:45
¿Sí o no? 00:24:50
Pues esto es un procedimiento 00:24:53
Los procedimientos también se pueden utilizar 00:24:55
Simplemente para ordenar el código 00:25:00
Y hacerlo más leíble 00:25:02
Yo tengo un main 00:25:03
Aquí hay un error 00:25:05
Tengo un main que hace 00:25:06
Inicializa el sistema, calcula datos y escribe resultados 00:25:08
Entonces el main no lo entiendes perfectamente 00:25:11
Porque está haciendo tres operaciones que se entienden 00:25:14
¿Esta operación qué hará? 00:25:17
¿Qué quiere decir? No lo sé 00:25:20
Dependerá del programa que estoy haciendo 00:25:22
Pero sé que todas las operaciones 00:25:24
De inicialización se harán aquí 00:25:27
Luego estará calcula datos 00:25:29
Y en este método de aquí 00:25:31
Es donde haré 00:25:32
Los datos y haré las operaciones que tengo que hacer 00:25:34
Y luego estará una parte de output 00:25:37
Que es escribir el resultado 00:25:39
Y luego me creo los tres 00:25:40
Métodos 00:25:43
Y en cada uno de estos tres métodos 00:25:44
En cada uno de estos tres procedimientos 00:25:46
Haré las operaciones para inicializar 00:25:47
Las operaciones para calcular 00:25:49
Las operaciones para escribir el resultado 00:25:51
Entonces se me queda más bonito 00:25:52
En vez de salir un caos 00:25:56
El otro día cuando nosotros 00:25:57
No me acuerdo que era exactamente la cosa 00:25:59
Pillé una parte del código 00:26:02
Lo saqué fuera 00:26:04
Y en el main se quedaba más bonito 00:26:05
Porque se quedaba una línea que decía que hacía esa cosa 00:26:08
Y como se hace 00:26:10
Lo escondo 00:26:11
pero sé lo que hace, que es un poco una forma de 00:26:12
yo aquí sé qué se está haciendo, pero escondo 00:26:16
el cómo se hace, el cómo se hace es engorroso, para que sea más leíble 00:26:21
mi texto, pues lo saco fuera, lo hago aparte, que así es un programita 00:26:24
más sencillo, es un poquito el divide tímpera, el divide vencerás 00:26:28
que os digo alguna vez, cada parte de mi programa lo estoy sacando 00:26:32
fuera en partes distintas y luego me centro en cada una de estas partes 00:26:37
¿Dudas? 00:26:40
No, es que como estáis aprendiendo a hacer los métodos 00:26:43
Habrá parte del examen que te dice 00:26:54
Haz un método con esta cosa 00:26:56
Si no lo haces, no sacas punto 00:26:57
Veremos en el día del examen 00:26:59
No lo sé, no veo el futuro 00:27:05
Todavía 00:27:06
Funciones, ¿vale? 00:27:07
Si en vez de un procedimiento hay que hacer una función 00:27:10
¿En qué se diferencia? 00:27:12
¿Cuál es la diferencia entre funciones y procedimiento? 00:27:14
Una función es parecida a un procedimiento 00:27:18
Pero sirve para obtener un determinado resultado 00:27:20
Que se devolverá al programa que ha llamado la función 00:27:22
¿Vale? 00:27:25
Entonces, por ejemplo 00:27:26
Tendré una cosa que te dice 00:27:28
Calcularea de lado 1 y lado 2 00:27:31
Esto calculará, hará lado 1 por lado 2, lo que sea 00:27:34
Y el valor que saca al final 00:27:37
Me lo devuelve 00:27:40
¿Y cómo me lo devuelve? 00:27:41
Yo lo puedo guardar en algún lado 00:27:43
Por ejemplo, en una variable 00:27:47
Los métodos anteriores 00:27:48
Los procedimientos 00:27:52
No permiten hacer esta parte 00:27:53
Aquí de la izquierda 00:27:56
Esta 00:27:57
El procedimiento no te devuelve un valor 00:27:58
Entonces no puedes decir, oye lo que has creado 00:28:01
Devuélvelo y métemelo en una variable int 00:28:04
Porque no has creado nada 00:28:06
Tipo de devolución es 00:28:08
Dios 00:28:12
Es void 00:28:13
Esto me está diciendo 00:28:17
No te voy a devolver nada 00:28:19
Por lo tanto no puedes hacer nada 00:28:21
Tendría que buscar otra forma 00:28:23
De guardar ese valor 00:28:30
O volver a hacerlo 00:28:31
O no lo sé 00:28:32
Pero si tú necesitas 00:28:34
Tu valor 00:28:36
No haces un procedimiento 00:28:37
Haces una función 00:28:38
Eres tú que decides 00:28:39
No es que 00:28:41
Oye o haces uno 00:28:42
O haces otro 00:28:43
Dependiendo si es martes 00:28:43
O miércoles 00:28:44
Pues quieres hacer una función 00:28:45
Tienes que esperar miércoles 00:28:46
Pues no 00:28:47
Tu programador dice 00:28:47
Este dato lo necesito 00:28:49
¿En quién lo llama? 00:28:51
¿Lo necesito en el main? 00:28:52
pues esto traiga una función y el dato final 00:28:53
me lo devuelva, que no lo necesito 00:28:56
quiero que esto haga trabajo así 00:28:58
y lo escriba ya en pantalla o lo guarde en un fichero 00:29:00
o haga lo que sea, pues entonces 00:29:02
hago un procedimiento 00:29:04
cuando luego tendremos los métodos 00:29:04
pues yo puedo hacer procedimientos 00:29:08
que lo que hacen es, perdón 00:29:10
los objetos, es que modifican el objeto 00:29:12
y como el objeto ya lo tenía antes 00:29:14
pues 00:29:16
haremos algunos ejemplos con los arrays 00:29:16
para entender lo que entiendo 00:29:20
¿Vale? 00:29:21
¿Dudas? 00:29:23
Entonces 00:29:25
Por ejemplo aquí yo tengo un creasaludo 00:29:25
Con un nombre, esto me creará 00:29:29
HolaStefano pero no lo imprime en pantalla 00:29:31
Me lo devuelve a mi 00:29:33
En formato de string 00:29:35
Lo puede hasta imprimir en pantalla y luego devolverme 00:29:36
Todo depende de como lo codifico yo 00:29:39
¿Si? 00:29:41
Pero el objetivo, la función 00:29:43
Al final tiene que tener 00:29:45
Una operación que se llama return 00:29:47
Que es este valor 00:29:49
es el que me devuelve, ¿cómo se declara? pues es igual al otro 00:29:51
solo que en vez de void voy a poner el tipo del valor 00:29:58
que se devolverá, entonces public static int 00:30:03
no se que, quiere decir que al final todas las operaciones tendrá un int 00:30:07
y este int me lo devuelve a quien lo ha llamado 00:30:13
public static string saluda no se que, pues creará un string 00:30:16
Y ese string me lo empaquetará y devolverá a quien ha llamado este método 00:30:22
Es decir, que cuando se llama, se hará tipo variable, nombre variable 00:30:27
Es igual al nombre del método con sus parámetros 00:30:34
Esto de los parámetros se queda igual 00:30:38
Este tipo tiene que ser este tipo 00:30:41
Si lo almacenas en una variable 00:30:46
Si yo hago esto, o lo usas como parámetros en otra función, o lo usas como parte de una expresión para luego sumarle 3, pues eso no se sabe. 00:30:57
Esto es una expresión y al final hará algo y al final valdrá algo. 00:31:13
Esto vale 3 00:31:21
Y luego, ¿qué haces tú con este 3? 00:31:23
Guardarlo en una variable, guardarlo en una array 00:31:26
Multiplicarlo por 5, exprimirlo por pantalla 00:31:28
Pues eso depende de ti 00:31:30
¿Qué haces con una variable? 00:31:31
Lo que quieras 00:31:36
¿Qué haces con un método que devuelve algo? 00:31:36
Pues lo que tienes que hacer con ese método 00:31:39
Que no lo sé 00:31:41
Se puede hacer lo que 00:31:41
Donde tú pondrías una expresión 00:31:44
3, n, nombre 00:31:46
Puedes poner un método 00:31:49
Que luego será al final 00:31:51
Su valor, su tipo 00:31:53
Será el return de ese método 00:31:54
Yo os entiendo 00:31:57
Miramos los ejemplos 00:32:03
Y luego después me hacéis las preguntas 00:32:05
¿Puedo devolver? 00:32:07
¿Te puedo devolver varios datos? 00:32:10
¿Cómo? 00:32:15
No, poniendo un array 00:32:17
Devuelves un array de enteros 00:32:18
Y me puedes devolver 50 arrays 00:32:23
Lo que no puedes hacer es devolver 00:32:24
Un int y un string 00:32:26
Porque aquí pones un tipo solo 00:32:28
Pues int o string 00:32:30
Pues hago un array 00:32:31
Devuelvo un array de int 00:32:39
Y cuando devuelvo sé que en la posición 0 00:32:41
Tendré el área y en la posición 1 tendré 00:32:44
El perímetro 00:32:46
Y lo utilizo como yo sé 00:32:47
¿Sí? 00:32:48
Entonces, ejemplo de funciones 00:32:52
¿Vale? Aquí yo tengo 00:32:54
Saluda a Estefano 00:32:56
Que lo que hace al final es 00:32:57
Producir un string 00:32:59
Y este string lo guardo aquí 00:33:01
Y ahora si quiero lo imprimo en pantalla 00:33:03
O le añado algo 00:33:05
O le pongo delante 00:33:07
El primer saludo es 00:33:09
Más saludo uno 00:33:10
¿Sí? 00:33:12
¿Cómo sería saluda 00:33:14
Que pilla un string? 00:33:16
¿Vale? 00:33:19
Public static string 00:33:19
No void 00:33:21
Esto es que al final me tienes que devolver un string 00:33:22
Saluda 00:33:26
String nombre es el parámetro 00:33:27
Y aquí dentro lo que hago es 00:33:30
crearme una variable que se llama resultado 00:33:32
que es igual a hola 00:33:34
más el nombre 00:33:36
return resultado 00:33:37
este return 00:33:40
es la operación que me dice 00:33:42
devuélvelo 00:33:44
si yo le he dicho que devuelve algo 00:33:46
y no he puesto un return 00:33:48
se enfada 00:33:50
hoy me has dicho que devuelves un 00:33:51
string pero en ningún lado has dicho 00:33:54
que devuelve 00:33:56
es obligatorio si aquí pones algo 00:33:57
que no sea void, poner un return 00:34:00
en algún lado 00:34:02
y siempre tiene que llegar a return 00:34:03
siempre 00:34:06
si yo aquí pongo 00:34:07
aquí arriba 00:34:09
if string.length mayor que 0 00:34:11
hago todo esto 00:34:14
se enfada 00:34:16
porque si string no es 00:34:17
mayor que 0, si name 00:34:20
no es mayor que 0, no hay un return 00:34:21
entonces se enfadaría 00:34:24
siempre tengo que tener un return 00:34:26
Y ahora veremos ejemplo 00:34:28
Porque es una función 00:34:31
Y tienes que devolver algo 00:34:44
Si tú no sientes la necesidad de poner un return 00:34:46
Estás haciendo un procedimiento 00:34:52
Entonces pones void 00:34:54
Porque es una función 00:34:55
Si tú estás haciendo una función es porque quieres que te calcule algo 00:35:00
Y te dé resultado 00:35:03
Y si no le dices 00:35:04
Devuélveme el resultado 00:35:07
No estás haciendo una función 00:35:08
Estás haciendo un procedimiento 00:35:09
Tened en cuenta también 00:35:11
Que el return acaba el método 00:35:17
Cuando llega un return 00:35:19
Salgo del método 00:35:20
Vuelvo a quien me ha llamado 00:35:22
Yo estoy aquí, llamo esta cosa de aquí 00:35:24
Me teletransporto a esto 00:35:27
Estoy ejecutando 00:35:29
En cuanto ejecute un return 00:35:30
Vuelvo aquí 00:35:32
Guardo lo que he guardado 00:35:33
Y pasa al siguiente 00:35:35
String n es igual a pago 00:35:36
Saludo 2, saluda n 00:35:39
pues lo que hará es ejecutarme este método de aquí, entra aquí dentro, ahora n está asociado con nombre, 00:35:41
por lo tanto aquí nombre vale el contenido de n, o sea nombre vale pago, hará que el resultado es hola espacio pago, 00:35:49
esto lo guarda dentro del resultado y me lo devuelve, entonces el resultado de esta operación de aquí es hola espacio pago 00:35:57
y por lo tanto me lo guardará dentro de saludo2. 00:36:06
¿Entiendes? 00:36:11
Más ejemplos. 00:36:13
Tengo un main que dice saludos es igual a repiteSaludo de Luis4. 00:36:17
Y luego imprimo lo que haya generado aquí. 00:36:24
¿Qué genero? 00:36:27
Pues aquí tengo un public static string repiteSaludo que pilla un nombre en una repetición, 00:36:28
crea un resultado vacío 00:36:35
¿vale? una cadena vacía 00:36:38
por cuatro veces, por repeticiones 00:36:40
veces, que luego se hará asociado 00:36:43
con cuatro, lo que hace es 00:36:44
acumular dentro 00:36:47
el resultado es igual a lo que hay en 00:36:48
resultado más hola, más 00:36:50
nombre, más espacio 00:36:52
y luego hará return el resultado 00:36:54
entonces lo que hace es 00:36:56
escribir hola Luis 00:36:58
hola Luis, hola Luis, hola Luis, todo en una 00:37:00
línea en este caso 00:37:02
4 veces 00:37:03
La versión anterior me lo ponía 00:37:07
Como hacía println me lo ponía 00:37:11
Uno en cada línea 00:37:13
Este de aquí como lo estoy acumulando 00:37:15
Me lo está poniendo 00:37:17
Todo en la misma línea 00:37:18
Si yo en vez de este espacio 00:37:20
Aquí pusiera un barra n 00:37:21
Pues entonces me lo pondría uno en cada línea 00:37:23
¿Dudas? 00:37:26
Ejemplo otro 00:37:31
¿Vale? 00:37:32
Leo 00:37:38
Creo un escáner 00:37:39
¿Vale? 00:37:43
Lado 1 es igual a 00:37:46
Leginum de esta cosa 00:37:48
De aquí, coma S 00:37:50
Fijaos, estoy pasando 00:37:52
Una frase 00:37:54
Que es un string 00:37:55
Y, ¿qué es esto? 00:37:57
Un escáner 00:38:01
¿Vale? 00:38:02
Mira como es Leginum 00:38:03
Recibe un string 00:38:04
Y un objeto escáner 00:38:06
como le he pasado este objeto 00:38:09
escáner de aquí 00:38:13
pues entonces yo puedo utilizar 00:38:14
aquí dentro eso 00:38:17
utilizando la palabra teclado 00:38:19
entonces puedo hacer, escribe 00:38:20
el mensaje 00:38:23
que me has dado 00:38:25
luego 00:38:26
teclado.nextint 00:38:28
estoy utilizando el escáner 00:38:30
lo que tú me has escrito 00:38:32
lo guardo en numleído 00:38:35
y te devuelvo numleído 00:38:36
Entonces lo que nosotros hacíamos siempre en dos pasos de escribe lo que quieres hacer y guarda las variables 00:38:39
Ahora me he creado un método, una función, que lo que hace es leer un número 00:38:45
Me dices cuál tiene que ser el prompt que pone que tengo que hacer 00:38:52
Por ejemplo, dame el primer lado del rectángulo y le paso el objeto por el que tiene que leer 00:38:57
Que está asociado con el teclado 00:39:03
la segunda vez 00:39:05
llamo otra vez leggiNum 00:39:08
con otro nombre, dame el otro lado 00:39:10
del rectángulo, el mismo 00:39:12
objeto es S, por lo tanto esto de aquí 00:39:14
me le da un primer número y lo guarda en el lado 1 00:39:16
esto de aquí me le da un segundo número y lo guarda 00:39:18
en el lado 2 00:39:20
¿se entiende? 00:39:21
¿qué parámetros tiene? stringMessage 00:39:23
y scannerTeclado 00:39:26
entonces aquí dentro usaré 00:39:28
msg y teclado 00:39:30
cuando llamaré 00:39:31
este método, msg 00:39:34
estará asociado con este 00:39:36
string de aquí, o sea 00:39:38
msg vale esto 00:39:40
y teclado vale 00:39:41
esto, que vale esto 00:39:44
¿entiende? 00:39:46
¿se entiende? 00:39:50
¿sí? fijaos que 00:39:52
la devolución de este señor es un int 00:39:54
public static int 00:39:56
yo me espero que al final 00:39:58
tú me devuelvas un entero, y de hecho 00:40:00
return no me he leído, y no me he leído 00:40:02
fíjate tú 00:40:04
Duda 00:40:04
Porque aquí dentro 00:40:06
Tú no sabes 00:40:19
Qué escáner te van a pasar 00:40:20
Podría ser otro objeto escáner 00:40:22
Tú haces una asociación 00:40:25
Entre teclado, que es esta cosa aquí 00:40:27
Y S 00:40:29
Paint 00:40:30
Esto es un objeto escáner 00:40:34
Y yo estoy creando 00:40:38
Creo un objeto S 00:40:41
Que apunta al objeto escáner 00:40:43
cuando ahora 00:40:47
llamo 00:40:50
leggi, numero 00:40:50
y le paso una 00:40:52
string, s 00:40:54
vale 00:40:57
dentro del mundo 00:40:58
de este metodo 00:41:00
yo tengo un teclado 00:41:02
que es una variable 00:41:04
y cuanto vale la variable 00:41:09
se asocia con el contenido de s 00:41:11
cual es el contenido de s 00:41:13
es esta cosa de aqui 00:41:14
que es un puntero 00:41:16
Es una zona de memoria 00:41:18
Donde está un objeto 00:41:20
Por lo tanto yo pillo esta cosa de aquí 00:41:21
Y la copio aquí 00:41:23
Para esta ejecución de teclado 00:41:24
Es decir que esto me está apuntando 00:41:27
A este objeto 00:41:29
Por lo tanto estoy usando 00:41:30
El teclado que había creado antes 00:41:32
Acordaos que 00:41:34
Las variables 00:41:36
Al fin y al cabo 00:41:38
Son representaciones 00:41:40
Alfanuméricas 00:41:43
De algo, de un valor, de un objeto 00:41:44
Y nosotros hemos visto dos cosas 00:41:46
La hemos hablado un poquito en algunos casos 00:41:49
Puede ser que sean por valor 00:41:51
Como cuando uso int 00:41:54
Entonces se crea una copia del mismo valor 00:41:55
Y si modifico uno no modifico el otro 00:41:58
Pero hay casos 00:42:00
Spoiler, cada vez que uso un objeto 00:42:01
En el que 00:42:04
No estoy usando dos copias de lo mismo 00:42:06
Si no estoy usando 00:42:08
La misma cosa 00:42:10
Esto lo hemos visto con los 00:42:11
Arrays 00:42:14
Si yo hacía S, cuando hacía ArrayX y luego hacía ArrayY es igual a X 00:42:15
No estoy creando un nuevo Array, más estoy creando dos punteros al mismo objeto 00:42:24
Como Scanner es un objeto, pues funciona así 00:42:28
Es lo que se llama paso por valor o paso por referencia 00:42:33
Del que hablaremos dentro de un rato 00:42:38
¿Más preguntas? 00:42:40
Porque dentro de este bloque de aquí 00:43:02
No existe ningún S 00:43:06
Tú estás declarando 00:43:08
Scanner S y aquí usas S 00:43:11
Tu S aquí dentro es este S de aquí 00:43:13
A la hora de llamarlo 00:43:16
Haces una asociación 00:43:18
Entre este S y este S 00:43:20
Pero están en dos sitios distintos 00:43:22
Están en dos bloques distintos, no se molesta 00:43:24
¿Y otra? 00:43:25
Si en vez de S ahí arriba 00:43:28
Si S es un string explotaría 00:43:31
¿Aquí? 00:43:33
Claro, porque te dice 00:43:34
No está definido ningún leginum 00:43:36
Cuya firma sea 00:43:38
Leginum string string 00:43:40
Imagínate que tú tienes un escáner que lee de teclado 00:43:42
Un escáner que lee de un fichero 00:43:54
Un escáner que lee de internet 00:43:55
Pues entonces dependiendo de donde quieres leer 00:43:57
Pues usa uno o otro 00:44:00
No, porque un número de ratón 00:44:01
Un escáner no es para leer de ratón 00:44:12
Pero si de un fichero, sí 00:44:14
¿Sí? 00:44:16
Más dudas 00:44:18
No hay dos escáneres, hay un escáner solo 00:44:21
Lo repito 00:44:25
Hay un escáner solo, aquí 00:44:26
Escáner solo, hay un objeto escáner solo 00:44:28
Solo que hay dos referencias al escáner 00:44:31
Vale 00:44:33
Entonces 00:44:36
Aquí pide dos números 00:44:38
Y luego dice, calcula área 00:44:41
¿Vale? 00:44:43
¿Qué será calcular área la de uno y la de dos? 00:44:44
Pues será un método 00:44:47
Es una procedura 00:44:48
Es un procedimiento o es una función 00:44:50
Función porque devuelve algo 00:44:53
¿Cuál es la firma de esta función? 00:44:57
Calcular, int, int 00:45:05
Nombre y tipos 00:45:08
¿Sí? 00:45:09
Entonces, si voy a mirar 00:45:11
Public static int 00:45:14
Devuelve un entero 00:45:15
Calcular es un nombre 00:45:17
Recibe un entero lado 1, entero lado 2 00:45:19
Lado 1 se asociará con este lado 1 de aquí 00:45:22
Lado 2 se asociará con este lado 2 de aquí 00:45:25
Que serán los que he leído aquí 00:45:28
Y aquí contesta tu pregunta de antes 00:45:30
Y returna lado 1 por lado 2 00:45:31
Esto de aquí es una expresión que se evaluará 00:45:37
Sacará lo que es y este lo devuelve como entero 00:45:41
Y este de aquí pilla ese entero y lo guarda en el área 00:45:45
Estamos aprendiendo 00:45:48
De todas formas es más bonito 00:45:54
Este de aquí a poner esta cosa de aquí 00:45:57
Que no se entiende 00:45:59
¿No hemos dicho antes que no? 00:45:59
No se puede devolver un string unid 00:46:16
O devolverse un string o devolverse un unid 00:46:18
Pero puedes siempre devolver 00:46:20
Un array de string donde por un lado 00:46:22
Pones la palabra que quieres y en otro lado 00:46:24
Un string que es un número 00:46:26
Y luego harás algo para transformar 00:46:28
Este string en un número 00:46:30
Pues, tú estás llamando aquí una función 00:46:31
A ver, tú tienes, piénsalo en abstracto 00:46:48
Tú quieres crear una función a la que te pasan dos cosas 00:46:58
Te pasan un mensaje y te pasan algo desde que tú puedes leer 00:47:03
Si a ti te dan estas dos cosas, tú haces lo tuyo 00:47:09
Que es imprimir en pantalla el mensaje y luego leer en esta cosa que te han dado un número, guardarlo dentro de una variable y revolver esa variable. 00:47:13
Ahora, esto funciona siempre cuando te manden un mensaje, string, y algo que pueda leer de teclado, un escáner. 00:47:27
Entonces, cuando tú lo vas a llamar este método 00:47:38
Tú le pasarás un string 00:47:42
Y le tienes que pasar algo que pueda leer de teclado 00:47:46
¿Qué es este algo que puede leer de teclado? 00:47:51
Un objeto scanner 00:47:53
Entonces tú te creas un objeto scanner 00:47:54
Creas un nuevo objeto capaz de leer de teclado 00:47:57
Y a él le dices, mira, haz lo tuyo 00:48:00
Que es leer un número con este mensaje de aquí 00:48:03
Y este objeto que puede leer de teclado 00:48:06
Te lo paso aquí. 00:48:08
Él hará una asociación entre este mensaje y este mensaje. 00:48:11
Entonces, cada vez que tú usas aquí SMSG, estás haciendo esto. 00:48:15
Y cada vez que aquí usas teclado, como esto está asociado con este S, estás usando S. 00:48:23
A ver, tú aquí dentro tienes que usar un mensaje y tienes que utilizar un teclado 00:48:29
Si no le das un nombre, ¿cómo los usa? 00:48:53
Tendrás que decir, oye, mira, cuando a mí me llaman me pasarán un mensaje 00:48:56
¿Y este mensaje cómo se llama? 00:48:59
Hola, Estefano 00:49:01
Pues no, porque tú me puedes escribir hola, Estefano, me puedes escribir cocodrilo 00:49:02
Entonces digo, vale, será una variable 00:49:04
Y yo digo que esto es MSG 00:49:06
Luego este msg ahora mismo no vale nada, pero aquí dentro digo imprímelo, ¿vale? Sea cual sea el contenido de smg. ¿Cuándo sabré cuándo vale? Cuando haré la llamada y entonces tú me has pasado un string y entonces yo puedo asociar el valor de este string con este msg. 00:49:09
Esto se llama 00:49:27
Parámetro formal 00:49:31
Esto se llama 00:49:33
Parámetro actual 00:49:35
Parámetro formal es msg 00:49:37
Es una cosa genérica 00:49:40
Es imprime esto 00:49:41
Y en esta llamada de aquí 00:49:43
Actualmente 00:49:46
Este msg es 00:49:47
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
22
Fecha:
7 de noviembre de 2024 - 13:52
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 49″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
108.68 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid