Valores de retorno e sobrecarga
Aprenda instruções de retorno, retornos antecipados e sobrecarga de métodos por quantidade e tipo de parâmetros. Inclui demonstrações de varargs e seleção de sobrecargas.
Valores de retorno e sobrecarga é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 3 aulas no total.
Visão geral
Objetivo: dominar instruções de retorno e sobrecarga de métodos. Você verá retornos antecipados (cláusulas de guarda), sobrecargas por quantidade e por tipo e uma breve demonstração de argumentos variáveis.
Retorno e guarda
Retorno envia um valor de volta para quem chama e encerra o método. Cláusulas de guarda (retorno antecipado) mantêm o código simples ao tratar primeiro os casos especiais.
public class Main {
// Double an integer and return the result
static int doubleIt(int x) {
return x * 2;
}
// Return a label using a simple early-return pattern (guard clause)
static String parity(int n) {
if (n % 2 == 0) {
return "even"; // early return ends the method here
}
return "odd"; // otherwise this path executes
}
public static void main(String[] args) {
System.out.println("doubleIt(7) = " + doubleIt(7));
System.out.println("parity(10) = " + parity(10));
System.out.println("parity(11) = " + parity(11));
}
}
Vários retornos
Retornar antecipadamente para uma entrada inválida evita aninhamentos profundos. Aqui, a divisão por zero retorna 0 como uma política simples (mais tarde, você aprenderá sobre exceções).
public class Main {
// Safe integer division with simple validation
static int safeDiv(int num, int den) {
if (den == 0) {
return 0; // simple policy: return 0 if denominator is zero
}
return num / den; // normal path
}
public static void main(String[] args) {
System.out.println("safeDiv(8, 2) = " + safeDiv(8, 2));
System.out.println("safeDiv(5, 0) = " + safeDiv(5, 0));
}
}
Sobrecarga: quantidade
Sobrecarga significa usar o mesmo nome de método com uma lista de parâmetros diferente. Alterar a quantidade de parâmetros é uma sobrecarga válida.
public class Main {
// Overload 1: max of two numbers
static int max(int a, int b) {
return (a > b) ? a : b;
}
// Overload 2: max of three numbers (different parameter COUNT)
static int max(int a, int b, int c) {
int m = (a > b) ? a : b;
return (m > c) ? m : c;
}
public static void main(String[] args) {
System.out.println("max(3, 9) = " + max(3, 9));
System.out.println("max(3, 9, 5) = " + max(3, 9, 5));
}
}
Sobrecarga: tipos
A sobrecarga por tipo permite reutilizar um nome para operações relacionadas. Argumentos numéricos mistos são promovidos para a assinatura correspondente mais específica.
public class Main {
// Overload for integers
static int add(int a, int b) {
return a + b;
}
// Overload for doubles (different parameter TYPES)
static double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
System.out.println("add(2, 3) = " + add(2, 3)); // calls int version
System.out.println("add(2.5, 3.5) = " + add(2.5, 3.5)); // calls double version
System.out.println("add(2, 3.5) = " + add(2, 3.5)); // numeric promotion chooses double version
}
}
Sobrecarga: argumentos variáveis
Argumentos variáveis (int...) reúnem zero ou mais argumentos. A resolução de sobrecarga prefere uma correspondência exata sem argumentos variáveis quando ela está disponível.
public class Main {
// Specific overload for two ints
static int sum(int a, int b) {
return a + b;
}
// Varargs overload for many ints
static int sum(int... nums) {
int s = 0;
for (int i = 0; i < nums.length; i = i + 1) s = s + nums[i];
return s;
}
public static void main(String[] args) {
// Exact match beats varargs
System.out.println("sum(4, 5) = " + sum(4, 5)); // picks (int,int)
System.out.println("sum(1,2,3,4) = " + sum(1, 2, 3, 4)); // uses varargs
}
}
Verificação de sobrecarga
Verificação rápida: Qual par pode ser uma sobrecarga válida na mesma classe?
Recapitulação e próxima etapa
Recapitulação: Você usou return e retornos antecipados, criou sobrecargas válidas por quantidade e por tipo e praticou argumentos variáveis. A seguir: escopo e tempo de vida de variáveis e métodos.
Perguntas Frequentes
A aula “Valores de retorno e sobrecarga” é grátis?
Sim — o texto completo de “Valores de retorno e sobrecarga” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 3 aulas no total.
O que vou aprender em “Valores de retorno e sobrecarga”?
Aprenda instruções de retorno, retornos antecipados e sobrecarga de métodos por quantidade e tipo de parâmetros. Inclui demonstrações de varargs e seleção de sobrecargas. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.
Quanto tempo leva a aula “Valores de retorno e sobrecarga”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Definição de métodos e parâmetros
- Valores de retorno e sobrecarga
- Escopo e tempo de vida