Estructura de control 3: procedimientos y funciones

Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra voz, ¿vale? 00:00:00

Entonces, nosotros, a nivel teórico, hemos visto las sentencias de control. 00:00:06

Las sentencias de control me permiten variar, modificar el orden con que ejecuto las sentencias, los comandos de Java, ¿vale? 00:00:14

La sentencia de control más fácil es la secuencial, es decir, voy uno tras otro, que es la base que hemos empezado a aprender al principio. 00:00:25

Y luego hemos introducido dos tipos de estructuras de control que me permiten modificar esta secuencialidad. 00:00:34

Por un lado el condicional, que me dice si tengo o no que ejecutar un determinado bloque. 00:00:43

¿vale? Entonces podría, esto 00:00:48

introduce la posibilidad de saltar 00:00:50

un bloque de instrucciones si una 00:00:52

condición es falsa o ejeutarlo 00:00:54

si esta condición es verdadera 00:00:57

y luego las iterativas que me 00:00:59

permiten pillar un bloque de 00:01:00

comandos 00:01:02

y iterrar 00:01:05

sobre este bloque una 00:01:06

y otra vez y otra vez según 00:01:08

una determinada condición 00:01:10

¿vale? Hemos visto el while que me dice 00:01:12

mientras esta condición es verdadera sigue 00:01:14

aquí dentro atrapado en este bucle 00:01:16

y cuando esta condición se vuelve falsa, sal, ¿vale? 00:01:18

Entonces hemos visto que dentro del bucle necesitamos que esta condición 00:01:22

se modifique en un determinado momento, porque si no siempre me quedaré atrapado en ese bucle. 00:01:25

O si no, el for, que es un poquito distinto, que es cuando ya me sé el número de veces 00:01:31

que tengo que hacer una determinada acción, pues entonces tengo este for. 00:01:36

En particular, el for me permite también de tener de forma fácil un índice 00:01:41

que varía en cada una de las 00:01:47

iteraciones, entonces mi int i es igual a 0 00:01:51

i menor de 10, en cada iteración este i va modificándose 00:01:55

y por lo tanto lo puedo utilizar normalmente allí dentro para hacer 00:01:59

algo, para buscar una posición, para 00:02:03

incrementar un valor, etc. 00:02:06

Los dos son idénticos, no se os olvide esto, todo lo que puedo 00:02:11

hacer con un wire lo puede hacer con un for, todo lo que pueda hacer un for lo puede hacer con un wire. 00:02:15

En el caso de los condicionales hemos visto el if que es el que utilizamos normalmente y luego hemos visto el 00:02:20

switch. Yo puedo hacer con un if o puedo hacer un switch tranquilamente. Con el switch puede haber 00:02:24

casos en que el if no lo puedo hacer. Pero bueno, es una forma más práctica cuando yo tengo que 00:02:30

hacer algo en base al valor concreto de una variable. Entonces se usa el switch, si no, 00:02:38

yes. Hemos hecho ejercicios, hemos probado, se nos ha quedado en esta transparencia, 00:02:43

en esta diapositiva, en esta slide, no sé cómo se llama en español, pues el concepto de llamadas 00:02:50

a métodos, que es la última, digamos, posibilidad que tenemos para que nuestra sentencia de control 00:02:56

no sean una tras otra 00:03:03

más cambien 00:03:06

el flujo de ejecución 00:03:07

la llamada a esa método 00:03:09

la hemos visto en algunos ejercicios 00:03:11

hemos hecho algunos ejemplos básicos 00:03:14

hoy simplemente lo que vamos a hacer es 00:03:15

darle un poco más de formalidad 00:03:17

teórica pero la idea 00:03:20

es pillar un trozo de código 00:03:21

y darle un nombre 00:03:23

yo tengo calcular área del cuadrado 00:03:25

lo llamo así 00:03:28

y dentro tendré todo el mecanismo 00:03:29

todo el algoritmo, todas las instrucciones necesarias para calcular el área del cuadrado. 00:03:32

Y al final de la ejecución de este método, haré algo. 00:03:39

O lo escribo, o te devuelvo el valor, o lo guardo en una variable, no lo sé. 00:03:43

Eso ya veremos qué opciones hay. 00:03:48

El concepto es que cuando llamo a un método, paro la ejecución allí donde está la llamada del método, 00:03:51

Me voy al bloque de código con ese nombre 00:03:58

Ejecuto ese bloque de código 00:04:01

Y una vez acabado ese bloque de código 00:04:03

Vuelvo a donde se había llamado 00:04:05

Y sigo adelante 00:04:07

Entonces he hecho un salto 00:04:08

Me he ido a otra parte 00:04:11

De mi programa 00:04:14

Y he vuelto 00:04:15

Cuidado 00:04:16

Lo diré ahora 00:04:19

Y lo diré al final 00:04:21

Nosotros ahora estamos viendo 00:04:22

Los métodos o las funciones 00:04:25

o los procedimientos desde una perspectiva más vieja de lo que es Java. 00:04:28

O sea, no lo estamos viendo como orientado a objeto. 00:04:34

Lo estamos viendo como programación estructural. 00:04:38

Entonces, lo que tenemos aquí ahora es una parte de lo que podemos hacer con los métodos. 00:04:41

Que por ahora, eso es lo que va. 00:04:47

En un futuro, cuando veremos las clases, veremos los objetos, 00:04:50

volveremos al concepto de método y lo veremos desde una perspectiva de orientada a objetos. 00:04:53

Pero por ahora lo que vamos a ver es como la mitad de lo que se puede hacer. 00:04:58

Nosotros para llamar un método podemos o llamar directamente al método, es lo que hemos usado 00:05:07

nosotros varias veces. Hemos llamado un método, hemos llamado un bloque de código con un nombre 00:05:13

y hemos llamado ese nombre, ¿vale? 00:05:18

Eso quiere decir que cuando llegue allí, 00:05:20

voy a este bloque, lo ejecuto y vuelvo atrás. 00:05:22

Object.metodo es algo un poquito más complejo, ¿vale? 00:05:26

Nosotros lo hemos utilizado. 00:05:30

¿Dónde lo hemos utilizado esta cosa aquí? 00:05:31

Scan. 00:05:38

Nosotros hemos creado scanner, scanner es igual a new scanner. 00:05:39

Ahí hemos creado un objeto scanner. 00:05:43

Y luego hemos utilizado un método sobre la variable scan. 00:05:44

Esto ya no... ¿Qué? No entiendo. ¿Qué es esto de un objeto? ¿Cómo que he creado un objeto? Sí, cuando 00:05:49

tenéis un new habéis creado un objeto, ¿vale? Pero por ahora, si no lo entendéis, no pasa nada. Esto de 00:05:56

aquí lo veremos poco o nada porque es lo que veremos en un futuro. Está aquí por ser completos. 00:06:02

Y otra forma es, en vez de un objeto, clase, punto y un metodito. ¿Dónde hemos visto esto de aquí? 00:06:07

math.rando 00:06:14

por ejemplo, no he hecho nunca 00:06:21

math x es igual a new math 00:06:23

lo he llamado directamente 00:06:26

sobre la clase 00:06:28

estos son métodos estáticos 00:06:29

estos son métodos no estáticos 00:06:32

y esto depende 00:06:34

depende de si lo estoy 00:06:35

llamando sobre el objeto o si lo estoy llamando sobre la clase 00:06:38

¿vale? 00:06:40

pero todo esto es complejo y no lo entendemos 00:06:41

porque nosotros no sabemos nada de 00:06:44

programación de objetos, no sabemos que son los objetos 00:06:46

no sabemos qué son las clases, y entonces no entendemos la diferencia entre esto. 00:06:48

No hace falta. Por ahora, no lo pensamos. 00:06:52

Y lo pensamos principalmente así. 00:06:56

Vamos a ver qué son estas cosas. Llamadas a métodos. 00:07:01

Entonces, si un programa repite muchas veces el mismo código, 00:07:12

que es como lo vamos a usar nosotros en un futuro, quizás de una forma 00:07:16

un poquito distinta, pero por ahora es donde nos sirve de verdad, es esto. 00:07:19

Yo tengo el mismo código y se repite muchas veces, ¿vale? 00:07:23

Entonces, he escrito siempre la misma cosa, ¿vale? 00:07:26

El ejemplo que hace aquí, por ejemplo, aquí quiere calcular el, ¿qué es? 00:07:29

La área, el perímetro de varios rectángulos, ¿sí? 00:07:35

