Вы находитесь на странице: 1из 33

Java 2 Standard Edition

Interfaces e
polimorfismo
Helder da Rocha (helder@acm.org) argonavis.com.br1
O que é polimorfismo

ƒ Polimorfismo (poli=muitos, morfo=forma) é uma


característica essencial de linguagens orientadas a
objeto
ƒ Como funciona?
ƒ Um objeto que faz papel de interface serve de
intermediário fixo entre o programa-cliente e os objetos
que irão executar as mensagens recebidas
ƒ O programa-cliente não precisa saber da existência dos
outros objetos
ƒ Objetos podem ser substituídos sem que os programas
que usam a interface sejam afetados

2
Objetos substituíveis

ƒ Polimorfismo significa que um objeto pode ser usado


no lugar de outro objeto
• Uma interface
Usuário do objeto • Múltiplas implementações
enxerga somente esta interface

freia() Onibus
acelera() Veiculo
vira(1) freia() Jipe Subclasses
acelera() de Veiculo!
vira(direcao) Jegue (herdam
todos os
Aviao métodos)
Por exemplo: objeto do tipo Manobrista
sabe usar comandos básicos para controlar Usuário de Veiculo
Veiculo (não interessa a ele saber como ignora existência desses
cada Veiculo diferente vai acelerar, frear objetos substituíveis
ou mudar de direção). Se outro objeto tiver
a mesma interface, Manobrista saberá usá-lo
3
Programas extensíveis
ƒ Novos objetos podem ser usados em programas que não
previam a sua existência
ƒ Garantia que métodos da interface existem nas classes novas
ƒ Objetos de novas classes podem ser criados e usados (programa pode
ser estendido durante a execução)
...
Veiculo Jipe
freia() freia() LandRover
acelera() acelera()
vira(0) vira(direcao) AirBus LandRover

Concorde
Mesmo nome. Aviao
Implementações Veiculo v1 = new Veiculo();
diferentes. Veiculo v2 = new Aviao();
Veiculo v3 = new Airbus();
v1.acelera(); // acelera Veiculo Concorde AirBus
v2.acelera(); // acelera Aviao
v3.acelera(); // acelera AirBus
4
Interface vs. implementação
Estabelece uma
ƒ Polimorfismo permite separar a interface comum
interface da implementação
ƒ A classe base define a interface Veiculo
freia() {}
comum acelera() {}
ƒ Não precisa dizer como isto vai ser feito vira(dir) {}
Não diz: eu sei como frear um Carro ou
um Ônibus
ƒ Diz apenas que os métodos existem, que
eles retornam determinados tipos de
dados e que requerem certos parâmetros Onibus Carro
Diz: Veiculo pode acelerar, frear e virar freia() {} freia() {}
para uma direção, mas a direção deve ser acelera() {} acelera() {}
vira(dir) {} vira(dir) {}
fornecida
Implementações
da interface
(dizem como fazer)
5
Como funciona

ƒ Suporte a polimorfismo depende do suporte à ligação


tardia (late binding) de chamadas de função
ƒ A referência (interface) é conhecida em tempo de
compilação mas o objeto a que ela aponta
(implementação) não é
ƒ O objeto pode ser da mesma classe ou de uma subclasse
da referência (garante que a TODA a interface está
implementada no objeto)
ƒ Uma única referência, pode ser ligada, durante a
execução, a vários objetos diferentes (a referência é
polimorfa: pode assumir muitas formas)

6
Ligação de chamadas de função

ƒ Em tempo de compilação (early binding) - C!


não pode
chamada 1 função() 0xff52 haver
endereço 0xff52 Código polimorfismo
..
. fixo! da pois código
função está sempre
função() ligado à
chamada 2 0xff52 .. chamada da
. função

ƒ Em tempo de execução (late binding) - Java!


v.freia() 0xff52 existe
chamada 1 ??? Carro polimorfismo
.. mecanismo freia() pois cada
. que faz a chamada
ligação poderá causar
v.freia()
0cff99 Onibus execução de
chamada 2 ???
freia() código
ligação entre diferente
dependem do referência e objeto
objeto ao qual a durante a execução
referência atual aponta
7
Exemplo (1)
Manobrista manda
ƒ Considere a mensagens para
Veiculo
hierarquia de
classes ao lado Veiculo Manobrista
usa
freia() {...} estaciona
acelera() {...} (Veiculo v) {...}
vira(direcao) {...}

