1. Pasar argumentos

Y ahora comienza la diversión. Probablemente ya sepa por métodos como System.out.println()ese que podemos pasar argumentos a métodos. Una vez que estamos dentro del método, nos referimos a ellos como parámetros. De hecho, los parámetros mejoran en gran medida los beneficios que obtenemos al crear y usar métodos.

¿Cómo declaramos un método con parámetros? En realidad es bastante simple:

public static void name(parameters)
{
  method body
}

Donde name es el nombre único del método y method body representa los comandos que componen el método. Y parameters es un marcador de posición para los parámetros del método, separados por comas. Describamos esta plantilla con más detalle:

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

Ejemplos:

Código Explicación
public static void print(String str)
{
}
El printmétodo se declara con un parámetro:
String str
public static void print(String str, int count)
{
}
El printmétodo se declara con dos parámetros:
String str
int count
public static void write(int x, int y)
{
}
El writemétodo se declara con dos parámetros:
int x
int y

Si no queremos que el método tenga parámetros, dejamos los paréntesis vacíos.

Los parámetros son variables especiales dentro de un método. Con su ayuda, puede pasar varios valores al método cuando se llama.

Por ejemplo, escribamos un método que muestre una cadena de texto un número determinado de veces.

Ya sabe cómo escribir código para mostrar una cadena en la pantalla varias veces. Pero, ¿qué cadena deberías imprimir? ¿Y cuántas veces? Para eso necesitamos los parámetros.

El código que hace esto se vería así:

Código Explicación
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);
   }
}


Declaramos el printLinesmétodo con los siguientes parámetros:
String text, int count
El método muestra String text counttimes





Llamamos al printLinesmétodo con varios parámetros

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.


2. Argumentos

Me gustaría llamar su atención un poco más sobre llamar a un método con parámetros.

Los valores que se pasan al método generalmente se denominan argumentos cuando se pasan al método.

Veamos otro ejemplo:

Código Explicación
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);
   }
}


Declaramos el printLinesmétodo con los siguientes parámetros:
String text, int count
El método muestra String text counttimes




Llamamos al printLinesmétodo con los siguientes argumentos:
text = "Hi"; count = 10;
text = "Bye"; count = 20;

Cuando printLines se 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 diferentes valores:
String text = "Bye", int count = 20.

Los parámetros son nada más y nada 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".


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

Las variables se pueden utilizar como argumentos de método. Esto es simple y comprensible, pero potencialmente puede producir algunas dificultades. Volvamos al mismo ejemplo, pero esta vez moveremos los argumentos a variables separadas:

Código Explicación
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";
     int n = 10;
     printLines(str, n);
   }
}


Declaramos el printLinesmétodo con los siguientes parámetros:
String text, int count
El método muestra String text counttimes







Llamamos al printLinesmétodo con los siguientes argumentos:
text = str;
count = n;

Hasta aquí todo bien: 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.

Ahora cambiemos el nombre de nuestras variables en el mainmétodo:

Código Explicación
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";
     int count = 10;
     printLines(text, count);
   }
}


Declaramos el printLinesmétodo con los siguientes parámetros:
String text, int count
El método muestra String text counttimes







Llamamos al printLinesmétodo con los siguientes argumentos:
text = text;
count = 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 sucede 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í siguen siendo. No existe una conexión mágica entre las variables text y text .



4. Pasar referencias a métodos

Espero que hayas entendido todo lo de la lección anterior, porque ahora vamos a volver a pasar argumentos a métodos, solo que profundizaremos más.

Como ya sabe, algunas variables de 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 asigna otra variable de matriz a una variable de matriz, ¿qué sucede? Así es. Las dos variables comienzan a referirse al mismo espacio en la memoria:

Pasar referencias a métodos

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

Código Explicación
class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }

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


El printArraySummétodo calcula la suma de los números en la matriz pasada y la muestra en la pantalla

Sucede exactamente lo mismo: el data pará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 printArraySum método no solo puede leer valores de la matriz, ¡sino también cambiarlos!

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

Código Explicación
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);
   }
}


El fill método itera sobre cada celda de la matriz bidimensional pasada y se valuelas asigna.








Creamos una matriz bidimensional.
Llenamos toda la matriz con el número 8.


5. Métodos con el mismo nombre

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

Los estándares de Java requieren que todos los métodos de la misma clase tengan nombres únicos. En otras palabras, es imposible declarar dos métodos con nombres idénticos en la misma clase.

Cuando se comparan los métodos por igualdad, no solo se tienen en cuenta los nombres, sino también los tipos de los parámetros . Tenga en cuenta que los nombres de los parámetros no se tienen en cuenta . Ejemplos:

Código Explicación
void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}
Estos tres métodos son métodos diferentes . Se pueden declarar en la misma clase.
void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}
Cada uno de estos cinco métodos se considera diferente . Se pueden declarar en la misma clase.
void sum(int x, int y) {
}
void sum(int data, int value) {
}
Estos dos métodos se consideran iguales , lo que significa que no se pueden declarar en la misma clase.

¿Por qué algunos métodos se consideran iguales , mientras que otros son diferentes ? ¿Y por qué no se tienen en cuenta los nombres de los parámetros al determinar la unicidad de un método?

¿Por qué es necesaria la unicidad? 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.System.out.println("Hi")println()String

Pero si escribe , el compilador verá una llamada al método con un parámetro.System.out.println(1.0)println()double

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 llamar. Y por eso no se tienen en cuenta a la hora de determinar la unicidad de un método.

El nombre de un método y los tipos de sus parámetros se denominan firma del método . Por ejemplo,sum(int, int)

Cada clase debe tener métodos con firmas únicas en lugar de métodos con nombres únicos.