Entonces, lo que hace es establecer el primer rectángulo, calcular su área, su perímetro y escribirlo. 00:07:39

Luego, el segundo rectángulo, calcular otra vez su área y su perímetro. 00:07:46

Calcular el tercer rectángulo y su área y su perímetro. 00:07:50

Si os fijáis, la parte de calcular y escribir es igual, es lo mismo en las tres cosas. 00:07:52

La única cosa que estoy haciendo es cambiar el valor, ¿vale? 00:07:59

Esto es repetir mucho el código. 00:08:04

Si estoy repitiendo mucho el código, lo mejor que puedo hacer es este código, darle un nombre y llamarlo 00:08:06

haz los cálculos que tienes que hacer y luego llamaré haz los cálculos, haz los cálculos, haz los cálculos. 00:08:12

la ventaja que me da esto también 00:08:18

es que si luego me doy cuenta 00:08:24

que he hecho mal las operaciones 00:08:26

o que hay una forma más eficiente 00:08:27

de hacer las operaciones 00:08:29

aquí las debería cambiar 00:08:30

todas las veces que aparecen 00:08:32

sin embargo en la otra forma 00:08:34

lo cambio una vez 00:08:37

en el bloque con su nombre 00:08:39

y esto se aplicará todas las veces 00:08:41

que he usado ese bloque 00:08:43

¿se entiende? 00:08:44

entonces sabíamos una cosa de este estilo 00:08:49

Por un lado tengo el método main, que es el punto de acceso. 00:08:52

Esto siempre se queda así. 00:08:57

Y aquí lo que hago es calcular el perímetro 3, 4. 00:08:59

Calcular el perímetro 5, 10. 00:09:03

Calcular el perímetro 2 y 7. 00:09:05

¿Y qué es esto? 00:09:07

Esto es un bloque que tiene un nombre, que tiene el nombre calcular el perímetro, que es este de aquí. 00:09:08

Declarado como hermano del main. 00:09:14

Lo veis, hasta ahora nosotros hemos trabajado todo dentro del main. 00:09:16

En realidad el main acaba en esta paréntesis de aquí abajo y por lo tanto esto es un hermano, es al mismo nivel del main. 00:09:19

Y es un nuevo método. Si os fijáis, comparte public static void con el otro. Es la declaración de un método. 00:09:29

Estoy definiendo un nuevo método, estoy definiendo una procedura, una función. En Java se llaman métodos. 00:09:36

¿Cómo se llama este código? 00:09:43

Este código se llama calcular área de perímetro 00:09:46

Ahora, cuando yo declaro un método 00:09:49

Y digo, se llama así, calcular área de perímetro 00:09:53

Puedo parametrizarlo 00:09:56

O sea, decir, oye, mira, aquí dentro voy a utilizar unos valores paramétricos 00:09:58

O sea, tú me dirás cuántos valen en el momento en que llamas este trozo 00:10:03

Y usaré los valores que tú me das 00:10:08

¿Vale? En particular, para poder utilizar, calcular el perímetro, necesito dos valores. 00:10:10

Necesito dos int. 00:10:17

Cuando tú llamas este trozo de código, dentro de este trozo de código voy a utilizar un int lado 1 y un int lado 2. 00:10:19

Como es un rectángulo, necesito dos lados. 00:10:27

¿Sí? 00:10:30

¿Cuánto vale? No lo sé. 00:10:31

Estos se llaman parámetros formales. 00:10:34

Es decir, yo sé que voy a necesitar lado 1 como entero y lado 2 como entero, lo sé, 00:10:37

y los voy a utilizar, pero no sé cuánto valdrán hasta que tú llames, 00:10:42

hasta que tú hagas la llamada de este método, hasta que tú lo uses este método. 00:10:48

Esta es la definición abstracta del método. 00:10:53

Te estoy diciendo, hay un trozo de código que usa estas dos variables. 00:10:56

¿Cuánto valen? Lo veremos. 00:10:59

Ahora, si tú me has dado estas dos variables 00:11:01

Que yo no sé cuánto valen, por lo tanto le llamaré lado 1 y lado 2 00:11:05

Lo que voy a hacer es que calculo la área de rectángulo como lado 1 por lado 2 00:11:08

Y el perímetro como lado 1 por 2 más lado 2 por 2 00:11:14

Y esto es el código que se le envía a la vez 00:11:17

¿Sí? 00:11:22

¿Sí? 00:11:28

Y luego escribiré que el rectángulo de lado, el lado 1 y el lado 2, los dos lados que me has dado, tienen área, lo que he calculado, y perímetro, lo que he calculado. 00:11:28

Ahora, cuando yo llamo este método diciéndole 3, 4, este 3 se vincula con este lado 1, este 4 se vincula con este lado 2, y entonces haré todos los cálculos con 3 y 4. 00:11:41

Cuando tú vuelves a llamar el mismo código pero en vez de 3 y 4 me pasas 5 y 10 00:11:55

Lo que está haciendo es vinculando el lado 1 con 5 y el lado 2 con 10 00:12:02

Y haré todos esos cálculos con 5 y 10 00:12:06

¿Se entiende? 00:12:08

Estos se llaman parámetros actuales 00:12:10

O sea lo que estoy utilizando actualmente en este momento 00:12:14

Parámetros formales 00:12:17

Los parámetros genéricos que no sé cuánto valdrán pero utilizo 00:12:19

Yo sé que me darán estos valores, pero todavía no sé cuáles son, ¿sí? Sin embargo, los parámetros actuales son cuando voy a llamar a hacer la llamada del método, le tengo que pasar los valores que vas a utilizar en esta llamada del método. 00:12:24

¿Dudas? ¿Preguntas? ¿Se entiende? 00:12:41

Definición o declaración del método, llamada del método. 00:12:49

Parámetros formales, parámetros actuales. 00:12:55

¿Puedo yo hacer calcular el parámetro de tres punto y coma? 00:12:59

No, porque este bloque de código aquí, este método, necesita dos parámetros, no uno solo. 00:13:06

Si tú le pones un parámetro solo, te dice, no puedo. 00:13:13

¿Sí? 00:13:17

¿Puedo hacer el calcular el perímetro de 3, gato? 00:13:20

No, porque este bloque de aquí necesita un entero y otro entero. 00:13:26

No le puedo poner un string. 00:13:31

¿Se entiende? 00:13:34

¿Dudas? 00:13:35

Un procedimiento es un conjunto de instrucciones que cumple una determinada tarea. 00:13:41

¿Vale? 00:13:47

como la que acabamos de ver ahora, ¿vale? 00:13:47

Esta tarea puede 00:13:49

depender de algunos valores que son 00:13:50

llamados los parámetros o no, 00:13:53

¿vale? Yo podría declararlo 00:13:55

sin ningún parámetro. 00:13:57

Entonces este es un 00:14:00

bloque de código que se ejecuta 00:14:01

claramente aquí dentro tendré que 00:14:02

hacer algo. Calcular 00:14:05

el perímetro como lo hemos pensado nosotros 00:14:07

sin ponerle parámetro no tendría sentido 00:14:09

porque sólo podría calcular 00:14:11

el perímetro de un determinado 00:14:12

Triángulo, rectángulo 00:14:15

El que pongo aquí, dos y tres 00:14:17

Ya está, me haría solo eso 00:14:19

El parámetrizado me permite 00:14:21

Hacerlo de todos los rectángulos posibles 00:14:23

Pero 00:14:25

Podría haber otros 00:14:28

Métodos, como por ejemplo 00:14:31

El método random 00:14:33

¿Random pilla algún parámetro? 00:14:34

No, era más 00:14:40

Punto random, abierto, cerrado, paréntesis 00:14:41

Cerrado, paréntesis 00:14:43

Porque no me sirven los parámetros 00:14:44

Porque es un número aleatorio entre 0 00:14:46

y 0,99999999 00:14:50

¿Vale? 00:14:52

Y por eso no es paramétrico 00:14:53

Es siempre así 00:14:55

Es siempre un número aleatorio entre 0 y 0,9999 00:14:56

No hay parámetros ahí 00:14:59

¿Se entiende? 00:15:00

Si quiero puedo hacerlo sin parámetros 00:15:02

Si quiero puedo ponerle los parámetros 00:15:05

¿Cuántos? ¿Cuánto me da la gana? 00:15:07

1, 3, 97, 100, 1000 00:15:10

Pues me da igual 00:15:12

