Valores de retorno, return

1. Introdução

Vamos começar com uma pergunta: por que um método precisa retornar algo? Por que não fazer tudo dentro do método e apenas imprimir o resultado na tela?

A questão é que muitas vezes não precisamos apenas executar uma ação, mas obter um resultado que será útil em outras partes do programa. Por exemplo:

• O método calcula a soma de dois números e a retorna, para que possamos usar o resultado em cálculos posteriores.
• O método verifica se um número é par e retorna true ou false, para que possamos tomar uma decisão.
• O método retorna uma string de saudação para o usuário, e nós decidimos para onde enviá-la — exibir na tela, salvar em arquivo, enviar pela rede.

Se os métodos sempre apenas imprimissem o resultado, nosso programa ficaria rigidamente preso a um único cenário e seria difícil reutilizar a lógica. O valor de retorno torna os métodos flexíveis e universais.

Analogia

Imagine uma máquina de café. Você coloca o dinheiro, aperta o botão — e recebe o café. Se a máquina apenas dissesse em voz alta “Café pronto!” (mas não entregasse o café), você não ficaria feliz. É o mesmo com métodos: às vezes não queremos apenas ouvir “Pronto!”, mas sim obter o resultado.

2. Tipo de valor de retorno: o que um método pode retornar

Em Java, ao declarar um método, você especifica o tipo do valor de retorno — pode ser qualquer tipo: int, double, String, boolean, um array, até um objeto da sua própria classe. Se o método não retornar nada — escrevemos void.

Sintaxe:

tip_vozvrashchaemogo_znacheniya imyaMetoda(parametry)
{
    // corpo do método
}

Exemplos:

int sum(int a, int b) 
{
    // retorna int
}

String getGreeting(String name) 
{
    // retorna String
}

boolean isEven(int number) 
{
    // retorna boolean
}

void printHello() 
{
    // não retorna nada — apenas executa uma ação
}

Importante! O tipo do valor de retorno é uma “promessa” do método: ele é obrigado a retornar um valor desse tipo. Se você prometeu retornar int, mas retorna String — o compilador ficará indignado e não permitirá compilar o programa.

3. Operador return: como retornar um valor de um método

Para realmente entregar o resultado do trabalho do método “para fora”, usamos o operador return. Essa palavra diz: “Aqui está o resultado — e com isso meu trabalho terminou”.

int sum(int a, int b) 
{
    int result = a + b;
    return result; // retornamos o resultado
}

Pode ser ainda mais curto:

int sum(int a, int b) 
{
    return a + b;
}

Quando o método alcança a linha return, ele encerra a execução, retorna o valor especificado e o entrega para o ponto de onde foi chamado.

Importante: o tipo do valor após return deve coincidir com o tipo declarado do método.

4. Uso do valor de retorno: o que fazer com ele?

Quando um método retorna um valor, você pode:

• Armazená-lo em uma variável.
• Usá-lo diretamente em uma expressão.
• Passá-lo para outro método.

int result = sum(5, 7); // armazenamos em uma variável
System.out.println(result); // imprimimos o resultado

System.out.println(sum(10, 20)); // imprimimos o resultado diretamente

if (isEven(42)) 
{
    System.out.println("O número é par!");
}

Exemplo: método que retorna uma string

String getGreeting(String name) 
{
    return "Olá, " + name + "!";
}

// Uso:
String greeting = getGreeting("Alice");
System.out.println(greeting); // Olá, Alice!

5. Prática: exemplos de métodos com valor de retorno

Método que retorna o máximo de dois números

int max(int a, int b) 
{
    if (a > b) 
    {
        return a;
    } 
    else 
    {
        return b;
    }
}

Pode ser ainda mais curto, se você já dominou o operador ternário:

int max(int a, int b) 
{
    return (a > b) ? a : b;
}

Uso:

int maximum = max(10, 25);
System.out.println("Máximo: " + maximum); // Máximo: 25

Método que retorna true se o número for par

boolean isEven(int number) 
{
    return number % 2 == 0;
}

Uso:

if (isEven(18)) 
{
    System.out.println("O número é par!");
} 
else 
{
    System.out.println("O número é ímpar!");
}

Método que retorna a soma dos elementos de um array

int sumArray(int[] arr) 
{
    int sum = 0;
    for (int i = 0; i < arr.length; i++) 
    {
        sum += arr[i];
    }
    return sum;
}

Uso:

int[] grades = {5, 4, 3, 5, 4};
int total = sumArray(grades);
System.out.println("Soma das notas: " + total);

6. O que acontece ao chamar um método com return

Quando você chama um método com valor de retorno, a execução do programa “entra” no método, executa seu código, chega ao return, retorna o valor — e o substitui no local da chamada.

Esquematicamente:

int a = 2;
int b = 3;
int c = sum(a, b); // aqui sum(2, 3) é chamado, 5 é retornado, c torna-se 5

Fluxograma

        graph TD
        A["main"] --> B["sum(a, b)"]
        B --> C[cálculos]
        C --> D[return result]
        D -->|o resultado é retornado| A
    

7. Nuances úteis

return encerra a execução do método

Assim que um return aparece no método, a execução é interrompida imediatamente. Tudo o que estiver depois — não será executado.

int test()
{
    return 42;
    System.out.println("Isto não será impresso"); // unreachable
}

return em um método do tipo void

Em um método void (que não retorna nada) é possível usar return sem valor — apenas para encerrar o método antecipadamente, por exemplo, sob alguma condição.

void printPositive(int number)
{
    if (number <= 0) 
    {
        System.out.println("O número não é positivo!");
        return; // apenas saímos do método
    }
    System.out.println("Número: " + number);
}

8. Erros comuns ao trabalhar com return

Erro nº 1: Nem todos os caminhos retornam um valor

int getSign(int number)
{
    if (number > 0) 
    {
        return 1;
    }
    // E se number <= 0? Não há return!
}
// Erro: nem todos os ramos do código retornam um valor

Como corrigir: sempre preveja um return em todos os caminhos de execução.

int getSign(int number)
{
    if (number > 0) 
    {
        return 1;
    } 
    else if (number < 0) 
    {
        return -1;
    } 
    else 
    {
        return 0;
    }
}

Erro nº 2: Incompatibilidade do tipo do valor de retorno

int getNumber()
{
    return "42"; // Erro! Esperava-se int, não String
}

Erro nº 3: return após return

int test()
{
    return 5;
    System.out.println("Isto não será executado"); // unreachable statement
}

Erro nº 4: return com expressão em método void

void printSomething()
{
    return 42; // Erro! Um método void não pode retornar um valor
}

Erro nº 5: Ignorar o valor de retorno

sum(10, 20); // e só? O resultado se perdeu!

Se você não usa o valor retornado, ele simplesmente se perde. Não se esqueça de armazená-lo ou passá-lo adiante no código!

Erro nº 6: Esperar que return imprima algo

int result = sum(2, 3);
// return não imprime nada!
// É preciso imprimir explicitamente:
System.out.println(result);