Polimorfismo estático - compilação

Introdução

• polimorfismo estático / polimorfismo de compilação / sobrecarga de métodos = ocorre quando o compilador é capaz de determinar, durante a compilação, qual método será invocado
• caracterizado pela sobrecarga de métodos / overloading
• esse tipo de polimorfismo se refere a quando uma classe tem múltiplos métodos com o mesmo nome, mas com assinaturas diferentes, como parâmetros diferentes em tipo ou número
• o compilador escolhe qual versão do método chamar com base na correspondência de tipos no momento da compilação
• este tipo de polimorfismo melhora a legibilidade e a flexibilidade do código
  • permite que os desenvolvedores usem o mesmo nome de método para ações relacionadas, mas com diferentes tipos de entradas

// Polimorfismo estático
public class Calculadora {

    // 3 versões para o método somar

    // método para somar dois números inteiros
    public int somar(int a, int b) {
        return a + b;
    }

    // método para somar três números inteiros
    public int somar(int a, int b, int c) {
        return a + b + c;
    }

    // método para somar dois números de ponto flutuante
    public double somar(double a, double b) {
        return a + b;
    }
}

• no exemplo, quando o método somar for chamado em uma instância de Calculadora, o compilador escolherá a versão correta do método a ser invocada com base nos parâmetros passados para o método

public class Main {
    public static void main(String[] args) {
        Calculadora calc = new Calculadora();

        // chama o método que soma dois números inteiros
        System.out.println(calc.somar(5, 10)); // saída: 15

        // chama o método que soma três números inteiros
        System.out.println(calc.somar(5, 10, 15)); // saída: 30

        // chama o método que soma dois números de ponto flutuante
        System.out.println(calc.somar(5.5, 10.5)); // saída: 16.0
    }
}

Regras para criar métodos sobrecarregados

• assinatura diferente = para que o método seja considerado sobrecarregado, a assinatura - nome e parâmetros - deve ser diferente. Isso pode incluir:
  • diferente número de parâmetros
  • diferente tipo de parâmetros
  • diferente ordem dos parâmetros

public class Exemplo {

    // Método válido: diferente número de parâmetros
    public void metodo(int a) { }

    // Método válido: tipo de parâmetro diferente
    public void metodo(String a) { }

    // Método inválido: assinatura idêntica ao anterior
    public void metodo(int b) { } // Erro, já existe um método com a mesma assinatura
}

• tipo de retorno não conta = o tipo de retorno não é considerado parte da assinatura do método
• por isso, não é possível sobrecarregar métodos apenas alterando o tipo de retorno

public class Exemplo {
    // método válido
    public int somar(int a, int b) { return a + b; }

    // erro: tentativa de sobrecarga apenas com tipo de retorno diferente
    public double somar(int a, int b) { return a + b; } // Erro: assinatura igual
}

Exercícios

Questões

1. Polimorfismo estático ocorre quando o método a ser chamado é resolvido em tempo de compilação.
2. No polimorfismo estático, a resolução do método a ser invocado depende do tipo do objeto em tempo de execução.
3. A sobrecarga de métodos é um exemplo de polimorfismo estático.
4. O polimorfismo estático permite que dois métodos com o mesmo nome tenham diferentes tipos de parâmetros ou número de parâmetros.
5. Em polimorfismo estático, a escolha do método a ser invocado é feita com base no tipo da variável em tempo de execução, e não na assinatura do método.
6. O polimorfismo estático ocorre apenas com métodos que possuem a anotação @Override.
7. Em polimorfismo estático, o compilador escolhe qual método chamar com base no número e tipo de parâmetros passados na invocação.
8. O polimorfismo estático é mais flexível que o polimorfismo dinâmico, pois permite mais de uma assinatura de método com o mesmo nome.
9. A sobrecarga de métodos é uma característica do polimorfismo dinâmico, pois o método correto é escolhido em tempo de execução.
10. No polimorfismo estático, os métodos sobrecarregados devem ter a mesma assinatura, isto é, tipo ou número de parâmetros.

Gabarito

1. Verdadeiro: polimorfismo estático ocorre quando o método é resolvido em tempo de compilação. A resolução é feita com base na assinatura do método, ou seja, no número e tipo dos parâmetros.
2. Falso: no polimorfismo estático, a resolução do método é feita em tempo de compilação, e não em tempo de execução. O tipo do objeto não é o que determina qual método será chamado nesse caso.
3. Verdadeiro: a sobrecarga de métodos (ter métodos com o mesmo nome, mas com diferentes parâmetros) é um exemplo clássico de polimorfismo estático, pois o método correto é resolvido em tempo de compilação, dependendo da assinatura.
4. Verdadeiro: o polimorfismo estático permite que dois métodos tenham o mesmo nome, mas uma diferença em seus tipos de parâmetros ou no número de parâmetros. Isso é uma característica da sobrecarga de métodos.
5. Falso: no polimorfismo estático, a escolha do método é feita em tempo de compilação, com base na assinatura do método (número e tipo de parâmetros), e não com base no tipo do objeto em tempo de execução.
6. Falso: o polimorfismo estático não está relacionado à anotação @Override. A anotação é usada no polimorfismo dinâmico (sobrescrita de métodos), onde o método é resolvido em tempo de execução.
7. Verdadeiro: no polimorfismo estático, o compilador escolhe qual método chamar com base no número e tipo de parâmetros passados na invocação. Isso é chamado de sobrecarga de métodos.
8. Falso: o polimorfismo estático não é necessariamente mais flexível que o polimorfismo dinâmico. O polimorfismo dinâmico, ao contrário, permite a substituição de métodos em tempo de execução, o que dá mais flexibilidade em muitos cenários.
9. Falso: a sobrecarga de métodos é uma característica do polimorfismo estático, pois é resolvida em tempo de compilação. O polimorfismo dinâmico envolve sobrescrita de métodos, resolvida em tempo de execução.
10. Falso: no polimorfismo estático (sobrecarga de métodos), os métodos devem ter o mesmo nome, mas diferentes assinaturas (tipos ou número de parâmetros). Isso permite que o compilador escolha o método correto.