Los pongo allí, un entero 00:15:13

Luego me das un string 00:15:15

y luego me das un boolean, luego me das lo que yo quiera. 00:15:16

Cuando lo llamo, lo tendré que usar con los mismos parámetros 00:15:21

ordenados de esa forma. 00:15:24

Ejemplo, calcular el lado 1 como el lado 2, 00:15:30

saluda o saluda de nombre. 00:15:33

Estas son llamadas de métodos posibles. 00:15:36

Este de aquí me pillará dos variables que no sé qué son 00:15:40

porque no sé qué es el lado 1 y el lado 2, probablemente enteros. 00:15:44

Este de aquí no tiene ningún parámetro, y este de aquí tiene un parámetro nombre, 00:15:47

que probablemente será un string, pero no lo sé porque no he visto que sea esta cosa. 00:15:54

¿Sí? 00:16:00

Se declara con public static void nombre, y luego la lista de parámetros como tipo del parámetro 1, 00:16:03

nombre del parámetro 1, coma tipo del parámetro 2, nombre del parámetro 2, etc., etc., etc., todos los que yo quiera. 00:16:11

¿Sí? 00:16:18

Aquí entre paréntesis, entre llave y llave va el cuerpo del procedimiento, o sea, lo que hace el procedimiento, ¿vale? 00:16:20

Para llamarlos uso el nombre del parámetro con aberta paréntesis, valor del tipo 1, valor del tipo 2, valor del tipo 3, ¿entiendes? 00:16:27

Ejemplo, ¿vale? 00:16:45

Tengo la videoclase encendida 00:16:46

Si esto es demasiado pequeño 00:16:50

Lo podéis meter en vuestra pantalla 00:16:51

Este es el main 00:16:53

¿Qué hace el main? 00:16:55

El main llama el método saluda 00:16:57

O sea que 00:16:58

El flujo normal de ejecución 00:16:59

Aquí se interrumpe 00:17:02

Y salta hacia ese bloque 00:17:04

Que se llama saluda 00:17:06

Sin parámetros 00:17:08

¿Dónde está saluda sin parámetros? 00:17:09

Pues aquí 00:17:11

¿Vale? 00:17:12

Saluda sin parámetros 00:17:13

Vale, fenomenal. ¿Qué tiene que hacer? Pondrá system.out.ptle hola a todos. O sea que esta cosa de aquí me hará escribir hola a todos en pantalla. 00:17:15

Una vez acabado este método de aquí, volverá aquí y seguirá adelante. Y llama saluda con parámetros tson. 00:17:26

Entonces esto no lo puede usar 00:17:37

Porque saluda sin parámetro no es esto 00:17:39

Tiene que buscar un saluda 00:17:41

Que tenga como parámetro un 00:17:43

¿Qué tipo tiene Estefano? 00:17:45

Un string 00:17:49

Pues vamos a mirarlo 00:17:51

Saluda con string nombre 00:17:52

¿Y qué hace? Pues escribe hola 00:17:54

Y el nombre detrás 00:17:57

Entonces esta cosa de aquí escribirá hola Estefano 00:17:58

Acaba esto 00:18:01

Vuelve aquí, sigue adelante 00:18:05

Crea una variable que se llama 00:18:06

llama n y que pone paco, ¿vale? Y luego llama saluda n. ¿Qué hará esto? Volverá a saltar 00:18:08

a este método, porque es saluda de un string, ¿ok? Y aquí lo que hará es asociar este 00:18:16

nombre con este n, y este n contiene paco, por lo tanto ahora nombre vale paco y escribirá 00:18:24

o lavado. ¿Dudas? Claramente estos dos métodos son inútiles porque escriben una cosa, además me 00:18:31

compensa escribir directamente si están puntuados por internet aquí. Sí. Cuando estos son más 00:18:48

complejos, en vez de repetir toda esta complejidad aquí dos veces, porque si os fijáis esta parte 00:18:54

aquí se usa dos veces, este método se usa dos veces, este método se usa una vez sola, en vez de 00:19:01

tener que escribir este código, 00:19:05

imaginaos 30 líneas de código, dos 00:19:07

veces, entonces 60 líneas de código, o sea, 00:19:09

ahí es detorcido, pues lo escribo una vez 00:19:11

sola y desde aquí lo llamo. Otro 00:19:13

ejemplo, ¿vale? 00:19:17

Repite saludo 00:19:20

Luis Castro, ¿vale? 00:19:21

Esto es una llamada 00:19:23

a un método que se llama 00:19:25

repite saludo, que 00:19:26

tiene un string 00:19:29

y un int. 00:19:31

Esto, ¿vale? Esa es la 00:19:34

definición. Se llama repite saludo 00:19:35

recibe un parámetro 00:19:37

tipo string y un parámetro tipo int. Entonces, él asocia 00:19:41

este nombre con Luis y estas repeticiones con 4. 00:19:46

Y lo que hace es, desde y que va a 0 y menor 00:19:50

que repeticiones y más más, escribe hola nombre. Es decir, que 00:19:53

aquí cuando ejecuto este método, ¿qué hace? 00:19:57

¿Qué? Hola y 00:20:05

Escribe hola Luis cuatro veces. La misma línea, en línea, como está aprendiendo a 00:20:09

leerme, pues en línea siguiente. ¿Sí? Entonces escribe en cuatro líneas hola Luis, hola Luis, hola Luis, hola Luis. 00:20:19

¿Se entiende? ¿Dudas? Si yo hiciera repite, saludo, Estefano 27, ¿qué hace? Hola 00:20:26

Estefano, ¿cuántas veces? 00:20:39

27. 00:20:40

¿Sí? 00:20:42

Los procedimientos y los 00:20:49

métodos en general, ¿eh? ¿Vale? 00:20:52

Se pueden usar para ordenar el código 00:20:53

y hacerlo más bonito. Para hacerlo 00:20:55

más leíble. 00:20:58

¿Vale? En vez de poner todo el código 00:21:00

en el main, que salen 200 00:21:02

páginas, líneas de código retorcido 00:21:04

con cosas raras, que cuando vas a leer 00:21:06

dices, no lo entiendo, tú te 00:21:07

haces un buen main que dice 00:21:09

inicializa el sistema, calcula 00:21:11

datos escribe el resultado se entiende que está haciendo si muy bonito hace esto 00:21:14

hace esto hace esto si hasta en vez de así genérico pues le pusiera nombres reales 00:21:18

de recibe valores calcula áreas de rectángulo y escribe resultados sé que 00:21:24

sé que está haciendo el carapaz vale entonces me puede servir para que el 00:21:32

main se quede más limpio y que estos métodos de aquí en realidad sean que no 00:21:37

estén en otro lado, hasta en otras clases 00:21:43

veremos en el futuro, en otros ficheros 00:21:45

o, cosa también más 00:21:48

interesante, que una vez que yo he establecido 00:21:49

que el main es esto, le digo 00:21:51

hoy mira, este grupo implementa 00:21:53

inicializaSistema, ese grupo 00:21:56

implementa calculaDatos y este grupo 00:21:57

implementa escribeResultal 00:21:59

y estoy haciendo mi programa 00:22:01

separado en tres grupos de trabajo 00:22:03

entonces está de un tercer tiempo 00:22:05

¿Sí? 00:22:07

¿Y inicializaSistema? Pues hará todas 00:22:11

Todas las operaciones para reiniciar el sistema, recuperar los datos, 00:22:13

adquirir los datos, comprueba que los datos son correctos, etcétera, etcétera. 00:22:17

Cuando lo ha hecho, asumo que el sistema está inicializado, lo que quiera decir 00:22:21

el sistema está inicializado, es un ejemplo, no es un ejemplo completo. 00:22:25

Luego empieza con cálculo de datos, hará todos los cálculos sobre los datos, 00:22:29

asumiendo que el sistema ya está inicializado, porque ya lo ejecutaron. 00:22:32

Y finalmente estará, escribe el resultado que pillará lo que se ha calculado y lo 00:22:37

o en un fichero, o lo manda por internet, o... ¿sí? Estos serían los prototipos de estos métodos, ¿vale? 00:22:40

El prototipo es esta cosa aquí, ¿vale? Cuando yo te digo el prototipo de un método, es si es público, privado, 00:22:53

lo que sea, nosotros conocemos solo público, si es estático o no, nosotros conocemos solo el estático, 00:23:00

si es void o otra cosa, y nosotros por ahora hemos usado solo void, 00:23:05

