6 Métodos

6.1 Por que usar métodos

Métodos ajudam a organizar o programa.

Quando um trecho se repete, criamos um método para reaproveitar.

6.2 Método simples

public static void saudacao(String nome) {
    System.out.println("Bot: Olá, " + nome + "!");
}

6.3 Método com retorno

public static String responder(String msg) {
    if (msg.equalsIgnoreCase("oi")) {
        return "Olá!";
    }
    return "Ainda estou aprendendo.";
}

6.4 Exemplo completo

public class Main {
    public static String responder(String msg) {
        if (msg.equalsIgnoreCase("oi")) return "Olá!";
        if (msg.equalsIgnoreCase("ajuda")) return "Digite oi, ajuda ou sair.";
        return "Não entendi.";
    }

    public static void main(String[] args) {
        System.out.println("Bot: " + responder("oi"));
    }
}

6.5 Exercícios

Crie o método despedida().
Crie o método ehSaida(String msg).
Refatore seu chatbot usando métodos.

6.6 Anatomia de um método

Um método em Java possui assinatura e corpo.

A assinatura é composta por modificador de acesso, opcional static, tipo de retorno, nome e lista de parâmetros.

Quando você lê a assinatura com atenção, consegue entender o contrato técnico daquele trecho, ou seja, o que ele recebe e o que entrega para o restante do programa.

public static int somar(int a, int b) {
    return a + b;
}

Nesse exemplo, o método recebe dois inteiros e retorna um inteiro.

O nome somar deve descrever a intenção de forma objetiva, evitando nomes genéricos como fazer ou processar.

6.7 Parâmetros e passagem de valores

Em Java, argumentos de tipos primitivos são copiados quando enviados para um método.

Isso significa que alterar o parâmetro dentro do método não altera a variável original no método main.

public static void incrementar(int numero) {
    numero = numero + 1;
    System.out.println("Dentro do metodo: " + numero);
}

public static void main(String[] args) {
    int valor = 10;
    incrementar(valor);
    System.out.println("No main: " + valor);
}

A saída mostra 11 dentro do método e 10 no main.

Esse comportamento evita efeitos colaterais inesperados em vários cenários e ajuda no raciocínio sobre o fluxo de dados.

6.8 Escopo de variáveis

Variáveis declaradas dentro de um método existem apenas naquele bloco.

Tentativas de uso fora do escopo causam erro de compilação.

public static void exemploEscopo() {
    String resposta = "OK";
    System.out.println(resposta);
}

A variável resposta não pode ser usada em outro método diretamente.

Entender escopo é fundamental para evitar bugs e escrever código mais previsível.

6.9 Sobrecarga de métodos

Sobrecarga ocorre quando dois ou mais métodos têm o mesmo nome, mas assinaturas diferentes.

Esse recurso melhora a legibilidade quando a operação é a mesma, porém os tipos de entrada variam.

public static int calcular(int a, int b) {
    return a + b;
}

public static double calcular(double a, double b) {
    return a + b;
}

O compilador escolhe automaticamente o método mais adequado com base nos argumentos informados na chamada.

6.10 Métodos puros e efeitos colaterais

Um método puro depende apenas de seus parâmetros e sempre retorna o mesmo resultado para a mesma entrada.

Métodos desse tipo são mais fáceis de testar e reutilizar.

Já métodos com efeitos colaterais alteram estado externo, escrevem em arquivos, mudam coleções compartilhadas ou imprimem no console.

Durante a fase inicial de aprendizagem, separar calculo de exibicao ajuda bastante:

Um método calcula e retorna.
Outro método apresenta o resultado.

Essa divisão reduz acoplamento e facilita manutenção.

6.11 Validação em métodos

Métodos também podem proteger o programa com validações básicas.

public static int dividir(int a, int b) {
    if (b == 0) {
        throw new IllegalArgumentException("Divisor não pode ser zero.");
    }
    return a / b;
}

Com isso, o erro fica explícito e a causa do problema aparece de forma clara para quem está usando o método.

6.12 Boas práticas para iniciantes

Prefira métodos curtos com uma responsabilidade principal.

Evite concentrar muitas decisões diferentes no mesmo bloco, porque isso dificulta teste, leitura e evolução.

Use nomes claros para parâmetros, como mensagem, tentativas, limite, em vez de nomes vagos como x, y e valor1.

Por fim, sempre que um trecho começa a se repetir, trate isso como sinal para extrair um novo método.

Esse hábito simples melhora sua estrutura de código desde os primeiros projetos e prepara o terreno para tópicos mais avançados, como objetos, classes utilitárias e organização por camadas.

Expansão didática complementar

Neste capítulo, o estudo de métodos se torna realmente valioso quando você deixa de enxergar o conteúdo como uma lista de regras isoladas e passa a observar como cada decisão técnica influencia a qualidade do programa, a facilidade de manutenção e a capacidade de adaptar a solução sem quebrar o que já estava funcionando, especialmente em atividades progressivas que simulam situações de projeto real.

Para consolidar o aprendizado com profundidade, vale estruturar sua prática em uma sequência objetiva na qual você revisa o conceito principal, implementa um exemplo pequeno e legível e, logo em seguida, analisa de maneira crítica se houve melhoria concreta em assinatura e contrato, parâmetros e retorno, e reúso, porque esse ciclo consciente transforma estudo passivo em desenvolvimento de critério técnico.

Quando esse processo se repete ao longo das semanas, você começa a perceber que sua evolução não depende de decorar respostas prontas, mas sim de interpretar problemas com mais maturidade, justificar escolhas com argumentos claros e construir soluções cada vez mais consistentes, o que representa exatamente a transição de iniciante para praticante autônomo dentro da trilha de Java.