Metodos_Parametros

Vista previa del material en texto

MÉTODOS CON PARÁMETROS EN JAVA 
 
Tabla de contenido 
Parámetros ............................................................................................................................. 1 
Argumentos ........................................................................................................................... 3 
Otros ejemplos ....................................................................................................................... 5 
Colecciones de datos como parámetros ............................................................................. 6 
Otro ejemplo de arreglo como parámetros de un método ............................................... 8 
Bibliografía ........................................................................................................................... 10 
 
 
Tabla de Ilustraciones 
Ilustración 1: Método sin parámetros ........................................................................ 2 
Ilustración 2: Método con parámetros ....................................................................... 2 
Ilustración 3: invocación de un método con parámetros ............................................ 4 
Ilustración 4: Método saludar, con parámetros .......................................................... 6 
Ilustración 5: Método con arreglo como parámetro ................................................... 7 
Ilustración 6: Método que retorna un arreglo entero ................................................. 8 
 
 
 
1 
Parámetros 
Los parámetros de un método definen la cantidad y el tipo de dato de los valores que 
recibe un método para su ejecución (Ladron de Guevara, 2007). Es decir, definimos una 
lista de parámetros formales, con los cuales el método ejecutará un bloque de 
instrucciones. 
Un método puede tener tantos parámetros como sea necesario. La lista de parámetros 
de la cabecera de un método se define con la siguiente sintaxis: 
Acceso tipo nombreMetodo (tipo nombre, tipo nombre ){ 
 
//Cuerpo del método (bloque de instrucciones) 
 
return dato_tipado; 
} 
 
Donde tipo representa el tipo de datos del parámetro y nombre representa el 
identificador del parámetro. Ligado a este concepto, tenemos los argumentos. 
 
Recordemos el proceso que aplicabamos en clases anteriores, para obtener datos de los 
usuarios. Dentro del cuerpo del método utilizabamos cajas de diálogo para permitir, la 
recepeción de los datos y de esta manera realizar las diferentes operaciones del método. 
De esta manera realizabamos anteriormente el proceso de obtener datos del usuario en 
el cuerpo del método. 
 
 
 
2 
 
Ilustración 1: Método sin parámetros 
Ahora analicemos la otra forma de escritura de métodos, los métodos con una lista de 
parámetros formales definidos. 
Observemos las líneas 11 y 12 (cuerpo del método) que se utilizan cajas de diálogo para 
obtener los dos valores enteros, con los cuales el método realizará la sumatoria. Una 
forma correcta de escribir este método sería el siguiente: 
 
Ilustración 2: Método con parámetros 
El método o función suma, desempeña el mismo trabajo que el método descrito 
anteriormente. La diferencia rádica en qué los valores que serán sumados en el cuerpo 
del método, son definidos entre los parentesis del mismo. 
 
 
3 
Argumentos 
Los argumentos son los valores que se pasan a un método durante su invocación. El 
método recibe los argumentos correspondientes a los parámetros con los que ha 
sido declarado (Ladron de Guevara, 2007). 
Tomando como referencia la Ilustración 2, si al momento de determinar la lista de 
parámetros formales del método, definimos que se utilizarán dos variables enteras. Al 
momento de la invocación del mismo, se deben enviar dos valores enteros para que el 
método logre ejecutar los procesos definidos dentro del cuerpo del mismo. Es decir, 
durante la invocación de un método es necesario que tanto el número y el tipo 
de argumentos coincidan con el número y el tipo de parámetros declarados en la 
cabecera del método. 
 
 
 
 
 
 
4 
 
Ilustración 3: invocación de un método con parámetros 
Observemos que el método suma (), en la línea 5 dentro de los paréntesis, se detallan 
los parámetros que tendrá el mismo. En este caso son dos variables de tipo entero. 
Ahora dentro del método principal o método main, en la línea 22 se realiza la 
invocación del método suma y dentro sus paréntesis se envian dos valores de tipo 
entero, en caso de que envíe dos variables de otro tipo, el método mostrará un mensaje 
de error que diga que los argumentos recibidos no coinciden con los tipos de datos 
definidos dentro de los parámetros del método. 
Hasta este punto de la lección podemos realizar una diferenciación de lo que son los 
parámetros de un método con respecto a los argumentos de un método. 
 Párametros = lista de variables con los que trabajarán en el cuerpo del método. 
 Argumentos = datos o valores que recibe el método al momento de realizar la 
invocación del mismo. 
 
 
5 
Por ejemplo 
Dado el método retornarMayorDeDosNumero(int valor1, int valor2) 
 Esta llamada al método es incorrecto debido a que se están pasando valores de 