cómo se llama y qué parámetros tiene. 00:23:09

Ese es el prototipo. 00:23:12

La línea que define este método se llama prototipo del método. 00:23:14

Y si yo en vez de os digo la firma del método, 00:23:20

la firma del método es su nombre con los tipos de los datos, de los parámetros. 00:23:24

Es decir, que la firma de este método de aquí es saludaString. 00:23:32

La firma de este método de aquí es repiteSaludoStringInt. 00:23:39

Esto es saludaVoid, porque no tiene nada. 00:23:46

Preguntas. 00:23:54

Estos son los procedimientos. 00:24:00

¿Dudas sobre los procedimientos? 00:24:02

Vale. 00:24:04

Estamos en el mundo de la programación estructurada. 00:24:06

¿Vale? 00:24:09

Entonces, en el mundo de la programación estructurada existen dos cosas distintas. 00:24:10

Los procedimientos y las funciones. 00:24:15

En el mundo orientado a objetos, o sea, el mundo donde estaremos nosotros, no existe esta diferencia. 00:24:18

Existen métodos. 00:24:22

Y estos son métodos. 00:24:24

Todos son métodos. 00:24:26

Java es método. 00:24:26

Pero para entender la diferencia, hacemos esta división. 00:24:27

Procedimientos, lo habéis entendido. 00:24:33

En particular, los procedimientos son los que tienen aquí, voy. 00:24:35

si allí tiene void es un procedimiento 00:24:38

una función es una cosa un poquito distinta 00:24:41

es 00:24:46

un método, es un bloque de código 00:24:46

pero yo me espero 00:24:50

que al final de este bloque 00:24:51

de código, después que haya hecho lo que 00:24:53

tiene que hacer, él 00:24:55

llegue a un resultado 00:24:57

y me proporcione ese resultado 00:24:59

o sea, mientras el procedimiento 00:25:01

yo te llamo, tú haces tus cosas 00:25:03

no me espero nada de ti 00:25:06

cuando has hecho tus cosas sigo yo 00:25:07

la función es 00:25:09

tú haz tus cosas, pero cuando has 00:25:11

acabado de hacer tus cosas, tú tendrás 00:25:13

un valor calculado, sea 00:25:15

lo que sea, ese valor 00:25:17

me lo puedes dar a mí 00:25:19

a quien te he llamado, cuando yo 00:25:21

te llamo una función, puedo 00:25:23

recoger ese valor final 00:25:25

y traerlo a quien lo he llamado 00:25:27

una función es parecida a un procedimiento 00:25:29

pero sirve para obtener un determinado 00:25:33

resultado que se devolverá al programa que ha llamado la función. Yo llamo la función, la función 00:25:35

hace lo suyo y al final el valor final que ha calculado me lo devuelve a quien lo ha llamado 00:25:41

y yo lo puedo utilizar para cerrar. Ejemplos, int área es igual a cálcula área, lado 1, lado 2. 00:25:48

Yo me espero que cálcula área con lado 1 y lado 2 haga sus operaciones, por ejemplo, lado 1 por 00:26:02

lado 2, obtiene un valor 37, pues este 37 quiero que me lo devuelva a mí y que lo ponga en la int area, 00:26:09

o sea, en una variable que se llama area. Fijaos que con el procedimiento no lo puedo hacer. Si era 00:26:18

esto, calcular el perímetro, yo no puedo hacer int x es igual a calcular el perímetro, porque esta 00:26:27

cosa de aquí devuelve void es decir no devuelve nada no me espero que después de esto aquí te dé 00:26:39

algo a cambio tú si lo escribes en pantalla pero lo haces tú o sea el llamante o sea el main cuando 00:26:48

llama el método hace que el método haga todo es el método que escribe en pantalla pero cuando esto 00:26:57

vuelve al llamante, el llamante no tiene en mano nada de lo que ha hecho el procedimiento. 00:27:05

No recibe nada a cambio. El concepto de la función es que cuando yo acabo de ejecutar 00:27:12

la función, ésta haya calculado este dato y este dato me lo puede devolver a mí. Y 00:27:21

yo como llamante lo puedo guardar en una función, lo puedo utilizar directamente, lo puedo escribir 00:27:29

en pantalla, puedo hacer lo que me da la gana con eso 00:27:33

pero esto 00:27:35

es un 00:27:37

valor 00:27:39

una vez que se ha ejecutado esta cosa 00:27:40

eso vale algo 00:27:43

con un tipo concreto 00:27:45

¿me entiendes? 00:27:47

o string de saludo es igual 00:27:50

a crea saludo de nombre 00:27:51

pues crea saludo de nombre, pillará 00:27:53

un string, hará lo que le da la gana 00:27:55

creará un string más grande con dentro 00:27:57

el nombre y luego este string 00:27:59

me lo devuelve a quien me ha llamado 00:28:01

y yo lo puedo guardar 00:28:03

dentro de una... 00:28:04

Un no, pero... 00:28:06

Ejemplos. 00:28:08

Ah, no, declaración. 00:28:11

¿Cómo se declara? 00:28:13

Igual a que antes, 00:28:14

lo único que cambia 00:28:15

es que donde antes tenía void, 00:28:16

ahora tengo el tipo 00:28:19

del valor que se crea. 00:28:20

O sea, yo tengo una función, 00:28:24

hace lo que le da gana, 00:28:25

al final, ¿qué tiene? 00:28:26

¿Tiene un int? 00:28:27

Pues entonces devuelve un int. 00:28:28

Al final, ¿qué tiene? 00:28:31

¿Tiene un string? 00:28:31

Pues entonces aquí le pongo string. 00:28:32

Esto es lo que me espero que esta función de aquí haga y al final obtiene este valor. 00:28:34

¿Qué tipo tiene este valor final? 00:28:40

Pues un string, pues entonces lo pongo aquí para que sepa quién me usa, que después de todo mi trabajo, pues yo te puedo devolver un string, o te puedo devolver un int, o te puedo devolver un float. 00:28:42

¿Cómo se llama? 00:28:57

Pues se llama igual que antes. 00:28:58

¿Vale? 00:29:01

Tipo variable, nombre variable es igual a 00:29:01

Nombre, bla bla bla, esto es igual a que antes 00:29:04

¿Ve? 00:29:06

O declarando una variable nueva 00:29:08

Para poner dentro el resultado 00:29:10

O utilizando una variable 00:29:12

Ya de ese tipo 00:29:14

Y pillando el resultado 00:29:16

¿Ve? 00:29:18

Cuidado 00:29:20

Yo podría no poner esto 00:29:21

Si yo llamo una función 00:29:24

Y ignoro lo que ha calculado 00:29:25

Pues lo puedo hacer tranquilamente 00:29:29

no se suele hacer, cuando yo llamo a una función, es porque quiero el resultado de esa función, ¿vale? 00:29:30

Si yo quiero llamar a una función y no me interesa para nada el cálculo que hace, eso es un procedimiento. 00:29:37

Si yo no voy a utilizar lo que tú calculas, pues entonces ponme void y dime no te devuelvo nada. 00:29:50

Entonces se vuelve un procedimiento. 00:29:56

Pruebas, ejemplos, ¿vale? 00:30:01

Aquí tengo un main que dice string, saludo1 es igual a saluda a Estefan, ¿vale? 00:30:03

Fijaos, saluda ahora, pilla un string, pero no lo escribe en pantalla. 00:30:09

Lo que hace es, me crea un nuevo string de resultado, le pone hola y luego el nombre que ha recibido como parámetro formal aquí, ¿vale? 00:30:16

Y lo que hace es devolver return el resultado calculado. 00:30:26

esto es lo que me devuelve 00:30:31

y que yo pondré en saludón, ¿entiendes? 00:30:36

fijaos que aquí es public static string 00:30:42

no void, eso quiere decir que al final tengo que devolver 00:30:45

un string, sea cual sea el string 00:30:49

tiene que ser un valor de tipo string, aquí calcularé un string 00:30:53

y al final return string, cuidado, si yo no pongo return string 00:30:57

¿Por qué se enfada? Me dice, oye, mira, tú has hecho un método que devuelve algo y no has dicho que devuelve. 00:31:01

Entonces se va a enfadar si no le pongo return. 00:31:09

Se va a enfadar también si yo hago algo tipo if x es mayor que cero en turner, entonces return a Stéfano y ya está. 00:31:14

Porque él dice, oye, cuidado, que si x es mayor que cero esto funciona, pero si x es menor que cero no estás llegando a ningún return. 00:31:22

