Override vs Overload em Java

Em Java, frequentemente ouvimos falar em sobrescrita (Override) e sobrecarga (Overload), mas muitos desenvolvedorse têm dificuldade em distinguir essas duas funcionalidades importantes do paradigma de orientação a objetos.

Override - Sobrescrita de Métodos

A sobrescrita ocorre quando uma subclasse redefine um método herdado de sua classe pai. Isso permite que a classe filha forneça uma implementação específica para um método que já existe na classe pai.

Um exemplo clássico para ilustrar esse conceito é um sistema de gerenciamento de funcionários de uma empresa:

class Funcionario {
    protected String nome;
    protected double salario;
    
    public Funcionario(String nome, double salario) {
        this.nome = nome;
        this.salario = salario;
    }
    
    public void trabalhar() {
        System.out.println(nome + " está trabalhando.");
    }
    
    public double calcularBonus() {
        return salario * 0.05;
    }
}

class Gerente extends Funcionario {
    private int equipeSize;
    
    public Gerente(String nome, double salario, int equipeSize) {
        super(nome, salario);
        this.equipeSize = equipeSize;
    }
    
    @Override
    public void trabalhar() {
        System.out.println(nome + " está gerenciando a equipe de " + equipeSize + " pessoas.");
    }
    
    @Override
    public double calcularBonus() {
        return salario * 0.15;
    }
}

class Desenvolvedor extends Funcionario {
    private String linguagem;
    
    public Desenvolvedor(String nome, double salario, String linguagem) {
        super(nome, salario);
        this.linguagem = linguagem;
    }
    
    @Override
    public void trabalhar() {
        System.out.println(nome + " está programando em " + linguagem);
    }
}

public class SistemaEmpresa {
    public static void main(String[] args) {
        Funcionario[] funcionarios = new Funcionario[3];
        
        funcionarios[0] = new Funcionario("Carlos", 5000);
        funcionarios[1] = new Gerente("Ana", 10000, 8);
        funcionarios[2] = new Desenvolvedor("Bruno", 7000, "Java");
        
        for (Funcionario f : funcionarios) {
            f.trabalhar();
            System.out.println("Bônus: R$" + f.calcularBonus());
            System.out.println("---");
        }
    }
}

Saída esperada:

Carlos está trabalhando.
Bônus: R$250.0
---
Ana está gerenciando a equipe de 8 pessoas.
Bônus: R$1500.0
---
Bruno está programando em Java
Bônus: R$350.0
---

Perceba que cada subclasse sobrescreve o método trabalhar() para implementar seu próprio comportamento específico. A sobrescrita é fundamental quando precisamos alterar o comportamento de métodos herdados ou quando trabalhamos com classes abstratas e interfaces.

Overload - Sobrecarga de Métodos

A sobrecarga acontece quando temos múltiplos métodos com o mesmo nome na mesma classe, mas com parâmetros diferentes (quantidade ou tipo de parâmetros distintos).

class Calculadora {
    
    public int somar(int a, int b) {
        System.out.println("Somando dois inteiros");
        return a + b;
    }
    
    public double somar(double a, double b) {
        System.out.println("Somando dois doubles");
        return a + b;
    }
    
    public String somar(String a, String b) {
        System.out.println("Concatenando strings");
        return a + b;
    }
    
    public int somar(int a, int b, int c) {
        System.out.println("Somando três inteiros");
        return a + b + c;
    }
}

public class TesteCalculadora {
    public static void main(String[] args) {
        Calculadora calc = new Calculadora();
        
        int resultado1 = calc.somar(5, 3);
        System.out.println("Resultado: " + resultado1);
        
        double resultado2 = calc.somar(2.5, 3.7);
        System.out.println("Resultado: " + resultado2);
        
        String resultado3 = calc.somar("Olá, ", "Mundo!");
        System.out.println("Resultado: " + resultado3);
        
        int resultado4 = calc.somar(1, 2, 3);
        System.out.println("Resultado: " + resultado4);
    }
}

Saída esperada:

Somando dois inteiros
Resultado: 8
Somando dois doubles
Resultado: 6.2
Concatenando strings
Resultado:Olá, Mundo!
Somando três inteiros
Resultado: 6

Principais Diferenças

Uma prática recomendada é utilizar a anotação @Override ao sobrescrever métodos. Isso previne erros comuns, como digitar incorretamente o nome do método ou alterar a assinatura por engano, fazendo com que o compilador informe imediatamente o problema.

Referência: Thinking in Java — Bruce Eckel