Métodos em Java: Como Definir, Chamar e Usar Eficazmente

Métodos em Java

Este guia explica como métodos Java funcionam, como declará-los, chamá-los e aproveitar métodos definidos pelo usuário e da biblioteca padrão com exemplos claros.

O que é um Método Java?

Um método é um bloco de código auto-contido que executa uma única tarefa bem definida. Ao dividir problemas complexos em métodos menores, você melhora legibilidade, manutenibilidade e reutilizabilidade.

Por exemplo, para desenhar e colorir um círculo, você poderia criar:

• drawCircle() – renderiza o contorno do círculo.
• colorCircle() – preenche o círculo com uma cor.

Esta abordagem modular torna seu código mais fácil de entender e estender.

Java oferece duas categorias de métodos:

• Métodos Definidos pelo Usuário – criados por desenvolvedores para atender requisitos específicos.
• Métodos da Biblioteca Padrão – utilitários pré-construídos fornecidos pela Biblioteca Padrão Java.

Declarando um Método Java

A declaração mais simples parece assim:

tipoRetorno nomeMétodo() {
    // corpo do método
}

• tipoRetorno – o tipo de dado que o método retorna (ex: int). Use void quando nada é retornado.
• nomeMétodo – o identificador usado para invocar o método.
• corpo do método – o código que executa quando o método é chamado, entre chaves.

Exemplo:

int addNumbers() {
    // código
}

A sintaxe completa adiciona modificadores, palavra-chave static e parâmetros:

modificador static tipoRetorno nomeMétodo(parâmetro1, parâmetro2, ...) {
    // corpo do método
}

• modificador – especificador de acesso (public, private, protected, etc.).
• static – permite o método ser invocado sem uma instância.
• parâmetros – valores passados para o método.

Chamando um Método

Uma vez declarado, invoque um método usando seu nome seguido de parênteses. Exemplo:

addNumbers();

Exemplo 1: Método Definido pelo Usuário

class Main {
    // Método de instância
    public int addNumbers(int a, int b) {
        int sum = a + b;
        return sum;
    }
    public static void main(String[] args) {
        int num1 = 25;
        int num2 = 15;
        Main obj = new Main();
        int result = obj.addNumbers(num1, num2);
        System.out.println("Soma é: " + result);
    }
}

Saída

Soma é: 40

O método addNumbers() é invocado em um objeto porque não é static.

Tipos de Retorno

Métodos podem retornar um valor usando a instrução return. O tipo do valor retornado deve corresponder ao tipo de retorno declarado.

Exemplo 2: Método static retornando valor

class Main {
    public static int square(int num) {
        return num * num;
    }
    public static void main(String[] args) {
        int result = square(10);
        System.out.println("Valor ao quadrado de 10 é: " + result);
    }
}

Saída

Valor ao quadrado de 10 é: 100

Se um método não deve retornar nada, declare seu tipo de retorno como void:

public void display(int a) {
    System.out.println("Valor é: " + a);
}

Parâmetros

Parâmetros são placeholders na assinatura de um método que recebem argumentos durante a invocação. Java permite qualquer número de parâmetros.

int addNumbers(int a, int b) { /* ... */ }
int addNumbers() { /* ... */ }

Exemplo 3: Métodos com diferentes contagens de parâmetros

class Main {
    public void display1() {
        System.out.println("Método sem parâmetro");
    }
    public void display2(int a) {
        System.out.println("Método com um parâmetro: " + a);
    }
    public static void main(String[] args) {
        Main obj = new Main();
        obj.display1();
        obj.display2(24);
    }
}

Saída

Método sem parâmetro
Método com um parâmetro: 24

A tipagem forte do Java garante que o tipo de cada argumento corresponda ao seu parâmetro correspondente.

Métodos da Biblioteca Padrão

A Biblioteca de Classes Java (JCL) agrupa muitos métodos prontos para uso. Exemplos comuns incluem:

• print() – de java.io.PrintStream para saída de texto.
• sqrt() – de Math para calcular raízes quadradas.

Exemplo 4: Usando um método padrão

public class Main {
    public static void main(String[] args) {
        System.out.print("Raiz quadrada de 4 é: " + Math.sqrt(4));
    }
}

Saída

Raiz quadrada de 4 é: 2.0

Explore mais métodos da biblioteca na documentação oficial da API Java.

Por Que Usar Métodos?

1. Reutilização de Código – Escreva uma vez, use muitas vezes. Por exemplo:

public class Main {
    private static int getSquare(int x) {
        return x * x;
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            int result = getSquare(i);
            System.out.println("Quadrado de " + i + " é: " + result);
        }
    }
}

Saída:

Quadrado de 1 é: 1
Quadrado de 2 é: 4
Quadrado de 3 é: 9
Quadrado de 4 é: 16
Quadrado de 5 é: 25

Usar getSquare() evita código aritmético repetitivo.

2. Legibilidade e Depuração – Encapsular lógica em métodos cria unidades lógicas mais fáceis de entender e testar.