E aí, pessoal! Beleza? Hoje nós vamos ver e explicar os métodos em Java com teoria e prática. Vamos lá?

O que é um método?

Primeiramente, o que é um método? Um método em Java é um bloco de código que, ao ser chamado, executa ações específicas nele mencionadas. 

Por exemplo, se você declarou o método para enviar um e-mail de confirmação, ele fará essa tarefa. Você também pode inserir parâmetros em métodos, e eles só serão executados quando chamados.

Criando Métodos

Antes de mais nada, uma regra muito importante: um método não pode ser criado dentro de outro método, logo, no método main você não pode declarar nenhum método dentro.

Sintaxe

A sintaxe de um método é dessa forma abaixo:

Ou se preferir o “esqueleto” do método:

‘retorno’ ‘nome do método’ ‘(parâmetros)’{

‘corpo do método’

}

Agora, vamos verificar o que cada uma dessas palavras significa:

Em verde String significa o retorno do método, ou seja, esse método retornará uma String.

Em amarelo dizerOla é o nome do método.

Entre os parênteses “()” é onde consideramos os parâmetros, que iremos ver logo, logo.

Tudo isso mencionado acima faz parte da declaração do método.

Após os parênteses abriremos o escopo do método usando as chaves, começando com abre chave “{” e quando as instruções que iremos passar para nosso método finalizar, vamos fechar também com fecha chave “}”.

Em rosa, o return indica que, o que será retornado, é o que virá logo após a palavra return.

Nós consideramos o corpo do método tudo que está dentro das chaves.

Dentro do corpo do método iremos passar todas as instruções, de todos passos que o método vai fazer, inclusive, o retorno dele se ele tiver.

No nosso método de exemplo acima, dentro do corpo temos apenas passando a instrução dele retornar a String “Olá!”; e é exatamente isso que ele vai fazer: retornar “Olá!” como String.

Parâmetros

Os valores recebidos nos parênteses do método são os parâmetros.

Na declaração do método nós inserimos o tipo do parâmetro seguido do nome.

E, se na declaração houver mais que um parâmetro, ele deve ser separado por vírgulas no método da seguinte forma:

// Declaração
int somarDoisNumeros(int numero1, int numero2) {

        int soma = numero1 + numero2;

        return soma;
    }

// Chamando o método pasando dois parâmetros separados por vírgula
somarDoisNumeros(3, 4);

No exemplo acima nós recebemos 2 parâmetros, os dois sendo do tipo int e seus nomes sendo numero1 e numero2.

Os nomes que damos para os parâmetros são literalmente os nomes das variáveis que eles irão ficar armazenados, podendo ser qualquer outro nome, porém, nós iremos sempre botar nomes que façam sentido.

Mas que fique claro que o nome é você quem escolhe, e, você poderá acessar esse valor recebido por parâmetro por meio do nome que ele recebeu, e esse valor vai estar disponível dentro do escopo (corpo) do método inteiro, seguindo essa lógica nós apenas receberemos por parâmetro os valores que realmente farão sentido pra gente dentro do método, e também usar ele.

Todos as variáveis criadas dentro do método existirão apenas dentro do método.

Ou seja, toda vez que o método encerrar sua execução, ele também encerrará todas as variáveis contidas nele independentemente de terem sido criadas dentro do método ou recebidas por parâmetro.

Modificadores de Acesso

Os modificadores de acesso são literalmente algo que você modifica quem pode acessar ou não o método. Você pode escolher adicionar algum ou não, mas caso opte por não escolher, ele cairá como modificador padrão.

Nós temos diversos modificadores, são eles:

Lembre-se: você deve especificar os modificadores de acesso antes mesmo do tipo de retorno. Por exemplo:

(modificador) int somarDoisNumeros(int numero1, int numero2) {

        int soma = numero1 + numero2;

        return soma;
    }

Exemplo:

private int somarDoisNumeros(int numero1, int numero2) {

        int soma = numero1 + numero2;

        return soma;
    }

Padrão (defaut): O acesso desse modificador é apenas dentro do pacote. Não é possível o acesso de fora do pacote. Ele é aderido caso você não especifique um modificador.

private: O acesso desse modificador é apenas dentro da classe. Não é possível o acesso de fora da classe.

protected: O acesso desse modificador está dentro do pacote e fora do pacote por meio da classe filha. Se você não criar a classe filha, não é possível o acesso de fora do pacote.

public: O acesso desse modificador está em toda parte. O acesso é possível de dentro da classe, fora da classe, dentro do pacote e fora do pacote.

final: Esse modificador impede que o método seja sobrescrito por uma subclasse.

static: Esse modificador faz com que o método estático seja um método que faz parte de uma classe em vez de uma instância dessa classe. Cada instância de uma classe também tem acesso ao método. 

Os métodos estáticos têm acesso às variáveis de classe (variáveis estáticas) sem usar o objeto da classe (instância), ou seja, se você tiver uma classe Pessoa e ela tiver um método falarOla e esse método for estático, você não precisa criar uma instância de Pessoa para chamar esse método, basta chamar a própria classe Pessoa.falarOla();.

Chamando Métodos

A seguir, vamos ver como executar os métodos. Lembrando que eles são trechos de códigos, então, quando chamamos um método ele irá executar esse trecho de código.

Vamos criar o seguinte cenário:

import java.util.Scanner;

public class Metodos {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        System.out.print("Digite seu nome: ");
        String nome = scan.nextLine();

        saudacao(nome);   // Chamada do método passando variável como parâmetro
        saudacao("Aluno");   // Chamada do método passando apenas o parâmetro

    }

    static void saudacao(String nome) {
				// Dentro do método podemos usar o parâmetro recebido pelo nome, nesse caso o nome
        // do parâmetro nós chamamos de "nome", mas poderia ser qualquer outro nome
        System.out.println("Olá, seja bem vindo(a) " + nome + "!");
    }
}

Temos uma classe e criamos um método nessa classe, também temos o método main nela. No entanto, como eu mencionei anteriormente, você não consegue criar um método dentro de outro, por isso o método está fora do escopo do main.

Nós chamamos o método exatamente pelo nome dele seguido de parênteses e finalizamos com ponto e vírgula.

Se existirem parâmetros, o usuário deverá inserir apenas a variável ou o próprio parâmetro, e, caso haja mais de um, ele deve separá-los por vírgula, como exemplificado:

Declaração do método:

// O retorno do método sendo void significa que não irá retornar nada, então
// não precisamos usar a palavra "return"
void saudacao(String nomeParaSaldar){
        System.out.println("Olá, seja bem vindo(a) " + nomeParaSaldar + "!");
    }

Chamada do método:

        nomeParaSaldar("Aluno");

Não precisamos declarar o tipo do parâmetro passado, até porque isso já foi declara na declaração do método, então o método já espera que você esteja passando o tipo esperado, e, se tentar passar um tipo que não é o especificado, haverá erro.

Outro exemplo:

// Declaração
void somar(int num1, int num2){
        System.out.println("A soma dos números é" + (num1 + num2));
    } 

// Chamada do método
somar(1, 3);
// Deve ser passado dois números inteiros, sejam eles por meio de variáveis ou o próprio valor.

Conclusão

A partir de agora espero que consigam declarar métodos e utilizá-los, e não menos importante, realmente entendê-los com esses exemplos práticos de criação e chamada de método com um ou mais parâmetros.

Espero realmente ter ajudado vocês a entenderem esse conceito, grande abraço e espero vocês na próxima!

Você também pode gostar…

Boas práticas em Java e a sua importância

Composição no Java: O que é e como funciona?

Aprendendo a Escrever “Olá Mundo” com Java sem Ponto e Vírgula