Me tienes que cubrir 00:31:30

las dos posibilidades. 00:31:31

No puedo yo tener una posibilidad 00:31:33

que me diga, sí, con esto de return 00:31:35

y con esto no. 00:31:37

Si tiene que devolver algo, tiene que devolver algo 00:31:39

siempre. 00:31:41

¿Entiendes? Vale. 00:31:43

Más ejemplos. 00:31:48

¿Vale? Entonces tengo 00:31:50

string saludos es igual, repite 00:31:51

saludos de Luis 4. ¿Vale? 00:31:53

Esta es la misma versión de antes, pero en vez 00:31:55

que como procedimiento, ¿os acordáis? El procedimiento 00:31:57

lo escribía él directamente. 00:31:59

en vez de aquí lo que hace es 00:32:00

nombre de repeticiones 00:32:03

empiezo con un resultado que es vacío 00:32:04

¿vale? por cuatro veces 00:32:07

por repeticiones veces 00:32:09

lo que hago es resultados igual 00:32:11

resultado más hola más nombre 00:32:13

entonces hola Estefano y un start 00:32:15

¿vale? retorno al resultado 00:32:17

es decir que si yo 00:32:19

hago esto y lo he imprimido por pantalla 00:32:21

¿qué hace este programa? 00:32:23

escribe hola Luis ¿cuántas veces? 00:32:37

cuatro ¿cómo? 00:32:39

una tras otra, lo veis 00:32:40

no una encima de otra 00:32:49

porque en cada círculo 00:32:51

lo que está haciendo lo está pegando 00:32:54

detrás, entonces me pone 00:32:56

hola Luis, hola Luis, hola Luis 00:32:58

cuatro veces pero en la misma línea 00:32:59

lo veis 00:33:01

si quisiera 00:33:02

uno por línea, aquí en vez de un espacio 00:33:05

le podría poner un barra n 00:33:08

entonces me está diciendo hola Luis 00:33:09

y un barra n que quiere decir vete a una nueva línea 00:33:12

es un único string 00:33:14

que pero me está diciendo esto en una línea, esto en otra línea, esto en otra línea. Pero así, me lo escribiría todo en la misma línea. 00:33:16

Lucas, ¿entendéis la diferencia entre una función y un apreciamiento? ¿Está claro? 00:33:25

Entonces, tengo un mail. Scanner S bla bla, leggi num, que pone dame el primer número de rectángulo, coma S. 00:33:33

leggi num dame el lado del rectángulo coma S, pregunta ¿estos dos, leggi num, 00:33:49

que son llamadas a procedimiento o a función? ¿Leggi num es un procedimiento o una función? 00:33:59

¿Me espero que me devuelva algo o no? Sí, porque lo guardo dentro de algo. 00:34:18

Y si espero que me devuelva algo, es una función. 00:34:28

De hecho, si me voy a legendum, veis que aquí no tiene void, tiene int. 00:34:33

Entonces, es una función que hace algo y al final devuelve un entero. 00:34:37

¿Sí? 00:34:43

Vamos a ver qué hace esta cosa aquí. 00:34:44

Él recibe un string y un scanner. 00:34:46

El scanner lo creo aquí y se lo paso como parámetro a este método. 00:34:50

De esta forma, este tiene el teclado, tiene este método estándar y puede leer de teclado y lo usa así. Escribe el mensaje, que en mi caso será dame el primer lado del triángulo porque estará asociado con este mensaje. La segunda vez será dame el otro lado del triángulo porque estará asociado con este mensaje. 00:34:54

Y luego dice, int numLeaders igual a teclado punto next int. 00:35:12

¿Qué es teclado? Es un objeto escáner. 00:35:17

Pero aquí no lo he definido el objeto escáner, porque lo recibo aquí. 00:35:19

Es este objeto escáner. 00:35:25

Objeto escáner lo creo una vez y luego te lo doy a ti para que lo uses aquí. 00:35:26

¿Cuál es el parámetro formal? Esto. 00:35:35

Y yo te digo, tú tendrás un escáner y lo podrás usar como se usan los escáner. 00:35:37

¿Cuál es el parámetro actual? 00:35:46

Este escáner creado aquí. 00:35:48

Tú necesitarás un mensaje. 00:35:53

¿Cuál es? 00:35:55

No lo sé. 00:35:56

Escribe el mensaje en pantalla. 00:35:57

¿Vale? 00:35:59

¿Cuál será el mensaje? 00:36:00

Este mensaje. 00:36:01

Parámetro actual, parámetro formal. 00:36:03

¿Se entiende? 00:36:06

¿Te gusta? 00:36:06

se devuelve, devuelve en un leído. O sea, este de aquí, LEGINUM, es una forma distinta, más fácil, 00:36:08

¿vale?, de hacer lo que hemos siempre hecho nosotros, de escribir un mensaje, de oye, 00:36:21

dame un número, leer el número y escribirlo. Ahora, en vez de tener que hacer estas tres 00:36:27

líneas de código para leer un código, pues tengo una línea sola que es LEGINUM con su mensaje, 00:36:36

S y S. ¿Por qué? Porque me gusta aquí. Ya lo podía hacer aquí. ¿Sí? ¿Sí? ¿Vale? 00:36:41

Entonces, leyes y números. Leyes y números lo que hacen es leer un número del teclado. 00:36:50

Perfecto. He leído el lado 1 y el lado 2. ¿Y ahora qué hace? Dice, int área es igual 00:36:53

a calcular el lado 1 y el lado 2. Pregunta para vosotros. ¿Calcular área es un procedimiento 00:36:57

no funciona. ¿Quién dice procedimiento? ¿Quién dice función? ¿Quién dice no tengo 00:37:05

idea? Es una función. ¿Por qué? Porque lo que hago lo guardo en algún lado y porque 00:37:18

calcularia tiene aquí interno voy. Más preguntas. ¿Cuáles son los parámetros actuales de 00:37:27

calcular para nuestros actuales serán lo que he leído por teclado aquí aquí 00:37:39

son los formales estos los que no sé cuál será pero sé que me 00:37:56

darán un lado uno o dos cuál es el la firma del método 00:38:02

calcular ya lo sabe 00:38:10

calcularia int, tal tal, dos int, calcularia int int, esa es su firma, ¿sí?, ¿cuál 00:38:26

es la firma de leggi num?, leggi es le en italiano, leggi num string scanner, esa es 00:38:40

¿Cuál es el prototipo de calcularia? 00:39:03

El prototipo de calcularia es toda esta cosa aquí. 00:39:10

Public static int calcularia int int. 00:39:26

Ese es su prototipo. 00:39:30

Entonces, he llegado aquí y he leído dos números en la apuesta en el lado uno y en el lado dos. 00:39:32

Luego he llamado calcularia, pasándole lo que he leído. 00:39:39

por lo tanto él me ha hecho este cálculo de aquí y lo ha devuelto por lo tanto esta cosa de aquí 00:39:43

calcula área de lado uno lado dos vale este valor de aquí y lo guardo dentro de área y a este punto 00:39:50

hago pinta bonito lado uno lado dos lado área sin mirar abajo me podéis decir cuál es el prototipo 00:39:58

de, no miréis la pantalla, el prototipo, perdón, la firma de tinta bonito, firma de pinta bonito, 00:40:07

int, int, int, que pinta bonito, retirar tres enteros, el entero A, el entero B, el entero R, 00:40:33

Pero A será un lado, entero B será otro lado, R será el resultado, ¿vale? 00:40:45

Y lo que hace es dibujar esto con un marquito bonito, ¿sí? 00:40:50

Me hace un marquito así, pues luego escribe rectángulo de lados A y B tiene área R y luego me pone otra marquita, ¿sí? 00:40:56

Pregunta, ¿pinta bonito es una función o un procedimiento? 00:41:11

Procedimi. ¿Por qué? Porque se me voy de aquí. ¿Por qué? Porque cuando yo lo llamo, no guardo el resultado de ningún lado, ¿sí? 00:41:16

¿Dudas? ¿Se entiende un poquito? 00:41:36

Pregunta, ¿podría eroter este programa sin usar ninguno de estos tres métodos? 00:41:41

Si, pillo esto, lo copio allí, pillo esto, lo copio allí, pillo esto, lo copio aquí, ya está. 00:41:48

Esto lo copiaría dos veces. 00:41:53

Pero el main queda mucho más bonito así, que si lo hacéis un poco más de pago con esta cosa. 00:42:00

Además, si yo leo este código, porque es la primera vez que lo veo, sin mirar estos, pues puedo más o 00:42:06

Tienen que entender qué está haciendo de una forma más rápida y más interesante que leyendo literalmente el código de estado. 00:42:14

¿Entienden? 00:42:22

Parámetros formales y parámetros actuales. 00:42:26

Los parámetros formales son los que se usan dentro de la función o del procedimiento. 00:42:28

No tienen un valor concreto hasta que se llame la función o el procedimiento. 00:42:33

Son abstractos. 00:42:38

Son estos. 00:42:41

MSG y teclado. 00:42:43

Lado 1 y lado 2. 00:42:44

A, B y D, R. ¿Cuánto valen? 00:42:45

No lo sé. Yo sé sólo que tú 00:42:48

me darás un A, que es un entero, 00:42:50

un B, que es un entero, un R, que es un entero. 00:42:51

Y yo escribiré el rectángulo 00:42:54

de lado y luego pego lo que tú me has 00:42:56

dado en A y 00:42:58

pego lo que me has dado en B, 00:42:59

tiene área y pego lo que pones en R. 00:43:01

Yo sé eso. Sé cómo 00:43:04

los uso, pero no sé cuáles serán los valores 00:43:05

reales. 00:43:08

Sin embargo, 00:43:10

los parámetros actuales son 00:43:12

los valores concretos que se asignan 00:43:13

los parámetros formales a la hora de llamar la función o procedimiento. 00:43:15

Es decir, que cuando llamo, pinta bonito, lado 1, lado 2, lado 3, área, 00:43:20

lo que estoy haciendo es, mírame que está en lado 1. 00:43:25

¿Hay 3? Pues vete aquí y A vale 3. 00:43:28

En esta llamada A vale 3. 00:43:32

¿Lado 2 cuánto es? 7. Pues pillo 7 y lo pongo en B. 00:43:35

B en esta llamada vale 7. 00:43:39

Y aquí valdrá 7 por 3. 00:43:42

Caveat, que en latino quiere decir cuidado, ¿sí?, funciones y procedimientos son propios 00:43:43

de la programación estructurada, que es a lo que estamos nosotros más sobrenombrados. 00:44:01

En Java se suele hablar más bien de métodos, sin embargo, el concepto de métodos está 00:44:06

vinculado a la programación orientada a objetos, en particular al concepto de clase y objeto, 00:44:11

que nosotros no sabemos nada por ahora. 00:44:17

Todo esto para decir que lo que hemos visto hasta ahora es un uso impropio de Java, estamos omitiendo la parte orientada a objetos, nosotros no sabemos qué son los objetos, no sabemos cómo estamos utilizando los objetos, no sabemos cuando hacemos scan.nextInt que estamos llamando un método de un objeto y no un método estático, y no sabemos qué quiere decir estático, que estático está asociado a la clase y no estático está asociado al objeto, para nosotros parecen palabras de un idioma arcano y maléfico, 00:44:21

Y no lo entenderemos hasta que veamos clases y objetos. 00:44:49

Cuando llegará el momento, en un futuro lejano, como por ejemplo diciembre, 00:44:57

volveremos a retomar estos conceptos y preguntaremos más en temas como 00:45:01

¿qué es este static? ¿qué es este public? 00:45:06

¿qué es el parámetro cuando se pasa un parámetro? 00:45:09

¿qué quiere decir que se pasa por valor o se pasa por referencia? 00:45:13

que es una referencia a un objeto, que es una clase, etc., etc., todos estos temas vendrán en un futuro, ¿vale? 00:45:17

Esto para deciros que no es que sabéis todo de métodos, sabéis una espincelada pequeña, ¿vale? 00:45:26

Bueno, hagamos un par de ejemplos, justo porque os quedan grabados, ¿vale? 00:45:41

Y luego ya veremos qué hacemos. 00:45:46

Ejemplo, procedimos. 00:45:59

Entonces, y aquí tengo un main. 00:46:03

El main es el punto de acceso. 00:46:08

El main es un método. 00:46:10

¿Es un procedimiento o no funciona el main? 00:46:12

Es un procedimiento, porque voy. 00:46:26

Cuidado, en algunos casos, como por ejemplo en C o C++, 00:46:31

el método main devuelve un valor. 00:46:36

Aquí también en realidad se devuelve un valor. 00:46:40

Ahora déjame ver si se ve. 00:46:43

Porque te dice que si te devuelve cero, un entero cero, ha ido todo bien, 00:46:44

he acabado sin problemas. 00:46:50

Si te devuelvo otro numerito, ese numerito representa un código de error. 00:46:52

Ha pasado algo malo en la ejecución, ello ha tenido que colapsar 00:46:58

y te dejo allí un numerito para que tú sepas, en base al numerito que es, 00:47:02

qué ha pasado. 00:47:07

Lo tienes que programar tú, no es automático. 00:47:08

Pero tú tienes opciones mientras va tu código de decidir en determinado caso. 00:47:10

Y si pasa esto, explota con el número 307. 00:47:16

Y tú sabes que cuando explota con el número 307, el error es, no lo sé, no he podido leer el fichero. 00:47:20

Y el error 409 es, tengo conexión a internet. 00:47:26

Lo sabes tú que has programado. 00:47:31

Pero en general, ya se puede hacer y se puede leer, pero por ahora lo dejamos. 00:47:34

Asumamos que este de aquí es un profil 00:47:38

¿Vale? 00:47:41

¿Qué vamos a hacer? Pues vamos a 00:47:42

Vamos a hacer un menú 00:47:45

¿Vale? Que si te doy uno 00:47:57

Me dices si un número que te doy 00:48:00

Es primo o no 00:48:03

Y si te doy dos 00:48:04

Con uno es un programa 00:48:08

Para saber si es par o impar 00:48:11

Con dos 00:48:13

para si es múltiplo de un número 00:48:15

que te doy. 00:48:17

Entonces, yo te pido 00:48:19

hay un menú, ¿vale? 00:48:21

Para pintar el menú, llamo 00:48:22

pinta menú. 00:48:24

Pinta menú 00:48:27

escribe el menú 00:48:28

de las opciones que yo tengo. 00:48:30

¿Vale? Pregunta para vosotros. 00:48:33

¿Pinta menú es 00:48:35

una función 00:48:37

o un procedimiento? 00:48:38

Depende. 00:48:46

¿Sólo pinta el menú? 00:48:48

es un procedimiento 00:48:49

pinta el menú 00:48:50

y me pide la opción 00:48:53

y te devuelve la opción que ha elegido el usuario 00:48:54

sería una función 00:48:57

¿cómo lo queréis? 00:48:59

¿como procedimiento o como función? 00:49:02

como función 00:49:04

¿vale? entonces 00:49:07

yo pondré aquí 00:49:09

int opción elegida 00:49:10

es igual a 00:49:13

pinta menú 00:49:15

¿ok? ahora o me lo escribo 00:49:16

yo o si no aquí si vais aquí os lo dice o mira que no lo encuentro pinta menú quieres crearlo 00:49:19

aquí y me crea el el o sea maestro no el prototipo es eso vale basado sobre lo que 00:49:25

ha visto aquí él ha visto que lo que quieres tú es un int pues entonces te pongo un int vale y ya 00:49:40

que estoy te digo mira te pongo un retorno tanto tienes que poner fijaos que si yo lo haga así y le 00:49:47

digo oye a lo tú pues se me dice a vale como no lo metes en un lado asumo que esto es un 00:49:56

procedimiento como voy a esta ayuda fijaos también que él te lo pone privado y que quiere decir esto 00:50:02

ni idea public vale él te pone lo que él quiere y luego eres tú que si no te vale lo que ve desde 00:50:16

que allí pues lo modificas vale entonces aquí el pintar menos vale y el resultado de esta de 00:50:24

esta función irá en opción elegida vale entonces aquí yo tengo que hacer todo el código que me 00:50:36

Pinta el menú, le pide al usuario qué opción quieres, y luego la recoja, la lea, y a ese punto esa opción me la devuelve, ¿vale? 00:50:44

Entonces, quinta opción, es igual a C. 00:50:55

Lo que hago es escribir el menú, CISO. 00:51:01

Uno, par o impar. 00:51:05

Dos, múltiplo de N. 00:51:13

3, salí 00:51:18

3 opciones 00:51:29

¿vale? y ahora como soy 00:51:33

