1 00:00:00,000 --> 00:00:06,500 Estoy grabando, por lo tanto, me autorizáis en el caso en que digáis algo a grabar vuestra voz, ¿vale? 2 00:00:06,500 --> 00:00:13,300 Entonces, hoy lo que vamos a ver es completar la parte de estas instrucciones de control, 3 00:00:13,300 --> 00:00:18,000 sentencias de control, o... ¿cómo se llaman? estructuras de control. 4 00:00:18,000 --> 00:00:23,800 Si os acordáis, la idea era que, antes de empezar esta parte de la programación, 5 00:00:23,800 --> 00:00:27,000 nosotros sabíamos hacer operaciones secuenciales, 6 00:00:27,000 --> 00:00:29,800 esto detrás de esto, luego esto, luego esto, luego esto, ¿vale? 7 00:00:29,800 --> 00:00:33,500 Lo hemos utilizado para algunos ejemplos, como calcular la red en cuadrado. 8 00:00:33,500 --> 00:00:37,800 Pues pillas un lado, pillas... no, solo el lado, lo multiplicas por sí mismo, 9 00:00:37,800 --> 00:00:40,500 y luego lo escribes en pantalla. Pues secuencial. 10 00:00:40,500 --> 00:00:43,700 A un cierto momento hemos dicho que, en determinados algoritmos, 11 00:00:43,700 --> 00:00:47,200 eso de hacer solo las cosas una tras otra, pues no nos sirve. 12 00:00:47,200 --> 00:00:53,700 Entonces hemos encontrado algunos mecanismos, algunas estructuras, 13 00:00:53,700 --> 00:01:00,200 que me permiten modificar el flujo secuencial de ejecución de un algoritmo, ¿vale? 14 00:01:00,200 --> 00:01:06,700 Y hemos introducido tanto el if, que me permite hacer un bloque o no hacerlo, 15 00:01:06,700 --> 00:01:11,700 en base a una condición, ¿vale? El if else, que me dice si la condición es verdadera, 16 00:01:11,700 --> 00:01:16,200 haz este bloque de información, y si no es verdadera, haz otra, ¿vale? 17 00:01:16,200 --> 00:01:18,200 Y estos son los condicionales. 18 00:01:18,200 --> 00:01:22,700 Tenemos también el switch, pero, al fin y al cabo, el switch es un if cómodo, 19 00:01:22,700 --> 00:01:25,200 es un if cómodo para determinadas circunstancias. 20 00:01:25,200 --> 00:01:27,700 Todo lo que se hace con el switch se puede hacer con un if, 21 00:01:27,700 --> 00:01:34,200 pero te sale un if dentro de un if dentro de un if, y a veces es un poco engorroso hacer, ¿vale? 22 00:01:34,200 --> 00:01:39,700 Y luego hemos visto el comando iterativo, ¿vale? Tanto en formato while como en formato for. 23 00:01:39,700 --> 00:01:43,200 Os recuerdo que existe también el do while, pero, sustancialmente, 24 00:01:43,200 --> 00:01:46,700 tanto do while como for como do while son intercambiables. 25 00:01:46,700 --> 00:01:50,200 Yo puedo cambiar algunas cosas, y en algunos lados es más cómodo uno, 26 00:01:50,200 --> 00:01:53,200 en algunos casos es más cómodo el otro. 27 00:01:53,200 --> 00:01:58,200 Os recuerdo que se usa while o do while cuando no sé el número de iteraciones que voy a hacer, 28 00:01:58,200 --> 00:02:01,700 y uso el for cuando sí sé el número de iteraciones que voy a hacer. 29 00:02:01,700 --> 00:02:05,700 Eso no quiere decir que tengo que tener un número claro mientras estoy programando. 30 00:02:05,700 --> 00:02:09,700 El número podría ser n, donde n es la longitud de una palabra, 31 00:02:09,700 --> 00:02:14,200 o el número que me ha puesto el usuario al principio. 32 00:02:14,200 --> 00:02:19,700 Pues eso puede ser una variable, pero yo sé que cuando estará fijado a tiempo de ejecución 33 00:02:19,700 --> 00:02:23,700 el número n, yo tengo que hacer n iteraciones de este programa. 34 00:02:23,700 --> 00:02:25,200 Pues entonces uso un for. 35 00:02:25,200 --> 00:02:29,200 Si en vez de no sé, porque es dame números hasta que pongas un cero, 36 00:02:29,200 --> 00:02:32,200 y no sé cuántos números dará el usuario que no sean cero, 37 00:02:32,200 --> 00:02:35,200 pues entonces el while es más cómodo normalmente, ¿vale? 38 00:02:35,200 --> 00:02:38,200 Como idea general sobre la que trabajar. 39 00:02:38,200 --> 00:02:44,200 Luego, vosotros que sabéis los dos, y habéis practicado ya bastante for y while, 40 00:02:44,200 --> 00:02:48,200 deberíais ser capaces ahora, frente a un posible programa que entendéis 41 00:02:48,200 --> 00:02:52,200 que tiene que reutilizar un programa iterativo, pensar, 42 00:02:52,200 --> 00:02:54,700 oye mira, ¿esto me conviene hacerlo con un while o con un for? 43 00:02:54,700 --> 00:02:58,700 Vamos a ver, y pensar, ¿necesito un índice que va incrementándose 44 00:02:58,700 --> 00:03:01,700 dentro de cada uno de los ciclos? 45 00:03:01,700 --> 00:03:04,700 Pues posiblemente el for es una opción buena. 46 00:03:04,700 --> 00:03:07,700 ¿No lo necesito? Pues posiblemente un while, ¿vale? 47 00:03:08,700 --> 00:03:19,700 La tercera forma de modificar el flujo secuencial de ejecución de un programa 48 00:03:19,700 --> 00:03:23,700 es lo que se llama, llamada función o procedimiento. 49 00:03:23,700 --> 00:03:28,700 En realidad, y lo repetiré al final de esta clase, 50 00:03:28,700 --> 00:03:33,700 en Java esto se llama métodos, ¿vale? 51 00:03:33,700 --> 00:03:37,700 Y no son exactamente ni funciones ni procedimientos. 52 00:03:37,700 --> 00:03:41,700 Pero nosotros todavía no estamos en programación orientada a objetos. 53 00:03:41,700 --> 00:03:46,700 Nosotros todo lo que estamos haciendo ahora es como si estuviéramos en el pasado 54 00:03:46,700 --> 00:03:51,700 y estuviéramos en el momento en que se programaba con programación estructurada. 55 00:03:51,700 --> 00:03:56,700 ¿Vale? Y en programación estructurada existen funciones y procedimientos. 56 00:03:56,700 --> 00:03:59,700 ¿Vale? Y ahora vamos a ver qué son, para qué sirven, 57 00:03:59,700 --> 00:04:01,700 y cuál es la diferencia entre los dos. 58 00:04:01,700 --> 00:04:06,700 Cuando veremos los objetos, pues cambiaremos esta cosa. 59 00:04:06,700 --> 00:04:09,700 Ah, vale, no son más funciones o procedimientos, son métodos. 60 00:04:09,700 --> 00:04:12,700 Y veremos cómo hay métodos estáticos, métodos no estáticos, 61 00:04:12,700 --> 00:04:15,700 métodos para objetos, etcétera, etcétera, etcétera. 62 00:04:15,700 --> 00:04:19,700 Como todavía ahora estos conceptos no los tenemos, no los podemos utilizar. 63 00:04:19,700 --> 00:04:24,700 Vale. Si un programa repite muchas veces el mismo código, 64 00:04:24,700 --> 00:04:27,700 a lo mejor pero con parámetros distintos, 65 00:04:27,700 --> 00:04:30,700 ahora aquí os lo hago más grande y veis un ejemplo, 66 00:04:30,700 --> 00:04:36,700 pues lo que se puede hacer es, en vez de escribir muchas veces el mismo código, 67 00:04:36,700 --> 00:04:41,700 sacar este código en algún lado, darle un nombre, 68 00:04:41,700 --> 00:04:44,700 y decir que cada vez que yo llamo ese nombre, 69 00:04:44,700 --> 00:04:47,700 en realidad quiero ejecutar ese bloque de código. 70 00:04:47,700 --> 00:04:50,700 Esa es la idea de la función y del procedimiento. 71 00:04:50,700 --> 00:04:53,700 Por ejemplo, veamos este programito de ejemplo aquí. 72 00:04:54,700 --> 00:04:56,700 No sé si se lee. 73 00:04:56,700 --> 00:05:02,700 Esto es un programa que calcula área del rectángulo. 74 00:05:02,700 --> 00:05:06,700 Entonces lo que hace es pillar un lado, pillar otro lado, 75 00:05:06,700 --> 00:05:10,700 podría pillar escrito por teclado, me da igual. 76 00:05:10,700 --> 00:05:16,700 Calcula la área del rectángulo, el perímetro, y luego lo escribe. 77 00:05:16,700 --> 00:05:20,700 El rectángulo de lado no sé qué, no sé qué, tiene área no sé qué, 78 00:05:20,700 --> 00:05:22,700 perímetro no sé qué. 79 00:05:22,700 --> 00:05:27,700 Y yo lo que quiero hacer es hacer esta misma cosa para varios rectángulos distintos. 80 00:05:27,700 --> 00:05:32,700 Este es el rectángulo 3x4, este es el rectángulo 5x10, este es el rectángulo 2x7. 81 00:05:32,700 --> 00:05:36,700 La verdad es que el código es el mismo, 82 00:05:36,700 --> 00:05:39,700 lo que cambia son los parámetros que le estoy dando. 83 00:05:39,700 --> 00:05:45,700 Una opción que podemos tener nosotros es esa de poner aquí dentro de un while, 84 00:05:45,700 --> 00:05:50,700 hacer que esto se repita las veces o de un for las veces que haga falta, 85 00:05:50,700 --> 00:05:53,700 y sustancialmente me vale. 86 00:05:53,700 --> 00:05:57,700 Otro método que puedo hacer es darme cuenta que esto es código repetido, 87 00:05:57,700 --> 00:06:04,700 e intentar sacar este código fuera y darle un nombre. 88 00:06:04,700 --> 00:06:10,700 Algo parecido a esto, creo, ahora luego vemos cómo se hace. 89 00:06:10,700 --> 00:06:16,700 En algún lado, una cosa nueva que se llama calcular el perímetro, 90 00:06:16,700 --> 00:06:22,700 le he dado este nombre, public, static, void, no suena de algo, 91 00:06:22,700 --> 00:06:28,700 ¿de qué no suena? del main, porque el main es un método en Java, 92 00:06:28,700 --> 00:06:32,700 es el método principal por donde empieza el programa, 93 00:06:32,700 --> 00:06:36,700 es la función principal que el programa empieza aquí. 94 00:06:36,700 --> 00:06:39,700 Entonces, ¿qué quieren decir estas palabras? 95 00:06:39,700 --> 00:06:41,700 ¿Qué quiere decir public? No tengo ni idea. 96 00:06:41,700 --> 00:06:43,700 ¿Qué quiere decir static? No tengo ni idea. 97 00:06:43,700 --> 00:06:47,700 ¿Qué quiere decir void? Lo sabré dentro de un rato. 98 00:06:47,700 --> 00:06:50,700 Este es el nombre, y ahora vemos los parámetros. 99 00:06:50,700 --> 00:06:52,700 Por ahora quedan así, ¿por qué? 100 00:06:52,700 --> 00:06:57,700 Porque estas son palabras que van muy entrelazadas con los conceptos de clase, 101 00:06:57,700 --> 00:07:03,700 de objeto, de otras cosas más avanzadas como herencia, etc., 102 00:07:03,700 --> 00:07:07,700 que por ahora no nos interesan porque no los conocemos. 103 00:07:07,700 --> 00:07:10,700 Por lo tanto, por ahora nosotros son palabras mágicas que ponemos allí, 104 00:07:10,700 --> 00:07:16,700 y son siempre así, public, static, void, para hacer un procedimiento. 105 00:07:16,700 --> 00:07:24,700 Además de esto, yo aquí, entre paréntesis, puedo poner lo que se llaman los parámetros. 106 00:07:24,700 --> 00:07:30,700 Son como variables, pero no están instanciadas en este momento. 107 00:07:30,700 --> 00:07:39,700 La instanciaré cuando quiera utilizar el método, la función o el procedimiento, 108 00:07:39,700 --> 00:07:43,700 estos son procedimientos, que se llama calcular el perímetro. 109 00:07:43,700 --> 00:07:46,700 Cuando yo voy a llamar a este trozo de código, le digo, 110 00:07:46,700 --> 00:07:51,700 mira, vas a hacer calcular el perímetro, pero vas a utilizar en particular 111 00:07:51,700 --> 00:07:55,700 este dato como lado 1 y este dato como lado 2. 112 00:07:56,700 --> 00:08:00,700 Entonces, estos se llaman parámetros formales. 113 00:08:04,700 --> 00:08:09,700 Los lados 1 y 2 es como si para ti existieran ya, 114 00:08:09,700 --> 00:08:14,700 cuando llamaran este método de aquí, te tienen que haber pasado estos valores. 115 00:08:14,700 --> 00:08:16,700 Ahora veremos cómo. 116 00:08:16,700 --> 00:08:21,700 Te habrán dicho que el lado 1 vale 3 y el lado 2 vale 7. 117 00:08:21,700 --> 00:08:27,700 Entonces, aquí dentro, cuando tú usas lado 1, estás usando el valor que te han pasado, el 3. 118 00:08:27,700 --> 00:08:30,700 Y cuando usas lado 2 aquí dentro, estás usando el 7. 119 00:08:30,700 --> 00:08:33,700 ¿Sabes cuáles son? No, son genéricos. 120 00:08:33,700 --> 00:08:41,700 A mí me habrán metido en estos dos espacios de memoria un determinado valor. 121 00:08:41,700 --> 00:08:45,700 Y aquí dentro usaré esos determinados valores de alguna forma. 122 00:08:45,700 --> 00:08:48,700 Pilla el primer espacio de memoria, va a mirar qué hay dentro, 123 00:08:48,700 --> 00:08:51,700 no sé qué hay dentro, pero pillarás eso, lado 1, 124 00:08:51,700 --> 00:08:55,700 y lo multiplicas, ves el espacio de memoria llamado lado 2, 125 00:08:55,700 --> 00:09:00,700 y lo que hay ahí dentro, que todavía no lo sé, pero lo tendrás que pillar y multiplicar. 126 00:09:00,700 --> 00:09:04,700 Y el resultado lo encontrarás dentro de esta variable de aquí. 127 00:09:04,700 --> 00:09:07,700 Y luego calculas el perímetro, lo mismo, usando lado 1 y lado 2, 128 00:09:07,700 --> 00:09:12,700 que son los parámetros formales que te han dado, y a este punto escribes lo que sea. 129 00:09:12,700 --> 00:09:15,700 Esto es el mismo código de antes. 130 00:09:15,700 --> 00:09:18,700 Es el código ese que se repetía mucho. 131 00:09:18,700 --> 00:09:20,700 ¿Recordáis? 132 00:09:20,700 --> 00:09:23,700 Pues ahora lo he sacado fuera y le he dado un nombre. 133 00:09:23,700 --> 00:09:27,700 Tú te llamas cálcula área y perímetro de rectángulo. 134 00:09:27,700 --> 00:09:30,700 Lo podría haber llamado cocodrilo, me da igual, es un nombre. 135 00:09:30,700 --> 00:09:34,700 Claramente el nombre normalmente de una función o de un procedimiento 136 00:09:34,700 --> 00:09:38,700 tiene que tener sentido, para que cuando tú lo uses, 137 00:09:38,700 --> 00:09:42,700 si se llama calcular el perímetro, te esperes que calcule área y perímetro, 138 00:09:42,700 --> 00:09:48,700 no que calcule el volumen, que no tiene porque un rectángulo no tiene volumen. 139 00:09:48,700 --> 00:09:51,700 ¿Dudas? 140 00:09:51,700 --> 00:09:53,700 ¿Sí? Vale. 141 00:09:53,700 --> 00:09:56,700 Entonces, más o menos esto es la idea. 142 00:09:56,700 --> 00:10:00,700 Yo tenía un código que se repetía mucho, lo he sacado fuera del main. 143 00:10:00,700 --> 00:10:04,700 Ten en cuenta que este es fuera del main, ahora lo veremos con más detalle. 144 00:10:04,700 --> 00:10:09,700 Le he dado un nombre, he escrito este código y le he dicho que tiene dos parámetros formales, 145 00:10:09,700 --> 00:10:14,700 o sea que cuando llamaré este método, este procedimiento, 146 00:10:14,700 --> 00:10:19,700 siempre le tendré que dar ¿cuántos valores aquí? 147 00:10:19,700 --> 00:10:25,700 Dos. Uno que se asociará con lado 1 y uno que se asociará con lado 2. 148 00:10:25,700 --> 00:10:28,700 ¿Puede ser que le des uno o que le des tres? 149 00:10:28,700 --> 00:10:29,700 No. 150 00:10:29,700 --> 00:10:31,700 No, lo digo para esta pauta. 151 00:10:31,700 --> 00:10:35,700 Digo que cuando tú creas otro, aquí puede haber uno, puede haber cero, puede haber tres. 152 00:10:35,700 --> 00:10:39,700 ¿Conoces otro método que tiene un solo parámetro? 153 00:10:41,700 --> 00:10:49,700 Public static void main, y entre paréntesis está string carácteres demoníaco args. 154 00:10:49,700 --> 00:10:52,700 Eso es que solo quiero un parámetro. 155 00:10:52,700 --> 00:10:55,700 Que será un string corchete. 156 00:10:55,700 --> 00:10:57,700 ¿Qué es un string corchete? No tengo ni idea. 157 00:10:57,700 --> 00:10:59,700 Porque todavía no he hecho los arrays. 158 00:10:59,700 --> 00:11:03,700 Si hubiese hecho los arrays, sabría que es un array de strings. 159 00:11:04,700 --> 00:11:07,700 Los parámetros pueden ser cuantos les da gana. 160 00:11:07,700 --> 00:11:10,700 Ahora lo veremos. Uno, dos, tres, cuatro, cero. 161 00:11:10,700 --> 00:11:13,700 Este método es sin parámetros. 162 00:11:13,700 --> 00:11:17,700 ¿Habéis visto otro método que utilizáis sin ponerle parámetros? 163 00:11:20,700 --> 00:11:30,700 Por ejemplo, .next, .length para saber la longitud de una string, 164 00:11:30,700 --> 00:11:34,700 el .next de scan, .next int, no pillan parámetros. 165 00:11:34,700 --> 00:11:40,700 Pillan las paréntesis, eso son funciones, pero sin parámetros. 166 00:11:40,700 --> 00:11:43,700 El parámetro se destila solamente a uno. 167 00:11:43,700 --> 00:11:46,700 No, no es un parámetro. Es que ese método no pilla un parámetro. 168 00:11:46,700 --> 00:11:49,700 Porque lo llama sobre un objeto. Eso no lo sabemos hacer todos. 169 00:11:49,700 --> 00:11:55,700 ¿Conocéis otro método que en vez de sí pilla un parámetro, por ejemplo? 170 00:11:56,700 --> 00:12:00,700 Charat, que pilla un int, le ponéis un numerito dentro. 171 00:12:00,700 --> 00:12:02,700 ¿Conocéis otro? 172 00:12:04,700 --> 00:12:08,700 System.out.println, que le ponéis dentro. 173 00:12:11,700 --> 00:12:14,700 ¿Un que queremos de qué tipo? 174 00:12:17,700 --> 00:12:19,700 ¿Un string? 175 00:12:20,700 --> 00:12:23,700 Poner un int, este hace la conversión automática en string. 176 00:12:23,700 --> 00:12:25,700 Pero lo que va allí dentro es un string. 177 00:12:27,700 --> 00:12:29,700 Nosotros ya estamos usando esto. 178 00:12:29,700 --> 00:12:33,700 Solo que no nos hemos parado a mirar. 179 00:12:33,700 --> 00:12:39,700 El programa de antes, que calculaba tres rectángulos de tipos distintos, 180 00:12:39,700 --> 00:12:43,700 ahora en el main, estos son los parámetros del main, 181 00:12:43,700 --> 00:12:47,700 que no usamos porque no sabemos todavía que es. 182 00:12:48,700 --> 00:12:54,700 Lo que hacemos es llamar tres veces este método externo, 183 00:12:54,700 --> 00:12:58,700 cambiándole los parámetros que yo quiero. 184 00:12:58,700 --> 00:13:00,700 Esto antes, ¿os acordáis? 185 00:13:00,700 --> 00:13:04,700 Quería calcular el área del perímetro de un rectángulo 186 00:13:04,700 --> 00:13:07,700 que tenga lado 3 y lado 4. 187 00:13:07,700 --> 00:13:09,700 Pues ahora lo llamo así. 188 00:13:09,700 --> 00:13:15,700 Este 3 se asociará con lado 1, con el primer parámetro. 189 00:13:17,700 --> 00:13:20,700 Este 3 de aquí ahora se asocia con este valor. 190 00:13:20,700 --> 00:13:23,700 Este 4 de aquí se asocia con este valor. 191 00:13:23,700 --> 00:13:26,700 Y ahora aquí dentro, para esta ejecución de este método, 192 00:13:26,700 --> 00:13:29,700 lado 1 vale 3 y lado 2 vale 4. 193 00:13:29,700 --> 00:13:31,700 Hago todo como si fueran así. 194 00:13:31,700 --> 00:13:33,700 Cuando lo vuelva a llamar la siguiente vez 195 00:13:33,700 --> 00:13:38,700 y pongo como parámetros actuales 5 y 10, 196 00:13:38,700 --> 00:13:43,700 actualmente los parámetros formales lado 1 y lado 2 197 00:13:43,700 --> 00:13:48,700 valen 5 y 10, respectivamente. 198 00:13:48,700 --> 00:13:52,700 Entonces, yo aquí pienso en abstracto. 199 00:13:52,700 --> 00:13:56,700 ¿Qué necesito para calcular el área del perímetro de un rectángulo? 200 00:13:56,700 --> 00:13:59,700 Pues necesito un lado y el otro lado. 201 00:13:59,700 --> 00:14:01,700 ¿Y cuánto valen? No lo sé. 202 00:14:01,700 --> 00:14:02,700 Estoy haciendo algo abstracto. 203 00:14:02,700 --> 00:14:05,700 Estoy haciendo una función, un procedimiento 204 00:14:05,700 --> 00:14:08,700 que valga para cualquier rectángulo posible. 205 00:14:08,700 --> 00:14:09,700 Entonces, ¿qué hago? 206 00:14:09,700 --> 00:14:11,700 En vez de ponerle aquí 3 y 4, 207 00:14:11,700 --> 00:14:14,700 le digo que el lado corto se llamará lado 1 208 00:14:14,700 --> 00:14:16,700 y el lado largo se llamará lado 2. 209 00:14:16,700 --> 00:14:19,700 Siempre, o no sé, tanto da igual. 210 00:14:19,700 --> 00:14:21,700 Tengo los dos lados, tengo dos medidas de lado. 211 00:14:21,700 --> 00:14:24,700 No necesito los cuatro porque dos a dos son iguales. 212 00:14:24,700 --> 00:14:26,700 Estos son los datos que necesito. 213 00:14:26,700 --> 00:14:28,700 ¿Y cuánto valen? No lo sé. 214 00:14:28,700 --> 00:14:35,700 Yo voy a utilizar esta representación literal, 215 00:14:35,700 --> 00:14:40,700 esta representación, ¿cómo decirlo? 216 00:14:40,700 --> 00:14:46,700 No numérica, sino gráfica de estos datos. 217 00:14:46,700 --> 00:14:49,700 Y voy a hacer lo que tengo que hacer con estos datos. 218 00:14:49,700 --> 00:14:51,700 Esto es genérico. 219 00:14:51,700 --> 00:14:56,700 Si yo os doy solo esto, ¿sabéis el área del rectángulo? 220 00:14:56,700 --> 00:15:00,700 No, porque no sabéis todavía cuánto vale el lado 1. 221 00:15:00,700 --> 00:15:02,700 ¿Y dónde sé cuánto vale el lado 1? 222 00:15:02,700 --> 00:15:04,700 Cuando llamo este método. 223 00:15:04,700 --> 00:15:08,700 Aquí es donde fijo que en esta ejecución de esta función, 224 00:15:08,700 --> 00:15:18,700 de este procedimiento, este señor, lado 1, vale 3. 225 00:15:18,700 --> 00:15:22,700 Tú podrías poner aquí scan.exit, scan.exit 226 00:15:22,700 --> 00:15:26,700 y cuando tú estás poniendo los datos te van uno aquí y uno aquí. 227 00:15:26,700 --> 00:15:27,700 O haberlo pedido antes. 228 00:15:27,700 --> 00:15:30,700 Dame la cosa A y ponlo en A. 229 00:15:30,700 --> 00:15:32,700 Y luego dame otra cosa y ponlo en B. 230 00:15:32,700 --> 00:15:35,700 Y luego aquí se llama perímetro de A, B. 231 00:15:38,700 --> 00:15:40,700 La idea es que aquí hay dos parámetros. 232 00:15:40,700 --> 00:15:44,700 Hay parámetros formales y parámetros actuales. 233 00:15:44,700 --> 00:15:47,700 Los parámetros formales son los que no sé cuánto valen, 234 00:15:47,700 --> 00:15:51,700 pero los uso de forma abstracta dentro del método. 235 00:15:51,700 --> 00:15:55,700 Los parámetros actuales son los parámetros que uso 236 00:15:55,700 --> 00:15:58,700 al momento de llamar y que vinculan, 237 00:15:58,700 --> 00:16:04,700 hacen una bind entre el parámetro actual correspondiente 238 00:16:04,700 --> 00:16:06,700 y el valor actual que le estoy dando. 239 00:16:20,700 --> 00:16:22,700 Lo mismo, esto no cambia. 240 00:16:22,700 --> 00:16:26,700 Es aquí, porque tú estás modificando los parámetros actuales, 241 00:16:26,700 --> 00:16:28,700 pero esto se queda exactamente igual. 242 00:16:28,700 --> 00:16:33,700 Cuando tú luego harás la unión dirás que el lado 1 corresponde a A, 243 00:16:33,700 --> 00:16:35,700 pero no es que le pones A como carácter, 244 00:16:35,700 --> 00:16:39,700 pones lo que está dentro de la memoria que se llama A. 245 00:16:39,700 --> 00:16:43,700 O sea, irás a la variable, irás a su parte de int, 246 00:16:43,700 --> 00:16:47,700 buscará el valor que está ahora mismo allí dentro, que es 18, 247 00:16:47,700 --> 00:16:49,700 pues este 18 ahora está vinculado con A. 248 00:16:56,700 --> 00:16:58,700 Fíjate que están en bloques distintos. 249 00:16:58,700 --> 00:17:02,700 Fijaos en esto, el main acaba aquí. 250 00:17:04,700 --> 00:17:08,700 La declaración del método, de este procedimiento, 251 00:17:08,700 --> 00:17:12,700 no está dentro del main, es hermana al main. 252 00:17:18,700 --> 00:17:20,700 Esto provoca algunos problemillas. 253 00:17:20,700 --> 00:17:24,700 En plan, ¿puedo aquí utilizar una variable que está aquí? 254 00:17:26,700 --> 00:17:28,700 Porque son bloques distintos. 255 00:17:29,700 --> 00:17:32,700 Si yo quiero leer de teclado, o leo en el main, 256 00:17:32,700 --> 00:17:35,700 y luego se lo paso por parámetro a esto, 257 00:17:35,700 --> 00:17:38,700 o no leo en el main, leo directamente aquí, 258 00:17:38,700 --> 00:17:44,700 pero el objeto scanner no lo puedo crear en el main 259 00:17:44,700 --> 00:17:49,700 y luego usarlo en el método, porque en el método no existe. 260 00:17:50,700 --> 00:17:51,700 ¿Pero puedes crearlo en los dos? 261 00:17:51,700 --> 00:17:52,700 Sí. 262 00:17:54,700 --> 00:17:59,700 Normalmente lo creas donde tú quieres crearlo, no en todos lados. 263 00:17:59,700 --> 00:18:02,700 Tú piensas en el algoritmo que quieres hacer, 264 00:18:02,700 --> 00:18:05,700 y lo que quieres es, ¿quieres que sea el main que compruebe 265 00:18:05,700 --> 00:18:08,700 si los datos son correctos y luego después los usa? 266 00:18:08,700 --> 00:18:10,700 Pues pides aquí. 267 00:18:10,700 --> 00:18:13,700 ¿Quieres que el método mismo, cada vez que se lanza, 268 00:18:13,700 --> 00:18:15,700 haga este trabajo? Pues lo haces aquí. 269 00:18:15,700 --> 00:18:19,700 Pero es una decisión del diseño del programa tuyo. 270 00:18:20,700 --> 00:18:21,700 Más dudas. 271 00:18:22,700 --> 00:18:25,700 La única cosa que sí tiene que ser igual, 272 00:18:25,700 --> 00:18:31,700 es que si yo te he dicho que este señor pilla un entero, 273 00:18:31,700 --> 00:18:35,700 tú aquí me tendrás que poner un entero, 274 00:18:35,700 --> 00:18:37,700 o me puedes poner la palabra gato, 275 00:18:37,700 --> 00:18:40,700 porque te dice, este es un string, aquí quiero su int, 276 00:18:40,700 --> 00:18:42,700 no los puedo conectar. 277 00:18:46,700 --> 00:18:49,700 ¿Puedo utilizar métodos que estén dentro de mi proyecto, 278 00:18:49,700 --> 00:18:51,700 dentro de mi paquete? 279 00:18:52,700 --> 00:18:53,700 Puedes usar muchas cosas. 280 00:18:53,700 --> 00:18:55,700 Por ahora nosotros tenemos una clase, usamos esa. 281 00:18:55,700 --> 00:18:58,700 ¿Quién de vosotros ha usado paquete y se ha puesto a ver? 282 00:18:58,700 --> 00:19:01,700 Es porque ha querido hacerlo y yo todavía no lo he explicado. 283 00:19:03,700 --> 00:19:06,700 Nosotros por ahora, los métodos que necesitamos, 284 00:19:06,700 --> 00:19:08,700 los metemos todos dentro de la misma clase, 285 00:19:08,700 --> 00:19:09,700 y los usamos desde ahí. 286 00:19:09,700 --> 00:19:14,700 Y además, los métodos actuales que nosotros creamos, son estáticos. 287 00:19:14,700 --> 00:19:15,700 ¿Qué quiere decir? 288 00:19:15,700 --> 00:19:19,700 No lo sabemos, porque no sabemos programación orientada a los objetos. 289 00:19:19,700 --> 00:19:21,700 Pero por ahora usamos esto. 290 00:19:21,700 --> 00:19:24,700 Veremos que en un futuro, esto lo usamos muy poco. 291 00:19:25,700 --> 00:19:26,700 Esto lo quitaré. 292 00:19:27,700 --> 00:19:28,700 ¿Más dudas? 293 00:19:33,700 --> 00:19:34,700 Sigamos adelante. 294 00:19:34,700 --> 00:19:36,700 Este es el primer ejemplito. 295 00:19:36,700 --> 00:19:39,700 La idea que os tenéis que haber llevado con esto, 296 00:19:39,700 --> 00:19:41,700 es que yo antes pienso, 297 00:19:41,700 --> 00:19:44,700 que uso mi función o mi procedimiento de forma abstracta, 298 00:19:44,700 --> 00:19:46,700 utilizando parámetros abstractos. 299 00:19:46,700 --> 00:19:50,700 Aquí los uso como si supiera cuánto vale lado 1. 300 00:19:50,700 --> 00:19:51,700 ¿Cuánto vale lado 1? 301 00:19:51,700 --> 00:19:52,700 Pues vale lado 1. 302 00:19:52,700 --> 00:19:54,700 En un futuro me dirán cuánto vale. 303 00:19:54,700 --> 00:19:57,700 Por ahora lo uso haciendo fórmulas genéricas. 304 00:19:57,700 --> 00:20:00,700 Es como si yo os digo, ¿cómo se calcula el área? 305 00:20:00,700 --> 00:20:01,700 Pues lado por altura. 306 00:20:03,700 --> 00:20:06,700 No os estoy diciendo cuánto vale lado y cuánto vale altura. 307 00:20:06,700 --> 00:20:07,700 Es una fórmula genérica. 308 00:20:07,700 --> 00:20:08,700 Aquí, fórmula genérica. 309 00:20:08,700 --> 00:20:09,700 Y luego, cuando os digo, 310 00:20:09,700 --> 00:20:12,700 ¿y lado vale 3 y altura vale 7? 311 00:20:12,700 --> 00:20:15,700 Pues entonces vosotros podéis aplicar la regla 312 00:20:15,700 --> 00:20:21,700 en base a los datos actuales que os he pasado. 313 00:20:21,700 --> 00:20:23,700 Los parámetros actuales que os he pasado. 314 00:20:23,700 --> 00:20:24,700 ¿Entienden? 315 00:20:24,700 --> 00:20:26,700 Esto lo estáis haciendo desde siempre. 316 00:20:27,700 --> 00:20:32,700 Solo que de una forma un poquito más formal, 317 00:20:32,700 --> 00:20:34,700 de hacerlo en programación. 318 00:20:36,700 --> 00:20:37,700 ¿Dudas? 319 00:20:39,700 --> 00:20:42,700 Entonces, ¿qué es un procedimiento? 320 00:20:42,700 --> 00:20:45,700 Un procedimiento es un conjunto de instrucciones 321 00:20:45,700 --> 00:20:47,700 que cumple una determinada tarea. 322 00:20:47,700 --> 00:20:48,700 ¿Vale? 323 00:20:48,700 --> 00:20:49,700 Hace algo. 324 00:20:49,700 --> 00:20:51,700 Esta tarea puede depender de algunos valores, 325 00:20:51,700 --> 00:20:54,700 que son los parámetros o no. 326 00:20:54,700 --> 00:20:55,700 ¿Vale? 327 00:20:55,700 --> 00:20:56,700 Hemos dicho que, por ejemplo, 328 00:20:56,700 --> 00:21:00,700 la length no necesita parámetros. 329 00:21:00,700 --> 00:21:04,700 O la nextInt no necesita parámetros. 330 00:21:04,700 --> 00:21:09,700 La print o la charAt, 331 00:21:09,700 --> 00:21:12,700 pues sí necesita un parámetro para poder funcionar. 332 00:21:12,700 --> 00:21:15,700 Eso lo decidís vosotros cuando creáis el procedimiento. 333 00:21:15,700 --> 00:21:17,700 Si yo quiero hacer el procedimiento 334 00:21:17,700 --> 00:21:19,700 que calcula la área del cuadrado 335 00:21:19,700 --> 00:21:21,700 y no pido el lado, 336 00:21:21,700 --> 00:21:23,700 quiero ver cómo lo hago. 337 00:21:24,700 --> 00:21:28,700 Otra opción es que sea sin parámetros, 338 00:21:28,700 --> 00:21:30,700 pero dentro de la propia procedura, 339 00:21:30,700 --> 00:21:33,700 pida al usuario, dame un dato. 340 00:21:33,700 --> 00:21:35,700 Pues eso se puede hacer. 341 00:21:35,700 --> 00:21:37,700 Me explico mejor. 342 00:21:37,700 --> 00:21:39,700 Si yo hago el método 343 00:21:39,700 --> 00:21:42,700 de calcular el pedímetro de un cuadrado, 344 00:21:42,700 --> 00:21:44,700 que es lado por 4, 345 00:21:44,700 --> 00:21:46,700 puedo tener dos opciones. 346 00:21:46,700 --> 00:21:49,700 Una es que cuando llamen este procedimiento 347 00:21:49,700 --> 00:21:52,700 ya sepan el lado y me lo pasen a mí. 348 00:21:52,700 --> 00:21:56,700 Entonces no necesito poner un parámetro. 349 00:21:56,700 --> 00:21:59,700 O podría ser que tú puedes llamarlo sin parámetro 350 00:21:59,700 --> 00:22:01,700 y lo que hace el procedimiento dentro 351 00:22:01,700 --> 00:22:03,700 es crearse un objeto scan 352 00:22:03,700 --> 00:22:05,700 y pedir al usuario, dame el lado del cuadrado. 353 00:22:05,700 --> 00:22:07,700 Y el usuario lo pone allí, 354 00:22:07,700 --> 00:22:11,700 entonces no necesito tener un parámetro que me pasen. 355 00:22:11,700 --> 00:22:13,700 Lo pide el mismo método, 356 00:22:13,700 --> 00:22:15,700 el mismo procedimiento. 357 00:22:15,700 --> 00:22:17,700 ¿Se entiende? 358 00:22:17,700 --> 00:22:19,700 Eso lo decido yo. 359 00:22:21,700 --> 00:22:25,700 Ejemplos de posibles procedimientos. 360 00:22:27,700 --> 00:22:29,700 Está aquí. 361 00:22:29,700 --> 00:22:31,700 Calcula área. 362 00:22:31,700 --> 00:22:35,700 Recibe el lado 1 y el lado 2. 363 00:22:35,700 --> 00:22:37,700 ¿Qué hará esto? 364 00:22:37,700 --> 00:22:39,700 Pues pillará el lado 1, 365 00:22:39,700 --> 00:22:41,700 lo multiplicará por el lado 2 366 00:22:41,700 --> 00:22:43,700 y lo que sea lo imprime en pantalla. 367 00:22:43,700 --> 00:22:45,700 ¿Sí? 368 00:22:45,700 --> 00:22:47,700 Otro método, saluda. 369 00:22:47,700 --> 00:22:49,700 ¿Qué parámetros tiene este? 370 00:22:49,700 --> 00:22:51,700 Ninguno. 371 00:22:51,700 --> 00:22:53,700 Entonces este señor te dice hola. 372 00:22:53,700 --> 00:22:55,700 ¿Sí? 373 00:22:55,700 --> 00:22:57,700 El método saluda, 374 00:22:57,700 --> 00:22:59,700 ¿qué hará? 375 00:23:01,700 --> 00:23:03,700 Hola y el nombre que me ha pasado. 376 00:23:03,700 --> 00:23:05,700 Si yo le pongo saludo entre comillas, 377 00:23:05,700 --> 00:23:07,700 le pongo Estefano, 378 00:23:07,700 --> 00:23:09,700 pues le dirá hola Estefano. 379 00:23:09,700 --> 00:23:11,700 ¿Dudas? 380 00:23:13,700 --> 00:23:15,700 Vamos a verlo. 381 00:23:17,700 --> 00:23:19,700 ¿Cómo se declara un procedimiento? 382 00:23:19,700 --> 00:23:21,700 Por ahora estamos con procedimientos. 383 00:23:21,700 --> 00:23:23,700 En cuanto llegamos a las funciones 384 00:23:23,700 --> 00:23:25,700 vemos la diferencia. 385 00:23:25,700 --> 00:23:27,700 Un procedimiento se declara con 386 00:23:27,700 --> 00:23:29,700 public, static, void, nombre del procedimiento, 387 00:23:29,700 --> 00:23:31,700 abierta paréntesis, 388 00:23:31,700 --> 00:23:33,700 tipo 1, parámetro 1, 389 00:23:33,700 --> 00:23:35,700 coma tipo 2, parámetro 2, 390 00:23:35,700 --> 00:23:37,700 coma tipo 3, parámetro 3, 391 00:23:37,700 --> 00:23:39,700 coma... 392 00:23:39,700 --> 00:23:41,700 ¿Cuántos parámetros yo quiero? 393 00:23:41,700 --> 00:23:43,700 ¿Sí? 394 00:23:43,700 --> 00:23:45,700 Al final, 395 00:23:45,700 --> 00:23:47,700 abro un bloque, 396 00:23:47,700 --> 00:23:49,700 pongo aquí el código 397 00:23:49,700 --> 00:23:51,700 que tiene este nombre, 398 00:23:51,700 --> 00:23:53,700 el código, el cuerpo del procedimiento 399 00:23:53,700 --> 00:23:55,700 y cierro el bloque. 400 00:23:57,700 --> 00:23:59,700 Esto como hermano del main. 401 00:23:59,700 --> 00:24:01,700 No dentro del main, 402 00:24:01,700 --> 00:24:03,700 sino fuera del main. 403 00:24:03,700 --> 00:24:05,700 Por arriba, por abajo, me da igual. 404 00:24:05,700 --> 00:24:07,700 Pero dentro del class. 405 00:24:07,700 --> 00:24:09,700 ¿Recordáis public class, 406 00:24:09,700 --> 00:24:11,700 el nombre de la clase, y abro un bloque? 407 00:24:11,700 --> 00:24:13,700 Dentro de ese bloque, 408 00:24:13,700 --> 00:24:15,700 pero fuera del main. 409 00:24:15,700 --> 00:24:17,700 Es hermano del main. 410 00:24:17,700 --> 00:24:19,700 Ni dentro, 411 00:24:19,700 --> 00:24:21,700 ni fuera de clase. 412 00:24:21,700 --> 00:24:23,700 O sale algún error de 413 00:24:23,700 --> 00:24:25,700 ¿Qué es esto? 414 00:24:25,700 --> 00:24:27,700 Y lo he metido mal. 415 00:24:27,700 --> 00:24:29,700 ¿Cómo se llama 416 00:24:29,700 --> 00:24:31,700 este procedimiento? 417 00:24:31,700 --> 00:24:33,700 Utilizando el nombre 418 00:24:33,700 --> 00:24:35,700 que he puesto arriba, 419 00:24:35,700 --> 00:24:37,700 abierta paréntesis, 420 00:24:37,700 --> 00:24:39,700 el valor actual 421 00:24:39,700 --> 00:24:41,700 del parámetro 1, 422 00:24:41,700 --> 00:24:43,700 coma el valor actual 423 00:24:43,700 --> 00:24:45,700 del parámetro 2, 424 00:24:45,700 --> 00:24:47,700 coma etc, etc. 425 00:24:47,700 --> 00:24:49,700 Estos valores tienen que estar 426 00:24:49,700 --> 00:24:51,700 asociados con el tipo 427 00:24:51,700 --> 00:24:53,700 que he puesto aquí. 428 00:24:53,700 --> 00:24:55,700 Si aquí he puesto que es tipo 1, 429 00:24:55,700 --> 00:24:57,700 que se llama nombre, 430 00:24:57,700 --> 00:24:59,700 y es un string, pues este valor 431 00:24:59,700 --> 00:25:01,700 de aquí tiene que ser un string. 432 00:25:01,700 --> 00:25:03,700 No los puedo mezclar. 433 00:25:03,700 --> 00:25:05,700 Va a decir, tú querías un string 434 00:25:05,700 --> 00:25:07,700 e un int, he dado un int y un string. 435 00:25:07,700 --> 00:25:09,700 Vale igual, los datos los tiene. 436 00:25:09,700 --> 00:25:11,700 Tiene que ir con el orden que yo he fijado. 437 00:25:19,700 --> 00:25:21,700 Ejemplos. 438 00:25:27,700 --> 00:25:29,700 Aquí yo tengo un main. 439 00:25:29,700 --> 00:25:31,700 Lo vamos a ver después. 440 00:25:31,700 --> 00:25:33,700 Tengo el método saluda, 441 00:25:33,700 --> 00:25:35,700 y el método saluda que pilla un string. 442 00:25:35,700 --> 00:25:37,700 ¿Qué hace el método saluda? 443 00:25:37,700 --> 00:25:39,700 No pilla ningún parámetro. 444 00:25:39,700 --> 00:25:41,700 Y lo único que hace es 445 00:25:41,700 --> 00:25:43,700 hola a todos. 446 00:25:43,700 --> 00:25:45,700 Si os fijáis, aquí no uso ningún parámetro. 447 00:25:45,700 --> 00:25:47,700 Hará siempre lo mismo. 448 00:25:47,700 --> 00:25:49,700 Porque no es paramétrico, 449 00:25:49,700 --> 00:25:51,700 no depende de algo que le ponga aquí 450 00:25:51,700 --> 00:25:53,700 para hacer su trabajo. 451 00:25:53,700 --> 00:25:55,700 Siempre hará lo mismo. 452 00:25:55,700 --> 00:25:57,700 Sin embargo, 453 00:25:57,700 --> 00:25:59,700 saluda que recibe 454 00:25:59,700 --> 00:26:01,700 un nombre de tipo string. 455 00:26:01,700 --> 00:26:03,700 Aquí mi parámetro 456 00:26:03,700 --> 00:26:05,700 formal se llama 457 00:26:05,700 --> 00:26:07,700 nombre. 458 00:26:07,700 --> 00:26:09,700 Entonces aquí dentro puedo utilizar nombre. 459 00:26:09,700 --> 00:26:11,700 ¿Y cuál es nombre? No lo sé. 460 00:26:11,700 --> 00:26:13,700 Lo sabré cuando me llaman. 461 00:26:13,700 --> 00:26:15,700 Cuando llamarán al método saluda 462 00:26:15,700 --> 00:26:17,700 con un string, 463 00:26:17,700 --> 00:26:19,700 pues entonces sabré cuánto vale. 464 00:26:19,700 --> 00:26:21,700 Fijaos que los dos señores 465 00:26:21,700 --> 00:26:23,700 se llaman igual. 466 00:26:23,700 --> 00:26:25,700 Los dos se llaman saluda. 467 00:26:25,700 --> 00:26:27,700 Entonces, cuando llaman saluda, 468 00:26:27,700 --> 00:26:29,700 ¿cómo hago yo a saber 469 00:26:29,700 --> 00:26:31,700 si tengo que utilizar el de arriba o el de abajo? 470 00:26:33,700 --> 00:26:35,700 Según el parámetro. 471 00:26:35,700 --> 00:26:37,700 Lo que se llama la firma del método. 472 00:26:37,700 --> 00:26:39,700 ¿Vale? 473 00:26:39,700 --> 00:26:41,700 Nombre y tipos de datos 474 00:26:41,700 --> 00:26:43,700 de los parámetros. 475 00:26:43,700 --> 00:26:45,700 Saluda, sin nada, 476 00:26:45,700 --> 00:26:47,700 es un método distinto, 477 00:26:47,700 --> 00:26:49,700 es un procedimiento distinto de saluda con string. 478 00:26:49,700 --> 00:26:51,700 Que es distinto 479 00:26:51,700 --> 00:26:53,700 de saluda con int. 480 00:26:53,700 --> 00:26:55,700 Que es distinto de saluda con string e int. 481 00:26:55,700 --> 00:26:57,700 Que es distinto de int-string. 482 00:26:59,700 --> 00:27:01,700 ¿Sí? Todos se llaman saluda, 483 00:27:01,700 --> 00:27:03,700 pero este método saluda 484 00:27:03,700 --> 00:27:05,700 es sobrecargado, en cierto sentido, 485 00:27:05,700 --> 00:27:07,700 con varios posibles parámetros. 486 00:27:07,700 --> 00:27:09,700 Y cuando tú lo llamas, 487 00:27:09,700 --> 00:27:11,700 según los parámetros que pones, 488 00:27:11,700 --> 00:27:13,700 pues él sabrá 489 00:27:13,700 --> 00:27:15,700 si tiene que utilizar esto o esto. 490 00:27:15,700 --> 00:27:17,700 ¿Puedo hacer dos métodos 491 00:27:17,700 --> 00:27:19,700 o dos procedimientos 492 00:27:19,700 --> 00:27:21,700 que se llamen saluda 493 00:27:21,700 --> 00:27:23,700 y que tengan los dos string nombre 494 00:27:23,700 --> 00:27:25,700 y otro string apellido 495 00:27:25,700 --> 00:27:27,700 y hagan cosas distintas? 496 00:27:27,700 --> 00:27:29,700 No. 497 00:27:31,700 --> 00:27:33,700 Si yo tuviera aquí, pongamos aquí 498 00:27:33,700 --> 00:27:35,700 string apellido. 499 00:27:35,700 --> 00:27:37,700 Cuando yo te llamo saluda de Stefano, 500 00:27:37,700 --> 00:27:39,700 ¿cómo sabes tú 501 00:27:39,700 --> 00:27:41,700 si tienes que ejecutar esto o esto 502 00:27:41,700 --> 00:27:43,700 si los dos tienen un string? 503 00:27:43,700 --> 00:27:45,700 Entonces no sería determinista. 504 00:27:45,700 --> 00:27:47,700 El procesador llegaría allí 505 00:27:47,700 --> 00:27:49,700 y diría, mira, 506 00:27:49,700 --> 00:27:51,700 tengo dos opciones para poder ejecutar 507 00:27:51,700 --> 00:27:53,700 y no sé cuál de las dos quieres tú. 508 00:27:53,700 --> 00:27:55,700 Porque tú me has dicho Stefano 509 00:27:55,700 --> 00:27:57,700 y yo no sé 510 00:27:57,700 --> 00:27:59,700 si esto es un apellido o es un nombre. 511 00:27:59,700 --> 00:28:01,700 Para mí es un string. 512 00:28:01,700 --> 00:28:03,700 Y tengo dos procedimientos 513 00:28:03,700 --> 00:28:05,700 que reciben un string. 514 00:28:05,700 --> 00:28:07,700 Pues eso no me vale. 515 00:28:07,700 --> 00:28:09,700 Puedo hacer varios procedimientos 516 00:28:09,700 --> 00:28:11,700 que se llamen igual, 517 00:28:11,700 --> 00:28:13,700 pero tienen que diferir 518 00:28:13,700 --> 00:28:15,700 en los tipos, o sea, 519 00:28:15,700 --> 00:28:17,700 tienen que ser distintos en los tipos 520 00:28:17,700 --> 00:28:19,700 de datos que reciben. 521 00:28:21,700 --> 00:28:23,700 ¿Cuántos métodos saluda puede hacer máximo? 522 00:28:27,700 --> 00:28:29,700 Infinitos. 523 00:28:29,700 --> 00:28:31,700 Con que yo ponga más parámetros 524 00:28:31,700 --> 00:28:33,700 y que no coincidan con parámetros, 525 00:28:33,700 --> 00:28:35,700 todo lo saluda que yo quiera. 526 00:28:35,700 --> 00:28:37,700 ¿Dudas? 527 00:28:37,700 --> 00:28:39,700 Entonces, ¿cómo llamo estos? 528 00:28:43,700 --> 00:28:45,700 Por ejemplo, yo tengo un main 529 00:28:45,700 --> 00:28:47,700 que llama saluda. 530 00:28:47,700 --> 00:28:49,700 ¿Cuál estoy llamando, el de arriba o el de abajo? 531 00:28:49,700 --> 00:28:51,700 El de arriba. 532 00:28:51,700 --> 00:28:53,700 No tiene parámetros, llamo esto. 533 00:28:53,700 --> 00:28:55,700 Me dirá hola a todos. 534 00:28:55,700 --> 00:28:57,700 Luego llamo saluda con dentro un string. 535 00:28:57,700 --> 00:28:59,700 ¿Cuál está llamando? 536 00:28:59,700 --> 00:29:01,700 El de abajo. 537 00:29:01,700 --> 00:29:03,700 Y dirá hola Stefano. 538 00:29:03,700 --> 00:29:05,700 Luego me creo una variable 539 00:29:05,700 --> 00:29:07,700 que se llama n, 540 00:29:07,700 --> 00:29:09,700 que dentro tiene Paco, 541 00:29:09,700 --> 00:29:11,700 y llamo saluda de n. 542 00:29:11,700 --> 00:29:13,700 ¿Qué hará? 543 00:29:13,700 --> 00:29:15,700 La de abajo. 544 00:29:15,700 --> 00:29:17,700 Y escribirá hola Paco. 545 00:29:17,700 --> 00:29:19,700 O sea, que yo aquí 546 00:29:19,700 --> 00:29:21,700 puedo poner un literal 547 00:29:21,700 --> 00:29:23,700 o una variable. Variable y literal 548 00:29:23,700 --> 00:29:25,700 son la misma cosa, al fin y al cabo, 549 00:29:25,700 --> 00:29:27,700 en tiempo de ejecución, simplemente yo me iré a mirar 550 00:29:27,700 --> 00:29:29,700 en la trozo de memoria 551 00:29:29,700 --> 00:29:31,700 que se llama n, lo que hay allí dentro. 552 00:29:31,700 --> 00:29:33,700 Y ese es el valor que utilizaré. 553 00:29:39,700 --> 00:29:41,700 Me aparecerían tres saludos. 554 00:29:41,700 --> 00:29:43,700 Saluda hola a todos, 555 00:29:43,700 --> 00:29:45,700 hola Stefano, 556 00:29:45,700 --> 00:29:47,700 hola Paco. 557 00:29:51,700 --> 00:29:53,700 Vamos a ver 558 00:29:53,700 --> 00:29:55,700 el prueba 4. 559 00:29:55,700 --> 00:29:57,700 Tengo el main. 560 00:29:57,700 --> 00:29:59,700 Tengo ahora aquí 561 00:29:59,700 --> 00:30:01,700 un programa que se llama 562 00:30:01,700 --> 00:30:03,700 repitesaludo, 563 00:30:03,700 --> 00:30:05,700 que recibe dos parámetros. 564 00:30:05,700 --> 00:30:07,700 String nombre, 565 00:30:07,700 --> 00:30:09,700 int repeticiones. 566 00:30:09,700 --> 00:30:11,700 Y lo que hace aquí dentro, 567 00:30:11,700 --> 00:30:13,700 sin saber qué es nombre, qué es repeticiones, 568 00:30:13,700 --> 00:30:15,700 hace esto. 569 00:30:15,700 --> 00:30:17,700 ¿Qué os espera ahí que abra? 570 00:30:17,700 --> 00:30:19,700 ¿Repite qué? 571 00:30:27,700 --> 00:30:29,700 ¿Repite qué? 572 00:30:31,700 --> 00:30:33,700 ¿Repite qué? 573 00:30:33,700 --> 00:30:35,700 Imprime en pantalla qué. 574 00:30:37,700 --> 00:30:39,700 Hola el nombre que le he pasado, ¿cuántas veces? 575 00:30:41,700 --> 00:30:43,700 ¿Cuántas veces? 576 00:30:43,700 --> 00:30:45,700 No, aquí es nombre. 577 00:30:47,700 --> 00:30:49,700 ¿Cuántas veces? 578 00:30:51,700 --> 00:30:53,700 ¿Cuántas veces? 579 00:30:53,700 --> 00:30:55,700 Repeticiones veces, 580 00:30:55,700 --> 00:30:57,700 hola nombre. 581 00:31:01,700 --> 00:31:03,700 Entonces si yo hago 582 00:31:03,700 --> 00:31:05,700 repitesaludo de Luis, 583 00:31:05,700 --> 00:31:07,700 coma cuatro, 584 00:31:07,700 --> 00:31:09,700 ¿qué me hace? 585 00:31:09,700 --> 00:31:11,700 Hola Luis, hola Luis, hola Luis, 586 00:31:11,700 --> 00:31:13,700 hola Luis, cuatro veces, 587 00:31:13,700 --> 00:31:15,700 hola Luis. 588 00:31:17,700 --> 00:31:19,700 ¿Dudas? 589 00:31:21,700 --> 00:31:23,700 Si yo copio esto 590 00:31:23,700 --> 00:31:25,700 y lo pego aquí, 591 00:31:25,700 --> 00:31:27,700 y le pongo que 592 00:31:27,700 --> 00:31:29,700 repeticiones es igual a cuatro 593 00:31:29,700 --> 00:31:31,700 y nombre es igual a Luis, ¿qué cambia? 594 00:31:31,700 --> 00:31:33,700 ¿Qué hace? 595 00:31:33,700 --> 00:31:35,700 Lo mismo. 596 00:31:35,700 --> 00:31:37,700 Esto de aquí 597 00:31:37,700 --> 00:31:39,700 es como funciona 598 00:31:41,700 --> 00:31:43,700 la llamada de método, 599 00:31:43,700 --> 00:31:45,700 es como si en esta línea de aquí 600 00:31:45,700 --> 00:31:47,700 yo la borrara 601 00:31:47,700 --> 00:31:49,700 y copiara el código 602 00:31:49,700 --> 00:31:51,700 que está aquí dentro, 603 00:31:51,700 --> 00:31:53,700 aquí, ¿vale? 604 00:31:53,700 --> 00:31:55,700 Sostituyendo donde aquí pone 605 00:31:55,700 --> 00:31:57,700 nombre, Luis, 606 00:31:57,700 --> 00:31:59,700 y donde aquí pone repeticiones, 607 00:31:59,700 --> 00:32:01,700 cuatro. 608 00:32:01,700 --> 00:32:03,700 ¿Se entiende? 609 00:32:09,700 --> 00:32:11,700 No, si hago menor o igual 610 00:32:11,700 --> 00:32:13,700 me hace repeticiones más uno, 611 00:32:13,700 --> 00:32:15,700 porque empieza de cero. 612 00:32:15,700 --> 00:32:17,700 Si yo pongo cuatro, 613 00:32:17,700 --> 00:32:19,700 cero, uno, dos y tres, 614 00:32:19,700 --> 00:32:21,700 y a cuatro sale, son cuatro veces. 615 00:32:21,700 --> 00:32:23,700 ¿Sí? 616 00:32:23,700 --> 00:32:25,700 Puedes hacer de i igual a uno 617 00:32:25,700 --> 00:32:27,700 a i menor o igual a repeticiones, 618 00:32:27,700 --> 00:32:29,700 siempre son cuatro veces. 619 00:32:29,700 --> 00:32:31,700 Con esto podéis jugar vosotros, ¿vale? 620 00:32:31,700 --> 00:32:33,700 Nos vendrá bien esto 621 00:32:33,700 --> 00:32:35,700 y es porque lo veis así, 622 00:32:35,700 --> 00:32:37,700 porque cuando tendremos los arrays 623 00:32:37,700 --> 00:32:39,700 la primera posición de la array es la cero. 624 00:32:39,700 --> 00:32:41,700 Entonces me vale, 625 00:32:41,700 --> 00:32:43,700 me viene mejor que i empiece de cero. 626 00:32:45,700 --> 00:32:47,700 ¿Más dudas? 627 00:32:53,700 --> 00:32:55,700 Vale. 628 00:32:55,700 --> 00:32:57,700 Entonces la idea es 629 00:32:57,700 --> 00:32:59,700 simplemente esta, yo tengo un método. 630 00:32:59,700 --> 00:33:01,700 Hemos hecho algunos ejercicios 631 00:33:01,700 --> 00:33:03,700 donde un cierto 632 00:33:03,700 --> 00:33:05,700 trozo de 633 00:33:05,700 --> 00:33:07,700 método, 634 00:33:07,700 --> 00:33:09,700 trozo de código se repetía varias veces. 635 00:33:09,700 --> 00:33:11,700 Pues yo allí habría podido sacarlo fuera, 636 00:33:11,700 --> 00:33:13,700 poner allí, 637 00:33:13,700 --> 00:33:15,700 darle un nombre y decir 638 00:33:15,700 --> 00:33:17,700 todas las veces que yo tenía, pues repite este nombre. 639 00:33:17,700 --> 00:33:19,700 ¿Vale? 640 00:33:19,700 --> 00:33:21,700 Ahora para luego hacemos más ejemplos después. 641 00:33:21,700 --> 00:33:23,700 Los procedimientos 642 00:33:23,700 --> 00:33:25,700 como tales 643 00:33:25,700 --> 00:33:27,700 se pueden utilizar también 644 00:33:27,700 --> 00:33:29,700 con la idea 645 00:33:29,700 --> 00:33:31,700 de 646 00:33:31,700 --> 00:33:33,700 organizar el código, ¿vale? 647 00:33:33,700 --> 00:33:35,700 En vez de hacer estos programas 648 00:33:35,700 --> 00:33:37,700 absurdos de complejos que tenéis 649 00:33:37,700 --> 00:33:39,700 vosotros con todo metido allí, 650 00:33:39,700 --> 00:33:41,700 yo podría decir, oye mira, 651 00:33:41,700 --> 00:33:43,700 mi programa main 652 00:33:43,700 --> 00:33:45,700 es esto. 653 00:33:45,700 --> 00:33:47,700 Inicializa el sistema, 654 00:33:47,700 --> 00:33:49,700 calcula datos, escribe el resultado. 655 00:33:49,700 --> 00:33:51,700 Tres pasos. 656 00:33:51,700 --> 00:33:53,700 Este es el main. 657 00:33:53,700 --> 00:33:55,700 Y luego ahora irme en cada uno 658 00:33:55,700 --> 00:33:57,700 de estos métodos y hacer 659 00:33:57,700 --> 00:33:59,700 todo el código para inicializar el sistema, 660 00:33:59,700 --> 00:34:01,700 todo el código para calcular 661 00:34:01,700 --> 00:34:03,700 los datos, todo el código para escribir 662 00:34:03,700 --> 00:34:05,700 el resultado. 663 00:34:05,700 --> 00:34:07,700 Además, si yo lo hago así, 664 00:34:07,700 --> 00:34:09,700 puedo pillar tres grupos de trabajos 665 00:34:09,700 --> 00:34:11,700 y decirle, oye mira, 666 00:34:11,700 --> 00:34:13,700 tú tienes que encargarte de inicializar 667 00:34:13,700 --> 00:34:15,700 el sistema, tú de calcular 668 00:34:15,700 --> 00:34:17,700 los datos y tú de escribir 669 00:34:17,700 --> 00:34:19,700 los resultados. Luego 670 00:34:19,700 --> 00:34:21,700 vosotros desarrolláis por separados 671 00:34:21,700 --> 00:34:23,700 a lo mejor con los parámetros que te he 672 00:34:23,700 --> 00:34:25,700 dado yo, ¿vale? 673 00:34:25,700 --> 00:34:27,700 Los distintos programas, luego 674 00:34:27,700 --> 00:34:29,700 los pongo todos juntos y he trabajado 675 00:34:29,700 --> 00:34:31,700 en paralelo. 676 00:34:31,700 --> 00:34:33,700 Entonces hago más rápido. 677 00:34:33,700 --> 00:34:35,700 Realmente esto necesita que antes alguien 678 00:34:35,700 --> 00:34:37,700 sepa de que va el sistema, 679 00:34:37,700 --> 00:34:39,700 que lo haya dividido en métodos, 680 00:34:39,700 --> 00:34:41,700 o sea, en una descomposición funcional, 681 00:34:41,700 --> 00:34:43,700 algo parecido al que os digo que tenéis 682 00:34:43,700 --> 00:34:45,700 que hacer vosotros cuando hacemos los ejercicios, 683 00:34:45,700 --> 00:34:47,700 ¿vale? Y luego ha asignado 684 00:34:47,700 --> 00:34:49,700 a varios grupos de trabajos 685 00:34:49,700 --> 00:34:51,700 trozos de este sistema. 686 00:34:51,700 --> 00:34:53,700 ¿Os acordáis cuál era el ejercicio 687 00:34:53,700 --> 00:34:55,700 que hemos hecho el viernes? Me parece 688 00:34:55,700 --> 00:34:57,700 que tenía como tres fases. Antes 689 00:34:57,700 --> 00:34:59,700 ver si los números eran positivos 690 00:34:59,700 --> 00:35:01,700 o qué era, y luego ver 691 00:35:01,700 --> 00:35:03,700 que quedaban como tres ejercicios 692 00:35:03,700 --> 00:35:05,700 en uno. ¿Os acordáis? 693 00:35:05,700 --> 00:35:07,700 Pues ahora a lo mejor lo buscamos 694 00:35:07,700 --> 00:35:09,700 después, repillamos eso 695 00:35:09,700 --> 00:35:11,700 e intentamos traducirlo a una 696 00:35:11,700 --> 00:35:13,700 cosa de ese estilo. 697 00:35:13,700 --> 00:35:15,700 ¿Vale? 698 00:35:15,700 --> 00:35:17,700 ¿Dudas? 699 00:35:19,700 --> 00:35:21,700 ¿Dudas sobre los procedimientos? 700 00:35:21,700 --> 00:35:23,700 ¿Para qué sirven? 701 00:35:23,700 --> 00:35:25,700 Para no escribir varias veces el código, 702 00:35:25,700 --> 00:35:27,700 para 703 00:35:27,700 --> 00:35:29,700 ordenar el código 704 00:35:29,700 --> 00:35:31,700 y también la tercera 705 00:35:31,700 --> 00:35:33,700 cosa interesante es que 706 00:35:33,700 --> 00:35:35,700 si yo uso la misma... 707 00:35:35,700 --> 00:35:37,700 Pongamos el calcular el área del cuadrado, 708 00:35:37,700 --> 00:35:39,700 ¿vale? Si yo lo uso muchas veces 709 00:35:39,700 --> 00:35:41,700 en mi programa, si yo 710 00:35:41,700 --> 00:35:43,700 lo escribo cada vez como se 711 00:35:43,700 --> 00:35:45,700 calcula y luego me doy cuenta que 712 00:35:45,700 --> 00:35:47,700 quien me ha dado la fórmula se ha equivocado 713 00:35:47,700 --> 00:35:49,700 y en vez de el por 714 00:35:49,700 --> 00:35:51,700 tenía que utilizar otra variable, 715 00:35:51,700 --> 00:35:53,700 otra operación, pues debería 716 00:35:53,700 --> 00:35:55,700 ir a buscar en todo mi programa 717 00:35:55,700 --> 00:35:57,700 las mil veces que lo he utilizado 718 00:35:57,700 --> 00:35:59,700 y modificarlo. 719 00:35:59,700 --> 00:36:01,700 Si yo cada vez que he utilizado 720 00:36:01,700 --> 00:36:03,700 ese procedimiento 721 00:36:03,700 --> 00:36:05,700 llamaba el método calcular área 722 00:36:05,700 --> 00:36:07,700 ahora yo me voy 723 00:36:07,700 --> 00:36:09,700 al método calcular área, lo soluciona 724 00:36:09,700 --> 00:36:11,700 allí el problema y automáticamente 725 00:36:11,700 --> 00:36:13,700 se ha solucionado todas las veces que se ha llamado. 726 00:36:15,700 --> 00:36:17,700 ¿Sí o no? 727 00:36:17,700 --> 00:36:19,700 ¿Dudas? 728 00:36:19,700 --> 00:36:21,700 Vale. 729 00:36:21,700 --> 00:36:23,700 ¿Entonces qué es 730 00:36:23,700 --> 00:36:25,700 en vez de una función? Una función lo sabéis 731 00:36:25,700 --> 00:36:27,700 vosotros, que sois 732 00:36:27,700 --> 00:36:29,700 la mayoría de vosotros 733 00:36:29,700 --> 00:36:31,700 unos cuantos de vosotros habrán pasado por 734 00:36:31,700 --> 00:36:33,700 bachillerato y sabéis perfectamente que es una función. 735 00:36:33,700 --> 00:36:35,700 ¿Qué es una función? 736 00:36:39,700 --> 00:36:41,700 ¿Recordáis? 737 00:36:41,700 --> 00:36:43,700 f de x es igual a 738 00:36:43,700 --> 00:36:45,700 x cuadro más tres 739 00:36:45,700 --> 00:36:47,700 punto y coma. ¿Qué es eso? 740 00:36:47,700 --> 00:36:49,700 Es una máquina, ¿vale? 741 00:36:49,700 --> 00:36:51,700 Es una máquina en la que tú pones 742 00:36:51,700 --> 00:36:53,700 un input, la x, un valor 743 00:36:53,700 --> 00:36:55,700 de la x, y él te lo transforma 744 00:36:55,700 --> 00:36:57,700 en otro input. 745 00:36:57,700 --> 00:36:59,700 Pero la particularidad de la función 746 00:36:59,700 --> 00:37:01,700 es que te devuelve algo. 747 00:37:01,700 --> 00:37:03,700 Cuando tú 748 00:37:03,700 --> 00:37:05,700 llamas una función, le das 749 00:37:05,700 --> 00:37:07,700 unos parámetros de entrada 750 00:37:07,700 --> 00:37:09,700 y él te da un 751 00:37:09,700 --> 00:37:11,700 resultado de la función. 752 00:37:11,700 --> 00:37:13,700 Cosa que si os fijáis 753 00:37:13,700 --> 00:37:15,700 el procedimiento no hace. 754 00:37:15,700 --> 00:37:17,700 El procedimiento tú le dices, haz algo 755 00:37:17,700 --> 00:37:19,700 y él lo hace. Imprime por pantalla 756 00:37:19,700 --> 00:37:21,700 calcula y hace así. 757 00:37:21,700 --> 00:37:23,700 No te devuelve un valor. 758 00:37:23,700 --> 00:37:25,700 No crea un valor, lo calcula y te dice 759 00:37:25,700 --> 00:37:27,700 mira, aquí está el resultado 760 00:37:27,700 --> 00:37:29,700 de tu operación, el resultado de tu 761 00:37:29,700 --> 00:37:31,700 función. Eso no lo hace. 762 00:37:31,700 --> 00:37:33,700 La función sí. 763 00:37:33,700 --> 00:37:35,700 La función es parecida a un procedimiento, 764 00:37:35,700 --> 00:37:37,700 pero sirve para obtener un determinado 765 00:37:37,700 --> 00:37:39,700 resultado que se devolverá 766 00:37:39,700 --> 00:37:41,700 al término de la función. 767 00:37:43,700 --> 00:37:45,700 Es decir, algo parecido 768 00:37:45,700 --> 00:37:47,700 a esto. 769 00:37:47,700 --> 00:37:49,700 Antes yo hacía 770 00:37:49,700 --> 00:37:51,700 calcularea. 771 00:37:51,700 --> 00:37:53,700 Y era el calcularea 772 00:37:53,700 --> 00:37:55,700 que hacía lado por lado 773 00:37:55,700 --> 00:37:57,700 y escribía en pantalla 774 00:37:57,700 --> 00:37:59,700 el resultado es 37. 775 00:37:59,700 --> 00:38:01,700 Pero este 37 776 00:38:01,700 --> 00:38:03,700 o 40, yo no lo tenía. 777 00:38:03,700 --> 00:38:05,700 Lo tenía impreso 778 00:38:05,700 --> 00:38:07,700 pero era en el procedimiento. 779 00:38:07,700 --> 00:38:09,700 Y si yo lo quería utilizar 780 00:38:09,700 --> 00:38:11,700 donde se llama 781 00:38:11,700 --> 00:38:13,700 en el main, es decir, 782 00:38:13,700 --> 00:38:15,700 o sea, en el main, es decir, 783 00:38:23,700 --> 00:38:25,700 esto calcularea el perímetro 784 00:38:25,700 --> 00:38:27,700 y me lo escribe en pantalla. 785 00:38:27,700 --> 00:38:29,700 Y si yo quisiera en el main 786 00:38:29,700 --> 00:38:31,700 utilizar este resultado, utilizar 787 00:38:31,700 --> 00:38:33,700 el área, por ejemplo, 788 00:38:35,700 --> 00:38:37,700 ¿podría hacerlo o no? 789 00:38:37,700 --> 00:38:39,700 No, porque no está allí. 790 00:38:39,700 --> 00:38:41,700 No hay ninguna forma 791 00:38:41,700 --> 00:38:43,700 aquí que me diga 792 00:38:43,700 --> 00:38:45,700 oye mira, te lo doy, 793 00:38:45,700 --> 00:38:47,700 te doy el área, 794 00:38:47,700 --> 00:38:49,700 tú guárdatelo en una variable 795 00:38:49,700 --> 00:38:51,700 porque esto será el área calculada. 796 00:39:11,700 --> 00:39:13,700 No puedes. ¿Cómo lo hace? 797 00:39:13,700 --> 00:39:15,700 Un procedimiento, 798 00:39:15,700 --> 00:39:17,700 la diferencia de procedimiento funciona 799 00:39:17,700 --> 00:39:19,700 es que el procedimiento no puede hacer esto, 800 00:39:19,700 --> 00:39:21,700 el procedimiento no hace esto. 801 00:39:21,700 --> 00:39:23,700 Y la clave está aquí. 802 00:39:23,700 --> 00:39:25,700 Void, que en inglés 803 00:39:25,700 --> 00:39:27,700 quiere decir 804 00:39:27,700 --> 00:39:29,700 vacío, 805 00:39:29,700 --> 00:39:31,700 quiere decir que esta cosa 806 00:39:31,700 --> 00:39:33,700 de aquí no devuelve 807 00:39:33,700 --> 00:39:35,700 nada. Tú no puedes hacer aquí 808 00:39:35,700 --> 00:39:37,700 int x es igual a 809 00:39:37,700 --> 00:39:39,700 calcular el perímetro, 810 00:39:39,700 --> 00:39:41,700 este calcula del perímetro no te devuelve 811 00:39:41,700 --> 00:39:43,700 nada. 812 00:39:45,700 --> 00:39:47,700 La función 813 00:39:49,700 --> 00:39:51,700 es distinta. 814 00:39:51,700 --> 00:39:53,700 La función, cuando tú llamas 815 00:39:53,700 --> 00:39:55,700 calcula área sobre estos dos, 816 00:39:55,700 --> 00:39:57,700 te calculará el área 817 00:39:57,700 --> 00:39:59,700 y al final de la función 818 00:39:59,700 --> 00:40:01,700 pilla estos datos calculados 819 00:40:01,700 --> 00:40:03,700 y lo puede hasta escribir en pantalla, 820 00:40:03,700 --> 00:40:05,700 no hay que ser ese el problema, pero al final de eso 821 00:40:05,700 --> 00:40:07,700 te lo devuelve 822 00:40:07,700 --> 00:40:09,700 este valor calculado, 823 00:40:09,700 --> 00:40:11,700 lo devuelve a 824 00:40:11,700 --> 00:40:13,700 quien lo ha llamado, en este caso 825 00:40:13,700 --> 00:40:15,700 al main 826 00:40:15,700 --> 00:40:17,700 y entonces el main lo puede almacenar 827 00:40:17,700 --> 00:40:19,700 en una variable. 828 00:40:21,700 --> 00:40:23,700 La diferencia entre procedimiento 829 00:40:23,700 --> 00:40:25,700 y función es que la función 830 00:40:25,700 --> 00:40:27,700 devuelve algo y entonces 831 00:40:27,700 --> 00:40:29,700 lo puedo guardar en una variable, mientras el procedimiento 832 00:40:29,700 --> 00:40:31,700 no devuelve nada y por lo 833 00:40:31,700 --> 00:40:33,700 tanto no puedo 834 00:40:33,700 --> 00:40:35,700 guardar su resultado en algún lado. 835 00:40:37,700 --> 00:40:39,700 Lo que tú dices es que 836 00:40:39,700 --> 00:40:41,700 de hecho esto no es 837 00:40:41,700 --> 00:40:43,700 calcular el área del perímetro, 838 00:40:43,700 --> 00:40:45,700 o devuelvo un array 839 00:40:45,700 --> 00:40:47,700 donde la primera posición 840 00:40:47,700 --> 00:40:49,700 es un área 841 00:40:49,700 --> 00:40:51,700 del segundo del perímetro, 842 00:40:51,700 --> 00:40:53,700 pero no sabemos que es un array 843 00:40:53,700 --> 00:40:55,700 por lo tanto no. 844 00:40:55,700 --> 00:40:57,700 O devuelvo un string 845 00:40:57,700 --> 00:40:59,700 donde dentro está el área, 846 00:40:59,700 --> 00:41:01,700 punto y coma, 847 00:41:01,700 --> 00:41:03,700 y luego eres tú 848 00:41:03,700 --> 00:41:05,700 que te la tiene que buscar la vida. 849 00:41:05,700 --> 00:41:07,700 ¿O eres tú que te la tiene que buscar la vida 850 00:41:07,700 --> 00:41:09,700 para dividir esta en 12 851 00:41:09,700 --> 00:41:11,700 y usarla como número? 852 00:41:15,700 --> 00:41:17,700 Por ahora sí. 853 00:41:17,700 --> 00:41:19,700 ¿Os veo en movimiento porque ya ha sonado 854 00:41:19,700 --> 00:41:21,700 y es recreo? 855 00:41:21,700 --> 00:41:23,700 No, todavía no. 856 00:41:23,700 --> 00:41:25,700 Vale, entonces 857 00:41:25,700 --> 00:41:27,700 la idea es esta, ¿vale? 858 00:41:27,700 --> 00:41:29,700 Entonces ahora yo tengo creaSaludo 859 00:41:29,700 --> 00:41:31,700 de nombre, y esto puede 860 00:41:31,700 --> 00:41:33,700 que me escriba en pantalla o no, no lo sé, 861 00:41:33,700 --> 00:41:35,700 pero sé que al final de esta operación 862 00:41:35,700 --> 00:41:37,700 deberá haber creado un string 863 00:41:37,700 --> 00:41:39,700 que es mi saludo creado, 864 00:41:39,700 --> 00:41:41,700 y yo este saludo creado lo puedo guardar 865 00:41:41,700 --> 00:41:43,700 dentro de saludo. 866 00:41:45,700 --> 00:41:47,700 ¿Cómo se hace esto? 867 00:41:53,700 --> 00:41:55,700 La función se declara como antes, 868 00:41:55,700 --> 00:41:57,700 public static, 869 00:41:57,700 --> 00:41:59,700 solo que aquí en vez de void 870 00:41:59,700 --> 00:42:01,700 va el tipo de dato 871 00:42:01,700 --> 00:42:03,700 y se devuelve al final 872 00:42:03,700 --> 00:42:05,700 public static int 873 00:42:05,700 --> 00:42:07,700 nombre 874 00:42:07,700 --> 00:42:09,700 public static string 875 00:42:09,700 --> 00:42:11,700 saludo 876 00:42:13,700 --> 00:42:15,700 ¿Y cómo se llama? 877 00:42:15,700 --> 00:42:17,700 Pues igual que antes, 878 00:42:17,700 --> 00:42:19,700 solo que ahora 879 00:42:19,700 --> 00:42:21,700 lo que puedo hacer es que 880 00:42:21,700 --> 00:42:23,700 el mismo tipo que he usado aquí arriba 881 00:42:25,700 --> 00:42:27,700 lo puedo usar aquí 882 00:42:27,700 --> 00:42:29,700 para almacenar 883 00:42:29,700 --> 00:42:31,700 el resultado de esta función 884 00:42:31,700 --> 00:42:33,700 Funcionará lo que sea la gana 885 00:42:33,700 --> 00:42:35,700 empaquetará un objeto 886 00:42:35,700 --> 00:42:37,700 de tipo 887 00:42:37,700 --> 00:42:39,700 devuelto, y esta cosa de aquí 888 00:42:39,700 --> 00:42:41,700 esta variable de aquí 889 00:42:41,700 --> 00:42:43,700 la puedo guardar en una variable del mismo tipo 890 00:42:43,700 --> 00:42:45,700 Si una función devuelve string 891 00:42:45,700 --> 00:42:47,700 no la puedo guardar en un int 892 00:42:49,700 --> 00:42:51,700 ¿Sí? 893 00:42:51,700 --> 00:42:53,700 Ejemplo más concreto 894 00:42:53,700 --> 00:42:55,700 y luego os dejo ahí 895 00:42:55,700 --> 00:42:57,700 Por ejemplo, public static 896 00:42:57,700 --> 00:42:59,700 string 897 00:42:59,700 --> 00:43:01,700 ¿Lo veis que aquí en vez de void esta string? 898 00:43:01,700 --> 00:43:03,700 Quiere decir que es una función 899 00:43:03,700 --> 00:43:05,700 Saluda string nombre 900 00:43:05,700 --> 00:43:07,700 Entonces ahora yo me creo una variable 901 00:43:07,700 --> 00:43:09,700 que se llama resultado 902 00:43:09,700 --> 00:43:11,700 le digo hola más nombre 903 00:43:11,700 --> 00:43:13,700 entonces resultado vale hola nombre 904 00:43:13,700 --> 00:43:15,700 y lo que hago es esto 905 00:43:15,700 --> 00:43:17,700 return resultado 906 00:43:17,700 --> 00:43:19,700 este return quiere decir que 907 00:43:19,700 --> 00:43:21,700 cuando acaba este procedimiento 908 00:43:21,700 --> 00:43:23,700 lo que hay dentro del resultado 909 00:43:23,700 --> 00:43:25,700 te lo devuelve 910 00:43:25,700 --> 00:43:27,700 lo que quieras 911 00:43:27,700 --> 00:43:29,700 lo puedes ignorar 912 00:43:29,700 --> 00:43:31,700 o lo puedes guardar 913 00:43:33,700 --> 00:43:35,700 en una variable 914 00:43:37,700 --> 00:43:39,700 Entonces 915 00:43:39,700 --> 00:43:41,700 dentro de la variable saludo1 916 00:43:41,700 --> 00:43:43,700 me guardo el resultado de saludastéfano 917 00:43:43,700 --> 00:43:45,700 o sea que esto será holastéfano 918 00:43:45,700 --> 00:43:47,700 que se guarda aquí dentro 919 00:43:47,700 --> 00:43:49,700 luego creo Paco 920 00:43:49,700 --> 00:43:51,700 llamo string saludo2 921 00:43:51,700 --> 00:43:53,700 que es una nueva variable 922 00:43:53,700 --> 00:43:55,700 y ahora n 923 00:43:55,700 --> 00:43:57,700 pues esto me pondrá 924 00:43:57,700 --> 00:43:59,700 hará todo lo que hace saluda 925 00:43:59,700 --> 00:44:01,700 que es crear la string holapaco 926 00:44:01,700 --> 00:44:03,700 y holapaco se guarda dentro saludo2 927 00:44:03,700 --> 00:44:05,700 y a este punto imprimo saludo1 928 00:44:05,700 --> 00:44:07,700 y imprimo saludo2 929 00:44:07,700 --> 00:44:09,700 esto imprimará holastéfano 930 00:44:09,700 --> 00:44:11,700 holapaco 931 00:44:15,700 --> 00:44:17,700 Venga 932 00:44:17,700 --> 00:44:19,700 después del recreo seguimos 933 00:44:19,700 --> 00:44:21,700 Entonces 934 00:44:21,700 --> 00:44:23,700 ahora que hemos vuelto 935 00:44:23,700 --> 00:44:25,700 de recreo 936 00:44:25,700 --> 00:44:27,700 estamos hablando de dos cosas 937 00:44:27,700 --> 00:44:29,700 procedimientos y funciones 938 00:44:29,700 --> 00:44:31,700 procedimientos son trozos de 939 00:44:31,700 --> 00:44:33,700 códigos que tienen un nombre 940 00:44:33,700 --> 00:44:35,700 que tienen que hacer una determinada tarea 941 00:44:35,700 --> 00:44:37,700 y que no me espero que me 942 00:44:37,700 --> 00:44:39,700 devuelvan nada 943 00:44:39,700 --> 00:44:41,700 funciones son trozos de código que hacen 944 00:44:41,700 --> 00:44:43,700 una determinada tarea 945 00:44:43,700 --> 00:44:45,700 y además me espero que al final 946 00:44:45,700 --> 00:44:47,700 me den algo 947 00:44:47,700 --> 00:44:49,700 que sea un 948 00:44:49,700 --> 00:44:51,700 booleano para decirme si han podido 949 00:44:51,700 --> 00:44:53,700 hacer la tarea o no 950 00:44:53,700 --> 00:44:55,700 que sea el resultado de la operación 951 00:44:55,700 --> 00:44:57,700 que han hecho 952 00:44:57,700 --> 00:44:59,700 que sea la concatenación 953 00:44:59,700 --> 00:45:01,700 de mil cosas que me pasan 954 00:45:01,700 --> 00:45:03,700 para que luego yo las descomponga 955 00:45:03,700 --> 00:45:05,700 y vaya leyendo toda la parte 956 00:45:05,700 --> 00:45:07,700 que tengo que leer de lo que me han pasado 957 00:45:07,700 --> 00:45:09,700 algo 958 00:45:09,700 --> 00:45:11,700 ese algo lo decido yo como programador 959 00:45:11,700 --> 00:45:13,700 te devuelvo un int 960 00:45:13,700 --> 00:45:15,700 te devuelvo una serie 961 00:45:15,700 --> 00:45:17,700 un string que es una serie de int 962 00:45:17,700 --> 00:45:19,700 preparados por coma que te paso allí 963 00:45:19,700 --> 00:45:21,700 66 int porque me da la gana 964 00:45:21,700 --> 00:45:23,700 vosotros sois los programadores 965 00:45:23,700 --> 00:45:25,700 vosotros decidís que hacer 966 00:45:25,700 --> 00:45:27,700 entonces 967 00:45:27,700 --> 00:45:29,700 en los procedimientos 968 00:45:29,700 --> 00:45:31,700 y aquí tengo public static void 969 00:45:31,700 --> 00:45:33,700 el tipo de vuelta es void 970 00:45:33,700 --> 00:45:35,700 void quiere decir nada, vacío 971 00:45:35,700 --> 00:45:37,700 entonces no te estoy devolviendo nada 972 00:45:37,700 --> 00:45:39,700 en las funciones public static 973 00:45:39,700 --> 00:45:41,700 es un tipo 974 00:45:41,700 --> 00:45:43,700 yo quiero que al final de mi función 975 00:45:43,700 --> 00:45:45,700 me devuelva algo de ese tipo 976 00:45:45,700 --> 00:45:47,700 si aquí he puesto string 977 00:45:47,700 --> 00:45:49,700 que era un string al final 978 00:45:49,700 --> 00:45:51,700 si he puesto un int, un int 979 00:45:51,700 --> 00:45:53,700 si un double, un double 980 00:45:53,700 --> 00:45:55,700 por ahora nosotros aquí utilizaremos 981 00:45:55,700 --> 00:45:57,700 solo tipos primitivos 982 00:45:57,700 --> 00:45:59,700 y string 983 00:45:59,700 --> 00:46:01,700 que no es un tipo primitivo 984 00:46:01,700 --> 00:46:03,700 pero casi 985 00:46:03,700 --> 00:46:05,700 entonces 986 00:46:05,700 --> 00:46:07,700 antes estamos viendo esto 987 00:46:07,700 --> 00:46:09,700 entonces 988 00:46:09,700 --> 00:46:11,700 lo que estamos haciendo aquí es 989 00:46:11,700 --> 00:46:13,700 llamar el método saluda 990 00:46:13,700 --> 00:46:15,700 saluda es un método que he creado que tiene que devolver un string 991 00:46:15,700 --> 00:46:17,700 villa como parámetro 992 00:46:17,700 --> 00:46:19,700 otro string, entonces cuando yo llamo 993 00:46:19,700 --> 00:46:21,700 saluda siempre le tengo que poner 994 00:46:21,700 --> 00:46:23,700 un string como parámetro 995 00:46:23,700 --> 00:46:25,700 que será el parámetro actual 996 00:46:25,700 --> 00:46:27,700 lo que hace él es pegar delante 997 00:46:27,700 --> 00:46:29,700 de lo que le he pasado yo 998 00:46:29,700 --> 00:46:31,700 un hola espacio 999 00:46:31,700 --> 00:46:33,700 y luego me lo devuelve 1000 00:46:33,700 --> 00:46:35,700 el return es esa cosa que me dice 1001 00:46:35,700 --> 00:46:37,700 devuelve a quien te he llamado 1002 00:46:37,700 --> 00:46:39,700 este valor 1003 00:46:39,700 --> 00:46:41,700 si yo no pongo string saludo1 1004 00:46:41,700 --> 00:46:43,700 aquí arriba 1005 00:46:43,700 --> 00:46:45,700 este método devolverá algo 1006 00:46:45,700 --> 00:46:47,700 al final me dará 1007 00:46:47,700 --> 00:46:49,700 esta información 1008 00:46:49,700 --> 00:46:51,700 pero como yo no la guardo 1009 00:46:51,700 --> 00:46:53,700 en ningún lado, esta información se perderá 1010 00:46:53,700 --> 00:46:55,700 y ya está 1011 00:46:55,700 --> 00:46:57,700 o sea que yo puedo utilizar una función 1012 00:46:57,700 --> 00:46:59,700 sin recibir nada 1013 00:46:59,700 --> 00:47:01,700 poniendo solo salud 1014 00:47:01,700 --> 00:47:03,700 pero normalmente 1015 00:47:03,700 --> 00:47:05,700 si lo he programado yo 1016 00:47:06,700 --> 00:47:08,700 segundo solo 1017 00:47:08,700 --> 00:47:10,700 entonces decíamos 1018 00:47:12,700 --> 00:47:14,700 no me acuerdo si estaba diciendo antes 1019 00:47:14,700 --> 00:47:16,700 pero el concepto es que 1020 00:47:16,700 --> 00:47:18,700 ah, si 1021 00:47:18,700 --> 00:47:20,700 la función devuelve algo 1022 00:47:20,700 --> 00:47:22,700 y yo lo puedo recoger 1023 00:47:22,700 --> 00:47:24,700 desde donde he llamado esta función 1024 00:47:24,700 --> 00:47:26,700 puedo no recogerlo, puedo no mirar 1025 00:47:26,700 --> 00:47:28,700 lo que me ha devuelto pero 1026 00:47:28,700 --> 00:47:30,700 si en mi programación cuando yo he pensado 1027 00:47:30,700 --> 00:47:32,700 que hago una función o un procedimiento 1028 00:47:32,700 --> 00:47:34,700 y me doy cuenta que lo que está 1029 00:47:34,700 --> 00:47:36,700 devolviendo esta función no lo uso nunca 1030 00:47:36,700 --> 00:47:38,700 pues posiblemente ese sea un procedimiento 1031 00:47:38,700 --> 00:47:40,700 y yo lo he enmascado 1032 00:47:40,700 --> 00:47:42,700 como función 1033 00:47:42,700 --> 00:47:44,700 teniendo en cuenta que 1034 00:47:44,700 --> 00:47:46,700 si yo pongo aquí algo que no sea void 1035 00:47:46,700 --> 00:47:48,700 o sea como string int 1036 00:47:48,700 --> 00:47:50,700 por el estilo, la función 1037 00:47:50,700 --> 00:47:52,700 en algún momento tiene que hacer un return 1038 00:47:52,700 --> 00:47:54,700 siempre 1039 00:47:54,700 --> 00:47:56,700 no puedo hacer 1040 00:47:56,700 --> 00:47:58,700 aquí dentro if 1041 00:47:58,700 --> 00:48:00,700 no sé qué, return no sé cuánto 1042 00:48:00,700 --> 00:48:02,700 else y no retornar nada 1043 00:48:02,700 --> 00:48:04,700 siempre tengo que returnar 1044 00:48:04,700 --> 00:48:06,700 como 1045 00:48:06,700 --> 00:48:08,700 idea principal y consejo 1046 00:48:08,700 --> 00:48:10,700 yo pondría un único 1047 00:48:10,700 --> 00:48:12,700 return al final 1048 00:48:12,700 --> 00:48:14,700 sabéis como cuando hacemos nosotros 1049 00:48:14,700 --> 00:48:16,700 que imprimimos solo una vez 1050 00:48:16,700 --> 00:48:18,700 en pantalla y luego preparamos 1051 00:48:18,700 --> 00:48:20,700 la string antes y luego imprimimos 1052 00:48:20,700 --> 00:48:22,700 esa string, pues mismo concepto 1053 00:48:22,700 --> 00:48:24,700 yo al final hago un return 1054 00:48:24,700 --> 00:48:26,700 de una variable, si es una string 1055 00:48:26,700 --> 00:48:28,700 nada más empezar hago string 1056 00:48:28,700 --> 00:48:30,700 resultado 1057 00:48:30,700 --> 00:48:32,700 resultado es igual a vacío 1058 00:48:32,700 --> 00:48:34,700 y al final pongo return resultado 1059 00:48:34,700 --> 00:48:36,700 y en el medio hago lo que me da la gana 1060 00:48:36,700 --> 00:48:38,700 en algunos casos concretos 1061 00:48:38,700 --> 00:48:40,700 puede ser útil 1062 00:48:40,700 --> 00:48:42,700 hacer un return antes 1063 00:48:42,700 --> 00:48:44,700 porque cuando hago el return 1064 00:48:44,700 --> 00:48:46,700 allí se para 1065 00:48:46,700 --> 00:48:48,700 el método 1066 00:48:48,700 --> 00:48:50,700 si yo tengo 1067 00:48:50,700 --> 00:48:52,700 un if 1068 00:48:52,700 --> 00:48:54,700 no sé qué, returna algo 1069 00:48:54,700 --> 00:48:56,700 else hace un montón de cosas 1070 00:48:56,700 --> 00:48:58,700 y después de este else 1071 00:48:58,700 --> 00:49:00,700 hace un montón de cosas 1072 00:49:00,700 --> 00:49:02,700 si yo pillo este if y pillo el return 1073 00:49:02,700 --> 00:49:04,700 todo el resto no lo ejecuto 1074 00:49:04,700 --> 00:49:06,700 el return devuelve 1075 00:49:06,700 --> 00:49:08,700 a donde ha sido llamado 1076 00:49:08,700 --> 00:49:10,700 pero a lo mejor esto lo veremos con más detalle 1077 00:49:10,700 --> 00:49:12,700 en el futuro con los ejemplos 1078 00:49:12,700 --> 00:49:14,700 pero la idea es como un break 1079 00:49:14,700 --> 00:49:16,700 sabéis cuando el break del switch 1080 00:49:16,700 --> 00:49:18,700 que salgo del switch, pues misma cosa 1081 00:49:18,700 --> 00:49:20,700 encuentro un return y el resto no lo ejecuto 1082 00:49:20,700 --> 00:49:22,700 allí se acabó el método 1083 00:49:22,700 --> 00:49:24,700 aquí se acabó la función 1084 00:49:24,700 --> 00:49:26,700 devuelvo el resultado y vuelvo 1085 00:49:27,700 --> 00:49:29,700 si os fijáis también 1086 00:49:29,700 --> 00:49:31,700 estas llamadas de función y procedimiento 1087 00:49:31,700 --> 00:49:33,700 son lo que decíamos al principio 1088 00:49:33,700 --> 00:49:35,700 interrumpen el normal 1089 00:49:35,700 --> 00:49:37,700 y secuencial 1090 00:49:37,700 --> 00:49:39,700 orden de ejecución 1091 00:49:39,700 --> 00:49:41,700 yo cuando estoy aquí 1092 00:49:41,700 --> 00:49:43,700 saludo, interrumpo el main 1093 00:49:43,700 --> 00:49:45,700 me voy a saludo 1094 00:49:45,700 --> 00:49:47,700 ejecuto estas dos líneas 1095 00:49:47,700 --> 00:49:49,700 y vuelvo allí donde estaba antes 1096 00:49:49,700 --> 00:49:51,700 y el resultado que me ha devuelto 1097 00:49:51,700 --> 00:49:53,700 lo pongo en saludo 1098 00:49:53,700 --> 00:49:55,700 y sigo desde aquí 1099 00:49:55,700 --> 00:49:57,700 si o no 1100 00:49:57,700 --> 00:49:59,700 dudas 1101 00:49:59,700 --> 00:50:01,700 preguntas 1102 00:50:05,700 --> 00:50:07,700 aquí 1103 00:50:07,700 --> 00:50:09,700 este es un parámetro 1104 00:50:11,700 --> 00:50:13,700 mira 1105 00:50:13,700 --> 00:50:15,700 aquí se lo he dado directamente el valor 1106 00:50:15,700 --> 00:50:17,700 aquí lo que tienes que hacer es el parámetro actual 1107 00:50:17,700 --> 00:50:19,700 o sea el valor que asociarás a esto 1108 00:50:19,700 --> 00:50:21,700 aquí dentro no 1109 00:50:21,700 --> 00:50:23,700 aquí dentro es sólo el nombre que usarás 1110 00:50:23,700 --> 00:50:25,700 el nombre variable que usarás aquí dentro 1111 00:50:25,700 --> 00:50:27,700 para referirte a lo que te van a dar 1112 00:50:27,700 --> 00:50:29,700 y tú se lo puedes dar como literal 1113 00:50:29,700 --> 00:50:31,700 o se lo puedes pasar como parámetro 1114 00:50:31,700 --> 00:50:33,700 como variable 1115 00:50:33,700 --> 00:50:35,700 o se lo puedes pasar como resultado 1116 00:50:35,700 --> 00:50:37,700 de otra función 1117 00:50:37,700 --> 00:50:39,700 tú aquí pones una función que al final te da un string 1118 00:50:39,700 --> 00:50:41,700 y lo que se da es un string 1119 00:50:41,700 --> 00:50:43,700 que uso como parámetro para saludo 1120 00:50:43,700 --> 00:50:45,700 una función dentro de una función 1121 00:50:45,700 --> 00:50:47,700 que no 1122 00:50:47,700 --> 00:50:49,700 dudas 1123 00:50:49,700 --> 00:50:51,700 vale 1124 00:50:53,700 --> 00:50:55,700 entonces 1125 00:50:55,700 --> 00:50:57,700 otro ejemplo 1126 00:50:57,700 --> 00:50:59,700 aquí tengo dos 1127 00:50:59,700 --> 00:51:01,700 funciones 1128 00:51:01,700 --> 00:51:03,700 una función y un método 1129 00:51:03,700 --> 00:51:05,700 esta función de aquí 1130 00:51:05,700 --> 00:51:07,700 pregunto 1131 00:51:07,700 --> 00:51:09,700 ¿cómo se llama esta función? 1132 00:51:11,700 --> 00:51:13,700 repite saludo 1133 00:51:13,700 --> 00:51:15,700 ¿por qué se crea una función? 1134 00:51:19,700 --> 00:51:21,700 porque aquí tiene 1135 00:51:21,700 --> 00:51:23,700 string y no void 1136 00:51:23,700 --> 00:51:25,700 no es un parámetro 1137 00:51:25,700 --> 00:51:27,700 como 1138 00:51:27,700 --> 00:51:29,700 este campo de aquí de la declaración 1139 00:51:29,700 --> 00:51:31,700 que me dice ¿qué devuelve al final 1140 00:51:31,700 --> 00:51:33,700 esta función? pues string 1141 00:51:33,700 --> 00:51:35,700 y no void pues es una función 1142 00:51:35,700 --> 00:51:37,700 al final tendrá que tener un return 1143 00:51:37,700 --> 00:51:39,700 si yo pongo un void pues no hace falta return 1144 00:51:39,700 --> 00:51:41,700 ¿sí? 1145 00:51:41,700 --> 00:51:43,700 ¿qué parámetros pilla? 1146 00:51:43,700 --> 00:51:45,700 un string 1147 00:51:45,700 --> 00:51:47,700 y un int 1148 00:51:47,700 --> 00:51:49,700 ¿vale? 1149 00:51:49,700 --> 00:51:51,700 el string será el nombre 1150 00:51:51,700 --> 00:51:53,700 el int la repetición 1151 00:51:53,700 --> 00:51:55,700 de cuántas veces tengo que repetir esto 1152 00:51:55,700 --> 00:51:57,700 ¿os acordáis que antes lo escribía 1153 00:51:57,700 --> 00:51:59,700 directamente en pantalla? 1154 00:51:59,700 --> 00:52:01,700 pues ahora no puedo 1155 00:52:01,700 --> 00:52:03,700 pero lo que yo quiero es que 1156 00:52:03,700 --> 00:52:05,700 el resultado de esta operación 1157 00:52:05,700 --> 00:52:07,700 de esta función se pase a quien me ha llamado 1158 00:52:07,700 --> 00:52:09,700 y luego sea quien me ha llamado 1159 00:52:09,700 --> 00:52:11,700 que lo imprima en pantalla si quiere 1160 00:52:11,700 --> 00:52:13,700 haga lo que sea con el resultado 1161 00:52:13,700 --> 00:52:15,700 entonces yo aquí hago un string 1162 00:52:15,700 --> 00:52:17,700 de resultado que no es nada 1163 00:52:17,700 --> 00:52:19,700 hago un for 1164 00:52:19,700 --> 00:52:21,700 un número de repeticiones 1165 00:52:21,700 --> 00:52:23,700 veces, si repetición vale 5 1166 00:52:23,700 --> 00:52:25,700 lo hago 5 veces, si repetición es 3 lo hago 3 veces 1167 00:52:25,700 --> 00:52:27,700 y lo que hago es que 1168 00:52:27,700 --> 00:52:29,700 concadeno al resultado 1169 00:52:29,700 --> 00:52:31,700 lo que haya en resultado 1170 00:52:31,700 --> 00:52:33,700 más hola 1171 00:52:33,700 --> 00:52:35,700 más el nombre 1172 00:52:35,700 --> 00:52:37,700 antes 1173 00:52:37,700 --> 00:52:39,700 si hacía println me salía uno por cada línea 1174 00:52:39,700 --> 00:52:41,700 ¿vale? 1175 00:52:41,700 --> 00:52:43,700 ahora no me saldría por cada línea 1176 00:52:43,700 --> 00:52:45,700 ¿vale? porque le he puesto un espacio 1177 00:52:45,700 --> 00:52:47,700 saldría, si yo le llamo sobre 1178 00:52:47,700 --> 00:52:49,700 estefano4 me saldría 1179 00:52:49,700 --> 00:52:51,700 hola estefano, espacio hola estefano, espacio hola estefano 1180 00:52:51,700 --> 00:52:53,700 espacio hola estefano, pero todo en la misma línea 1181 00:52:53,700 --> 00:52:55,700 si quisiera ir a una nueva línea 1182 00:52:55,700 --> 00:52:57,700 podría poner aquí un barra n 1183 00:52:57,700 --> 00:52:59,700 pero aquí no estoy imprimiendo 1184 00:52:59,700 --> 00:53:01,700 nada en pantalla, estoy creando 1185 00:53:01,700 --> 00:53:03,700 una nueva string 1186 00:53:03,700 --> 00:53:05,700 que luego al final devuelvo a quien me ha llamado 1187 00:53:05,700 --> 00:53:07,700 entonces 1188 00:53:07,700 --> 00:53:09,700 aquí arriba 1189 00:53:11,700 --> 00:53:13,700 llamo el método 1190 00:53:13,700 --> 00:53:15,700 repitesaludos, utilizando 1191 00:53:15,700 --> 00:53:17,700 Luis y 4 1192 00:53:17,700 --> 00:53:19,700 esto me creará hola Luis, espacio hola Luis 1193 00:53:19,700 --> 00:53:21,700 espacio hola Luis, espacio hola Luis 1194 00:53:21,700 --> 00:53:23,700 y me lo guarda 1195 00:53:23,700 --> 00:53:25,700 en esta variable aquí 1196 00:53:25,700 --> 00:53:27,700 del main 1197 00:53:27,700 --> 00:53:29,700 y ahora lo que puedo hacer es imprimir esa variable 1198 00:53:29,700 --> 00:53:31,700 habría podido hacer 1199 00:53:31,700 --> 00:53:33,700 system.auto.println 1200 00:53:33,700 --> 00:53:35,700 de entre paréntesis 1201 00:53:35,700 --> 00:53:37,700 repitesaludos Luis 4 1202 00:53:37,700 --> 00:53:39,700 si 1203 00:53:39,700 --> 00:53:41,700 porque el resultado de este método 1204 00:53:41,700 --> 00:53:43,700 es un string que lo pilla 1205 00:53:43,700 --> 00:53:45,700 como parámetro del println y me lo imprime 1206 00:53:47,700 --> 00:53:49,700 dudas 1207 00:53:51,700 --> 00:53:53,700 vamos a ver un ejemplo 1208 00:53:53,700 --> 00:53:55,700 un poquito más 1209 00:53:55,700 --> 00:53:57,700 complejo 1210 00:53:57,700 --> 00:53:59,700 entonces 1211 00:53:59,700 --> 00:54:01,700 vamos por parte 1212 00:54:01,700 --> 00:54:03,700 esto de aquí que son más fáciles 1213 00:54:05,700 --> 00:54:07,700 funciona el procedimiento 1214 00:54:09,700 --> 00:54:11,700 funciona, ¿qué parámetros pilla? 1215 00:54:13,700 --> 00:54:15,700 dos int, ¿cómo se llama? 1216 00:54:17,700 --> 00:54:19,700 calcular área, ¿qué devuelve? 1217 00:54:23,700 --> 00:54:25,700 tú le pasas estos dos lados 1218 00:54:25,700 --> 00:54:27,700 él te calcula el área 1219 00:54:27,700 --> 00:54:29,700 ¿sí? 1220 00:54:29,700 --> 00:54:31,700 este de aquí 1221 00:54:31,700 --> 00:54:33,700 el método pintabonito 1222 00:54:33,700 --> 00:54:35,700 pintabonito 1223 00:54:35,700 --> 00:54:37,700 ¿qué es? 1224 00:54:37,700 --> 00:54:39,700 ¿funciona el procedimiento? 1225 00:54:39,700 --> 00:54:41,700 procedimiento 1226 00:54:41,700 --> 00:54:43,700 no espero que me devuelva nada 1227 00:54:43,700 --> 00:54:45,700 porque tiene void aquí, de hecho no tiene return 1228 00:54:45,700 --> 00:54:47,700 ¿sí? 1229 00:54:47,700 --> 00:54:49,700 recibe 1230 00:54:49,700 --> 00:54:51,700 un int a 1231 00:54:51,700 --> 00:54:53,700 un int b y un int r 1232 00:54:53,700 --> 00:54:55,700 siendo posiblemente 1233 00:54:55,700 --> 00:54:57,700 un lado, otro lado 1234 00:54:57,700 --> 00:54:59,700 y el resultado 1235 00:54:59,700 --> 00:55:01,700 y lo que hace es 1236 00:55:01,700 --> 00:55:03,700 me lo pintabonito porque me hace 1237 00:55:03,700 --> 00:55:05,700 este marco 1238 00:55:05,700 --> 00:55:07,700 con los estereoscopios 1239 00:55:07,700 --> 00:55:09,700 y escribe el rectángulo de lados 1240 00:55:09,700 --> 00:55:11,700 a y b 1241 00:55:11,700 --> 00:55:13,700 tiene área r 1242 00:55:13,700 --> 00:55:15,700 a lo mejor esto 1243 00:55:15,700 --> 00:55:17,700 habría sido más bonito si aquí hubiese puesto 1244 00:55:17,700 --> 00:55:19,700 lado 1, lado 2 y área 1245 00:55:19,700 --> 00:55:21,700 en vez que a, b y r 1246 00:55:21,700 --> 00:55:23,700 que luego no se entiende que son 1247 00:55:23,700 --> 00:55:25,700 o sea que esto es un procedimiento 1248 00:55:25,700 --> 00:55:27,700 para escribir las cosas bonitas en pantalla 1249 00:55:27,700 --> 00:55:29,700 ¿sí? 1250 00:55:29,700 --> 00:55:31,700 vale 1251 00:55:31,700 --> 00:55:33,700 método 1252 00:55:33,700 --> 00:55:35,700 o sea, esta otra cosa de aquí 1253 00:55:35,700 --> 00:55:37,700 esta, ¿cómo se llama? 1254 00:55:39,700 --> 00:55:41,700 ¿eh? 1255 00:55:41,700 --> 00:55:43,700 legginum 1256 00:55:45,700 --> 00:55:47,700 ¿es un procedimiento 1257 00:55:47,700 --> 00:55:49,700 o una 1258 00:55:49,700 --> 00:55:51,700 una función? 1259 00:55:51,700 --> 00:55:53,700 ¿qué quiero que me devuelva? 1260 00:55:53,700 --> 00:55:55,700 un int 1261 00:55:55,700 --> 00:55:57,700 ¿vale? el resultado de todo esto 1262 00:55:57,700 --> 00:55:59,700 me tiene que devolver un int 1263 00:55:59,700 --> 00:56:01,700 o sea que por aquí tiene que haber un return 1264 00:56:01,700 --> 00:56:03,700 y tiene que retornar algo 1265 00:56:03,700 --> 00:56:05,700 y este algo tiene que ser un int 1266 00:56:05,700 --> 00:56:07,700 si no algo no funcionaría 1267 00:56:07,700 --> 00:56:09,700 ¿sí? 1268 00:56:09,700 --> 00:56:11,700 ¿qué recibe como parámetros? 1269 00:56:13,700 --> 00:56:15,700 un string 1270 00:56:15,700 --> 00:56:17,700 ¿y un escáner? 1271 00:56:19,700 --> 00:56:21,700 ¿y un escáner? 1272 00:56:21,700 --> 00:56:23,700 ¿qué es eso? 1273 00:56:25,700 --> 00:56:27,700 el string es un escáner 1274 00:56:27,700 --> 00:56:29,700 nosotros, esto quiere decir que cuando llamo 1275 00:56:29,700 --> 00:56:31,700 legginum le tengo que pasar 1276 00:56:31,700 --> 00:56:33,700 un string que se llama msg 1277 00:56:33,700 --> 00:56:35,700 que él imprime en pantalla, es el mensaje 1278 00:56:35,700 --> 00:56:37,700 ¿sabéis eso que nosotros hemos siempre dicho? 1279 00:56:37,700 --> 00:56:39,700 antes de hacer una lectura 1280 00:56:39,700 --> 00:56:41,700 por teclado 1281 00:56:41,700 --> 00:56:43,700 necesitaría mandar un mensaje 1282 00:56:43,700 --> 00:56:45,700 pues, lo pongo aquí 1283 00:56:45,700 --> 00:56:47,700 y luego 1284 00:56:47,700 --> 00:56:49,700 para que funcione le estoy pasando 1285 00:56:49,700 --> 00:56:51,700 el escáner 1286 00:56:51,700 --> 00:56:53,700 el escáner que he creado en el main 1287 00:56:53,700 --> 00:56:55,700 se lo paso a este 1288 00:56:55,700 --> 00:56:57,700 metodito de aquí para que tenga acceso al teclado 1289 00:56:57,700 --> 00:56:59,700 y pueda hacer teclado.ext 1290 00:56:59,700 --> 00:57:01,700 cuidado, aquí no lo está creando 1291 00:57:01,700 --> 00:57:03,700 no está haciendo 1292 00:57:03,700 --> 00:57:05,700 escáner teclado es igual a newScanner 1293 00:57:05,700 --> 00:57:07,700 porque esta cosa ya se ha creado 1294 00:57:07,700 --> 00:57:09,700 me la están pasando como parámetro 1295 00:57:09,700 --> 00:57:11,700 vamos a ver como se pasa el problema 1296 00:57:11,700 --> 00:57:13,700 pero es como decir 1297 00:57:13,700 --> 00:57:15,700 que mi función legginum 1298 00:57:15,700 --> 00:57:17,700 se espera que alguien 1299 00:57:17,700 --> 00:57:19,700 le dé 1300 00:57:19,700 --> 00:57:21,700 un string 1301 00:57:21,700 --> 00:57:23,700 y un teclado 1302 00:57:23,700 --> 00:57:25,700 ¿vale? con eso 1303 00:57:25,700 --> 00:57:27,700 ya puede escribir en pantalla 1304 00:57:27,700 --> 00:57:29,700 el mensaje, sea cual sea 1305 00:57:29,700 --> 00:57:31,700 el mensaje y pedir 1306 00:57:31,700 --> 00:57:33,700 un nuevo entero a ese teclado 1307 00:57:33,700 --> 00:57:35,700 sea cual sea ese teclado 1308 00:57:35,700 --> 00:57:37,700 ¿si? 1309 00:57:37,700 --> 00:57:39,700 no lo es instancial, pues si que lo es instancial 1310 00:57:39,700 --> 00:57:41,700 al momento en que llamaré 1311 00:57:41,700 --> 00:57:43,700 legginum con sus parámetros 1312 00:57:43,700 --> 00:57:45,700 actuales, pues haré 1313 00:57:45,700 --> 00:57:47,700 un colegamiento entre 1314 00:57:47,700 --> 00:57:49,700 este teclado y el otro parámetro 1315 00:57:49,700 --> 00:57:51,700 ¿dudas? 1316 00:57:53,700 --> 00:57:55,700 vamos a ver entonces como llamamos estos tres 1317 00:57:55,700 --> 00:57:57,700 métodos y como me sale el main 1318 00:57:57,700 --> 00:57:59,700 este es el main 1319 00:57:59,700 --> 00:58:01,700 ¿vale? 1320 00:58:01,700 --> 00:58:03,700 el main crea un objeto escáner 1321 00:58:03,700 --> 00:58:05,700 y lo guarda en la variable s 1322 00:58:05,700 --> 00:58:07,700 lo que hemos hecho siempre 1323 00:58:07,700 --> 00:58:09,700 antes de llamarlo scan o teclado 1324 00:58:09,700 --> 00:58:11,700 lo he llamado s 1325 00:58:11,700 --> 00:58:13,700 ahora, int lado1 1326 00:58:13,700 --> 00:58:15,700 ¿si? entonces 1327 00:58:15,700 --> 00:58:17,700 aquí dentro, guarda mi resultado 1328 00:58:17,700 --> 00:58:19,700 de esta 1329 00:58:19,700 --> 00:58:21,700 función, ¿que es esta función? 1330 00:58:21,700 --> 00:58:23,700 llama legginum, donde pones 1331 00:58:23,700 --> 00:58:25,700 como primer parámetro 1332 00:58:25,700 --> 00:58:27,700 dame el primer lado del rectángulo 1333 00:58:27,700 --> 00:58:29,700 y segundo parámetro 1334 00:58:29,700 --> 00:58:31,700 este s 1335 00:58:31,700 --> 00:58:33,700 estoy pasando 1336 00:58:33,700 --> 00:58:35,700 el escáner, para que luego tú allí dentro 1337 00:58:35,700 --> 00:58:37,700 puedas hacer 1338 00:58:37,700 --> 00:58:39,700 teclado. 1339 00:58:39,700 --> 00:58:41,700 ¿vale? 1340 00:58:41,700 --> 00:58:43,700 teniendo en cuenta que aquí dentro 1341 00:58:43,700 --> 00:58:45,700 esto se llama s 1342 00:58:45,700 --> 00:58:47,700 pero aquí dentro 1343 00:58:47,700 --> 00:58:49,700 esto se llamará teclal 1344 00:58:53,700 --> 00:58:55,700 aquí dentro hay una variable s más s 1345 00:58:55,700 --> 00:58:57,700 ¿no? porque 1346 00:58:57,700 --> 00:58:59,700 s vale solo dentro de este bloque de aquí 1347 00:58:59,700 --> 00:59:01,700 ¿vale? 1348 00:59:01,700 --> 00:59:03,700 aquí no se ha declarado ninguna variable s 1349 00:59:03,700 --> 00:59:05,700 ¿puedo declarar otra variable s? 1350 00:59:05,700 --> 00:59:07,700 sí, pero no sería la misma 1351 00:59:07,700 --> 00:59:09,700 variable s esta aquí, sería otra cosa 1352 00:59:11,700 --> 00:59:13,700 ¿si? yo aquí he creado 1353 00:59:13,700 --> 00:59:15,700 un objeto que le he de teclado 1354 00:59:15,700 --> 00:59:17,700 un algo, una entidad que le he de teclado 1355 00:59:17,700 --> 00:59:19,700 y aquí le estoy diciendo 1356 00:59:19,700 --> 00:59:21,700 que aquí dentro 1357 00:59:21,700 --> 00:59:23,700 tú me tienes que dar una entidad que le he de teclado 1358 00:59:23,700 --> 00:59:25,700 un escáner 1359 00:59:25,700 --> 00:59:27,700 y la asociación entre esta cosa de aquí 1360 00:59:27,700 --> 00:59:29,700 y la que yo he creado 1361 00:59:29,700 --> 00:59:31,700 es aquí 1362 00:59:33,700 --> 00:59:35,700 cuando yo estoy llamándole genoom 1363 00:59:35,700 --> 00:59:37,700 te está pasando el s 1364 00:59:37,700 --> 00:59:39,700 que es la entidad 1365 00:59:39,700 --> 00:59:41,700 lectora de teclado que he creado 1366 00:59:41,700 --> 00:59:43,700 y tú aquí dentro la tratarás 1367 00:59:43,700 --> 00:59:45,700 como si se llamara teclado 1368 00:59:45,700 --> 00:59:47,700 y entonces haces teclado.nexi 1369 00:59:49,700 --> 00:59:51,700 ¿pero por qué no se podría llamar s? 1370 00:59:51,700 --> 00:59:53,700 puede poner s aquí 1371 00:59:53,700 --> 00:59:55,700 entonces s, claro 1372 00:59:55,700 --> 00:59:57,700 ¿pero sería lo mismo? 1373 00:59:57,700 --> 00:59:59,700 bueno, esto lo decís tú 1374 00:59:59,700 --> 01:00:01,700 si lo llama escáner gatito 1375 01:00:01,700 --> 01:00:03,700 gatito.nexi 1376 01:00:05,700 --> 01:00:07,700 es que esto es genérico 1377 01:00:07,700 --> 01:00:09,700 o sea, esto tú luego lo puedes reutilizar 1378 01:00:09,700 --> 01:00:11,700 donde te da la gana 1379 01:00:11,700 --> 01:00:13,700 entonces, no lo sé 1380 01:00:13,700 --> 01:00:15,700 vale, si tú estás haciendo un ejercicio sencillo así 1381 01:00:15,700 --> 01:00:17,700 pues sí 1382 01:00:17,700 --> 01:00:19,700 si tú estás haciendo una librería de matemática 1383 01:00:19,700 --> 01:00:21,700 donde calculas la del triángulo 1384 01:00:21,700 --> 01:00:23,700 pues tú no lo sabes 1385 01:00:23,700 --> 01:00:25,700 si la persona que va a luego usarla 1386 01:00:25,700 --> 01:00:27,700 llamará el lado 1, el lado 2 1387 01:00:27,700 --> 01:00:29,700 o lo llamará l1, l2 1388 01:00:29,700 --> 01:00:31,700 o lo llamará a, b y c 1389 01:00:31,700 --> 01:00:33,700 tú lo llamas como quieras 1390 01:00:33,700 --> 01:00:35,700 y aquí dentro lo llamas como quieras tú 1391 01:00:35,700 --> 01:00:37,700 ¿vale? 1392 01:00:37,700 --> 01:00:39,700 yo habría podido llamarlo teclado aquí también 1393 01:00:39,700 --> 01:00:41,700 pero para no confundiros que estas son dos cosas distintas 1394 01:00:41,700 --> 01:00:43,700 ¿vale? 1395 01:00:45,700 --> 01:00:47,700 cuando tú llamas el leyenum 1396 01:00:47,700 --> 01:00:49,700 como pilla dos parámetros 1397 01:00:49,700 --> 01:00:51,700 esto lo has llamado teclado, aquí dentro usarás teclado 1398 01:00:51,700 --> 01:00:53,700 pero el vínculo 1399 01:00:53,700 --> 01:00:55,700 entre el objeto aquí que he creado 1400 01:00:55,700 --> 01:00:57,700 escáner y este teclado 1401 01:00:57,700 --> 01:00:59,700 es el mismo que a la hora de llamar 1402 01:01:03,700 --> 01:01:05,700 esto luego 1403 01:01:05,700 --> 01:01:07,700 se complica cuanto queráis 1404 01:01:07,700 --> 01:01:09,700 ¿vale? 1405 01:01:09,700 --> 01:01:11,700 esto también 1406 01:01:11,700 --> 01:01:13,700 lo hemos visto, está aquí 1407 01:01:13,700 --> 01:01:15,700 como ejemplo, echadle un vistazo 1408 01:01:15,700 --> 01:01:17,700 pero en teoría intentaremos 1409 01:01:17,700 --> 01:01:19,700 que para el examen 1410 01:01:19,700 --> 01:01:21,700 envíos 1411 01:01:21,700 --> 01:01:23,700 de objetos como pasa aquí 1412 01:01:23,700 --> 01:01:25,700 no sean necesarios, o sea que los parámetros 1413 01:01:25,700 --> 01:01:27,700 sean sólo 1414 01:01:31,700 --> 01:01:33,700 tipos primitivos o string 1415 01:01:33,700 --> 01:01:35,700 ¿vale? 1416 01:01:35,700 --> 01:01:37,700 intentaremos evitar 1417 01:01:37,700 --> 01:01:39,700 teniendo en cuenta que yo esto de leer 1418 01:01:39,700 --> 01:01:41,700 lo habría podido hacer aquí fuera 1419 01:01:41,700 --> 01:01:43,700 no es necesario hacerlo aquí 1420 01:01:43,700 --> 01:01:45,700 ¿vale? es más práctico porque 1421 01:01:45,700 --> 01:01:47,700 ahora ya aquí tengo mis 1422 01:01:47,700 --> 01:01:49,700 mis tres 1423 01:01:49,700 --> 01:01:51,700 ¿cómo se llaman? 1424 01:01:51,700 --> 01:01:53,700 mis dos líneas de código 1425 01:01:53,700 --> 01:01:55,700 porque aquí es una línea de código única 1426 01:01:57,700 --> 01:01:59,700 si esto fueran 50 líneas de código 1427 01:01:59,700 --> 01:02:01,700 porque luego tiene que mirar que los datos 1428 01:02:01,700 --> 01:02:03,700 sean correctos, que sean entre 1 1429 01:02:03,700 --> 01:02:05,700 y 100 y cosas por el estilo 1430 01:02:05,700 --> 01:02:07,700 en vez de escribirlo aquí dos veces 1431 01:02:07,700 --> 01:02:09,700 el mismo código, pues lo escribo sólo una vez 1432 01:02:09,700 --> 01:02:11,700 y llamo dos veces mi legion 1433 01:02:11,700 --> 01:02:13,700 ¿sí? 1434 01:02:15,700 --> 01:02:17,700 probamos con ejemplos 1435 01:02:17,700 --> 01:02:19,700 y lo hacemos juntos 1436 01:02:19,700 --> 01:02:21,700 ¿vale? entonces este es un ejemplo de un 1437 01:02:21,700 --> 01:02:23,700 ejercicio 1438 01:02:23,700 --> 01:02:25,700 que luego al final hará esto 1439 01:02:25,700 --> 01:02:27,700 ¿vale? 1440 01:02:27,700 --> 01:02:29,700 dice dame 1441 01:02:29,700 --> 01:02:31,700 esto es la primera 1442 01:02:31,700 --> 01:02:33,700 llamada de la 1443 01:02:33,700 --> 01:02:35,700 genoom 1444 01:02:35,700 --> 01:02:37,700 esta es la segunda llamada de la genoom 1445 01:02:37,700 --> 01:02:39,700 lo que han puesto se guardarán en los datos 1446 01:02:39,700 --> 01:02:41,700 y al final llamo el printabonito 1447 01:02:41,700 --> 01:02:43,700 no, bueno, llamo antes 1448 01:02:43,700 --> 01:02:45,700 el calcularia 1449 01:02:45,700 --> 01:02:47,700 y luego después el printabonito 1450 01:02:47,700 --> 01:02:49,700 dándole este número, este número 1451 01:02:49,700 --> 01:02:51,700 y el resultado 1452 01:02:51,700 --> 01:02:53,700 ¿sí? 1453 01:02:53,700 --> 01:02:55,700 lo vemos aquí 1454 01:02:57,700 --> 01:02:59,700 leo los dos números 1455 01:02:59,700 --> 01:03:01,700 área 1456 01:03:01,700 --> 01:03:03,700 será, calcula área 1457 01:03:03,700 --> 01:03:05,700 del lado 1 al lado 2, que son los dos que he leído 1458 01:03:05,700 --> 01:03:07,700 y luego printabonito del lado 1 al lado 2 1459 01:03:07,700 --> 01:03:09,700 y área 1460 01:03:09,700 --> 01:03:11,700 dura 1461 01:03:17,700 --> 01:03:19,700 ¿vale? y ya 1462 01:03:19,700 --> 01:03:21,700 ¿como? 1463 01:03:23,700 --> 01:03:25,700 normalmente el escáner se debería 1464 01:03:25,700 --> 01:03:27,700 cerrar ¿vale? 1465 01:03:27,700 --> 01:03:29,700 pero que pasa, que como nuestros programas luego acaban 1466 01:03:29,700 --> 01:03:31,700 cuando acaban todos los recursos 1467 01:03:31,700 --> 01:03:33,700 se destruyen 1468 01:03:33,700 --> 01:03:35,700 esto es necesario si mi programa aquí no 1469 01:03:35,700 --> 01:03:37,700 acabara e empezara a hacer otras cosas 1470 01:03:37,700 --> 01:03:39,700 como he dejado abierto el escáner 1471 01:03:39,700 --> 01:03:41,700 pues eso me ocupa recursos para nada 1472 01:03:41,700 --> 01:03:43,700 ¿vale? entonces 1473 01:03:43,700 --> 01:03:45,700 una buena práctica 1474 01:03:45,700 --> 01:03:47,700 que al final pues haga dosis 1475 01:03:47,700 --> 01:03:49,700 pero como estos son métodos, son objetos 1476 01:03:49,700 --> 01:03:51,700 y cosas por el estilo, yo estoy obviando 1477 01:03:51,700 --> 01:03:53,700 para eso, para que no me interese 1478 01:03:53,700 --> 01:03:55,700 ¿vale? por ahora no me interese esta cosa 1479 01:03:55,700 --> 01:03:57,700 cuando veremos los objetos y veremos 1480 01:03:57,700 --> 01:03:59,700 acceso a ficheros y cosas así 1481 01:03:59,700 --> 01:04:01,700 pues entonces estas cosas 1482 01:04:01,700 --> 01:04:03,700 tomarán más importancia 1483 01:04:03,700 --> 01:04:05,700 ¿sí? 1484 01:04:05,700 --> 01:04:07,700 vale, entonces 1485 01:04:07,700 --> 01:04:09,700 esto para repasar un poquito 1486 01:04:09,700 --> 01:04:11,700 el concepto de parámetros 1487 01:04:11,700 --> 01:04:13,700 formales y parámetros actuales 1488 01:04:13,700 --> 01:04:15,700 ¿vale? los parámetros formales 1489 01:04:15,700 --> 01:04:17,700 son los que se usan dentro de la función 1490 01:04:17,700 --> 01:04:19,700 o del procedimiento y no tienen un valor 1491 01:04:19,700 --> 01:04:21,700 concreto hasta que se llame la función 1492 01:04:21,700 --> 01:04:23,700 o el procedimiento, son números 1493 01:04:23,700 --> 01:04:25,700 son valores abstractos 1494 01:04:25,700 --> 01:04:27,700 yo sé que aquí tendré el lado 1 1495 01:04:27,700 --> 01:04:29,700 antes o después alguien me dirá cuanto vale 1496 01:04:29,700 --> 01:04:31,700 el lado 1, pero por ahora como no lo sé 1497 01:04:31,700 --> 01:04:33,700 lo uso de forma abstracta 1498 01:04:33,700 --> 01:04:35,700 diciendo aquí va lado 1 1499 01:04:35,700 --> 01:04:37,700 ¿qué tengo que hacer? lado 1 por lado 2 1500 01:04:37,700 --> 01:04:39,700 pero esto es 5 por 3, no lo sé 1501 01:04:39,700 --> 01:04:41,700 hasta que tú no me digas cuanto vale lado 1 1502 01:04:41,700 --> 01:04:43,700 y cuanto vale lado 2 1503 01:04:43,700 --> 01:04:45,700 pues no lo puedo saber, ¿cuando lo sabré? 1504 01:04:45,700 --> 01:04:47,700 cuando invocan el método, cuando lo llaman 1505 01:04:47,700 --> 01:04:49,700 cuando llaman la función 1506 01:04:49,700 --> 01:04:51,700 ¿sí? 1507 01:04:51,700 --> 01:04:53,700 y los parámetros actuales son los valores 1508 01:04:53,700 --> 01:04:55,700 concretos que se asignan a los parámetros 1509 01:04:55,700 --> 01:04:57,700 formales a la hora de la llamada 1510 01:04:57,700 --> 01:04:59,700 de la función, ¿vale? 1511 01:04:59,700 --> 01:05:01,700 los parámetros actuales son los que 1512 01:05:01,700 --> 01:05:03,700 se ponen en la llamada de la función 1513 01:05:03,700 --> 01:05:05,700 los parámetros formales son los que están 1514 01:05:05,700 --> 01:05:07,700 dentro de la definición, la declaración 1515 01:05:07,700 --> 01:05:09,700 de la función 1516 01:05:09,700 --> 01:05:11,700 estos son abstractos, no sé cuanto valen 1517 01:05:11,700 --> 01:05:13,700 estos son los valores 1518 01:05:13,700 --> 01:05:15,700 actuales de esa llamada 1519 01:05:15,700 --> 01:05:17,700 en ese momento, actualmente 1520 01:05:17,700 --> 01:05:19,700 los valores valen este y este 1521 01:05:19,700 --> 01:05:21,700 en otra llamada valdrán otra cosa 1522 01:05:21,700 --> 01:05:23,700 pero aquí valen estos 1523 01:05:23,700 --> 01:05:25,700 ¿estudas? 1524 01:05:25,700 --> 01:05:27,700 sustancialmente esto es 1525 01:05:27,700 --> 01:05:29,700 hago una abstracción 1526 01:05:29,700 --> 01:05:31,700 de un determinado 1527 01:05:31,700 --> 01:05:33,700 de una determinada tarea 1528 01:05:33,700 --> 01:05:35,700 parametrizable 1529 01:05:35,700 --> 01:05:37,700 y luego la reuso cuantas veces me dé la gana 1530 01:05:37,700 --> 01:05:39,700 con los parámetros que yo quiero 1531 01:05:39,700 --> 01:05:41,700 una vez con 3 y 5 1532 01:05:41,700 --> 01:05:43,700 una vez con 7 y 9, una vez con 45 y 32 1533 01:05:43,700 --> 01:05:45,700 y no tengo que reescribir ese código 1534 01:05:45,700 --> 01:05:47,700 otra vez, ese código es sustancialmente 1535 01:05:47,700 --> 01:05:49,700 me está definiendo 1536 01:05:49,700 --> 01:05:51,700 me está solucionando no una tarea sola 1537 01:05:51,700 --> 01:05:53,700 pero una clase de tareas 1538 01:05:53,700 --> 01:05:55,700 muchas tareas 1539 01:05:55,700 --> 01:05:57,700 calcular área me está solucionando 1540 01:05:57,700 --> 01:05:59,700 todos los cálculos de área posible 1541 01:06:07,700 --> 01:06:09,700 caveat 1542 01:06:09,700 --> 01:06:11,700 que en latín quiere decir, atención 1543 01:06:11,700 --> 01:06:13,700 funciones y procedimientos 1544 01:06:13,700 --> 01:06:15,700 son propios de la programación 1545 01:06:15,700 --> 01:06:17,700 estructurada 1546 01:06:17,700 --> 01:06:19,700 nosotros ahora estamos 1547 01:06:19,700 --> 01:06:21,700 utilizando y aprendiendo programación 1548 01:06:21,700 --> 01:06:23,700 estructural y con esto 1549 01:06:23,700 --> 01:06:25,700 grosso modo 1550 01:06:25,700 --> 01:06:27,700 la base de la programación estructurada 1551 01:06:27,700 --> 01:06:29,700 ya está, luego vamos a complicarla un poco 1552 01:06:29,700 --> 01:06:31,700 poniendo los arrays y poco más 1553 01:06:31,700 --> 01:06:33,700 pero la base de la programación 1554 01:06:33,700 --> 01:06:35,700 estructurada son 1555 01:06:35,700 --> 01:06:37,700 condicionales, iterativos 1556 01:06:37,700 --> 01:06:39,700 y llamadas de funciones 1557 01:06:41,700 --> 01:06:43,700 en Java 1558 01:06:43,700 --> 01:06:45,700 funciones y procedimientos 1559 01:06:45,700 --> 01:06:47,700 se suelen llamar métodos 1560 01:06:47,700 --> 01:06:49,700 en la 1561 01:06:49,700 --> 01:06:51,700 como se dice 1562 01:06:51,700 --> 01:06:53,700 las palabras que se usan 1563 01:06:53,700 --> 01:06:55,700 en Java 1564 01:06:55,700 --> 01:06:57,700 tú no dirías 1565 01:06:57,700 --> 01:06:59,700 esta es una función, este es un procedimiento 1566 01:06:59,700 --> 01:07:01,700 dirías este es un método, este es un método 1567 01:07:01,700 --> 01:07:03,700 un método estático, un método no estático 1568 01:07:03,700 --> 01:07:05,700 eso ya lo veremos 1569 01:07:05,700 --> 01:07:07,700 sin embargo 1570 01:07:07,700 --> 01:07:09,700 el concepto de método está vinculado a la programación 1571 01:07:09,700 --> 01:07:11,700 orientada a objetos 1572 01:07:11,700 --> 01:07:13,700 eso sirve cuando estamos 1573 01:07:13,700 --> 01:07:15,700 orientados a objetos 1574 01:07:15,700 --> 01:07:17,700 y nosotros todavía no estamos, estamos todavía en programación 1575 01:07:17,700 --> 01:07:19,700 estructurada, veremos cuando empezaremos 1576 01:07:19,700 --> 01:07:21,700 a ver los objetos, cual es el paso hacia 1577 01:07:21,700 --> 01:07:23,700 adelante, en realidad ya lo hemos visto desde una perspectiva 1578 01:07:23,700 --> 01:07:25,700 teórica al principio del curso 1579 01:07:25,700 --> 01:07:27,700 que nos permite hacer el salto desde 1580 01:07:27,700 --> 01:07:29,700 base de programación 1581 01:07:29,700 --> 01:07:31,700 estructurada a esta programación orientada 1582 01:07:31,700 --> 01:07:33,700 a objetos 1583 01:07:33,700 --> 01:07:35,700 y siempre que 1584 01:07:35,700 --> 01:07:37,700 hablamos de métodos, esto está vinculado 1585 01:07:37,700 --> 01:07:39,700 con los conceptos de clase objetos 1586 01:07:39,700 --> 01:07:41,700 que nosotros de vez en cuando lo oímos 1587 01:07:41,700 --> 01:07:43,700 hacemos una nueva clase 1588 01:07:43,700 --> 01:07:45,700 oye, escáner es un objeto, string 1589 01:07:45,700 --> 01:07:47,700 también es un objeto 1590 01:07:47,700 --> 01:07:49,700 algo, pero que es de verdad 1591 01:07:49,700 --> 01:07:51,700 todavía no lo sabemos, ni lo queremos saber 1592 01:07:51,700 --> 01:07:53,700 hasta dentro de un rato, ¿vale? 1593 01:07:53,700 --> 01:07:55,700 todo esto para decir 1594 01:07:55,700 --> 01:07:57,700 que lo que hemos visto hasta ahora 1595 01:07:57,700 --> 01:07:59,700 hace un uso impropio de Java 1596 01:07:59,700 --> 01:08:01,700 ¿vale? es como si nosotros 1597 01:08:01,700 --> 01:08:03,700 estamos utilizando Java, que es orientada a objetos 1598 01:08:03,700 --> 01:08:05,700 ignorando la parte 1599 01:08:05,700 --> 01:08:07,700 orientada a objetos y concentrándose 1600 01:08:07,700 --> 01:08:09,700 no solo en la parte estructurada 1601 01:08:09,700 --> 01:08:11,700 por lo tanto, algunas cosillas 1602 01:08:11,700 --> 01:08:13,700 que os he dicho ahora, para que entendáis 1603 01:08:13,700 --> 01:08:15,700 la base, pues en un futuro 1604 01:08:15,700 --> 01:08:17,700 posiblemente os diré, ¿os acordáis de esa cosa allí? 1605 01:08:17,700 --> 01:08:19,700 pues ahora, miradla desde 1606 01:08:19,700 --> 01:08:21,700 esta otra forma 1607 01:08:21,700 --> 01:08:23,700 ¿si? dentro de un rato, funciona 1608 01:08:23,700 --> 01:08:25,700 ese procedimiento, ya no lo llamamos función de procedimiento 1609 01:08:25,700 --> 01:08:27,700 se llamarán todos métodos 1610 01:08:27,700 --> 01:08:29,700 ¿vale? 1611 01:08:29,700 --> 01:08:31,700 cuando llegará el momento 1612 01:08:31,700 --> 01:08:33,700 volveremos a retomar estos conceptos 1613 01:08:33,700 --> 01:08:35,700 que profundizamos en temas como el static 1614 01:08:35,700 --> 01:08:37,700 el paso de parámetros por valores 1615 01:08:37,700 --> 01:08:39,700 referencia, la firma de un 1616 01:08:39,700 --> 01:08:41,700 método, sobrecarga de un método 1617 01:08:41,700 --> 01:08:43,700 todas estas cosas, son cosas que 1618 01:08:43,700 --> 01:08:45,700 a lo mejor ahora alguna de estas he nombrado 1619 01:08:45,700 --> 01:08:47,700 he dado una pincelada 1620 01:08:47,700 --> 01:08:49,700 pero todavía no sabemos que es 1621 01:08:49,700 --> 01:08:51,700 nos servirá esta 1622 01:08:51,700 --> 01:08:53,700 fundamental, es cuando estaremos en la programación 1623 01:08:53,700 --> 01:08:55,700 orientada a objetos