Parámetros de métodos en Java

"¡Hola Amigo! Espero que hayas disfrutado resolviendo tareas usando tus propios métodos y que te des cuenta de lo conveniente que es crear métodos. Ahora hablemos del tema más interesante de todos".

"Me has despertado el interés, Diego... ¿Un tema nuevo?"

"¡Todos los temas son nuevos para ti, mi joven robot! Y este no es una excepción. Aunque, una vez más, se trata de métodos. Probablemente ya hayas notado que de métodos como ese podemos pasar argumentos a métodos. Una vez que estamos dentro del System.out.println()método , nos referimos a ellos como parámetros".

"¿Los parámetros son lo que escribimos entre paréntesis?"

"Sí, exactamente. Y, de hecho, los parámetros mejoran en gran medida los beneficios que obtenemos de la creación y el uso de métodos".

"Entiendo lo que dices sobre usarlos, y resulta que ya lo hice. ¿Cómo declaramos un método con parámetros?"

"En realidad es bastante simple:

public static void name(parameters)
{
  method body
}

"Dónde nameestá el nombre único del método y method bodyrepresenta los comandos que componen el método. Y parameterses un marcador de posición para los parámetros del método, separados por comas".

"Hmm... Creo que entiendo... O tal vez no..."

"Permítanme darles algunos detalles más sobre esta plantilla para que estén seguros de que entienden que entienden:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

Aquí hay unos ejemplos:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

"Ah... Ahora está claro. Y si no queremos que el método tenga parámetros, simplemente dejamos los paréntesis vacíos".

"Exactamente. Básicamente, los parámetros son variables especiales dentro de un método. Con su ayuda, puede pasar varios valores al método cuando se llama. Y si no necesita pasar valores, deje los paréntesis vacíos.

"Por ejemplo, escribamos un método que muestre una línea de texto dada un número determinado de veces. ¿Alguna idea sobre cómo hacer esto?"

"Bueno... Parece que soy muy consciente de cómo escribir código para mostrar una cadena en la pantalla varias veces..."

"¿Cómo especificas la cadena que se mostrará? ¿Y cómo especificas el número de líneas mostradas? ¿Puedes adivinar?"

"Las cosas empiezan a aclararse... ¿Probablemente con la ayuda de los parámetros del método?"

"Exactamente. Un parámetro de cadena para la línea de texto y un parámetro numérico para el número de líneas mostradas. El código que hace esto se vería así:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

"Cada vez que se llama a un método, a sus parámetros se les asignan los valores pasados, y solo entonces comenzamos a ejecutar los comandos dentro del método.

Argumentos

"Quiero que preste especial atención a los métodos de llamada que tienen parámetros. Los valores que se pasan al método generalmente se llaman argumentos cuando se pasan al método.

Echemos otro vistazo a nuestro ejemplo:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

"Cuando printLinesse llamó al método por primera vez, a sus parámetros se les asignaron los siguientes valores:

String text = "Hi", int count = 10.

"Cuando printLinesse llamó al método por segunda vez, a sus parámetros se les asignaron valores diferentes:

String text = "Bye", int count = 20.

"Los parámetros no son más ni menos que variables a las que se les asignan ciertos valores cuando se llama a un método. Los valores "Hi", "Bye", 10y 20se denominan argumentos".

"Trataré de recordar la diferencia y no confundir estos conceptos".

Nombres de variables en conflicto al llamar a un método

"Cuando llamas a un método, puedes usar variables como argumentos.

"¡Bueno, eso tiene sentido!"

"Tiene sentido, pero potencialmente puede producir algunas dificultades. Volvamos a nuestro ejemplo una vez más, pero esta vez moveremos los argumentos a variables separadas:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     String n = 10;
     printLines(str, n);
   }
}

"Hmm... No veo ninguna dificultad. Tenemos una strvariable. Su valor se asigna al textparámetro cuando se llama al método. Tenemos una nvariable. Su valor se asigna al countparámetro cuando se llama al método". "Hasta ahora todo ESTÁ CLARO."

"Bien, bien. Ahora cambiemos el nombre de nuestras variables en el mainmétodo:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     String count = 10;
     printLines(text, count);
   }
}

"Presta atención a dos cosas

Primero: tenemos variables con el mismo nombre en diferentes métodos. Estas son variables diferentes (las representamos deliberadamente usando diferentes colores). Todo funciona igual que en el ejemplo anterior, donde las variables en el mainmétodo fueron nombrados stry n.