una función, quiero preguntarle 00:51:35

¿vale? ¿qué quieres hacer? 00:51:37

elige, y aquí 00:51:40

scanner 00:51:44

scan es igual a new scanner 00:51:45

de system.in 00:51:48

bueno, opción 00:51:50

opción es igual 00:51:55

a scan.next 00:51:57

y aquí 00:51:59

opción. Yo pinto el menú. El menú me dice las opciones que tengo, ¿vale? Me dice de elegir, a este punto 00:52:06

yo busco, leo una cosa por teclado, lo que he leído lo devuelvo. ¿A quién llegará? Aquí. Y este de aquí 00:52:20

será esta opción que yo he pintado 00:52:31

entonces la pondrá 00:52:33

si yo 00:52:34

escribo aquí opción 00:52:37

elegida, pasa esto 00:52:39

me ha escrito el menú 00:52:46

me dice elige, está funcionando 00:52:49

pero está parado, yo le pongo 3 00:52:52

y me dice 00:52:54

a 3 00:52:55

fijaos 00:52:56

soy pinta menú 00:52:59

pinta menú 00:53:11

ha acabado 00:53:22

esto lo está escribiendo el método 00:53:23

ha escrito todo esto 00:53:32

no ha acabado todavía 00:53:34

le pongo 3 00:53:35

acaba y esto lo escribe 00:53:37

el main 00:53:40

¿lo veis? 00:53:43

pregunta para vosotros 00:53:44

¿por qué esto no lo escribe aquí abajo? 00:53:46

porque cuando llega 00:53:55

a return se ha acabado 00:53:57

return es 00:53:59

he acabado 00:54:01

vuelve a quien me ha llamado 00:54:02

retorna, devuelve, vuelve a donde estabas antes. Entonces todo lo que está después de return es 00:54:04

inalcanzable. Se lo dice. Unreachable code. Código inalcanzable. Código inalcanzable. No puede llegar 00:54:12

aquí porque esto me bloquea antes. Por eso lo he apostado. Bueno, lo borro porque... ¿Os gusta? 00:54:20

Si le pongo "-7", pero debería decir, no me vale, y pedirte otra cosa. Pregunta, ¿quién no debería mirar esta cosa? 00:54:30

O sea, ¿es el Main que tiene que mirar que esta opción elegida esté bien, o es el mismo Pintamenu 00:54:55

que debería mirar si esta opción 00:55:05

está bien. 00:55:07

No lo sé. 00:55:10

Las dos son opciones 00:55:12

válidas. ¿Vale? 00:55:13

En un caso, aquí esto 00:55:15

lo debería meter en un while 00:55:17

que mientras, mirad, 00:55:19

asumo que esto valga menos uno. 00:55:27

Un valor 00:55:31

que no es válido. 00:55:31

Y te digo que 00:55:32

opción 00:55:34

elegida 00:55:36

sea menor que cero 00:55:38

menor que 1 00:55:42

y 00:55:43

opción elegida 00:55:45

sea mayor que 3 00:55:48

o sea una opción no 00:55:52

válida, entra aquí 00:55:54

dentro y pinta el menú 00:55:58

él lo que hará es, vale, muy bien 00:55:59

entra aquí dentro, como vale 00:56:03

menos 1 al principio, entro y 00:56:05

llamo el menú, si tú me das un 00:56:07

valor que no es 00:56:09

él volverá a escribir el pinta menú 00:56:10

porque lo vuelve a llamar 00:56:13

¿Y qué es un número? 00:56:28

Mientras que sea menor que 1 o mayor que 3, o sea, un valor no válido, quédate allí dentro. 00:56:31

No i. 00:56:38

Porque ningún número será nunca menor que 1 y a la vez mayor que 3. 00:56:40

¿Cuál es un número que es menor que 1 y mayor que 3? 00:56:46

No existe. 00:56:50

¿Vale? 00:56:51

Que te me he equivocado. 00:56:51

Vale. 00:56:53

¿Y vosotros por qué no lo habéis dicho? 00:56:54

entonces dice, ah si, dame un número 00:56:55

elige, y te digo, menos 8 00:56:58

y él dice 00:57:00

otra vez el menú 00:57:01

hasta que elija 00:57:03

2 00:57:07

esto lo he hecho 00:57:09

aquí, en el main 00:57:13

es una opción, otra opción 00:57:15

es no hacerlo en el main y hacerlo aquí 00:57:18

aquí dentro 00:57:20

¿lo creéis? 00:57:21

yo aquí podría hacer 00:57:25

también, no, voy a hacer 00:57:26

Entonces esta es una opción y esta es otra opción. Entonces si lo quiero delegar al pinta menú 00:57:28

y controla. Si elijo esta opción de aquí, llamo pinta menú. Nada más, pinta menú es tonto, 00:58:03

entre comillas, solo pinta y recibe una cosa, no controla nada. Si en vez uso esta otra opción, 00:58:17

pues uso pinta menú y controla, que es otro método que además de pintar el menú y leer, 00:58:23

ahora controla si está bien o no. Entonces, dile opción sea menor que 0 o opción mayor que 3, 00:58:29

Podría añadir aquí un if, esta misma cosa de aquí, opción no válida, no me gusta 00:58:53

mucho esto porque esta vez estoy comprobando la misma cosa dos veces. Entonces si hago 00:59:39

menos 5, mi reducción no vale. Una opción para evitar que haga dos veces esto. Hago 00:59:50

esta cosa de aquí. Entonces una vez lo hago siempre. Y leo la primera. Si tú me has dado 01:00:01

un valor que no es válido entonces entraré aquí te diré opción no válida y te lo vuelvo a pedir 01:00:39

y ahora entro en este bucle que mientras que tú me lo digas mal pues siempre me quedaré aquí vale 01:00:46

sin embargo si en un determinado momento me das una que es buena o me la das al primero una opción 01:00:52

buena me salto todo esto y salgo pero he escrito dos veces esto y ahí ahora tengo pinta menú que 01:00:58

lo que me hace escribir esto y leer 01:01:49

y cosas por el estilo, me devuelve la opción 01:01:51

si la opción es correcta 01:01:53

entonces salgo directamente 01:01:55

si la opción no es correcta, escribo opción 01:01:57

no valida y vuelvo a llamar pinta menú 01:01:59

de esta forma, si ahora 01:02:01

tengo que modificar el menú 01:02:08

en vez de tener que modificarlo dos veces 01:02:10

porque lo había escrito dos veces, pues solo 01:02:12

modifico aquí y ya está 01:02:14

y fijaos que ahora yo estoy llamando 01:02:16

desde el main un método 01:02:21

y este método salta aquí 01:02:22

que empieza a llamar esta cosa aquí 01:02:24

y aquí llama otro método que salta aquí 01:02:26

y esto ejecuta todo esto 01:02:28

al final devuelve la opción, vuelve aquí 01:02:30

que es quien ha llamado 01:02:33

lo pone aquí 01:02:35

y cuando llega aquí, quien lo devuelve 01:02:36

vuelve al main 01:02:38

del main salta un método 01:02:39

del método salta otro método, de este método vuelve 01:02:42

el primer método y cosa por esto 01:02:44

empiezo con el método main 01:02:46

el método main llama 01:02:56

el pinta 01:03:00

y controla 01:03:02

el método Pinta y Controla 01:03:03

llama el método 01:03:06

Pinta 01:03:08

cuando el método Pinta acaba 01:03:10

vuelvo al Pinta y Controla 01:03:15

cuando el Pinta y Controla 01:03:17

acaba, vuelvo al Main 01:03:18

Main 01:03:20

pongo por encima Pinta y Controla 01:03:25

pongo por encima el Pinta 01:03:28

quito el Pinta 01:03:29

imaginamos que me equivoco 01:03:31

Main, Pinta y Controla 01:03:34

pongo por encima pinta, vuelvo a pinta de controla, se da cuenta que está mal, vuelve a llamar el pinta, 01:03:36

quito el pinta, quito esto. Siempre vuelvo al último método llamado, no vuelvo directamente al main. 01:03:42

¿Lo veis? Esta cosa de aquí, de que meto una cosa, una cosa encima, una cosa encima, 01:03:54

y quito solo la última, se llama una pila. 01:04:02

Y la estudiaremos en el segundo trimestre. 01:04:11

Esta es hasta llamado last in, first out. 01:04:13

El último que ha llegado es el primero que quito. 01:04:28

Contrapuesto a fifo, first in, first out, 01:04:38

