Saltar navegación

Procedimientos 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 30 de octubre de 2023 por Stefano C.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Estoy grabando, por lo tanto, me autorizáis en el caso en que digáis algo a grabar vuestra voz, ¿vale? 00:00:00
Entonces, hoy lo que vamos a ver es completar la parte de estas instrucciones de control, 00:00:06
sentencias de control, o... ¿cómo se llaman? estructuras de control. 00:00:13
Si os acordáis, la idea era que, antes de empezar esta parte de la programación, 00:00:18
nosotros sabíamos hacer operaciones secuenciales, 00:00:23
esto detrás de esto, luego esto, luego esto, luego esto, ¿vale? 00:00:27
Lo hemos utilizado para algunos ejemplos, como calcular la red en cuadrado. 00:00:29
Pues pillas un lado, pillas... no, solo el lado, lo multiplicas por sí mismo, 00:00:33
y luego lo escribes en pantalla. Pues secuencial. 00:00:37
A un cierto momento hemos dicho que, en determinados algoritmos, 00:00:40
eso de hacer solo las cosas una tras otra, pues no nos sirve. 00:00:43
Entonces hemos encontrado algunos mecanismos, algunas estructuras, 00:00:47
que me permiten modificar el flujo secuencial de ejecución de un algoritmo, ¿vale? 00:00:53
Y hemos introducido tanto el if, que me permite hacer un bloque o no hacerlo, 00:01:00
en base a una condición, ¿vale? El if else, que me dice si la condición es verdadera, 00:01:06
haz este bloque de información, y si no es verdadera, haz otra, ¿vale? 00:01:11
Y estos son los condicionales. 00:01:16
Tenemos también el switch, pero, al fin y al cabo, el switch es un if cómodo, 00:01:18
es un if cómodo para determinadas circunstancias. 00:01:22
Todo lo que se hace con el switch se puede hacer con un if, 00:01:25
pero te sale un if dentro de un if dentro de un if, y a veces es un poco engorroso hacer, ¿vale? 00:01:27
Y luego hemos visto el comando iterativo, ¿vale? Tanto en formato while como en formato for. 00:01:34
Os recuerdo que existe también el do while, pero, sustancialmente, 00:01:39
tanto do while como for como do while son intercambiables. 00:01:43
Yo puedo cambiar algunas cosas, y en algunos lados es más cómodo uno, 00:01:46
en algunos casos es más cómodo el otro. 00:01:50
Os recuerdo que se usa while o do while cuando no sé el número de iteraciones que voy a hacer, 00:01:53
y uso el for cuando sí sé el número de iteraciones que voy a hacer. 00:01:58
Eso no quiere decir que tengo que tener un número claro mientras estoy programando. 00:02:01
El número podría ser n, donde n es la longitud de una palabra, 00:02:05
o el número que me ha puesto el usuario al principio. 00:02:09
Pues eso puede ser una variable, pero yo sé que cuando estará fijado a tiempo de ejecución 00:02:14
el número n, yo tengo que hacer n iteraciones de este programa. 00:02:19
Pues entonces uso un for. 00:02:23
Si en vez de no sé, porque es dame números hasta que pongas un cero, 00:02:25
y no sé cuántos números dará el usuario que no sean cero, 00:02:29
pues entonces el while es más cómodo normalmente, ¿vale? 00:02:32
Como idea general sobre la que trabajar. 00:02:35
Luego, vosotros que sabéis los dos, y habéis practicado ya bastante for y while, 00:02:38
deberíais ser capaces ahora, frente a un posible programa que entendéis 00:02:44
que tiene que reutilizar un programa iterativo, pensar, 00:02:48
oye mira, ¿esto me conviene hacerlo con un while o con un for? 00:02:52
Vamos a ver, y pensar, ¿necesito un índice que va incrementándose 00:02:54
dentro de cada uno de los ciclos? 00:02:58
Pues posiblemente el for es una opción buena. 00:03:01
¿No lo necesito? Pues posiblemente un while, ¿vale? 00:03:04
La tercera forma de modificar el flujo secuencial de ejecución de un programa 00:03:08
es lo que se llama, llamada función o procedimiento. 00:03:19
En realidad, y lo repetiré al final de esta clase, 00:03:23
en Java esto se llama métodos, ¿vale? 00:03:28
Y no son exactamente ni funciones ni procedimientos. 00:03:33
Pero nosotros todavía no estamos en programación orientada a objetos. 00:03:37
Nosotros todo lo que estamos haciendo ahora es como si estuviéramos en el pasado 00:03:41
y estuviéramos en el momento en que se programaba con programación estructurada. 00:03:46
¿Vale? Y en programación estructurada existen funciones y procedimientos. 00:03:51
¿Vale? Y ahora vamos a ver qué son, para qué sirven, 00:03:56
y cuál es la diferencia entre los dos. 00:03:59
Cuando veremos los objetos, pues cambiaremos esta cosa. 00:04:01
Ah, vale, no son más funciones o procedimientos, son métodos. 00:04:06
Y veremos cómo hay métodos estáticos, métodos no estáticos, 00:04:09
métodos para objetos, etcétera, etcétera, etcétera. 00:04:12
Como todavía ahora estos conceptos no los tenemos, no los podemos utilizar. 00:04:15
Vale. Si un programa repite muchas veces el mismo código, 00:04:19
a lo mejor pero con parámetros distintos, 00:04:24
ahora aquí os lo hago más grande y veis un ejemplo, 00:04:27
pues lo que se puede hacer es, en vez de escribir muchas veces el mismo código, 00:04:30
sacar este código en algún lado, darle un nombre, 00:04:36
y decir que cada vez que yo llamo ese nombre, 00:04:41
en realidad quiero ejecutar ese bloque de código. 00:04:44
Esa es la idea de la función y del procedimiento. 00:04:47
Por ejemplo, veamos este programito de ejemplo aquí. 00:04:50
No sé si se lee. 00:04:54
Esto es un programa que calcula área del rectángulo. 00:04:56
Entonces lo que hace es pillar un lado, pillar otro lado, 00:05:02
podría pillar escrito por teclado, me da igual. 00:05:06
Calcula la área del rectángulo, el perímetro, y luego lo escribe. 00:05:10
El rectángulo de lado no sé qué, no sé qué, tiene área no sé qué, 00:05:16
perímetro no sé qué. 00:05:20
Y yo lo que quiero hacer es hacer esta misma cosa para varios rectángulos distintos. 00:05:22
Este es el rectángulo 3x4, este es el rectángulo 5x10, este es el rectángulo 2x7. 00:05:27
La verdad es que el código es el mismo, 00:05:32
lo que cambia son los parámetros que le estoy dando. 00:05:36
Una opción que podemos tener nosotros es esa de poner aquí dentro de un while, 00:05:39
hacer que esto se repita las veces o de un for las veces que haga falta, 00:05:45
y sustancialmente me vale. 00:05:50
Otro método que puedo hacer es darme cuenta que esto es código repetido, 00:05:53
e intentar sacar este código fuera y darle un nombre. 00:05:57
Algo parecido a esto, creo, ahora luego vemos cómo se hace. 00:06:04
En algún lado, una cosa nueva que se llama calcular el perímetro, 00:06:10
le he dado este nombre, public, static, void, no suena de algo, 00:06:16
¿de qué no suena? del main, porque el main es un método en Java, 00:06:22
es el método principal por donde empieza el programa, 00:06:28
es la función principal que el programa empieza aquí. 00:06:32
Entonces, ¿qué quieren decir estas palabras? 00:06:36
¿Qué quiere decir public? No tengo ni idea. 00:06:39
¿Qué quiere decir static? No tengo ni idea. 00:06:41
¿Qué quiere decir void? Lo sabré dentro de un rato. 00:06:43
Este es el nombre, y ahora vemos los parámetros. 00:06:47
Por ahora quedan así, ¿por qué? 00:06:50
Porque estas son palabras que van muy entrelazadas con los conceptos de clase, 00:06:52
de objeto, de otras cosas más avanzadas como herencia, etc., 00:06:57
que por ahora no nos interesan porque no los conocemos. 00:07:03
Por lo tanto, por ahora nosotros son palabras mágicas que ponemos allí, 00:07:07
y son siempre así, public, static, void, para hacer un procedimiento. 00:07:10
Además de esto, yo aquí, entre paréntesis, puedo poner lo que se llaman los parámetros. 00:07:16
Son como variables, pero no están instanciadas en este momento. 00:07:24
La instanciaré cuando quiera utilizar el método, la función o el procedimiento, 00:07:30
estos son procedimientos, que se llama calcular el perímetro. 00:07:39
Cuando yo voy a llamar a este trozo de código, le digo, 00:07:43
mira, vas a hacer calcular el perímetro, pero vas a utilizar en particular 00:07:46
este dato como lado 1 y este dato como lado 2. 00:07:51
Entonces, estos se llaman parámetros formales. 00:07:56
Los lados 1 y 2 es como si para ti existieran ya, 00:08:04
cuando llamaran este método de aquí, te tienen que haber pasado estos valores. 00:08:09
Ahora veremos cómo. 00:08:14
Te habrán dicho que el lado 1 vale 3 y el lado 2 vale 7. 00:08:16
Entonces, aquí dentro, cuando tú usas lado 1, estás usando el valor que te han pasado, el 3. 00:08:21
Y cuando usas lado 2 aquí dentro, estás usando el 7. 00:08:27
¿Sabes cuáles son? No, son genéricos. 00:08:30
A mí me habrán metido en estos dos espacios de memoria un determinado valor. 00:08:33
Y aquí dentro usaré esos determinados valores de alguna forma. 00:08:41
Pilla el primer espacio de memoria, va a mirar qué hay dentro, 00:08:45
no sé qué hay dentro, pero pillarás eso, lado 1, 00:08:48
y lo multiplicas, ves el espacio de memoria llamado lado 2, 00:08:51
y lo que hay ahí dentro, que todavía no lo sé, pero lo tendrás que pillar y multiplicar. 00:08:55
Y el resultado lo encontrarás dentro de esta variable de aquí. 00:09:00
Y luego calculas el perímetro, lo mismo, usando lado 1 y lado 2, 00:09:04
que son los parámetros formales que te han dado, y a este punto escribes lo que sea. 00:09:07
Esto es el mismo código de antes. 00:09:12
Es el código ese que se repetía mucho. 00:09:15
¿Recordáis? 00:09:18
Pues ahora lo he sacado fuera y le he dado un nombre. 00:09:20
Tú te llamas cálcula área y perímetro de rectángulo. 00:09:23
Lo podría haber llamado cocodrilo, me da igual, es un nombre. 00:09:27
Claramente el nombre normalmente de una función o de un procedimiento 00:09:30
tiene que tener sentido, para que cuando tú lo uses, 00:09:34
si se llama calcular el perímetro, te esperes que calcule área y perímetro, 00:09:38
no que calcule el volumen, que no tiene porque un rectángulo no tiene volumen. 00:09:42
¿Dudas? 00:09:48
¿Sí? Vale. 00:09:51
Entonces, más o menos esto es la idea. 00:09:53
Yo tenía un código que se repetía mucho, lo he sacado fuera del main. 00:09:56
Ten en cuenta que este es fuera del main, ahora lo veremos con más detalle. 00:10:00
Le he dado un nombre, he escrito este código y le he dicho que tiene dos parámetros formales, 00:10:04
o sea que cuando llamaré este método, este procedimiento, 00:10:09
siempre le tendré que dar ¿cuántos valores aquí? 00:10:14
Dos. Uno que se asociará con lado 1 y uno que se asociará con lado 2. 00:10:19
¿Puede ser que le des uno o que le des tres? 00:10:25
No. 00:10:28
No, lo digo para esta pauta. 00:10:29
Digo que cuando tú creas otro, aquí puede haber uno, puede haber cero, puede haber tres. 00:10:31
¿Conoces otro método que tiene un solo parámetro? 00:10:35
Public static void main, y entre paréntesis está string carácteres demoníaco args. 00:10:41
Eso es que solo quiero un parámetro. 00:10:49
Que será un string corchete. 00:10:52
¿Qué es un string corchete? No tengo ni idea. 00:10:55
Porque todavía no he hecho los arrays. 00:10:57
Si hubiese hecho los arrays, sabría que es un array de strings. 00:10:59
Los parámetros pueden ser cuantos les da gana. 00:11:04
Ahora lo veremos. Uno, dos, tres, cuatro, cero. 00:11:07
Este método es sin parámetros. 00:11:10
¿Habéis visto otro método que utilizáis sin ponerle parámetros? 00:11:13
Por ejemplo, .next, .length para saber la longitud de una string, 00:11:20
el .next de scan, .next int, no pillan parámetros. 00:11:30
Pillan las paréntesis, eso son funciones, pero sin parámetros. 00:11:34
El parámetro se destila solamente a uno. 00:11:40
No, no es un parámetro. Es que ese método no pilla un parámetro. 00:11:43
Porque lo llama sobre un objeto. Eso no lo sabemos hacer todos. 00:11:46
¿Conocéis otro método que en vez de sí pilla un parámetro, por ejemplo? 00:11:49
Charat, que pilla un int, le ponéis un numerito dentro. 00:11:56
¿Conocéis otro? 00:12:00
System.out.println, que le ponéis dentro. 00:12:04
¿Un que queremos de qué tipo? 00:12:11
¿Un string? 00:12:17
Poner un int, este hace la conversión automática en string. 00:12:20
Pero lo que va allí dentro es un string. 00:12:23
Nosotros ya estamos usando esto. 00:12:27
Solo que no nos hemos parado a mirar. 00:12:29
El programa de antes, que calculaba tres rectángulos de tipos distintos, 00:12:33
ahora en el main, estos son los parámetros del main, 00:12:39
que no usamos porque no sabemos todavía que es. 00:12:43
Lo que hacemos es llamar tres veces este método externo, 00:12:48
cambiándole los parámetros que yo quiero. 00:12:54
Esto antes, ¿os acordáis? 00:12:58
Quería calcular el área del perímetro de un rectángulo 00:13:00
que tenga lado 3 y lado 4. 00:13:04
Pues ahora lo llamo así. 00:13:07
Este 3 se asociará con lado 1, con el primer parámetro. 00:13:09
Este 3 de aquí ahora se asocia con este valor. 00:13:17
Este 4 de aquí se asocia con este valor. 00:13:20
Y ahora aquí dentro, para esta ejecución de este método, 00:13:23
lado 1 vale 3 y lado 2 vale 4. 00:13:26
Hago todo como si fueran así. 00:13:29
Cuando lo vuelva a llamar la siguiente vez 00:13:31
y pongo como parámetros actuales 5 y 10, 00:13:33
actualmente los parámetros formales lado 1 y lado 2 00:13:38
valen 5 y 10, respectivamente. 00:13:43
Entonces, yo aquí pienso en abstracto. 00:13:48
¿Qué necesito para calcular el área del perímetro de un rectángulo? 00:13:52
Pues necesito un lado y el otro lado. 00:13:56
¿Y cuánto valen? No lo sé. 00:13:59
Estoy haciendo algo abstracto. 00:14:01
Estoy haciendo una función, un procedimiento 00:14:02
que valga para cualquier rectángulo posible. 00:14:05
Entonces, ¿qué hago? 00:14:08
En vez de ponerle aquí 3 y 4, 00:14:09
le digo que el lado corto se llamará lado 1 00:14:11
y el lado largo se llamará lado 2. 00:14:14
Siempre, o no sé, tanto da igual. 00:14:16
Tengo los dos lados, tengo dos medidas de lado. 00:14:19
No necesito los cuatro porque dos a dos son iguales. 00:14:21
Estos son los datos que necesito. 00:14:24
¿Y cuánto valen? No lo sé. 00:14:26
Yo voy a utilizar esta representación literal, 00:14:28
esta representación, ¿cómo decirlo? 00:14:35
No numérica, sino gráfica de estos datos. 00:14:40
Y voy a hacer lo que tengo que hacer con estos datos. 00:14:46
Esto es genérico. 00:14:49
Si yo os doy solo esto, ¿sabéis el área del rectángulo? 00:14:51
No, porque no sabéis todavía cuánto vale el lado 1. 00:14:56
¿Y dónde sé cuánto vale el lado 1? 00:15:00
Cuando llamo este método. 00:15:02
Aquí es donde fijo que en esta ejecución de esta función, 00:15:04
de este procedimiento, este señor, lado 1, vale 3. 00:15:08
Tú podrías poner aquí scan.exit, scan.exit 00:15:18
y cuando tú estás poniendo los datos te van uno aquí y uno aquí. 00:15:22
O haberlo pedido antes. 00:15:26
Dame la cosa A y ponlo en A. 00:15:27
Y luego dame otra cosa y ponlo en B. 00:15:30
Y luego aquí se llama perímetro de A, B. 00:15:32
La idea es que aquí hay dos parámetros. 00:15:38
Hay parámetros formales y parámetros actuales. 00:15:40
Los parámetros formales son los que no sé cuánto valen, 00:15:44
pero los uso de forma abstracta dentro del método. 00:15:47
Los parámetros actuales son los parámetros que uso 00:15:51
al momento de llamar y que vinculan, 00:15:55
hacen una bind entre el parámetro actual correspondiente 00:15:58
y el valor actual que le estoy dando. 00:16:04
Lo mismo, esto no cambia. 00:16:20
Es aquí, porque tú estás modificando los parámetros actuales, 00:16:22
pero esto se queda exactamente igual. 00:16:26
Cuando tú luego harás la unión dirás que el lado 1 corresponde a A, 00:16:28
pero no es que le pones A como carácter, 00:16:33
pones lo que está dentro de la memoria que se llama A. 00:16:35
O sea, irás a la variable, irás a su parte de int, 00:16:39
buscará el valor que está ahora mismo allí dentro, que es 18, 00:16:43
pues este 18 ahora está vinculado con A. 00:16:47
Fíjate que están en bloques distintos. 00:16:56
Fijaos en esto, el main acaba aquí. 00:16:58
La declaración del método, de este procedimiento, 00:17:04
no está dentro del main, es hermana al main. 00:17:08
Esto provoca algunos problemillas. 00:17:18
En plan, ¿puedo aquí utilizar una variable que está aquí? 00:17:20
Porque son bloques distintos. 00:17:26
Si yo quiero leer de teclado, o leo en el main, 00:17:29
y luego se lo paso por parámetro a esto, 00:17:32
o no leo en el main, leo directamente aquí, 00:17:35
pero el objeto scanner no lo puedo crear en el main 00:17:38
y luego usarlo en el método, porque en el método no existe. 00:17:44
¿Pero puedes crearlo en los dos? 00:17:50
Sí. 00:17:51
Normalmente lo creas donde tú quieres crearlo, no en todos lados. 00:17:54
Tú piensas en el algoritmo que quieres hacer, 00:17:59
y lo que quieres es, ¿quieres que sea el main que compruebe 00:18:02
si los datos son correctos y luego después los usa? 00:18:05
Pues pides aquí. 00:18:08
¿Quieres que el método mismo, cada vez que se lanza, 00:18:10
haga este trabajo? Pues lo haces aquí. 00:18:13
Pero es una decisión del diseño del programa tuyo. 00:18:15
Más dudas. 00:18:20
La única cosa que sí tiene que ser igual, 00:18:22
es que si yo te he dicho que este señor pilla un entero, 00:18:25
tú aquí me tendrás que poner un entero, 00:18:31
o me puedes poner la palabra gato, 00:18:35
porque te dice, este es un string, aquí quiero su int, 00:18:37
no los puedo conectar. 00:18:40
¿Puedo utilizar métodos que estén dentro de mi proyecto, 00:18:46
dentro de mi paquete? 00:18:49
Puedes usar muchas cosas. 00:18:52
Por ahora nosotros tenemos una clase, usamos esa. 00:18:53
¿Quién de vosotros ha usado paquete y se ha puesto a ver? 00:18:55
Es porque ha querido hacerlo y yo todavía no lo he explicado. 00:18:58
Nosotros por ahora, los métodos que necesitamos, 00:19:03
los metemos todos dentro de la misma clase, 00:19:06
y los usamos desde ahí. 00:19:08
Y además, los métodos actuales que nosotros creamos, son estáticos. 00:19:09
¿Qué quiere decir? 00:19:14
No lo sabemos, porque no sabemos programación orientada a los objetos. 00:19:15
Pero por ahora usamos esto. 00:19:19
Veremos que en un futuro, esto lo usamos muy poco. 00:19:21
Esto lo quitaré. 00:19:25
¿Más dudas? 00:19:27
Sigamos adelante. 00:19:33
Este es el primer ejemplito. 00:19:34
La idea que os tenéis que haber llevado con esto, 00:19:36
es que yo antes pienso, 00:19:39
que uso mi función o mi procedimiento de forma abstracta, 00:19:41
utilizando parámetros abstractos. 00:19:44
Aquí los uso como si supiera cuánto vale lado 1. 00:19:46
¿Cuánto vale lado 1? 00:19:50
Pues vale lado 1. 00:19:51
En un futuro me dirán cuánto vale. 00:19:52
Por ahora lo uso haciendo fórmulas genéricas. 00:19:54
Es como si yo os digo, ¿cómo se calcula el área? 00:19:57
Pues lado por altura. 00:20:00
No os estoy diciendo cuánto vale lado y cuánto vale altura. 00:20:03
Es una fórmula genérica. 00:20:06
Aquí, fórmula genérica. 00:20:07
Y luego, cuando os digo, 00:20:08
¿y lado vale 3 y altura vale 7? 00:20:09
Pues entonces vosotros podéis aplicar la regla 00:20:12
en base a los datos actuales que os he pasado. 00:20:15
Los parámetros actuales que os he pasado. 00:20:21
¿Entienden? 00:20:23
Esto lo estáis haciendo desde siempre. 00:20:24
Solo que de una forma un poquito más formal, 00:20:27
de hacerlo en programación. 00:20:32
¿Dudas? 00:20:36
Entonces, ¿qué es un procedimiento? 00:20:39
Un procedimiento es un conjunto de instrucciones 00:20:42
que cumple una determinada tarea. 00:20:45
¿Vale? 00:20:47
Hace algo. 00:20:48
Esta tarea puede depender de algunos valores, 00:20:49
que son los parámetros o no. 00:20:51
¿Vale? 00:20:54
Hemos dicho que, por ejemplo, 00:20:55
la length no necesita parámetros. 00:20:56
O la nextInt no necesita parámetros. 00:21:00
La print o la charAt, 00:21:04
pues sí necesita un parámetro para poder funcionar. 00:21:09
Eso lo decidís vosotros cuando creáis el procedimiento. 00:21:12
Si yo quiero hacer el procedimiento 00:21:15
que calcula la área del cuadrado 00:21:17
y no pido el lado, 00:21:19
quiero ver cómo lo hago. 00:21:21
Otra opción es que sea sin parámetros, 00:21:24
pero dentro de la propia procedura, 00:21:28
pida al usuario, dame un dato. 00:21:30
Pues eso se puede hacer. 00:21:33
Me explico mejor. 00:21:35
Si yo hago el método 00:21:37
de calcular el pedímetro de un cuadrado, 00:21:39
que es lado por 4, 00:21:42
puedo tener dos opciones. 00:21:44
Una es que cuando llamen este procedimiento 00:21:46
ya sepan el lado y me lo pasen a mí. 00:21:49
Entonces no necesito poner un parámetro. 00:21:52
O podría ser que tú puedes llamarlo sin parámetro 00:21:56
y lo que hace el procedimiento dentro 00:21:59
es crearse un objeto scan 00:22:01
y pedir al usuario, dame el lado del cuadrado. 00:22:03
Y el usuario lo pone allí, 00:22:05
entonces no necesito tener un parámetro que me pasen. 00:22:07
Lo pide el mismo método, 00:22:11
el mismo procedimiento. 00:22:13
¿Se entiende? 00:22:15
Eso lo decido yo. 00:22:17
Ejemplos de posibles procedimientos. 00:22:21
Está aquí. 00:22:27
Calcula área. 00:22:29
Recibe el lado 1 y el lado 2. 00:22:31
¿Qué hará esto? 00:22:35
Pues pillará el lado 1, 00:22:37
lo multiplicará por el lado 2 00:22:39
y lo que sea lo imprime en pantalla. 00:22:41
¿Sí? 00:22:43
Otro método, saluda. 00:22:45
¿Qué parámetros tiene este? 00:22:47
Ninguno. 00:22:49
Entonces este señor te dice hola. 00:22:51
¿Sí? 00:22:53
El método saluda, 00:22:55
¿qué hará? 00:22:57
Hola y el nombre que me ha pasado. 00:23:01
Si yo le pongo saludo entre comillas, 00:23:03
le pongo Estefano, 00:23:05
pues le dirá hola Estefano. 00:23:07
¿Dudas? 00:23:09
Vamos a verlo. 00:23:13
¿Cómo se declara un procedimiento? 00:23:17
Por ahora estamos con procedimientos. 00:23:19
En cuanto llegamos a las funciones 00:23:21
vemos la diferencia. 00:23:23
Un procedimiento se declara con 00:23:25
public, static, void, nombre del procedimiento, 00:23:27
abierta paréntesis, 00:23:29
tipo 1, parámetro 1, 00:23:31
coma tipo 2, parámetro 2, 00:23:33
coma tipo 3, parámetro 3, 00:23:35
coma... 00:23:37
¿Cuántos parámetros yo quiero? 00:23:39
¿Sí? 00:23:41
Al final, 00:23:43
abro un bloque, 00:23:45
pongo aquí el código 00:23:47
que tiene este nombre, 00:23:49
el código, el cuerpo del procedimiento 00:23:51
y cierro el bloque. 00:23:53
Esto como hermano del main. 00:23:57
No dentro del main, 00:23:59
sino fuera del main. 00:24:01
Por arriba, por abajo, me da igual. 00:24:03
Pero dentro del class. 00:24:05
¿Recordáis public class, 00:24:07
el nombre de la clase, y abro un bloque? 00:24:09
Dentro de ese bloque, 00:24:11
pero fuera del main. 00:24:13
Es hermano del main. 00:24:15
Ni dentro, 00:24:17
ni fuera de clase. 00:24:19
O sale algún error de 00:24:21
¿Qué es esto? 00:24:23
Y lo he metido mal. 00:24:25
¿Cómo se llama 00:24:27
este procedimiento? 00:24:29
Utilizando el nombre 00:24:31
que he puesto arriba, 00:24:33
abierta paréntesis, 00:24:35
el valor actual 00:24:37
del parámetro 1, 00:24:39
coma el valor actual 00:24:41
del parámetro 2, 00:24:43
coma etc, etc. 00:24:45
Estos valores tienen que estar 00:24:47
asociados con el tipo 00:24:49
que he puesto aquí. 00:24:51
Si aquí he puesto que es tipo 1, 00:24:53
que se llama nombre, 00:24:55
y es un string, pues este valor 00:24:57
de aquí tiene que ser un string. 00:24:59
No los puedo mezclar. 00:25:01
Va a decir, tú querías un string 00:25:03
e un int, he dado un int y un string. 00:25:05
Vale igual, los datos los tiene. 00:25:07
Tiene que ir con el orden que yo he fijado. 00:25:09
Ejemplos. 00:25:19
Aquí yo tengo un main. 00:25:27
Lo vamos a ver después. 00:25:29
Tengo el método saluda, 00:25:31
y el método saluda que pilla un string. 00:25:33
¿Qué hace el método saluda? 00:25:35
No pilla ningún parámetro. 00:25:37
Y lo único que hace es 00:25:39
hola a todos. 00:25:41
Si os fijáis, aquí no uso ningún parámetro. 00:25:43
Hará siempre lo mismo. 00:25:45
Porque no es paramétrico, 00:25:47
no depende de algo que le ponga aquí 00:25:49
para hacer su trabajo. 00:25:51
Siempre hará lo mismo. 00:25:53
Sin embargo, 00:25:55
saluda que recibe 00:25:57
un nombre de tipo string. 00:25:59
Aquí mi parámetro 00:26:01
formal se llama 00:26:03
nombre. 00:26:05
Entonces aquí dentro puedo utilizar nombre. 00:26:07
¿Y cuál es nombre? No lo sé. 00:26:09
Lo sabré cuando me llaman. 00:26:11
Cuando llamarán al método saluda 00:26:13
con un string, 00:26:15
pues entonces sabré cuánto vale. 00:26:17
Fijaos que los dos señores 00:26:19
se llaman igual. 00:26:21
Los dos se llaman saluda. 00:26:23
Entonces, cuando llaman saluda, 00:26:25
¿cómo hago yo a saber 00:26:27
si tengo que utilizar el de arriba o el de abajo? 00:26:29
Según el parámetro. 00:26:33
Lo que se llama la firma del método. 00:26:35
¿Vale? 00:26:37
Nombre y tipos de datos 00:26:39
de los parámetros. 00:26:41
Saluda, sin nada, 00:26:43
es un método distinto, 00:26:45
es un procedimiento distinto de saluda con string. 00:26:47
Que es distinto 00:26:49
de saluda con int. 00:26:51
Que es distinto de saluda con string e int. 00:26:53
Que es distinto de int-string. 00:26:55
¿Sí? Todos se llaman saluda, 00:26:59
pero este método saluda 00:27:01
es sobrecargado, en cierto sentido, 00:27:03
con varios posibles parámetros. 00:27:05
Y cuando tú lo llamas, 00:27:07
según los parámetros que pones, 00:27:09
pues él sabrá 00:27:11
si tiene que utilizar esto o esto. 00:27:13
¿Puedo hacer dos métodos 00:27:15
o dos procedimientos 00:27:17
que se llamen saluda 00:27:19
y que tengan los dos string nombre 00:27:21
y otro string apellido 00:27:23
y hagan cosas distintas? 00:27:25
No. 00:27:27
Si yo tuviera aquí, pongamos aquí 00:27:31
string apellido. 00:27:33
Cuando yo te llamo saluda de Stefano, 00:27:35
¿cómo sabes tú 00:27:37
si tienes que ejecutar esto o esto 00:27:39
si los dos tienen un string? 00:27:41
Entonces no sería determinista. 00:27:43
El procesador llegaría allí 00:27:45
y diría, mira, 00:27:47
tengo dos opciones para poder ejecutar 00:27:49
y no sé cuál de las dos quieres tú. 00:27:51
Porque tú me has dicho Stefano 00:27:53
y yo no sé 00:27:55
si esto es un apellido o es un nombre. 00:27:57
Para mí es un string. 00:27:59
Y tengo dos procedimientos 00:28:01
que reciben un string. 00:28:03
Pues eso no me vale. 00:28:05
Puedo hacer varios procedimientos 00:28:07
que se llamen igual, 00:28:09
pero tienen que diferir 00:28:11
en los tipos, o sea, 00:28:13
tienen que ser distintos en los tipos 00:28:15
de datos que reciben. 00:28:17
¿Cuántos métodos saluda puede hacer máximo? 00:28:21
Infinitos. 00:28:27
Con que yo ponga más parámetros 00:28:29
y que no coincidan con parámetros, 00:28:31
todo lo saluda que yo quiera. 00:28:33
¿Dudas? 00:28:35
Entonces, ¿cómo llamo estos? 00:28:37
Por ejemplo, yo tengo un main 00:28:43
que llama saluda. 00:28:45
¿Cuál estoy llamando, el de arriba o el de abajo? 00:28:47
El de arriba. 00:28:49
No tiene parámetros, llamo esto. 00:28:51
Me dirá hola a todos. 00:28:53
Luego llamo saluda con dentro un string. 00:28:55
¿Cuál está llamando? 00:28:57
El de abajo. 00:28:59
Y dirá hola Stefano. 00:29:01
Luego me creo una variable 00:29:03
que se llama n, 00:29:05
que dentro tiene Paco, 00:29:07
y llamo saluda de n. 00:29:09
¿Qué hará? 00:29:11
La de abajo. 00:29:13
Y escribirá hola Paco. 00:29:15
O sea, que yo aquí 00:29:17
puedo poner un literal 00:29:19
o una variable. Variable y literal 00:29:21
son la misma cosa, al fin y al cabo, 00:29:23
en tiempo de ejecución, simplemente yo me iré a mirar 00:29:25
en la trozo de memoria 00:29:27
que se llama n, lo que hay allí dentro. 00:29:29
Y ese es el valor que utilizaré. 00:29:31
Me aparecerían tres saludos. 00:29:39
Saluda hola a todos, 00:29:41
hola Stefano, 00:29:43
hola Paco. 00:29:45
Vamos a ver 00:29:51
el prueba 4. 00:29:53
Tengo el main. 00:29:55
Tengo ahora aquí 00:29:57
un programa que se llama 00:29:59
repitesaludo, 00:30:01
que recibe dos parámetros. 00:30:03
String nombre, 00:30:05
int repeticiones. 00:30:07
Y lo que hace aquí dentro, 00:30:09
sin saber qué es nombre, qué es repeticiones, 00:30:11
hace esto. 00:30:13
¿Qué os espera ahí que abra? 00:30:15
¿Repite qué? 00:30:17
¿Repite qué? 00:30:27
¿Repite qué? 00:30:31
Imprime en pantalla qué. 00:30:33
Hola el nombre que le he pasado, ¿cuántas veces? 00:30:37
¿Cuántas veces? 00:30:41
No, aquí es nombre. 00:30:43
¿Cuántas veces? 00:30:47
¿Cuántas veces? 00:30:51
Repeticiones veces, 00:30:53
hola nombre. 00:30:55
Entonces si yo hago 00:31:01
repitesaludo de Luis, 00:31:03
coma cuatro, 00:31:05
¿qué me hace? 00:31:07
Hola Luis, hola Luis, hola Luis, 00:31:09
hola Luis, cuatro veces, 00:31:11
hola Luis. 00:31:13
¿Dudas? 00:31:17
Si yo copio esto 00:31:21
y lo pego aquí, 00:31:23
y le pongo que 00:31:25
repeticiones es igual a cuatro 00:31:27
y nombre es igual a Luis, ¿qué cambia? 00:31:29
¿Qué hace? 00:31:31
Lo mismo. 00:31:33
Esto de aquí 00:31:35
es como funciona 00:31:37
la llamada de método, 00:31:41
es como si en esta línea de aquí 00:31:43
yo la borrara 00:31:45
y copiara el código 00:31:47
que está aquí dentro, 00:31:49
aquí, ¿vale? 00:31:51
Sostituyendo donde aquí pone 00:31:53
nombre, Luis, 00:31:55
y donde aquí pone repeticiones, 00:31:57
cuatro. 00:31:59
¿Se entiende? 00:32:01
No, si hago menor o igual 00:32:09
me hace repeticiones más uno, 00:32:11
porque empieza de cero. 00:32:13
Si yo pongo cuatro, 00:32:15
cero, uno, dos y tres, 00:32:17
y a cuatro sale, son cuatro veces. 00:32:19
¿Sí? 00:32:21
Puedes hacer de i igual a uno 00:32:23
a i menor o igual a repeticiones, 00:32:25
siempre son cuatro veces. 00:32:27
Con esto podéis jugar vosotros, ¿vale? 00:32:29
Nos vendrá bien esto 00:32:31
y es porque lo veis así, 00:32:33
porque cuando tendremos los arrays 00:32:35
la primera posición de la array es la cero. 00:32:37
Entonces me vale, 00:32:39
me viene mejor que i empiece de cero. 00:32:41
¿Más dudas? 00:32:45
Vale. 00:32:53
Entonces la idea es 00:32:55
simplemente esta, yo tengo un método. 00:32:57
Hemos hecho algunos ejercicios 00:32:59
donde un cierto 00:33:01
trozo de 00:33:03
método, 00:33:05
trozo de código se repetía varias veces. 00:33:07
Pues yo allí habría podido sacarlo fuera, 00:33:09
poner allí, 00:33:11
darle un nombre y decir 00:33:13
todas las veces que yo tenía, pues repite este nombre. 00:33:15
¿Vale? 00:33:17
Ahora para luego hacemos más ejemplos después. 00:33:19
Los procedimientos 00:33:21
como tales 00:33:23
se pueden utilizar también 00:33:25
con la idea 00:33:27
organizar el código, ¿vale? 00:33:31
En vez de hacer estos programas 00:33:33
absurdos de complejos que tenéis 00:33:35
vosotros con todo metido allí, 00:33:37
yo podría decir, oye mira, 00:33:39
mi programa main 00:33:41
es esto. 00:33:43
Inicializa el sistema, 00:33:45
calcula datos, escribe el resultado. 00:33:47
Tres pasos. 00:33:49
Este es el main. 00:33:51
Y luego ahora irme en cada uno 00:33:53
de estos métodos y hacer 00:33:55
todo el código para inicializar el sistema, 00:33:57
todo el código para calcular 00:33:59
los datos, todo el código para escribir 00:34:01
el resultado. 00:34:03
Además, si yo lo hago así, 00:34:05
puedo pillar tres grupos de trabajos 00:34:07
y decirle, oye mira, 00:34:09
tú tienes que encargarte de inicializar 00:34:11
el sistema, tú de calcular 00:34:13
los datos y tú de escribir 00:34:15
los resultados. Luego 00:34:17
vosotros desarrolláis por separados 00:34:19
a lo mejor con los parámetros que te he 00:34:21
dado yo, ¿vale? 00:34:23
Los distintos programas, luego 00:34:25
los pongo todos juntos y he trabajado 00:34:27
en paralelo. 00:34:29
Entonces hago más rápido. 00:34:31
Realmente esto necesita que antes alguien 00:34:33
sepa de que va el sistema, 00:34:35
que lo haya dividido en métodos, 00:34:37
o sea, en una descomposición funcional, 00:34:39
algo parecido al que os digo que tenéis 00:34:41
que hacer vosotros cuando hacemos los ejercicios, 00:34:43
¿vale? Y luego ha asignado 00:34:45
a varios grupos de trabajos 00:34:47
trozos de este sistema. 00:34:49
¿Os acordáis cuál era el ejercicio 00:34:51
que hemos hecho el viernes? Me parece 00:34:53
que tenía como tres fases. Antes 00:34:55
ver si los números eran positivos 00:34:57
o qué era, y luego ver 00:34:59
que quedaban como tres ejercicios 00:35:01
en uno. ¿Os acordáis? 00:35:03
Pues ahora a lo mejor lo buscamos 00:35:05
después, repillamos eso 00:35:07
e intentamos traducirlo a una 00:35:09
cosa de ese estilo. 00:35:11
¿Vale? 00:35:13
¿Dudas? 00:35:15
¿Dudas sobre los procedimientos? 00:35:19
¿Para qué sirven? 00:35:21
Para no escribir varias veces el código, 00:35:23
para 00:35:25
ordenar el código 00:35:27
y también la tercera 00:35:29
cosa interesante es que 00:35:31
si yo uso la misma... 00:35:33
Pongamos el calcular el área del cuadrado, 00:35:35
¿vale? Si yo lo uso muchas veces 00:35:37
en mi programa, si yo 00:35:39
lo escribo cada vez como se 00:35:41
calcula y luego me doy cuenta que 00:35:43
quien me ha dado la fórmula se ha equivocado 00:35:45
y en vez de el por 00:35:47
tenía que utilizar otra variable, 00:35:49
otra operación, pues debería 00:35:51
ir a buscar en todo mi programa 00:35:53
las mil veces que lo he utilizado 00:35:55
y modificarlo. 00:35:57
Si yo cada vez que he utilizado 00:35:59
ese procedimiento 00:36:01
llamaba el método calcular área 00:36:03
ahora yo me voy 00:36:05
al método calcular área, lo soluciona 00:36:07
allí el problema y automáticamente 00:36:09
se ha solucionado todas las veces que se ha llamado. 00:36:11
¿Sí o no? 00:36:15
¿Dudas? 00:36:17
Vale. 00:36:19
¿Entonces qué es 00:36:21
en vez de una función? Una función lo sabéis 00:36:23
vosotros, que sois 00:36:25
la mayoría de vosotros 00:36:27
unos cuantos de vosotros habrán pasado por 00:36:29
bachillerato y sabéis perfectamente que es una función. 00:36:31
¿Qué es una función? 00:36:33
¿Recordáis? 00:36:39
f de x es igual a 00:36:41
x cuadro más tres 00:36:43
punto y coma. ¿Qué es eso? 00:36:45
Es una máquina, ¿vale? 00:36:47
Es una máquina en la que tú pones 00:36:49
un input, la x, un valor 00:36:51
de la x, y él te lo transforma 00:36:53
en otro input. 00:36:55
Pero la particularidad de la función 00:36:57
es que te devuelve algo. 00:36:59
Cuando tú 00:37:01
llamas una función, le das 00:37:03
unos parámetros de entrada 00:37:05
y él te da un 00:37:07
resultado de la función. 00:37:09
Cosa que si os fijáis 00:37:11
el procedimiento no hace. 00:37:13
El procedimiento tú le dices, haz algo 00:37:15
y él lo hace. Imprime por pantalla 00:37:17
calcula y hace así. 00:37:19
No te devuelve un valor. 00:37:21
No crea un valor, lo calcula y te dice 00:37:23
mira, aquí está el resultado 00:37:25
de tu operación, el resultado de tu 00:37:27
función. Eso no lo hace. 00:37:29
La función sí. 00:37:31
La función es parecida a un procedimiento, 00:37:33
pero sirve para obtener un determinado 00:37:35
resultado que se devolverá 00:37:37
al término de la función. 00:37:39
Es decir, algo parecido 00:37:43
a esto. 00:37:45
Antes yo hacía 00:37:47
calcularea. 00:37:49
Y era el calcularea 00:37:51
que hacía lado por lado 00:37:53
y escribía en pantalla 00:37:55
el resultado es 37. 00:37:57
Pero este 37 00:37:59
o 40, yo no lo tenía. 00:38:01
Lo tenía impreso 00:38:03
pero era en el procedimiento. 00:38:05
Y si yo lo quería utilizar 00:38:07
donde se llama 00:38:09
en el main, es decir, 00:38:11
o sea, en el main, es decir, 00:38:13
esto calcularea el perímetro 00:38:23
y me lo escribe en pantalla. 00:38:25
Y si yo quisiera en el main 00:38:27
utilizar este resultado, utilizar 00:38:29
el área, por ejemplo, 00:38:31
¿podría hacerlo o no? 00:38:35
No, porque no está allí. 00:38:37
No hay ninguna forma 00:38:39
aquí que me diga 00:38:41
oye mira, te lo doy, 00:38:43
te doy el área, 00:38:45
tú guárdatelo en una variable 00:38:47
porque esto será el área calculada. 00:38:49
No puedes. ¿Cómo lo hace? 00:39:11
Un procedimiento, 00:39:13
la diferencia de procedimiento funciona 00:39:15
es que el procedimiento no puede hacer esto, 00:39:17
el procedimiento no hace esto. 00:39:19
Y la clave está aquí. 00:39:21
Void, que en inglés 00:39:23
quiere decir 00:39:25
vacío, 00:39:27
quiere decir que esta cosa 00:39:29
de aquí no devuelve 00:39:31
nada. Tú no puedes hacer aquí 00:39:33
int x es igual a 00:39:35
calcular el perímetro, 00:39:37
este calcula del perímetro no te devuelve 00:39:39
nada. 00:39:41
La función 00:39:45
es distinta. 00:39:49
La función, cuando tú llamas 00:39:51
calcula área sobre estos dos, 00:39:53
te calculará el área 00:39:55
y al final de la función 00:39:57
pilla estos datos calculados 00:39:59
y lo puede hasta escribir en pantalla, 00:40:01
no hay que ser ese el problema, pero al final de eso 00:40:03
te lo devuelve 00:40:05
este valor calculado, 00:40:07
lo devuelve a 00:40:09
quien lo ha llamado, en este caso 00:40:11
al main 00:40:13
y entonces el main lo puede almacenar 00:40:15
en una variable. 00:40:17
La diferencia entre procedimiento 00:40:21
y función es que la función 00:40:23
devuelve algo y entonces 00:40:25
lo puedo guardar en una variable, mientras el procedimiento 00:40:27
no devuelve nada y por lo 00:40:29
tanto no puedo 00:40:31
guardar su resultado en algún lado. 00:40:33
Lo que tú dices es que 00:40:37
de hecho esto no es 00:40:39
calcular el área del perímetro, 00:40:41
o devuelvo un array 00:40:43
donde la primera posición 00:40:45
es un área 00:40:47
del segundo del perímetro, 00:40:49
pero no sabemos que es un array 00:40:51
por lo tanto no. 00:40:53
O devuelvo un string 00:40:55
donde dentro está el área, 00:40:57
punto y coma, 00:40:59
y luego eres tú 00:41:01
que te la tiene que buscar la vida. 00:41:03
¿O eres tú que te la tiene que buscar la vida 00:41:05
para dividir esta en 12 00:41:07
y usarla como número? 00:41:09
Por ahora sí. 00:41:15
¿Os veo en movimiento porque ya ha sonado 00:41:17
y es recreo? 00:41:19
No, todavía no. 00:41:21
Vale, entonces 00:41:23
la idea es esta, ¿vale? 00:41:25
Entonces ahora yo tengo creaSaludo 00:41:27
de nombre, y esto puede 00:41:29
que me escriba en pantalla o no, no lo sé, 00:41:31
pero sé que al final de esta operación 00:41:33
deberá haber creado un string 00:41:35
que es mi saludo creado, 00:41:37
y yo este saludo creado lo puedo guardar 00:41:39
dentro de saludo. 00:41:41
¿Cómo se hace esto? 00:41:45
La función se declara como antes, 00:41:53
public static, 00:41:55
solo que aquí en vez de void 00:41:57
va el tipo de dato 00:41:59
y se devuelve al final 00:42:01
public static int 00:42:03
nombre 00:42:05
public static string 00:42:07
saludo 00:42:09
¿Y cómo se llama? 00:42:13
Pues igual que antes, 00:42:15
solo que ahora 00:42:17
lo que puedo hacer es que 00:42:19
el mismo tipo que he usado aquí arriba 00:42:21
lo puedo usar aquí 00:42:25
para almacenar 00:42:27
el resultado de esta función 00:42:29
Funcionará lo que sea la gana 00:42:31
empaquetará un objeto 00:42:33
de tipo 00:42:35
devuelto, y esta cosa de aquí 00:42:37
esta variable de aquí 00:42:39
la puedo guardar en una variable del mismo tipo 00:42:41
Si una función devuelve string 00:42:43
no la puedo guardar en un int 00:42:45
¿Sí? 00:42:49
Ejemplo más concreto 00:42:51
y luego os dejo ahí 00:42:53
Por ejemplo, public static 00:42:55
string 00:42:57
¿Lo veis que aquí en vez de void esta string? 00:42:59
Quiere decir que es una función 00:43:01
Saluda string nombre 00:43:03
Entonces ahora yo me creo una variable 00:43:05
que se llama resultado 00:43:07
le digo hola más nombre 00:43:09
entonces resultado vale hola nombre 00:43:11
y lo que hago es esto 00:43:13
return resultado 00:43:15
este return quiere decir que 00:43:17
cuando acaba este procedimiento 00:43:19
lo que hay dentro del resultado 00:43:21
te lo devuelve 00:43:23
lo que quieras 00:43:25
lo puedes ignorar 00:43:27
o lo puedes guardar 00:43:29
en una variable 00:43:33
Entonces 00:43:37
dentro de la variable saludo1 00:43:39
me guardo el resultado de saludastéfano 00:43:41
o sea que esto será holastéfano 00:43:43
que se guarda aquí dentro 00:43:45
luego creo Paco 00:43:47
llamo string saludo2 00:43:49
que es una nueva variable 00:43:51
y ahora n 00:43:53
pues esto me pondrá 00:43:55
hará todo lo que hace saluda 00:43:57
que es crear la string holapaco 00:43:59
y holapaco se guarda dentro saludo2 00:44:01
y a este punto imprimo saludo1 00:44:03
y imprimo saludo2 00:44:05
esto imprimará holastéfano 00:44:07
holapaco 00:44:09
Venga 00:44:15
después del recreo seguimos 00:44:17
Entonces 00:44:19
ahora que hemos vuelto 00:44:21
de recreo 00:44:23
estamos hablando de dos cosas 00:44:25
procedimientos y funciones 00:44:27
procedimientos son trozos de 00:44:29
códigos que tienen un nombre 00:44:31
que tienen que hacer una determinada tarea 00:44:33
y que no me espero que me 00:44:35
devuelvan nada 00:44:37
funciones son trozos de código que hacen 00:44:39
una determinada tarea 00:44:41
y además me espero que al final 00:44:43
me den algo 00:44:45
que sea un 00:44:47
booleano para decirme si han podido 00:44:49
hacer la tarea o no 00:44:51
que sea el resultado de la operación 00:44:53
que han hecho 00:44:55
que sea la concatenación 00:44:57
de mil cosas que me pasan 00:44:59
para que luego yo las descomponga 00:45:01
y vaya leyendo toda la parte 00:45:03
que tengo que leer de lo que me han pasado 00:45:05
algo 00:45:07
ese algo lo decido yo como programador 00:45:09
te devuelvo un int 00:45:11
te devuelvo una serie 00:45:13
un string que es una serie de int 00:45:15
preparados por coma que te paso allí 00:45:17
66 int porque me da la gana 00:45:19
vosotros sois los programadores 00:45:21
vosotros decidís que hacer 00:45:23
entonces 00:45:25
en los procedimientos 00:45:27
y aquí tengo public static void 00:45:29
el tipo de vuelta es void 00:45:31
void quiere decir nada, vacío 00:45:33
entonces no te estoy devolviendo nada 00:45:35
en las funciones public static 00:45:37
es un tipo 00:45:39
yo quiero que al final de mi función 00:45:41
me devuelva algo de ese tipo 00:45:43
si aquí he puesto string 00:45:45
que era un string al final 00:45:47
si he puesto un int, un int 00:45:49
si un double, un double 00:45:51
por ahora nosotros aquí utilizaremos 00:45:53
solo tipos primitivos 00:45:55
y string 00:45:57
que no es un tipo primitivo 00:45:59
pero casi 00:46:01
entonces 00:46:03
antes estamos viendo esto 00:46:05
entonces 00:46:07
lo que estamos haciendo aquí es 00:46:09
llamar el método saluda 00:46:11
saluda es un método que he creado que tiene que devolver un string 00:46:13
villa como parámetro 00:46:15
otro string, entonces cuando yo llamo 00:46:17
saluda siempre le tengo que poner 00:46:19
un string como parámetro 00:46:21
que será el parámetro actual 00:46:23
lo que hace él es pegar delante 00:46:25
de lo que le he pasado yo 00:46:27
un hola espacio 00:46:29
y luego me lo devuelve 00:46:31
el return es esa cosa que me dice 00:46:33
devuelve a quien te he llamado 00:46:35
este valor 00:46:37
si yo no pongo string saludo1 00:46:39
aquí arriba 00:46:41
este método devolverá algo 00:46:43
al final me dará 00:46:45
esta información 00:46:47
pero como yo no la guardo 00:46:49
en ningún lado, esta información se perderá 00:46:51
y ya está 00:46:53
o sea que yo puedo utilizar una función 00:46:55
sin recibir nada 00:46:57
poniendo solo salud 00:46:59
pero normalmente 00:47:01
si lo he programado yo 00:47:03
segundo solo 00:47:06
entonces decíamos 00:47:08
no me acuerdo si estaba diciendo antes 00:47:12
pero el concepto es que 00:47:14
ah, si 00:47:16
la función devuelve algo 00:47:18
y yo lo puedo recoger 00:47:20
desde donde he llamado esta función 00:47:22
puedo no recogerlo, puedo no mirar 00:47:24
lo que me ha devuelto pero 00:47:26
si en mi programación cuando yo he pensado 00:47:28
que hago una función o un procedimiento 00:47:30
y me doy cuenta que lo que está 00:47:32
devolviendo esta función no lo uso nunca 00:47:34
pues posiblemente ese sea un procedimiento 00:47:36
y yo lo he enmascado 00:47:38
como función 00:47:40
teniendo en cuenta que 00:47:42
si yo pongo aquí algo que no sea void 00:47:44
o sea como string int 00:47:46
por el estilo, la función 00:47:48
en algún momento tiene que hacer un return 00:47:50
siempre 00:47:52
no puedo hacer 00:47:54
aquí dentro if 00:47:56
no sé qué, return no sé cuánto 00:47:58
else y no retornar nada 00:48:00
siempre tengo que returnar 00:48:02
como 00:48:04
idea principal y consejo 00:48:06
yo pondría un único 00:48:08
return al final 00:48:10
sabéis como cuando hacemos nosotros 00:48:12
que imprimimos solo una vez 00:48:14
en pantalla y luego preparamos 00:48:16
la string antes y luego imprimimos 00:48:18
esa string, pues mismo concepto 00:48:20
yo al final hago un return 00:48:22
de una variable, si es una string 00:48:24
nada más empezar hago string 00:48:26
resultado 00:48:28
resultado es igual a vacío 00:48:30
y al final pongo return resultado 00:48:32
y en el medio hago lo que me da la gana 00:48:34
en algunos casos concretos 00:48:36
puede ser útil 00:48:38
hacer un return antes 00:48:40
porque cuando hago el return 00:48:42
allí se para 00:48:44
el método 00:48:46
si yo tengo 00:48:48
un if 00:48:50
no sé qué, returna algo 00:48:52
else hace un montón de cosas 00:48:54
y después de este else 00:48:56
hace un montón de cosas 00:48:58
si yo pillo este if y pillo el return 00:49:00
todo el resto no lo ejecuto 00:49:02
el return devuelve 00:49:04
a donde ha sido llamado 00:49:06
pero a lo mejor esto lo veremos con más detalle 00:49:08
en el futuro con los ejemplos 00:49:10
pero la idea es como un break 00:49:12
sabéis cuando el break del switch 00:49:14
que salgo del switch, pues misma cosa 00:49:16
encuentro un return y el resto no lo ejecuto 00:49:18
allí se acabó el método 00:49:20
aquí se acabó la función 00:49:22
devuelvo el resultado y vuelvo 00:49:24
si os fijáis también 00:49:27
estas llamadas de función y procedimiento 00:49:29
son lo que decíamos al principio 00:49:31
interrumpen el normal 00:49:33
y secuencial 00:49:35
orden de ejecución 00:49:37
yo cuando estoy aquí 00:49:39
saludo, interrumpo el main 00:49:41
me voy a saludo 00:49:43
ejecuto estas dos líneas 00:49:45
y vuelvo allí donde estaba antes 00:49:47
y el resultado que me ha devuelto 00:49:49
lo pongo en saludo 00:49:51
y sigo desde aquí 00:49:53
si o no 00:49:55
dudas 00:49:57
preguntas 00:49:59
aquí 00:50:05
este es un parámetro 00:50:07
mira 00:50:11
aquí se lo he dado directamente el valor 00:50:13
aquí lo que tienes que hacer es el parámetro actual 00:50:15
o sea el valor que asociarás a esto 00:50:17
aquí dentro no 00:50:19
aquí dentro es sólo el nombre que usarás 00:50:21
el nombre variable que usarás aquí dentro 00:50:23
para referirte a lo que te van a dar 00:50:25
y tú se lo puedes dar como literal 00:50:27
o se lo puedes pasar como parámetro 00:50:29
como variable 00:50:31
o se lo puedes pasar como resultado 00:50:33
de otra función 00:50:35
tú aquí pones una función que al final te da un string 00:50:37
y lo que se da es un string 00:50:39
que uso como parámetro para saludo 00:50:41
una función dentro de una función 00:50:43
que no 00:50:45
dudas 00:50:47
vale 00:50:49
entonces 00:50:53
otro ejemplo 00:50:55
aquí tengo dos 00:50:57
funciones 00:50:59
una función y un método 00:51:01
esta función de aquí 00:51:03
pregunto 00:51:05
¿cómo se llama esta función? 00:51:07
repite saludo 00:51:11
¿por qué se crea una función? 00:51:13
porque aquí tiene 00:51:19
string y no void 00:51:21
no es un parámetro 00:51:23
como 00:51:25
este campo de aquí de la declaración 00:51:27
que me dice ¿qué devuelve al final 00:51:29
esta función? pues string 00:51:31
y no void pues es una función 00:51:33
al final tendrá que tener un return 00:51:35
si yo pongo un void pues no hace falta return 00:51:37
¿sí? 00:51:39
¿qué parámetros pilla? 00:51:41
un string 00:51:43
y un int 00:51:45
¿vale? 00:51:47
el string será el nombre 00:51:49
el int la repetición 00:51:51
de cuántas veces tengo que repetir esto 00:51:53
¿os acordáis que antes lo escribía 00:51:55
directamente en pantalla? 00:51:57
pues ahora no puedo 00:51:59
pero lo que yo quiero es que 00:52:01
el resultado de esta operación 00:52:03
de esta función se pase a quien me ha llamado 00:52:05
y luego sea quien me ha llamado 00:52:07
que lo imprima en pantalla si quiere 00:52:09
haga lo que sea con el resultado 00:52:11
entonces yo aquí hago un string 00:52:13
de resultado que no es nada 00:52:15
hago un for 00:52:17
un número de repeticiones 00:52:19
veces, si repetición vale 5 00:52:21
lo hago 5 veces, si repetición es 3 lo hago 3 veces 00:52:23
y lo que hago es que 00:52:25
concadeno al resultado 00:52:27
lo que haya en resultado 00:52:29
más hola 00:52:31
más el nombre 00:52:33
antes 00:52:35
si hacía println me salía uno por cada línea 00:52:37
¿vale? 00:52:39
ahora no me saldría por cada línea 00:52:41
¿vale? porque le he puesto un espacio 00:52:43
saldría, si yo le llamo sobre 00:52:45
estefano4 me saldría 00:52:47
hola estefano, espacio hola estefano, espacio hola estefano 00:52:49
espacio hola estefano, pero todo en la misma línea 00:52:51
si quisiera ir a una nueva línea 00:52:53
podría poner aquí un barra n 00:52:55
pero aquí no estoy imprimiendo 00:52:57
nada en pantalla, estoy creando 00:52:59
una nueva string 00:53:01
que luego al final devuelvo a quien me ha llamado 00:53:03
entonces 00:53:05
aquí arriba 00:53:07
llamo el método 00:53:11
repitesaludos, utilizando 00:53:13
Luis y 4 00:53:15
esto me creará hola Luis, espacio hola Luis 00:53:17
espacio hola Luis, espacio hola Luis 00:53:19
y me lo guarda 00:53:21
en esta variable aquí 00:53:23
del main 00:53:25
y ahora lo que puedo hacer es imprimir esa variable 00:53:27
habría podido hacer 00:53:29
system.auto.println 00:53:31
de entre paréntesis 00:53:33
repitesaludos Luis 4 00:53:35
porque el resultado de este método 00:53:39
es un string que lo pilla 00:53:41
como parámetro del println y me lo imprime 00:53:43
dudas 00:53:47
vamos a ver un ejemplo 00:53:51
un poquito más 00:53:53
complejo 00:53:55
entonces 00:53:57
vamos por parte 00:53:59
esto de aquí que son más fáciles 00:54:01
funciona el procedimiento 00:54:05
funciona, ¿qué parámetros pilla? 00:54:09
dos int, ¿cómo se llama? 00:54:13
calcular área, ¿qué devuelve? 00:54:17
tú le pasas estos dos lados 00:54:23
él te calcula el área 00:54:25
¿sí? 00:54:27
este de aquí 00:54:29
el método pintabonito 00:54:31
pintabonito 00:54:33
¿qué es? 00:54:35
¿funciona el procedimiento? 00:54:37
procedimiento 00:54:39
no espero que me devuelva nada 00:54:41
porque tiene void aquí, de hecho no tiene return 00:54:43
¿sí? 00:54:45
recibe 00:54:47
un int a 00:54:49
un int b y un int r 00:54:51
siendo posiblemente 00:54:53
un lado, otro lado 00:54:55
y el resultado 00:54:57
y lo que hace es 00:54:59
me lo pintabonito porque me hace 00:55:01
este marco 00:55:03
con los estereoscopios 00:55:05
y escribe el rectángulo de lados 00:55:07
a y b 00:55:09
tiene área r 00:55:11
a lo mejor esto 00:55:13
habría sido más bonito si aquí hubiese puesto 00:55:15
lado 1, lado 2 y área 00:55:17
en vez que a, b y r 00:55:19
que luego no se entiende que son 00:55:21
o sea que esto es un procedimiento 00:55:23
para escribir las cosas bonitas en pantalla 00:55:25
¿sí? 00:55:27
vale 00:55:29
método 00:55:31
o sea, esta otra cosa de aquí 00:55:33
esta, ¿cómo se llama? 00:55:35
¿eh? 00:55:39
legginum 00:55:41
¿es un procedimiento 00:55:45
o una 00:55:47
una función? 00:55:49
¿qué quiero que me devuelva? 00:55:51
un int 00:55:53
¿vale? el resultado de todo esto 00:55:55
me tiene que devolver un int 00:55:57
o sea que por aquí tiene que haber un return 00:55:59
y tiene que retornar algo 00:56:01
y este algo tiene que ser un int 00:56:03
si no algo no funcionaría 00:56:05
¿sí? 00:56:07
¿qué recibe como parámetros? 00:56:09
un string 00:56:13
¿y un escáner? 00:56:15
¿y un escáner? 00:56:19
¿qué es eso? 00:56:21
el string es un escáner 00:56:25
nosotros, esto quiere decir que cuando llamo 00:56:27
legginum le tengo que pasar 00:56:29
un string que se llama msg 00:56:31
que él imprime en pantalla, es el mensaje 00:56:33
¿sabéis eso que nosotros hemos siempre dicho? 00:56:35
antes de hacer una lectura 00:56:37
por teclado 00:56:39
necesitaría mandar un mensaje 00:56:41
pues, lo pongo aquí 00:56:43
y luego 00:56:45
para que funcione le estoy pasando 00:56:47
el escáner 00:56:49
el escáner que he creado en el main 00:56:51
se lo paso a este 00:56:53
metodito de aquí para que tenga acceso al teclado 00:56:55
y pueda hacer teclado.ext 00:56:57
cuidado, aquí no lo está creando 00:56:59
no está haciendo 00:57:01
escáner teclado es igual a newScanner 00:57:03
porque esta cosa ya se ha creado 00:57:05
me la están pasando como parámetro 00:57:07
vamos a ver como se pasa el problema 00:57:09
pero es como decir 00:57:11
que mi función legginum 00:57:13
se espera que alguien 00:57:15
le dé 00:57:17
un string 00:57:19
y un teclado 00:57:21
¿vale? con eso 00:57:23
ya puede escribir en pantalla 00:57:25
el mensaje, sea cual sea 00:57:27
el mensaje y pedir 00:57:29
un nuevo entero a ese teclado 00:57:31
sea cual sea ese teclado 00:57:33
¿si? 00:57:35
no lo es instancial, pues si que lo es instancial 00:57:37
al momento en que llamaré 00:57:39
legginum con sus parámetros 00:57:41
actuales, pues haré 00:57:43
un colegamiento entre 00:57:45
este teclado y el otro parámetro 00:57:47
¿dudas? 00:57:49
vamos a ver entonces como llamamos estos tres 00:57:53
métodos y como me sale el main 00:57:55
este es el main 00:57:57
¿vale? 00:57:59
el main crea un objeto escáner 00:58:01
y lo guarda en la variable s 00:58:03
lo que hemos hecho siempre 00:58:05
antes de llamarlo scan o teclado 00:58:07
lo he llamado s 00:58:09
ahora, int lado1 00:58:11
¿si? entonces 00:58:13
aquí dentro, guarda mi resultado 00:58:15
de esta 00:58:17
función, ¿que es esta función? 00:58:19
llama legginum, donde pones 00:58:21
como primer parámetro 00:58:23
dame el primer lado del rectángulo 00:58:25
y segundo parámetro 00:58:27
este s 00:58:29
estoy pasando 00:58:31
el escáner, para que luego tú allí dentro 00:58:33
puedas hacer 00:58:35
teclado. 00:58:37
¿vale? 00:58:39
teniendo en cuenta que aquí dentro 00:58:41
esto se llama s 00:58:43
pero aquí dentro 00:58:45
esto se llamará teclal 00:58:47
aquí dentro hay una variable s más s 00:58:53
¿no? porque 00:58:55
s vale solo dentro de este bloque de aquí 00:58:57
¿vale? 00:58:59
aquí no se ha declarado ninguna variable s 00:59:01
¿puedo declarar otra variable s? 00:59:03
sí, pero no sería la misma 00:59:05
variable s esta aquí, sería otra cosa 00:59:07
¿si? yo aquí he creado 00:59:11
un objeto que le he de teclado 00:59:13
un algo, una entidad que le he de teclado 00:59:15
y aquí le estoy diciendo 00:59:17
que aquí dentro 00:59:19
tú me tienes que dar una entidad que le he de teclado 00:59:21
un escáner 00:59:23
y la asociación entre esta cosa de aquí 00:59:25
y la que yo he creado 00:59:27
es aquí 00:59:29
cuando yo estoy llamándole genoom 00:59:33
te está pasando el s 00:59:35
que es la entidad 00:59:37
lectora de teclado que he creado 00:59:39
y tú aquí dentro la tratarás 00:59:41
como si se llamara teclado 00:59:43
y entonces haces teclado.nexi 00:59:45
¿pero por qué no se podría llamar s? 00:59:49
puede poner s aquí 00:59:51
entonces s, claro 00:59:53
¿pero sería lo mismo? 00:59:55
bueno, esto lo decís tú 00:59:57
si lo llama escáner gatito 00:59:59
gatito.nexi 01:00:01
es que esto es genérico 01:00:05
o sea, esto tú luego lo puedes reutilizar 01:00:07
donde te da la gana 01:00:09
entonces, no lo sé 01:00:11
vale, si tú estás haciendo un ejercicio sencillo así 01:00:13
pues sí 01:00:15
si tú estás haciendo una librería de matemática 01:00:17
donde calculas la del triángulo 01:00:19
pues tú no lo sabes 01:00:21
si la persona que va a luego usarla 01:00:23
llamará el lado 1, el lado 2 01:00:25
o lo llamará l1, l2 01:00:27
o lo llamará a, b y c 01:00:29
tú lo llamas como quieras 01:00:31
y aquí dentro lo llamas como quieras tú 01:00:33
¿vale? 01:00:35
yo habría podido llamarlo teclado aquí también 01:00:37
pero para no confundiros que estas son dos cosas distintas 01:00:39
¿vale? 01:00:41
cuando tú llamas el leyenum 01:00:45
como pilla dos parámetros 01:00:47
esto lo has llamado teclado, aquí dentro usarás teclado 01:00:49
pero el vínculo 01:00:51
entre el objeto aquí que he creado 01:00:53
escáner y este teclado 01:00:55
es el mismo que a la hora de llamar 01:00:57
esto luego 01:01:03
se complica cuanto queráis 01:01:05
¿vale? 01:01:07
esto también 01:01:09
lo hemos visto, está aquí 01:01:11
como ejemplo, echadle un vistazo 01:01:13
pero en teoría intentaremos 01:01:15
que para el examen 01:01:17
envíos 01:01:19
de objetos como pasa aquí 01:01:21
no sean necesarios, o sea que los parámetros 01:01:23
sean sólo 01:01:25
tipos primitivos o string 01:01:31
¿vale? 01:01:33
intentaremos evitar 01:01:35
teniendo en cuenta que yo esto de leer 01:01:37
lo habría podido hacer aquí fuera 01:01:39
no es necesario hacerlo aquí 01:01:41
¿vale? es más práctico porque 01:01:43
ahora ya aquí tengo mis 01:01:45
mis tres 01:01:47
¿cómo se llaman? 01:01:49
mis dos líneas de código 01:01:51
porque aquí es una línea de código única 01:01:53
si esto fueran 50 líneas de código 01:01:57
porque luego tiene que mirar que los datos 01:01:59
sean correctos, que sean entre 1 01:02:01
y 100 y cosas por el estilo 01:02:03
en vez de escribirlo aquí dos veces 01:02:05
el mismo código, pues lo escribo sólo una vez 01:02:07
y llamo dos veces mi legion 01:02:09
¿sí? 01:02:11
probamos con ejemplos 01:02:15
y lo hacemos juntos 01:02:17
¿vale? entonces este es un ejemplo de un 01:02:19
ejercicio 01:02:21
que luego al final hará esto 01:02:23
¿vale? 01:02:25
dice dame 01:02:27
esto es la primera 01:02:29
llamada de la 01:02:31
genoom 01:02:33
esta es la segunda llamada de la genoom 01:02:35
lo que han puesto se guardarán en los datos 01:02:37
y al final llamo el printabonito 01:02:39
no, bueno, llamo antes 01:02:41
el calcularia 01:02:43
y luego después el printabonito 01:02:45
dándole este número, este número 01:02:47
y el resultado 01:02:49
¿sí? 01:02:51
lo vemos aquí 01:02:53
leo los dos números 01:02:57
área 01:02:59
será, calcula área 01:03:01
del lado 1 al lado 2, que son los dos que he leído 01:03:03
y luego printabonito del lado 1 al lado 2 01:03:05
y área 01:03:07
dura 01:03:09
¿vale? y ya 01:03:17
¿como? 01:03:19
normalmente el escáner se debería 01:03:23
cerrar ¿vale? 01:03:25
pero que pasa, que como nuestros programas luego acaban 01:03:27
cuando acaban todos los recursos 01:03:29
se destruyen 01:03:31
esto es necesario si mi programa aquí no 01:03:33
acabara e empezara a hacer otras cosas 01:03:35
como he dejado abierto el escáner 01:03:37
pues eso me ocupa recursos para nada 01:03:39
¿vale? entonces 01:03:41
una buena práctica 01:03:43
que al final pues haga dosis 01:03:45
pero como estos son métodos, son objetos 01:03:47
y cosas por el estilo, yo estoy obviando 01:03:49
para eso, para que no me interese 01:03:51
¿vale? por ahora no me interese esta cosa 01:03:53
cuando veremos los objetos y veremos 01:03:55
acceso a ficheros y cosas así 01:03:57
pues entonces estas cosas 01:03:59
tomarán más importancia 01:04:01
¿sí? 01:04:03
vale, entonces 01:04:05
esto para repasar un poquito 01:04:07
el concepto de parámetros 01:04:09
formales y parámetros actuales 01:04:11
¿vale? los parámetros formales 01:04:13
son los que se usan dentro de la función 01:04:15
o del procedimiento y no tienen un valor 01:04:17
concreto hasta que se llame la función 01:04:19
o el procedimiento, son números 01:04:21
son valores abstractos 01:04:23
yo sé que aquí tendré el lado 1 01:04:25
antes o después alguien me dirá cuanto vale 01:04:27
el lado 1, pero por ahora como no lo sé 01:04:29
lo uso de forma abstracta 01:04:31
diciendo aquí va lado 1 01:04:33
¿qué tengo que hacer? lado 1 por lado 2 01:04:35
pero esto es 5 por 3, no lo sé 01:04:37
hasta que tú no me digas cuanto vale lado 1 01:04:39
y cuanto vale lado 2 01:04:41
pues no lo puedo saber, ¿cuando lo sabré? 01:04:43
cuando invocan el método, cuando lo llaman 01:04:45
cuando llaman la función 01:04:47
¿sí? 01:04:49
y los parámetros actuales son los valores 01:04:51
concretos que se asignan a los parámetros 01:04:53
formales a la hora de la llamada 01:04:55
de la función, ¿vale? 01:04:57
los parámetros actuales son los que 01:04:59
se ponen en la llamada de la función 01:05:01
los parámetros formales son los que están 01:05:03
dentro de la definición, la declaración 01:05:05
de la función 01:05:07
estos son abstractos, no sé cuanto valen 01:05:09
estos son los valores 01:05:11
actuales de esa llamada 01:05:13
en ese momento, actualmente 01:05:15
los valores valen este y este 01:05:17
en otra llamada valdrán otra cosa 01:05:19
pero aquí valen estos 01:05:21
¿estudas? 01:05:23
sustancialmente esto es 01:05:25
hago una abstracción 01:05:27
de un determinado 01:05:29
de una determinada tarea 01:05:31
parametrizable 01:05:33
y luego la reuso cuantas veces me dé la gana 01:05:35
con los parámetros que yo quiero 01:05:37
una vez con 3 y 5 01:05:39
una vez con 7 y 9, una vez con 45 y 32 01:05:41
y no tengo que reescribir ese código 01:05:43
otra vez, ese código es sustancialmente 01:05:45
me está definiendo 01:05:47
me está solucionando no una tarea sola 01:05:49
pero una clase de tareas 01:05:51
muchas tareas 01:05:53
calcular área me está solucionando 01:05:55
todos los cálculos de área posible 01:05:57
caveat 01:06:07
que en latín quiere decir, atención 01:06:09
funciones y procedimientos 01:06:11
son propios de la programación 01:06:13
estructurada 01:06:15
nosotros ahora estamos 01:06:17
utilizando y aprendiendo programación 01:06:19
estructural y con esto 01:06:21
grosso modo 01:06:23
la base de la programación estructurada 01:06:25
ya está, luego vamos a complicarla un poco 01:06:27
poniendo los arrays y poco más 01:06:29
pero la base de la programación 01:06:31
estructurada son 01:06:33
condicionales, iterativos 01:06:35
y llamadas de funciones 01:06:37
en Java 01:06:41
funciones y procedimientos 01:06:43
se suelen llamar métodos 01:06:45
en la 01:06:47
como se dice 01:06:49
las palabras que se usan 01:06:51
en Java 01:06:53
tú no dirías 01:06:55
esta es una función, este es un procedimiento 01:06:57
dirías este es un método, este es un método 01:06:59
un método estático, un método no estático 01:07:01
eso ya lo veremos 01:07:03
sin embargo 01:07:05
el concepto de método está vinculado a la programación 01:07:07
orientada a objetos 01:07:09
eso sirve cuando estamos 01:07:11
orientados a objetos 01:07:13
y nosotros todavía no estamos, estamos todavía en programación 01:07:15
estructurada, veremos cuando empezaremos 01:07:17
a ver los objetos, cual es el paso hacia 01:07:19
adelante, en realidad ya lo hemos visto desde una perspectiva 01:07:21
teórica al principio del curso 01:07:23
que nos permite hacer el salto desde 01:07:25
base de programación 01:07:27
estructurada a esta programación orientada 01:07:29
a objetos 01:07:31
y siempre que 01:07:33
hablamos de métodos, esto está vinculado 01:07:35
con los conceptos de clase objetos 01:07:37
que nosotros de vez en cuando lo oímos 01:07:39
hacemos una nueva clase 01:07:41
oye, escáner es un objeto, string 01:07:43
también es un objeto 01:07:45
algo, pero que es de verdad 01:07:47
todavía no lo sabemos, ni lo queremos saber 01:07:49
hasta dentro de un rato, ¿vale? 01:07:51
todo esto para decir 01:07:53
que lo que hemos visto hasta ahora 01:07:55
hace un uso impropio de Java 01:07:57
¿vale? es como si nosotros 01:07:59
estamos utilizando Java, que es orientada a objetos 01:08:01
ignorando la parte 01:08:03
orientada a objetos y concentrándose 01:08:05
no solo en la parte estructurada 01:08:07
por lo tanto, algunas cosillas 01:08:09
que os he dicho ahora, para que entendáis 01:08:11
la base, pues en un futuro 01:08:13
posiblemente os diré, ¿os acordáis de esa cosa allí? 01:08:15
pues ahora, miradla desde 01:08:17
esta otra forma 01:08:19
¿si? dentro de un rato, funciona 01:08:21
ese procedimiento, ya no lo llamamos función de procedimiento 01:08:23
se llamarán todos métodos 01:08:25
¿vale? 01:08:27
cuando llegará el momento 01:08:29
volveremos a retomar estos conceptos 01:08:31
que profundizamos en temas como el static 01:08:33
el paso de parámetros por valores 01:08:35
referencia, la firma de un 01:08:37
método, sobrecarga de un método 01:08:39
todas estas cosas, son cosas que 01:08:41
a lo mejor ahora alguna de estas he nombrado 01:08:43
he dado una pincelada 01:08:45
pero todavía no sabemos que es 01:08:47
nos servirá esta 01:08:49
fundamental, es cuando estaremos en la programación 01:08:51
orientada a objetos 01:08:53
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
16
Fecha:
30 de octubre de 2023 - 12:55
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 09′ 03″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
197.60 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid