Parâmetros e Argumentos: passando informações para os métodos

Em nosso curso de Java, até o momento, os nossos métodos faziam coisas bem específicas, como exibir uma string, um menu ou realizavam cálculos matemáticos.
Isso, na prática, não é muito útil.

Diferença entre parâmetro e Argumento em Java

Parâmetro e argumentos são os meios na quais nós passaremos dados para o método, e estes métodos irão trabalhar especificamente em cima dessas informações que nós demos.
E, geralmente, vão nos retornar algum resultado.

Declarando métodos com parâmetros

Sempre que um method receber dados, estes serão recebidos através dos parâmetros.
Em Java, assim como em C ou C++, você precisa deixar bem claro quais e qual o tipo dos dados que você vai passar.
Em algumas linguagens, como Perl, isso não é necessário.

Isso tem a ver com tipagem, alocação de memória e outras coisas de mais baixo nível.
(Quando falamos em baixo nível, em Java ou computação, estamos no referindo ao nível de abstração. Quanto mais baixo mais próximo do hardware ou dos bits estamos falando).

A sintaxe da declaração fica assim:
[dados_do_método] tipo_de_retorno nome_do_método (tipo nome_do_parametro1, tipo nome_do_parametro2){
    //código
    // do
    // method
}


Uma função que recebe um inteiro e retorna um inteiro teria a seguinte 'cara':
public int metodo(int numero){
    //código
    return intNumber;
}


Esse tipo, no caso 'int', que vem logo antes do nome do método se refere ao tipo do retorno.
Se seu method retorna float, deverá ser: public float metodo(....)
Se for String, deverá ser: public static String metodo(...)

O static será explicado mais adiante em nosso curso Java Progressivo, na seção de Orientação a Objetos da apostila online.
Até então estamos usando pois estamos chamando os métodos a partir da main, que é um static também.


Exemplo: Passando argumentos para um método - Função que calcula o quadrado de um número


Pela declaração, vemos que o seguinte método recebe um inteiro, o 'num' e retorna um inteiro também.
Dentro de métodos podemos declarar tipos. No caso, declaramos o tipo 'quadrado', que recebe o valor de 'num' elevado ao quadrado, ou seja: num*num
e retorna esse 'quadrado'.
    public static int quadrado(int num){
        int quadrado;
        quadrado = num * num;
        return quadrado;
    }


Para usarmos um método que recebe um inteiro como parâmetro precisamos passar um argumento ao método. Por argumento, entenda um valor, algo real.
No programa, a chamada do método seria a seguinte: quadrado(numero);

Nos exemplos passados não colocávamos nada entre parênteses, pois os métodos que criamos nos artigos passado de nosso curso não tinham parâmetro. Agora, temos que passar um número, ficaria algo do tipo: quadrado(2), quadrado(3) etc.

Veja como ficaria esse método em um aplicativo Java que pede ao usuário um número inteiro e retorna o quadrado desse valor:
import java.util.Scanner;

public class quadrado {
    
    public static int quadrado(int num){
        int quadrado;
        quadrado = num * num;
        return quadrado;
    }
    
    public static void main(String[] args) {
        int numero, numero_quadrado;
        Scanner entrada = new Scanner(System.in);
        
        System.out.print("Entre com um inteiro: ");
        numero = entrada.nextInt();
        
        numero_quadrado=quadrado(numero);
        
        System.out.printf("%d elevado ao quadrado é %d", numero, numero_quadrado);
    }
}


Note que, na 'main', declaramos o valor 'numero', fizemos com que ele receba um valor inteiro e passamos esse valor inteiro ao método.
Você pode achar estranho o fato de usarmos 'numero' na 'main' e 'num' no método 'quadrado()'. Porém, é assim mesmo.

Na 'main', o número que o usuário forneceu fica armazenado na variável 'numero', mas quando passamos este valor ao método, estamos passando um número.
Este número, agora, será armazenado na variável 'num' do método 'quadrado()'.

Chamamos essa variável, 'num', de variável local, pois ela só existe dentro do método. Se você tentar usar ela fora do método, obterá um erro.
Teste, adicione a linha seguinte ao programa:
System.out.println(num)

Você nem vai conseguir compilar, pois para a 'main', não existe 'num'.

Declaramos dentro do method 'quadrado()' a variável 'quadrado' somente para efeitos didáticos, para mostrar que podemos declarar variáveis dentro de um método, mas à rigor, ela não é necessária, poderíamos simplesmente ter feito:
    public static int quadrado(int num){
        return num * num;
    }


Nesse exemplo, 'num' seria um parâmetro e o valor de 'numero' seria o argumento.

Exemplo: passando uma lista de parâmetros para um método - Cálculo do IMC


No artigo sobre operações Matemáticas em Java, passamos como exercício o cálculo do IMC (índice de massa corporal). Que nada mais é um número, que é calculado pelo peso (em kilogramas) dividido pelo quadrado da altura (em metros) da pessoa.

O nosso método IMC recebe dois valores float, o peso e a altura, e retorna outro float, que é o valor do IMC. A declaração de um método com mais de um parâmetro ficaria assim:
public static float IMC(float peso, float altura)


Nosso programa ficaria assim:
import java.util.Scanner;

public class IMC {
    
    public static float IMC(float peso, float altura){
        float imc;
        imc = peso/(altura*altura);
        return imc;
    }
    
    public static void main(String[] args) {
        float peso, altura, imc;
        Scanner entrada = new Scanner(System.in);
        
        System.out.print("Entre com seu peso, em kilos: ");
        peso = entrada.nextFloat();
        
        System.out.print("Entre com sua altura, em metros: ");
        altura = entrada.nextFloat();
        
        imc = IMC(peso, altura);
        
        System.out.printf("Seu IMC vale: %.2f",imc);

    }
}


Note que agora invocamos o método IMC e passamos dois argumentos: peso e altura
Note que na 'main', usei exatamente as mesmas variáveis que usei dentro do method IMC(), fiz isso pra mostrar que não há problemas em fazer isso.

Porém, quando usamos essas variáveis dentro da 'main', os valores serão os que o usuário passou. Dentro do método, esses valores podem ser alterados e poderão representar outros valores.
Cuidado para não confundir. Embora tenham o mesmo nome, estamos usando em lugares diferentes de nosso aplicativo Java.

Exemplo: chamando um método dentro do outro - Cálculo do IMC

Lembra que falei várias vezes sobre organização, fazer métodos simples e diretos?
Pois é, vamos mostrar, na prática, como fazer isso.

Notou que no cálculo do IMC elevamos um número ao quadrado, a altura?
Notou que o primeiro método calcula um número ao quadrado?

Você deve estar pensando:
'Ora, vamos usar o primeiro exemplo para fazer um cálculo dentro do segundo.'

Quase. Note que o primeiro exemplo usamos inteiros! Mas a altura, que usamos no segundo exemplo desse artigo, se refere a float!
Então vamos modificar um pouco nossa função que calcula o quadrado de um número, para receber e retornar decimais e usar dentro do método IMC();
Os métodos ficariam assim:
    public static float quadrado(float num){
        return num*num;
    }    

    public static float IMC(float peso, float altura){
        float imc;
        imc = peso/quadrado(altura);
        return imc;
    }


E o aplicativo Java ficaria assim:

import java.util.Scanner;

public class IMC {
    
    public static void main(String[] args) {
        float peso, altura;
        Scanner entrada = new Scanner(System.in);
        
        System.out.print("Entre com seu peso, em kilos: ");
        peso = entrada.nextFloat();
        
        System.out.print("Entre com sua altura, em metros: ");
        altura = entrada.nextFloat();
        
        System.out.printf("Seu IMC vale: %.2f", IMC(peso, altura));

    }
    
    public static float IMC(float peso, float altura){
        return peso/quadrado(altura);
    }
    
    public static float quadrado(float num){
        return num*num;
    }
}



Pronto, usamos um método - quadrado() - dentro de outro, IMC().
Note que a ordem em que declaramos os métodos dentro de uma classe não importa.

Dicas e Novidades de Java por e-mail

Sabe quanto custa um bom livro de java?
Entre R$ 100,00 e R$300,00

Sabe quanto custa um bom curso presencial de Java?
Entre R$ 1.500,00 até R$ 4.000,00

Sabe quanto custa estudar pelo Java Progressivo?
Absolutamente nada.

Porém, também precisamos de sua ajuda e apoio.
Para isso, basta curtir nossa Fan Page e clicar no botão G+ do Google.