herdam interface
Herdam interface
mas sobrepõem
Jegue implementação
LandRover
(cada objeto
executa o método
freia() {...} freia() {...}
de forma particular)
acelera() {...} acelera() {...}
vira(direcao) {...} vira(direcao) {...}

8
Exemplo (2)
Trecho de programa que usa Manobrista: Manobrista usa a classe
Em tempo de execução passa implementação de Veiculo (e ignora a existência
Jegue e LandRover no lugar da implementação de tipos específicos de Veiculo
original de Veiculo como Jegue e LandRover
(aproveita apenas a interface de Veiculo)

Veiculo Manobrista
(...)
(...)
Manobrista
Manobrista mano
mano freia() {...}
== new
new Manobrista (); acelera() {...}
Manobrista ();
vira(direcao) {...}

Veiculo
Veiculo v1
v1 == new
new Jegue();
Jegue();
Veiculo
Veiculo v2
v2 == new
new LandRover();
LandRover(); herdam interface

mano.estaciona(v1);
mano.estaciona(v1); public void
estaciona (Veiculo v) {
mano.estaciona(v2);
mano.estaciona(v2); Jegue freia() {...}
LandRover ...
acelera() {...} v.freia();
(...)
(...) ...
vira(direcao) {...}
freia() {...} freia() {...} }
acelera() {...} acelera() {...}
vira(direcao) {...} vira(direcao) {...}
9
Detalhes (1) Manobrista
public void
estaciona (Veiculo v) {
...
Pilha (referências) Heap (objetos) v.freia();
...
03b7 }
Veiculo v1 0xffa903b7 Jegue

freia() {/* J */}


acelera() {/* J */}
Veiculo v2 0xffa96f55 vira() {/* J */}
Qual freia() será
6f55 LandRover executado quando
o trecho abaixo
null freia() {/* R */} for executado?
Veiculo v
acelera() {/* R */} (...)
vira() {/* R */} Veiculo v1 =
(referência local
do método estaciona) a22c new Jegue();
Veiculo
mano.estaciona(v1);

Endereços (hipotéticos) freia() {/* V */} (...)


recebidos durante a acelera() {/* V */}
execução (inaccessíveis ao vira() {/* V */} ( mano é do tipo
programador) ...
Manobrista )

10
Como funciona (3) Manobrista
public void
estaciona (Veiculo v) {
...
v.freia();
...
03b7 }
Veiculo v1 0xffa903b7 Jegue

freia() {/* J */} Na chamada abaixo,


acelera() {/* J */} Veiculo foi "substituído"
Veiculo v2 0xffa96f55 vira() {/* J */} com Jegue.
A implementação
6f55 LandRover usada foi Jegue.freia()

Veiculo v 0xffa903b7 freia() {/* R */} (...)


acelera() {/* R */} Veiculo v1 =
vira() {/* R */} new Jegue();
mano.estaciona(v1);
Referência de v1 foi a22c
Veiculo (...)
copiada para referência
local v do método freia() {/* V */} Veiculo v = v1
Manobrista.estaciona() acelera() {/* V */}
vira() {/* V */}
Nos trechos de código Argumento do
...
mostrados, este objeto método estaciona()
nunca chegou a ser criado 11
Conceitos abstratos
ƒ Como deve ser implementado freia() na classe Veiculo?
ƒ Faz sentido dizer como um veículo genérico deve frear?
ƒ Como garantir que cada tipo específico de veículo redefina a
implementação de freia()?
ƒ O método freia() é um procedimento abstrato em Veiculo
ƒ Deve ser usada apenas a implementação das subclasses
ƒ E se não houver subclasses?
ƒ Como freia um Veiculo genérico?
ƒ Com que se parece um Veiculo generico?
ƒ Conclusão: não há como construir objetos do tipo Veiculo
ƒ É um conceito genérico demais
ƒ Mas é ótimo como interface! Eu posso saber dirigir um Veiculo sem
precisar saber dos detalhes de sua implementação

12
Métodos e classes abstratos

ƒ Procedimentos genéricos que têm a finalidade de


servir apenas de interface são métodos abstratos
ƒ declarados com o modificador abstract
ƒ não têm corpo {}. Declaração termina em ";"
public abstract void freia();
public abstract float velocidade();
ƒ Métodos abstratos não podem ser usados, apenas
declarados
ƒ São usados através de uma subclasse que os implemente!

13
Classes abstratas

ƒ Uma classe pode ter métodos concretos e abstratos


ƒ Se tiver um ou mais método abstrato, classe não pode ser
usada para criar objetos e precisa ter declaração
abstract
public abstract class Veiculo { ... }
ƒ Objetos do tipo Veiculo não podem ser criados
ƒ Subclasses de Veiculo podem ser criados desde que
implementem TODOS os métodos abstratos herdados
ƒ Se a implementação for parcial, a subclasse também terá
que ser declarada abstract

14
Classes abstratas (2)

ƒ Classes abstratas são criadas para serem estendidas


ƒ Podem ter
ƒ métodos concretos (usados através das subclasses)
ƒ campos de dados (memória é alocada na criação de
objetos pelas suas subclasses)
ƒ construtores (chamados via super() pelas subclasses)
ƒ Classes abstratas "puras"
ƒ não têm procedimentos no construtor (construtor vazio)
ƒ não têm campos de dados (a não ser constantes
estáticas)
ƒ todos os métodos são abstratos
ƒ Classes abstratas "puras" podem ser definidas como
"interfaces" para maior flexibilidade de uso
15
Template Method design pattern
Classe
Algoritmos resultantes
void concreto() { Algoritmo
Classe x =
new ClasseConcretaUm()
um() x.concreto()
Template
Method três()

dois()
}

abstract void um(); Métodos


abstract int dois();
abstratos
Classe x =
abstract Object tres();
new ClasseConcretaDois()
x.concreto()

ClasseConcretaUm ClasseConcretaDois

16
Template method: implementação
public abstract class Template {
public abstract String link(String texto, String url);
public String transform(String texto) { return texto; }

public String templateMethod() {


String msg = "Endereço: " + link("Empresa", "http://www.empresa.com");
return transform(msg);
}

public class HTMLData extends Template {


public String link(String texto, String url) {
return "<a href='"+url+"'>"+texto+"</a>";
}
public String transform(String texto) {
return texto.toLowerCase();
}
}

public class XMLData extends Template {


public String link(String texto, String url) {
return "<endereco xlink:href='"+url+"'>"+texto+"</endereco>";
}
} 17
Exercício

ƒ 1. Crie um novo projeto


ƒ Copie um build.xml genérico
ƒ 2. Implemente os exemplos da aula:
ƒ Manobrista, Veiculo, Jegue e LandRover
ƒ a) Implemente os métodos com instruções de impressão,
por exemplo:
public void freia() {
System.out.println("Chamou Jegue.freia()");
}
ƒ b) Faça com que os métodos de Veiculo sejam abstratos e
refaça o exercício

