Polimorfismo - Revisão¶

Sobrecarga¶

sobrecarga = métodos com mesmo nome, normalmente mesmo tipo de retorno, listas de parâmetros diferentes - na mesma classe ou hierarquia

class A {
  int boo(int a, int b){
  }

  int foo(double x){
  }
}

class B {
    private int a;
    private string b;

    B (int a){
        this.x = a; // this(a, NULL);
    }
    B (int a, string b){
        // this.b = a; // -> this(a);
        // this.b = b;
    }
}

this = coringa
- com . = atributos e métodos
- com () = construtor
"match" de uma chamada a um método que possui homônimos sobrecarregados
- pelos tipos de sequências de parâmetros
- em tempo de compilação
- ligação estática = static binding
na prática, Java considera que métodos sobrecarregados são métodos diferentes
na hora que se compila, o compilador gera métodos diferentes, inclusive com identificadores/endereços diferentes

Princípio da Substituição¶

um filho pode ser "visto" como um pai

principio_substituicao.java

// quem define o que será visto é o tipo da variável
A a = new (C);
B b = new (C);

quem define o que será visto é o tipo da variável
consequências do princípio da substituição
variável vira um coringa
se uma rotina/método qualquer só usa coisas de a, este método único pode servir a todos os tipos de objetos filhos de a

void Boo(A a){
 // só usa classes de A
 // recebe A, B, C, D

 // ou

}

passagem de parâmetro = atribuição

Conversão de Tipos¶

Conversão Implícita¶

compila quando
tipo da direita = igual/subtipo da esquerda

void Boo(A a){
 <code>
 if (a instanceof b){
 }
}

instanceof
- operador
- palavra reservada da linguagem
- testa se o tipo do objeto referenciado pela variável da esquerda é igual ou subtipo do objeto da direita
alteração da projeção de um objeto através de uma nova variável
- quando se chega à conclusão de que um objeto é compatível, é possível alterar a projeção do objeto através de uma nova variável
- o nome dessa operação é conversão explícita

Conversão Explícita - Casting¶

regras de funcionamento
compilar - condições cumulativas
- tipo do casting é igual ou subtipo do tipo da variável de destino
- tipo do casting e tipo da variável de origem estão na mesma hierarquia
executar - condições cumulativas
- compilar
- tipo do casting igual ou supertipo do tipo do objeto referenciado pela variável de origem

Resolução¶

primeiro passo
- desenhar hierarquia
- na conversão implícita, não é preciso ter conhecimento do tipo de objeto referenciado
identificar hierarquia = apontar dedo para uma classe, percorrer uma linha para cima ou para baixo - se o percurso permitir identificar outra classe, essas classes estão na mesma hierarquia

// CONVERSÃO IMPLÍCITA
B b = new E(); // OK
D d = b; // X
E e = new E(); // OK
b = e; // OK
e = b; // X
F f = new A(); // X

// CONVERSÃO EXPLÍCITA
A a = new G();
D d  = new D();
B b = new F();
F f = (F) b; // compila e roda - (F) é igual/subtipo F, F e B na mesma hierarquia
G g = (D) a; // não compila - (D) não é subtipo/igual G
B b = (F) d; // não compila - (F) e D não estão na mesma hierarquia
E e = (E) b; // compila e não roda

Sobrescrita¶

métodos são sobrescritos quando têm a mesma assinatura em classes de uma mesma hierarquia e implementações diferentes

A a1 = new A();
A a2 = new B();
A a3 = new C();
A a4 = new D();

a1.x(p1, p2); // v1
a2.x(p1, p2); // v2
a3.x(p1, p2); // v2
a4.x(p1, p2); // v3

com a sobrescrita, se alcançam diferentes implementações para um único método definido do todo de uma mesma hierarquia
além dos recursos de A

Classes Abstratas e Interfaces¶

Classe Abstrata¶

característica principal = não pode ser instanciada
tem construtor
- serve para inicializar atributos e métodos
classe abstrata só não pode ser instanciada, mas pode
- ter construtor
- ter atributos
- ter métodos
- ter métodos abstratos
método abstrato = impõe comportamento polimórfico de sobrescrita em uma hierarquia
- para não permitir que se deixe de reimplementar o método, estabelecer padrões de comportamento
- primeira filha concreta deve implementar
- classes concretas não podem ter métodos abstratos
não existe atributo abstrato
classe abstrata resolve leque, falta de mecanismo que reflita, de fato, a realidade

Interface¶

interface = alternativa a herança múltipla
na prática, só pode ter métodos abstratos
não pode ter atributo
não pode ter construtor
não pode ter método concreto
eventualmente, atributo static file
relação entre classe e interface = implementação
- relação de herança declarada de uma forma alternativa através da palavra reservada implements
faz com que classes que já estejam numa hierarquia assumam características comuns
uma classe pode implementar quantas interfaces sejam convenientes
uma classe pode herdar de uma única classe e implementar várias interfaces
para implementar uma interface, não é preciso usar a palavra abstract, pois a interface já é abstrata por padrão