Introducción – ¿Qué es un método en programación?
ACLARACIÓN IMPORTANTE ANTES DE EMPEZAR
En programación, cuando vean la palabra «MÉTODO» normalmente se trata de un CONJUNTO DE INSTRUCCIONES DE CÓDIGO agrupadas dentro de una función. Recuerdo que este término me resultaba un poco extraño y solo cuando estudié programación orientada a objetos entendí la interpretación de la palabra «Método» en este contexto.
En este artículo vemos qué son los métodos en programación y encontrarás un vídeo de mi canal de YouTube en el que está resumida esta informacion.
Los métodos de programación sirven para agrupar instrucciones de código y luego este conjunto de instrucciones pueden ser llamadas cuantas veces sean necesarias simplemente haciendo la «llamada al método«, esto nos permite reutilizar código y resolver problemas cada vez mas complejos gracias al aumento de abstracción sobre un problema.
En este artículo se incluye como ejemplos la declaración de cuatro métodos de programación, un método void sin parámetros de entrada, otro método void con parámetros de entrada, un método con parámetro de salida pero sin parámetros de entrada y por último un método con parámetros de entrada y de salida.
En el siguiente vídeo explico detalladamente qué es un método en programación, su sintaxis y parámetros de entrada y salida:
¿Qué es un método en programación?
En programación, método se le llama a un bloque de código que tiene definido en su interior un conjunto de instrucciones, estas instrucciones realizan una determinada tarea. Cuando se necesita hacer uso de la función definida en el método simplemente se lo llama por su nombre, cuando el flujo del programa pasa por una llamada a un método el puntero salta a la región donde está definido el método, ejecuta todas sus instrucciones y al finalizar retorna a la línea posterior a la llamada al método.
Para definir un método hay que indicar si tendrá o no parámetros de salida, es decir si el método produce un dato como resultado de su ejecución y en caso afirmativo indicar ese tipo de dato. Luego se debe definir un nombre de identificación, por convención debe comenzar con la primera letra en mayúscula, además de intentar que el nombre sea representativo de la función que desempeña. Luego debemos indicar si tiene o no parámetros de entrada, en caso afirmativo, para cada parámetro de entrada incluir el tipo de cada uno y el nombre con el que se conocerá dicho parámetro dentro del método. Finalmente dentro del método se insertan todas las instrucciones de código a ejecutar, estas instrucciones pueden incluir la llamada a otros métodos, incluso un método puede llamarse a si mismo dando lugar a algoritmos recursivos, en este último caso, de no establecer bien la condición de finalización de las llamadas recursivas al método, tendríamos un método que se llama indefinidamente hasta que la pila de ejecuciones colapsa dando lugar al famoso error «Stack Overflow».
Módularización
En la figura 1 vemos al método representado como una caja, en la que aparece el nombre del método como título, se especifica el inicio y el final del método y el conjunto de instrucciones se encuentra dentro de esta región.
Para entender de qué se trata la modularización vamos a ver la figura 2. En la izquierda vemos representada una lista larga de instrucciones de programación.
Ahora dentro de esa lista hay cierto número de instrucciones que se utilizan en más de un lugar, las instrucciones A, B, C y D. Digamos que estas instrucciones realizan una tarea en concreto y siempre se ejecutan juntas.
A derecha el mismo código con módulos.
Supongamos que ahora debemos hacer cambios en esas instrucciones (por ejemplo para mejorar la manera en la que resuelve la tarea o agregar funcionalidad), lo que ocurre es que debemos identificar todas las regiones donde están esas instrucciones.
Seria genial si pudiésemos cambiar las cosas en un solo lugar y los cambios se apliquen en todas las regiones donde se usen estas instrucciones, ¿no?
Esto es precisamente lo que logramos con los métodos, nos permiten agrupar conjuntos de instrucciones en un módulo independiente, una caja negra por así decirlo, aquí es donde entra en juego el concepto de abstracción, sabemos que el método cumple una determinada función pero desde afuera no nos interesa realmente lo que hay en su interior, el método puede ser llamado cuando sea necesario sabiendo que cumplirá la función que le fue programada previamente. Como se observa a la derecha en la figura 2, las instrucciones ahora fueron reemplazadas por el nombre del método.
Parámetros de entrada y salida
En la figura 1 hay flechas que entran y salen del método. Con esto intento representar la entrada y salida de parámetros.
Podemos hacer que nuestro méteodo requiera parámetros de entrada, los cuales usamos en el interior para hacer cálculos o realizar cualquier tipo de tarea.
Además podemos hacer que la ejecución del método produzca un dato de salida, que usaremos fuera del método.
Métodos públicos y privados – Visibilidad
Por último en la figura 1 vemos un ojo normal y otro ojo tachado. Esto representa la visibilidad que tendrá el método, lo cual es un tema de programación orientada a objetos, no vamos a profundizar en este artículo pero en principio digamos que podemos tener métodos públicos y métodos privados.
Los métodos públicos podremos ejecutarlos desde otros Scripts por ejemplo, o podremos ejecutarlos desde un componente en la jerarquía en Unity, por ejemplo un botón.
Los métodos privados no serán accesibles desde contextos externos al Script donde está definido.
Sintaxis
La sintaxis es el conjunto de reglas establecidas en un lenguaje para escribir el código, en la figura 3 vemos posibles sintaxis de un método,
Esta sintaxis se puede aplicar al lenguaje C# y Java, un detalle es que todos los métodos son públicos, pero podríamos reemplazar la palabra «public» por «private» y la sintaxis sería correcta.
Declaración de un método
Ejemplo 1 – Método void que no requiere parámetros
Analicemos el método que se encuentra arriba a la izquierda en la figura 3. Tenemos la estructura de un método público que no requiere parámetros y no devuelve parámetros.
Esta estructura la podemos encontrar por ejemplo en el script «GameControl» del proyecto Mi primer juego en Unity.
Trabajamos en este script en el video 4 de la serie.
Observamos que ha sido declarado como privado en lugar de público, seguidamente encontramos la palabra «void» con la que indicamos que este método no va a devolver parámetros.
Luego el nombre del método: «placePlayerRandomly».
Se abre y se cierran paréntesis con lo que se indica que este método no necesita que le demos parámetros.
El comienzo y final del método se indica utilizando llaves. En el interior estarán todas las instrucciones del método.
Invocación o llamada a un método
Una vez que el método está definido podemos hacer que se ejecute desde cualquier parte del script, incluso podemos invocarlo desde otros scripts.
En la siguiente figura se muestra la invocación al método «placePlayerRandomly» efectuada en el método «startGame» del mismo script «GameControl».
Para invocar este método se escribe su nombre y se abren y cierran paréntesis, cerramos la instrucción con punto y coma. Haciendo esto estamos logrando que se ejecuten todas las instrucciones del método.
Noten como los nombres de los métodos ya nos van ayudando a entender lo que está pasando. Al comenzar el juego se debe colocar el personaje aleatoriamente.
Desde el punto de vista de «startGame» el método «placePlayerRandomly» es una función que hace todo lo necesario para colocar el personaje aleatoriamente. El método «startGame» no sabe cómo es que lo hace exactamente pero no le importa, debido a que «placePlayerRandomly» hace bien su trabajo.
Ejemplo 2 – Método void con parámetros de entrada
En la esquina superior derecha de la figura 3 tenemos la estructura de un método que no devuelve parámetros pero si los requiere para funcionar.
Este método requiere dos parámetros para funcionar: un valor entero m que indicará los minutos del timer y un valor entero s que indicará los segundos.
La invocación de este método ocurre en varios lugares del código, en particular el método «addSeconds» perteneciente al Script «Timer», este método recibe como parámetros un entero «s» que representa la cantidad de segundos que se deben agregar al timer debido a que el personaje agarró uno de los relojes que hay en el escenario.
El método «addSeconds» hace algunas operaciones con la variable «s» para actualizar el tiempo y finalmente ejecuta el método «writeTimer» que muestra los nuevos valores de tiempo en pantalla.
Dos observaciones: la primera es que como estamos ejecutando el método desde otro Script es necesario agregar «uiManager.» (prestar atención al punto) antes de escribir el nombre del método «writeTimer».
La segunda es que los parámetros se ingresan dentro de los paréntesis y separados por coma.
En ambos scripts utilicé nombres confusos (m y s) a propósito para que en el futuro, cuando hablemos sobre contextos, nos sirva para analizar.
Ejemplo 3 – Método con parámetro de salida pero no de entrada
Pasamos a los métodos que devuelven parámetros.
El siguiente ejemplo que se corresponde con la estructura ilustrada en la esquina inferior izquierda de la figura 3, un método que devuelve un dato y no requiere parámetros para funcionar.
El dato que devuelve este método es un «Vector3» y se indica en la declaración, luego de la palabra «public». Observen que la primer línea que no es un comentario dice: «Vector3 position;», ahí estamos declarando un Vector3 que llamamos «position», luego hacemos algunos cálculos y al final del método escribimos: «return position;» indicando que devolvemos ese Vector3.
Este método lo que hace es devolver un Vector3 (componente x,y,z) que representa una posición aleatoria que pertenece al interior de una determinada pieza de laberinto. De esta forma podemos usar esa posición para colocar el pedestal o los relojes sin preocuparnos por ejemplo de que aparezcan incrustados en una pared.
No es fácil entender la instrucción resaltada en la figura 9. Por ahora observemos dos cosas, la primera es que hacemos una llamada al método «getRandomPosition» utilizando su nombre (como se ve al final de la instrucción). La segunda es que el resultado de esa invocación es un dato Vector3, por lo tanto, utilizando el signo igual, lo asignamos al dato «rP» que se define como Vector3.
Ejemplo 4 – Métodos con parámetros de entrada y salida
El último ejemplo se corresponde con la estructura ilustrada en la esquina inferior derecha de la figura 3, un método que devuelve un dato y requiere parámetros para funcionar.
Vemos que en la declaración decimos que el método «isBestScore» devuelve un dato tipo bool y requiere un dato tipo int que llamamos «val».
Si querés saber un poco sobre datos primitivos te invito a leer este artículo sobre variables o ver este video.
El método «isBestScore» devuelve una variable que puede valer verdadero o false (true or false). La utilidad de este método es que lo utilizamos para preguntar si la puntuación obtenida en la partida (val) es mejor que la que hay guardada hasta el momento (bestScoreValue).
La invocación a este método se hace en el método «gameWon». Como el método devuelve un valor tipo bool, lo podemos usar directamente como argumento de una sentencia if, debido a que «score.isBestScore(time)» es equivalente a tener un valor verdadero o falso.
Método StartGame del Script GameControl
Para terminar la figura 12 se observa el método «startGame» junto con los demás métodos a los que va invocando.
Además de agrupar instrucciones, un método debe tener un propósito bien establecido y que sea coherente con el nombre que le dimos, de esta forma podremos saber rápidamente cúal es su funcion y qué tipo de instrucciones puede contener.
Por ejemplo el método «startGame» se encarga de coordinar una serie de acciones para comenzar el juego, pero no es él quien directamente realiza estas acciones, sino que invoca a otros métodos con tareas más específicas.
De esta forma nos resulta más simple realizar modificaciones en el código y depurar errores.
Conclusión
Los métodos constituyen una poderosa herramienta a la hora de elaborar soluciones específicas, eficientes, reutilizables y sostenibles en el tiempo.
Sostenibles en el tiempo porque en todas las etapas del desarrollo deberemos hacer cambios, de modo que tenemos que ser capaces de recordar o comprender rápidamente cómo funciona nuestro código.
Esto se logra utilizando nombres descriptivos, documentando nuestro código y aplicando el paradigma de orientación a objetos.