18
Upcasting

ƒ Tipos genéricos (acima, na hierarquia) sempre


podem receber objetos de suas subclasses:
upcasting
Veiculo v = new Carro();
ƒ Há garantia que subclasses possuem pelo menos os
mesmos métodos que a classe
ƒ v só tem acesso à "parte Veiculo" de Carro. Qualquer
extensão (métodos definidos em Carro) não faz parte da
extensão e não pode ser usada pela referência v.

19
Downcasting

ƒ Tipos específicos (abaixo, na hierarquia) não podem


receber explicitamente seus objetos que foram
declarados como referências de suas superclasses:
downcasting
Carro c = v; // não compila!
ƒ O código acima não compila, apesar de v apontar para
um Carro! É preciso converter a referência:
Carro c = (Carro) v;
ƒ E se v for Onibus e não Carro?

20
Upcasting e downcasting
• Upcasting • Downcasting
– sobe a hierarquia métodos visíveis – desce a hierarquia
– não requer cast na referência v – requer operador de cast
Veiculo v = new Jegue(); Jegue j = (Jegue) v;

Veiculo
freia()
j freia()
acelera()
Veiculo
freia()
acelera() vira() acelera()
vira(direcao) corre() vira(direcao)
v morde()

Jegue LandRover Jegue LandRover