tipo reales. 
retornarMayorDeDosNumero(3.1, 12.1); - incorreto 
 Esta llamada al método es incorrecto debido a que se está pasando un valor y 
es de tipo real. 
retornarMayorDeDosNumero(3.1); - incorreto 
 Esta llamada al método es correcta debido a que se están pasando valores de 
tipo enteros. 
retornarMayorDeDosNumero(3, 12); - Correcto 
Nota: Es importante mencionar que un método puede recibir como parámetros todos 
los tipos de datos conocidos en java. Esto según convenga o según la finalidad con la 
que sea descrito el método. 
Otros ejemplos 
Método saludar a un usuario. Este método permitirá recibir como parámetro, el nombre 
de una persona y el método retornará un saludo personalizado. 
 
 
6 
 
Ilustración 4: Método saludar, con parámetros 
Observemos en la línea 5, que dentro de los parámetros formales del método saludar(), 
tenemos definido una variable de tipo String. 
Ahora dentro del método principal de la clase, se declara e inicializa la variable nombre 
(línea 18) de tipo String, con el nombre de Francisco Hernández. 
Ahora en la línea 20, utilizando una caja de diálogo de tipo mensaje, invocamos el 
método saludar y como argumento le pasamos la variable nombre definida en la línea 
18. 
Colecciones de datos como parámetros 
 
En el siguiente ejemplo declararemos un método que tendrá como parámetro un 
arreglo de tipo entero cuya dimensión es de 5. El objetivo de este método es calcular el 
promedio de 5 calificaciones que se encuentran almacenadas dentro de un arreglo y 
retonar el resultado del cálculo del promedio. 
 
 
7 
 
Ilustración 5: Método con arreglo como parámetro 
 Linea 5: declaración del método promedio, público y de tipo entero, mismo que 
tiene como parámetro un arreglo de tipo entero. 
 Linea 7 y 6: declaración de las variables locales, resultado y promedio. La primera 
de ellas para almacenar la sumatoria de todas las calificaciones del arreglo y la 
segunda para almacenar el resultado del cálculo del promedio. 
 Lineas de la 10 – 14: ciclo for utilizado para sumar todos los valores contenidos 
en el arreglo. 
 Linea 16: se calcula el promedio dividiendo el valor contenido en la variable 
resultado entre el total de elementos que contiene el arreglo. 
 Linea 18: retonar el resultado del cálculo del promedio. 
 Línea 25 (método main): declaración de un arreglo que contiene las 
calificaciones de un estudiante. 
 
 
8 
 Linea 27: invocación del método promedio(), al cual pasamos como argumento 
el arreglo calificaciones definido en la línea 25. 
Otro ejemplo de arreglo como parámetros de un método 
 
En el siguiente ejemplo definiremos un método que recibe como parámetros un arreglo 
y una variable de tipo entera. El objetivode este método es qué, cada uno de las 
posiciones del arreglo sea rellenado con el valor que contiene la variable entera. 
El método deberá rellenar el arreglo de la siguiente manera: 
vectorEntero = {10, 10, 10, 10, 10} 
 
Ilustración 6: Método que retorna un arreglo entero 
 
 
9 
 Linea 7: declaramos un método llamado rellenarArreglo() público y de tipo 
arreglo entero (esto quiere decir que deberá retornar un arreglo de tipo entero). 
Cuyos parámetros son un arreglo y un número entero. 
 Lineas de la 9 – 13: utilizamos un ciclo for para recorrer cada una de las 
posiciones del arreglo y almacenar en ellas el valor de la variable entera llamada 
número. 
 Linea 15: retornamo el arreglo de tipo entero. 
 Linea 22: declaramos un arreglo entero llamado vectorEntero cuya dimensión es 
5. 
 Linea 24: invocamos el método rellenarArreglo y asignamos los argumentos 
correspondientes, el vectorEntero y el número 10. El retorno lo asignamos al 
vectorEntero. Al regresar del método, el vectorEntero traerá consigo 5 elementos 
(cada uno con el valor 10). 
 Linea 26: utilizamos una caja de dialogo de tipo mensaje, para mostrar el 
contenido del vectorEntero. Utilizando uno de los métodos de la clase arrays, 
llamado toString, que retorna una cadena de texto con los elementos del 
vectorEntero. 
 
 
 
10 
Bibliografía 
Ladron de Guevara, J. M. (05 de 05 de 2007). Fundamentos de la programación en 
Java. Madrid, España. 
Deitel, P., & Deitel, H. (05 de 03 de 2018). Java 9 for Programmers.