Segundo: nada mágico ocurre cuando se llama al método. A los parámetros simplemente se les asignan los valores de los argumentos. Independientemente de si son números, cadenas, variables o expresiones.

"Después de cambiar el nombre de las variables en el método principal, nada ha cambiado. Eran diferentes variables en diferentes métodos anteriormente, y así permanecen. No hay una conexión mágica entre las dos textvariables".

"Ahora sé."

Pasar referencias a métodos

"Espero que ya hayas asimilado todo lo que te he dicho sobre pasar argumentos a métodos. Lo digo porque ahora vamos a profundizar un poco más en este tema. Escucha con atención".

"Ya sabes que algunas variables en Java no almacenan los valores en sí, sino una referencia , es decir, la dirección del bloque de memoria donde se encuentran los valores. Así es como funcionan las variables de cadena y las variables de matriz.

"Cuando un desarrollador asigna otra variable de matriz a una variable de matriz, ¿qué sucede?"

"¿Entonces apuntan a la misma dirección?"

"Correcto. Las dos variables comienzan a referirse al mismo espacio en la memoria:

"¿Y qué pasa si una de estas variables es un parámetro de método?

class Solution
{
   public static void sum(int[] data)
   {
     int total = 0;
     for (int i = 0; i < data.length; i++)
       total = total + data[i];
     System.out.println(total);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     sum(months);
   }
}

"Sucede exactamente lo mismo: el dataparámetro contendrá una referencia a la misma área de memoria que la monthsvariable. Cuando se llama al método, se produce una asignación simple: .data = months

"Y dado que ambas variables se refieren a la misma área de memoria que almacena un número entero, entonces el summétodo no solo puede leer valores de la matriz, ¡sino también cambiarlos!"

"Supongo que entiendo, ¡pero necesito más ejemplos!"

"Bueno, por ejemplo, podemos escribir nuestro propio método que llene una matriz bidimensional con el mismo valor. Así es como podría verse:

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

Métodos con el mismo nombre

"Ahora volvamos a los nombres de los métodos una vez más".

"¡No puedo imaginar qué más podría decirse sobre los nombres!"

"Bueno, el estándar del lenguaje Java requiere que todos los métodos de la misma clase tengan nombres únicos.

"Entonces, ¿es imposible declarar dos métodos con nombres idénticos en la misma clase?"

"Ahora, ¡presta mucha atención! ¡Los métodos en una clase pueden tener nombres idénticos! Pero en este caso, deben tener diferentes parámetros. En otras palabras, los métodos se comparan por similitud, no solo se tienen en cuenta los nombres, sino también los tipos de los parámetros ! Tenga en cuenta que específicamente dije tipos. Los nombres de los parámetros no se tienen en cuenta . Ejemplos:

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

"¡Estoy totalmente confundido! ¿Por qué necesitamos todo esto? ¿Por qué algunos métodos se consideran iguales , mientras que otros son diferentes ? ¿Y por qué los nombres de los parámetros no se tienen en cuenta al determinar la unicidad de un método? ¿Por qué es necesaria la unicidad en ¿todo?"

"La cuestión es que cuando el compilador compila un programa, debe saber exactamente qué método pretende llamar en un lugar determinado.

"Por ejemplo, si escribe , el compilador es inteligente y concluirá fácilmente que tiene la intención de llamar al método aquí con un parámetro. Pero si escribe , el compilador verá una llamada al método con un parámetro. No tiene idea qué nombre le dio el programador al parámetro al declarar el método".System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

¡Ahh, parece estar empezando a pasar!

"Cuando se llama a un método, el compilador se asegura de que los tipos de los argumentos coincidan con los tipos de los parámetros. No presta atención al nombre de los argumentos. En Java, los nombres de los parámetros no ayudan al compilador a determinar qué método usar". llamar Los programadores los necesitan, no el compilador.

"¿Y supongo que es por eso que no se tienen en cuenta al determinar la singularidad de un método?"

"Sí, eso es completamente correcto. El nombre de un método y los tipos de sus parámetros se denominan firma del método . Por ejemplo, sum (int, int)"

"Entonces, cada clase debe tener métodos con firmas únicas en lugar de métodos con nombres únicos".

"¡Bien hecho, Amigo! Resumiste esta lección a la perfección. Si algo no está claro, no entres en pánico. Este tema se aclarará después de un par de tareas".