acelera() diesel() acelera() diesel()
vira(direcao) tracao(tipo) métodos visíveis corre() tracao(tipo)
corre(); na referência j morde()

21
ClassCastException
ƒ O downcasting explícito sempre é aceito pelo compilador se
o tipo da direita for superclasse do tipo da esquerda
Veiculo v = new Onibus();
Carro c = (Carro) v; // passa na compilação
ƒ Object, portanto, pode ser atribuída a qualquer tipo de referência
ƒ Em tempo de execução, a referência terá que ser ligada ao
objeto
ƒ Incompatibilidade provocará ClassCastException
ƒ Para evitar a exceção, use instanceof
if (v instanceof Carro)
c = (Carro) v;

22
Herança Pura vs. Extensão
• Herança pura: referência têm • Extensão: referência apenas tem
acesso a todo o objeto acesso à parte definida na
interface da classe base
Veiculo
freia() Veiculo
acelera()
Referência Veiculo freia()
vira(direcao)
acelera()
não enxerga estes vira(direcao)
métodos

Jegue LandRover
freia() freia() Jegue LandRover
acelera() acelera()
freia() freia()
vira(direcao) vira(direcao)
acelera() acelera()
vira(direcao) vira(direcao)
Veiculo v = new Jegue(); corre() diesel()
v.freia() // freia o Jegue morde() tracao(tipo)
v.acelera(); // acelera o Jegue
Veiculo v = new Jegue();
v.corre() // ERRADO!
v.acelera(); //OK
23
Ampliação da referência
ƒ Uma referência pode apontar para uma classe estendida, mas
só pode usar métodos e campos de sua interface Object
ƒ Para ter acesso total ao objeto que estende a interface equals()
original, é preciso usar referência que conheça toda sua
interface pública ERRADO: raio não faz parte da
Circulo
ƒ Exemplo interface de Object
raio
equals()
class
class Circulo
Circulo extends
extends Object
Object {{
public
public int int raio;
raio; class
class Circulo
Circulo extends
extends Object
Object {{
public
public boolean
boolean equals(Object
equals(Object obj)
obj) {{ public
public int int raio;
raio;
ifif (this.raio
(this.raio ==
== obj.raio)
obj.raio) public
public booleanboolean equals(Object
equals(Object obj)obj) {{
return
return true;
true; ifif (obj
(obj instanceof
instanceof Circulo)
Circulo) {{
verifica se obj Circulo
return
return false;
false; Circulo kk = = (Circulo)
(Circulo) obj;
obj;
}} realmente ifif (this.raio
(this.raio ==
== k.raio)
k.raio)
}} //// CÓDIGO
CÓDIGO ERRADO! ERRADO! é um Circulo return
return true;
true;
}}
cria nova referência return
return false; false;
que tem acesso a toda Como k é Circulo
}}
a interface de Circulo possui raio
}}
24
Interfaces Java

ƒ Interface é uma estrutura que representa uma classe


abstrata "pura" em Java
ƒ Não têm atributos de dados (só pode ter constantes
estáticas)
ƒ Não tem construtor
ƒ Todos os métodos são abstratos
ƒ Não é declarada como class, mas como interface
ƒ Interfaces Java servem para fornecer polimorfismo sem
herança
ƒ Uma classe pode "herdar" a interface (assinaturas dos
métodos) de várias interfaces Java, mas apenas de uma
classe
ƒ Interfaces, portanto, oferecem um tipo de herança múltipla
25
Herança múltipla em C++

ƒ Em linguagens como C++, uma classe pode herdar


métodos de duas ou mais classes
ƒ A classe resultante pode ser usada no lugar das suas duas
superclasses via upcasting
ƒ Vantagem de herança múltipla: mais flexibilidade
ƒ Problema
ƒ Se duas classes A e B estenderem uma mesma classe Z e
herdarem um método x() e, uma classe C herdar de A e
de B, qual será a implementação de x() que C deve usar?
A de A ou de B?
ƒ Desvantagem de herança múltipla: ambigüidade. Requer
código mais complexo para evitar problemas desse tipo

