O Peter explicou bem a idéia, vamos reforçar alguns pontos:
Uma referência de um determinado tipo (ex: Pessoa) pode apontar para
qualquer objeto que seja da classe Pessoa ou de alguma subclasse dela (ex:
Aluno, Professor):
Pessoa p1 = new Pessoa();
Pessoa p2 = new Aluno();
Pessoa p3 = new Professor();
E, em tempo de execução, podemos fazer qualquer dessas variaveis passar a
apontar para outro objeto, desde que seja Pessoa ou subclasse dela:
Ex: p2 = p1; // etc.
A única coisa que podemos garantir, a qualquer tempo, quando enviamos uma
mensagem a um objeto através de uma referência do tipo Pessoa, é que esse
objeto é capaz de responder ao protocolo de Pessoa.
Não podemos fazer algo como:
p2.getDre();
Porque nada nos garante que p2 estará apontando sempre para um Aluno.
Mas sempre poderemos fazer, com a certeza de que funcionará, algo assim:
p2.getNome();
Porque getNome() é um método definido em Pessoa, portanto herdado ou
modificado nas subclasses.
Alguém dirá: mas EU SEI que no meu programa, na hora que eu for fazer
p2.getDre(), p2 estará apontando para um Aluno, porque fui eu quem fiz isso
em uma linha anterior. Porque não compila?
A resposta é que o compilador não faz uma análise do seu código para checar
isso, senão a compilação levaria séculos. Mas ele aceita que você diga:
"Pode compilar, que eu garanto que vai funcionar". Para dizer isso ao
compilador, você precisa fazer uma coerção do tipo da referência (ou
casting, em inglês):
( (Aluno)p2).getDre();
ou, se preferir mais clareza:
Aluno alu = (Aluno) p2;
alu.getDre();
Aí o compilador não reclama mais.
Com interfaces, ocorre uma situação similar.
Assuma que Pessoa implementa a interface Comparable<Pessoa>. Nesse caso, é
como se Pessoa (e, por extensão, também Aluno e Professor) também herdassem
o método dessa interface. Na realidade Pessoa apenas herda a obrigação de
implementar esse método, mas na prática isso significa que podemos garantir
que Profesor, Aluno, e Data sempre responderão à mensagem compareTo(Pessoa
p).
Podemos fazer então:
Comparable<Pessoa> comp1 = new Aluno();
Comparable<Pessoa> comp2 = new Professor();
A única coisa que podemos garantir de uma variável tipo Comparable<Pessoa> é
que ela pode apontar para objetos que a implementam, mais nada.
Portanto, escrever comp1.getDre() dará erro de compilação, porque nada
impede que você tenha feito antes:
comp1 = comp2;
e, nesse caso, comp1 agora estaria apontando para um Professor, que não sabe
o que é getDre() !
Mas sempre poderemos escrever:
Pessoa p = new Pessoa(.....);
comp1.compareTo(p);
É isso aí...
Jonathan
2008/9/22 Zaedy Sayão <[EMAIL PROTECTED]>
> Eu cansei de falar isso na monitoria de hj....
> Eh bom q vc nao tenha ido, senao eu vou te matar...xD
>
> Mas isso eh meio complicado por email.
> Se me achar amanha antes do teste te explico pessoalmente...
>
> []s
>
> 2008/9/22 Peter <[EMAIL PROTECTED]>
>
> Vou me aventurar... vamos ver se consigo ajudar:
>>
>> Imagine uma variável do tipo int.
>> Ele só pode apontar para valores tipo int.
>> Logo, só vai poder participar de operações que estejam definidas para o
>> tipo int.
>> Quando definimos uma classe ou uma interface, estamos definindo um tipo
>> também.
>>
>> Uma variável de um tipo de uma interface só pode participar de operações
>> válidas para aquela interface, ou seja, vc só vai conseguir chamar os
>> métodos declarados naquela interface (ou numa interface da qual ela tenha
>> herdado).
>> Isso pq esta variável estará apontando para uma classe qualquer da qual a
>> única coisa que vc pode garantir é que ela implementa aqueles métodos. Logo,
>> vc só poderá chamar aqueles métodos, independe da classe da instância
>> apontada por aquela referência.
>>
>> O mesmo serve para classes abstratas E concretas. Se uma referência de um
>> tipo de uma classe X aponta para uma instância de uma subclasse Y, vc só
>> poderá chamar métodos da classe X e das superclasses dela, não conseguirá
>> acessar os métodos exclusivos da subclasse Y.
>>
>> Isto garante tipagem da linguagem. Java é uma linguagem fortemente tipada.
>>
>> Espero ter conseguido ajudar. Se vc tiver dúvidas, pode me ligar até 21:00
>> ou aparecer no msn, icq, google talk, skype, sinal de fumaça, etc, etc...
>>
>> Abraço!
>>
>> Peter P. Lupo
>> Undergraduating in Computer Science DCC/UFRJ
>> Sun Certified Java Associatehttp://pplupo.googlepages.com/
>> Cell. +55 (21) 81742487
>>
>>
>>
>> Flavio Costa wrote:
>>
>> Meio dificil explicar isso via e-mail.
>> Acho que essa dúvida deveria ser sanada pessoalmente com os monitores ou o
>> professor.
>>
>> 2008/9/22 FernandoKling <[EMAIL PROTECTED]>
>>
>>>
>>> se eu entendi bem, a dúvida do gustavo é em relaçao à variaveis cujo
>>> tipo sao interfaces ou classes abstratas
>>> tipo o trecho de código q tinha no teste 1:
>>> M x = new A();
>>> onde M podia ser uma interface...
>>>
>>> On 22 set, 19:27, Gustavo Cury <[EMAIL PROTECTED]> wrote:
>>> > Sobre esta dúvida: "Uso correto de variáveis do tipo de uma interface
>>> ou do tipo de uma classe abstrata"
>>> > Está na pagina do professor, fui olhando os tópicos e quando chegou
>>> nesse, não entendi.
>>> > Gustavo Cury
>>> >
>>>
>>>
>>>
>>
>>
>> --
>> Flávio Coutinho da Costa
>>
>>
>>
>>
>>
>
>
> --
> Zaedy Dantas Sayão
> Graduando em Ciência da Computação DCC/UFRJ
> http://www.manufato.com.br/
> MSN: [EMAIL PROTECTED]
>
> >
>
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "Comp
2 - Geral" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/comp2-geral?hl=en
-~----------~----~----~----~------~----~------~--~---