que es la cola que hacemos nosotros a correos. El primero que ha llegado bien atendido es el 01:04:43

primero que quito y ha llegado este el segundo que quito. Primo que ha llegado es el primero que quito. 01:04:52

Leaf o 50. Lo estudiaste. Más. Entonces con este de aquí hemos hecho nuestro control. Nosotros 01:04:58

llamamos pinta y controla 01:05:10

controla, hace un 01:05:12

pinta menú, el pinta menú 01:05:14

recoge una opción, si la opción 01:05:16

funciona, he acabado 01:05:18

si la opción no funciona 01:05:20

no es válida, entro aquí dentro 01:05:21

le diré opción no válida y volveré a repetir 01:05:24

esto hasta que me dé una opción válida 01:05:26

cuando estoy aquí 01:05:28

puedo asumir 01:05:29

tranquilamente que 01:05:34

opción elegida es un número entre 01:05:36

entre 1 y 3 01:05:39

Decidlo 01:05:46

Lo siento murmurarlo, pero no lo decís 01:05:48

¿Por qué? 01:05:50

Porque si no es un número entre 1 y 3 01:05:52

Me quedaré estancado aquí dentro 01:05:54

En este círculo aquí de pedir cosas 01:05:55

¿Vale? Entonces, ahora yo tengo 01:05:57

Opción elegida y sé que opción elegida 01:06:00

Es un número que vale 1, 2 o 3 01:06:01

Y tengo que hacer algo 01:06:03

En base a esa cosa. ¿Y qué hago? 01:06:05

Fitch 01:06:13

Opción elegida 01:06:14

Y tengo varias opciones 01:06:18

Casi 01:06:22

1, 2 puntos, casi, bueno ponemos el break que luego me lo miro, pre-apro, pongámoslo bonito que luego me lo miro, pre-apro, casi, 2 y casi 3, digamos que habría podido dejar que pillara cualquier número y poner aquí un default, ¿vale? 01:06:24

pero ahora como estoy mezclando la opción elegida con opción no válida, caos, ¿vale? 01:06:53

Tengo solo estas tres opciones, caso 1, caso 2 y caso 3. 01:07:00

Entonces, esto se enfada porque lo he escrito mal. 01:07:06

En caso 1 lo que quiero hacer es, hemos dicho paro en paro, ¿vale? 01:07:17

Entonces, llamaré el método par o impar. 01:07:27

¿Qué es esto? 01:07:36

Función o procedimiento. 01:07:39

Procedimiento, porque no lo guardo en ningún lado. 01:07:49

Él hará ahora el programita para hacer el par o impar. 01:07:52

Que lo escribiré aquí, en este método de aquí. 01:07:58

Esto será el metodito que me pillará un número y me dirá si es par o impar. 01:08:04

todo aquí. Si en vez es casi 2, lo que tengo que hacer es múltiplo de n. 01:08:09

Entonces llamaré el método múltiplo n, que estará aquí. 01:08:19

Y si no, si eso, adiós. Y sale. 01:08:30

dudas? Implementamos estos dos métodos que son muy fáciles, vale? Este de aquí, 01:08:36

scannerScan es igual a newScannerDeSystem.int, si eso, dame un número, int num es igual a 01:08:48

scan.exe si num módulo dos es cero, si eso num es par, es impar. Ya lo había importado. 01:09:11

Porque ya lo había utilizado aquí, ¿dónde estaba? Aquí, aquí. Entonces ya lo había 01:09:56

importada aquí. Pero se importa, fíjate, antes de la clase. Entonces, en toda la clase está importante. 01:10:01

Y la segunda opción empieza, que es este de aquí, de múltiplo a n. Es lo mismo, pero pido dos números. 01:10:10

Dame m, no, n. Y luego yo hago esto. 01:10:26

¿es múltiplo de n o no es múltiplo de n? 01:10:46

Sí. 01:11:03

Entonces ahora yo tengo un método, 01:11:04

un procedimiento que lo que hace es calcular si es par o impar 01:11:08

y un otro procedimiento que es calcular si un número es múltiplo de n o no. 01:11:12

Entonces ahora tengo mi programa. 01:11:23

Lanzo mi programa. ¿Qué quieres hacer? Pues el 66, pues opción no válida. El menos 7, opción no válida. 01:11:25

Pues dame un par o impar. Vale, dame un número. 8. Pues 8 es par. Y acabado. 01:11:38

Lanzo. Quiero múltiplo de n. Me dice dame un número 88. Dame n 5. Pues 88 no es múltiplo de 5. 01:11:45

y se ha acabado, lanzo esto 01:11:57

y digo, ¿qué quieres hacer? salir 01:12:02

pues, adiós 01:12:03

ahora 01:12:07

para completar 01:12:09

y definir esto 01:12:12

esta cosa de aquí 01:12:13

la quiero hacer 01:12:16

mientras 01:12:21

mejor, esta cosa de aquí 01:12:26

la quiero hacer mientras 01:12:32

si, mientras 01:12:33

tú no hayas elegido la opción 01:13:06

tres, que es salir 01:13:08

me quedo allí 01:13:09

y te pide otra vez el menú 01:13:11

te pongo el menú, tú eliges 01:13:13

crear el menú, 1, 2, entras 01:13:15

en 1, haces par en par, entras en 2 01:13:17

haces múltiplo par y vuelves aquí 01:13:19

otra vez, porque has elegido 01:13:21

1, 2, entonces lo vuelves a hacer 01:13:23

y me pides otra vez el menú 01:13:25

y así, así, así, todas las veces que me valga 01:13:27

hasta que tú me digas 3, que es salir 01:13:29

y entonces entrará aquí dentro 01:13:31

escribirá a ellos y saldrá 01:13:33

aquí hay algo raro 01:13:35

hay una paréntesis que no me 01:13:48

gusta 01:13:51

a play entonces y aquí me puede equivocar me puede equivocar ahora digo paro en par 01:13:52

pues le digo 88 es parte y vuelve al menú porque como la opción que elegido yo no es 01:14:07

tres, ha vuelto a pedirme el menú. Y ahora le digo, ¿me das otra vez para impar? Siete, pues es impar. Y vuelve al menú. Le digo, órame un múltiplo. Pues cinco es múltiplo de tres, pues no es múltiplo. Y vuelve al menú. Hasta que yo le diga salir. Entonces me dice adiós y acaba. 01:14:16

fijaos que mi main se ha quedado bastante limpio vale de que oye mira mientras la opción no sea 01:14:38

3 pues elige pinta y controla pinta menú y controla mira la opción elegida si es 1 2 o 3 01:14:56

en base a esto hace una cosa u otra 01:15:07

y vuelve arriba 01:15:09

todo lo que es el cálculo puro 01:15:10

lo he delegado 01:15:13

a otras funciones 01:15:15

o a otros métodos 01:15:17

podría haber hecho todo esto 01:15:18

sin ningún método 01:15:21

pero me había metido todo este código 01:15:23

de aquí, ahora estaría dentro del main 01:15:26

entonces el main sería mucho menos 01:15:27

libre 01:15:29

y por ahora 01:15:30

nosotros los métodos 01:15:35

O las funciones y procedimientos 01:15:39

Nos sirven más o menos para hacer 01:15:41

Más estructurado, más bonito 01:15:43

Nuestro código 01:15:44

Por poco más 01:15:46

Más reutilizable 01:15:48

Más bonito 01:15:51

Más organizado 01:15:52

Esto es lo que nos sirve para eso 01:15:54

Tened en cuenta que ahora yo tengo 01:15:56

Este método de aquí 01:15:59

Si mañana 01:15:59

Quiero hacer en otro lado 01:16:02

Un trozo de código 01:16:04

Que lo que haga es 01:16:07

ver si se hace múltiplo, no, no 01:16:08

pues pillo esto, lo copio allí y lo tengo 01:16:10

está organizado en funcionalidades 01:16:12

estructurado 01:16:16

funcionado 01:16:18

no oigo 01:16:19

no oigo vuestro compañero 01:16:24

ah, perdón 01:16:29

el cálculo que tenéis ahí en el link 01:16:30

¿está bien? 01:16:32

¿listo? 01:16:35

no, está mal, sí, ahora está bien 01:16:36

¿no está bien? 01:16:41

visitado, por ahí. 01:16:43

Sí. Vale. 01:16:46

Estructura de control 3: procedimientos y funciones - Contenido educativo

Del mismo autor…