26
Herança múltipla em Java
ƒ Classe resultante combina todas as interfaces, mas só possui
uma implementação: a da classe base <<interface>>
Empregado
<<interface>> <<interface>>
Animal Cidadao Contribuinte trabalha()
come() vota() pagaIR()
respira() getRG() getCPF() <<interface>>
Professor
ensina()

come()
respira() Este objeto pode ser usado
Pessoa ensina() em qualquer lugar onde
vota() for aceito um Animal, um
ensina() getRG()
vota() Professor, um Cidadao, um
trabalha()
getRG() pagaIR() Empregado, um Contribuinte,
trabalha() getCPF() um java.lang.Object
pagaIR() equals()
getCPF() toString()
... 27
Exemplo

interface Empregado { • Todos os métodos são


void trabalha(); implicitamente
}
– public
interface Cidadao { – abstract
void vota();
int getRG(); • Quaisquer campos de dados
} têm que ser inicializadas e
são implicitamente
interface Professor
extends Empregado { – static
void ensina(); – final (constantes)
}
• Indicar public, static, abstract
interface Contribuinte { e final é opcional
boolean pagaIR();
long getCPF(); • Interface pode ser declarada
} public (default: package-private)
28
Exemplo (2)
public class Pessoa
extends Animal
implements Professor, Cidadao, Contribuinte {

public void ensina() { /* votar */ }


public void vota() { /* votar */ }
public int getRG(){ return 12345; }
public void trabalha() {}
public boolean pagaIR() { return false; }
public long getCPF() { return 1234567890; }
}

• Palavra implements declara interfaces implementadas


– Exige que cada um dos métodos de cada interface sejam de fato
implementados (na classe atual ou em alguma superclasse)
– Se alguma implementação estiver faltando, classe só compila se for
declarada abstract
29
Uso de interfaces
public class Cidade {
public void contrata(Professor p) {
p.ensina();
p.trabalha();
}
public void contrata(Empregado e) { e.trabalha();}
public void cobraDe(Contribuinte c) { c.pagaIR();}
public void registra(Cidadao c) { c.getRG();}
public void alimenta(Animal a) { a.come();}
public static void main (String[] args) {
Pessoa joao = new Pessoa();
Cidade sp = new Cidade();
sp.contrata(joao); // considera Professor
sp.contrata((Empregado)joao); // Empregado
sp.cobraDe(joao); // considera Contribuinte
sp.registra(joao); // considera Cidadao
sp.alimenta(joao); // considera Animal
}
}
30
Conclusão

ƒ Use interfaces sempre que possível


ƒ Seu código será mais reutilizável!
ƒ Classes que já herdam de outra classe podem ser
facilmente redesenhadas para implementar uma interface
sem quebrar código existente que a utilize
ƒ Planeje suas interfaces com muito cuidado
ƒ É mais fácil evoluir classes concretas que interfaces
ƒ Não é possível acrescentar métodos a uma interface
depois que ela já estiver em uso (as classes que a
implementam não compilarão mais!)
ƒ Quando a evolução for mais importante que a
flexibilidade oferecido pelas interfaces, deve-se usar
classes abstratas.
31
Exercícios

1. Implemente e execute o exemplo mostrado


ƒ Coloque texto em cada método (um println() para mostrar
que o método foi chamado e descrever o que aconteceu)
ƒ Faça experimentos deixando de implementar certos
métodos para ver as mensagens de erro obtidas
2. Implemente o exercício do capítulo 9 com interfaces
ƒ Mude o nome de RepositorioDados para
RepositorioDadosMemoria
ƒ Crie uma interface RepositorioDados implementada por
RepositorioDadosMemoria
ƒ Altere a linha em que o RepositorioDados é construido na
classe Biblioteca e teste a aplicação.

32
Curso J100: Java 2 Standard Edition
Revisão 17.0

© 1996-2003, Helder da Rocha


(helder@acm.org)

argonavis.com.br
33

Оценить