Parâmetros de método em Java

"Olá Amigo! Espero que tenha gostado de resolver tarefas usando seus próprios métodos, e que tenha percebido como é conveniente criar métodos. Agora vamos falar sobre o assunto mais interessante de todos."

"Você despertou meu interesse, Diego... Um novo assunto?"

"Todo tópico é novo para você, meu jovem robô! E este não é exceção. Embora mais uma vez seja sobre métodos. Você provavelmente já percebeu que métodos como esse podem passar argumentos para métodos. Uma vez dentro do System.out.println()método , nos referimos a eles como parâmetros."

"Parâmetros são o que escrevemos entre parênteses?"

"Sim, exatamente. E, de fato, os parâmetros aumentam muito os benefícios que obtemos ao criar e usar métodos."

"Entendo o que você está dizendo sobre usá-los e descobri que já o fiz. Como declaramos um método com parâmetros?"

"Na verdade é bem simples:

public static void name(parameters)
{
  method body
}

"Onde nameé o nome exclusivo do método e method bodyrepresenta os comandos que compõem o método. E parametersé um espaço reservado para os parâmetros do método, separados por vírgulas."

"Hmm... acho que entendi... Ou talvez não..."

"Deixe-me dar mais alguns detalhes sobre este modelo para que você tenha certeza de que entende que entende:

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

aqui estão alguns exemplos:

public static void print(String str)
{
}

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

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

"Ah... Agora está claro. E se não queremos que o método tenha parâmetros, então é só deixar os parênteses vazios."

"Exatamente. Basicamente, parâmetros são variáveis ​​especiais dentro de um método. Com a ajuda deles, você pode passar vários valores para o método quando ele é chamado. E se você não precisar passar valores, deixe os parênteses vazios.

"Por exemplo, vamos escrever um método que exiba uma determinada linha de texto um determinado número de vezes. Alguma ideia de como fazer isso?"

"Bem... Parece que estou bem ciente de como escrever um código para exibir uma string na tela várias vezes..."

"Como você especifica a string a ser exibida? E como você especifica o número de linhas exibidas? Você consegue adivinhar?"

"As coisas estão começando a ficar claras... Provavelmente com a ajuda dos parâmetros do método?"

"Exatamente. Um parâmetro de string para a linha de texto e um parâmetro numérico para o número de linhas exibidas. O código que faz isso ficaria assim:

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 um método é chamado, seus parâmetros recebem os valores passados, e só então começamos a executar os comandos dentro do método.

argumentos

"Quero que você preste atenção especial ao chamar métodos que possuem parâmetros. Os valores passados ​​para o método geralmente são chamados de argumentos quando são passados ​​para o método.

Vamos dar outra olhada no nosso exemplo:

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);
   }
}

"Quando o printLinesmétodo foi chamado pela primeira vez, seus parâmetros receberam os seguintes valores:

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

"Quando o printLinesmétodo foi chamado pela segunda vez, seus parâmetros receberam valores diferentes:

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

"Parâmetros são nem mais nem menos do que variáveis ​​que recebem certos valores quando um método é chamado. Os valores "Hi", "Bye", 10e 20são eles próprios chamados de argumentos."

"Vou tentar lembrar a diferença e não confundir esses conceitos."

Nomes de variáveis ​​conflitantes ao chamar um método

"Ao chamar um método, você pode usar variáveis ​​como argumentos.

"Bem, isso faz sentido!"

"Faz sentido, mas pode potencialmente produzir algumas dificuldades. Vamos voltar ao nosso exemplo mais uma vez, mas desta vez vamos mover os argumentos para variáveis ​​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... Não vejo nenhuma dificuldade. Temos uma strvariável. Seu valor é atribuído ao textparâmetro quando o método é chamado. Temos uma nvariável. Seu valor é atribuído ao countparâmetro quando o método é chamado." "Até agora, tudo está claro."

"Bom, bom. Agora vamos renomear nossas variáveis ​​no 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);
   }
}

"Preste atenção em duas coisas

Primeiro: temos variáveis ​​com o mesmo nome em métodos diferentes. Estas são variáveis ​​diferentes (nós as representamos deliberadamente usando cores diferentes). Tudo funciona da mesma forma que no exemplo anterior, onde as variáveis ​​do mainmétodo foram nomeadas stre n.

