Métodos em Java: como definir e chamar métodos

Por que os métodos existem

Um método é um bloco de código nomeado que você pode executar sempre que chamar o seu nome. Em vez de escrever as mesmas linhas repetidamente, você as escreve uma única vez dentro de um método e o chama quantas vezes precisar. Isso deixa os programas mais curtos, mais fáceis de ler e bem mais fáceis de corrigir: você muda a lógica em um único lugar e todos que chamam o método recebem a atualização.

Você já vem chamando métodos: System.out.println(...) é uma chamada de método, e list.size() também. Agora você vai escrever os seus próprios.

Declarando e chamando um método

A declaração de um método tem quatro partes: um tipo de retorno, um nome, um par de parênteses (para os parâmetros) e um corpo entre chaves. Aqui está o menor exemplo útil: um método que faz algum trabalho e não devolve nada:

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // chame-o
        printGreeting();   // chame-o de novo
    }
}

Leia as partes de static void printGreeting():

• static: permite que main o chame diretamente sem criar um objeto (mais sobre isso abaixo).
• void: este método não devolve nenhum valor.
• printGreeting: o nome que você usa para chamá-lo.
• (): os parênteses vazios indicam que ele não recebe nenhuma entrada.

Você chama um método escrevendo o seu nome seguido de parênteses. As duas chamadas em main executam o corpo duas vezes, então isso imprime a saudação duas vezes.

Devolvendo um valor

A maioria dos métodos calcula algo e o devolve com return. O tipo de retorno antes do nome diz que tipo de valor sai; aqui, int:

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) é avaliado como 25, que você pode guardar em uma variável, imprimir ou usar dentro de uma expressão maior: uma chamada de método representa o valor que ela devolve. No momento em que return é executado, o método termina e o controle volta para quem o chamou. Qualquer código que venha depois de um return no mesmo caminho nunca é executado.

O tipo de retorno e o valor devolvido devem coincidir. Declarar int e tentar return "text"; é um erro de compilação: o compilador faz cumprir o contrato.

void versus um tipo de retorno

A distinção é simples: use um tipo de retorno real quando quem chama precisa receber um valor de volta, e void quando o método apenas faz algo (imprime, salva, atualiza o estado).

void logMessage(String msg)   // faz o trabalho, não devolve nada
int  add(int a, int b)        // calcula um valor que quem chama usa

Um erro comum de iniciantes é tentar usar o "resultado" de um método void:

int x = printGreeting();   // erro de compilação: printGreeting() devolve void

Não há nenhum valor para atribuir, então isso não compila. Se você se pegar querendo o resultado de um método void, é sinal de que ele deveria devolver algo.

Métodos que se ramificam e devolvem cedo

Você pode usar return em mais de um ponto. Devolver cedo, assim que você souber a resposta, costuma ser mais claro do que aninhar tudo dentro de else:

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

Como cada return sai imediatamente, vence a primeira condição que for satisfeita. Apenas garanta que todo caminho dentro de um método que devolve um valor termine em um return: se algum ramo puder sair sem devolver nada, o compilador reclama com "missing return statement". O return "F"; final cobre aqui o caso de saída.

O que static significa aqui

Você pode ter notado que todos os métodos acima são static. Um método static pertence à própria classe, não a nenhum objeto, então main (que também é static) pode chamá-lo diretamente pelo nome. Sem static, o método pertence a uma instância e você precisaria de um objeto para chamá-lo.

Por enquanto, enquanto você escreve programas pequenos cuja lógica vive junto de main, marque seus métodos auxiliares como static para que possam ser chamados da mesma maneira. Quando você começar a construir suas próprias classes e objetos, também vai escrever métodos não estáticos (de instância): isso vem com o capítulo de classes.

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main é static, então pode chamar doubleIt diretamente
        System.out.println(doubleIt(21));   // 42
    }
}

Variáveis locais ficam dentro do método

Variáveis declaradas dentro de um método existem apenas ali. Elas são criadas quando o método é executado e somem quando ele termina: quem o chama nunca as vê:

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // local de sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // erro: total não é visível aqui
    }
}

total e i vivem inteiramente dentro de sumTo. A única coisa que escapa do método é o valor que você return. Esse isolamento é uma vantagem: cada método é uma unidade autônoma sobre a qual você pode raciocinar sem se preocupar que suas variáveis temporárias vazem ou colidam com nomes de outro lugar.

Próximo: parâmetros de métodos

Todos os métodos aqui ou não recebiam nenhuma entrada ou recebiam um único valor. O verdadeiro poder vem de passar dados para dentro, e Java tem regras específicas sobre como os argumentos são passados, o que acontece com objetos versus primitivos e como dar a um parâmetro algo parecido com um valor padrão. É disso que trata a próxima página.