Segundo: Nada de mágico acontece quando o método é chamado. Os parâmetros são simplesmente atribuídos aos valores de argumento. Independentemente de serem números, strings, variáveis ​​ou expressões.

"Depois que renomeamos as variáveis ​​no método principal, nada mudou. Elas eram variáveis ​​diferentes em métodos diferentes anteriormente e assim permanecem. Não há conexão mágica entre as duas textvariáveis."

"Agora eu sei."

Passando referências a métodos

"Espero que você já tenha assimilado tudo o que eu disse sobre a passagem de argumentos para métodos. Digo isso porque agora vamos nos aprofundar um pouco mais nesse assunto. Ouça com atenção."

"Você já sabe que algumas variáveis ​​em Java armazenam não os valores em si, mas sim uma referência , ou seja, o endereço do bloco de memória onde os valores estão localizados. É assim que funcionam as variáveis ​​string e variáveis ​​array.

"Quando um desenvolvedor atribui outra variável de array a uma variável de array, o que acontece?"

"Então eles apontam para o mesmo endereço?"

"Correto. As duas variáveis ​​passam a se referir ao mesmo espaço na memória:

"E o que acontece se uma dessas variáveis ​​for um 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);
   }
}

"Acontece exatamente a mesma coisa: o dataparâmetro conterá uma referência à mesma área de memória que a monthsvariável. Quando o método é chamado, ocorre uma atribuição simples: .data = months

"E como ambas as variáveis ​​se referem à mesma área de memória que armazena um número inteiro, o summétodo pode não apenas ler valores da matriz, mas também alterá-los!"

"Acho que entendi, mas preciso de mais exemplos!"

"Bem, por exemplo, podemos escrever nosso próprio método que preenche um array bidimensional com o mesmo valor. Pode ser assim:

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 com o mesmo nome

"Agora vamos retornar aos nomes dos métodos mais uma vez."

"Não consigo imaginar o que mais poderia ser dito sobre nomes!"

"Bem, o padrão da linguagem Java exige que todos os métodos da mesma classe tenham nomes exclusivos.

"Então, é impossível declarar dois métodos com nomes idênticos na mesma classe?"

"Agora - preste muita atenção! Os métodos em uma classe podem realmente ter nomes idênticos! Mas, neste caso, eles devem ter parâmetros diferentes. Em outras palavras, os métodos são comparados quanto à semelhança, não apenas os nomes são levados em consideração, mas também os tipos dos parâmetros ! Observe que eu disse especificamente os tipos. Os nomes dos parâmetros não são levados em consideração . Exemplos:

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) {
}

"Estou totalmente confuso! Por que precisamos de tudo isso? Por que alguns métodos são considerados iguais , enquanto outros são diferentes ? E por que os nomes dos parâmetros não são levados em consideração ao determinar a exclusividade de um método? Por que a exclusividade é necessária em todos?"

"O problema é que, quando o compilador compila um programa, ele deve saber exatamente qual método você pretende chamar em determinado local.

"Por exemplo, se você escrever , o compilador é inteligente e facilmente concluirá que você pretende chamar o método aqui com um parâmetro. Mas se você escrever , o compilador verá uma chamada para o método com um parâmetro. Não faz ideia qual nome o programador deu ao parâmetro ao declarar o método."System.out.println("Hi")println()StringSystem.out.println(1.0)println()double

Ahh, parece que está começando a passar!

"Quando um método é chamado, o compilador garante que os tipos dos argumentos correspondam aos tipos dos parâmetros. Ele não presta atenção ao nome dos argumentos. Em Java, os nomes dos parâmetros não ajudam o compilador a determinar qual método usar Os programadores precisam deles, não do compilador.

"E eu acho que é por isso que eles não são levados em consideração ao determinar a exclusividade de um método?"

"Sim, está totalmente correto. O nome de um método e os tipos de seus parâmetros são chamados de assinatura de método . Por exemplo, sum (int, int)"

"Portanto, cada classe deve ter métodos com assinaturas exclusivas , em vez de métodos com nomes exclusivos."

"Muito bem, amigo! Você resumiu esta lição perfeitamente. Se algo não estiver claro, não entre em pânico. Este tópico ficará claro após algumas tarefas."