Herança - DEINF/UFMA

Programação Orientada a Objetos
C++
4 – Herança e Polimorfismo
Departamento de Informática
Prof. Anselmo C. de Paiva
Herança
• Como vimos anteriormente, classes podem ser
compostas em hierarquias, através do uso de
herança.
• Quando uma classe herda de outra, diz-se que
ela a estende ou a especializa, ou os dois.
• Herança implica tanto herança de interface
quanto herança de código.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
2
1
Objeto Poupança
Crédito
Saldo
Número
875,32
21.342-7
R. Juros
Débito
Estados do Objeto Poupança
creditar(20)
Creditar
Creditar
Crédito
Saldo
Saldo
Número
Número
875,32 21.342-7
875,32 21.342-7
Debitar
R. Juros
Saldo
Número
895,32
21.342-7
R. Juros
Debitar
Débito
2
Estados do Objeto Poupança
R. Juros(0.01)
Creditar
Saldo
Saldo
Creditar
Número
Número
R. Juros
875,32 21.342-7
875,32 21.342-7
Debitar
Debitar
Saldo
Número
884,07
21.342-7
R. Juros
Debitar
Débito
Classe de Poupanças: Assinatura
public class PoupancaD {
public PoupancaD (String n) {}
public void creditar(double valor) {}
public void debitar(double valor) {}
public String getNumero() {}
public double getSaldo() {}
public void renderJuros(double taxa) {}
}
3
Classe de Poupanças: Descrição
public class PoupancaD {
private String numero;
private double saldo;
public void creditar (double valor) {
saldo = saldo + valor;
} // ...
public void renderJuros(double taxa) {
this.creditar(saldo * taxa);
}
}
Classe de Bancos: Assinatura
public class BancoD {
public BancoD() {}
public void cadastrarConta(Conta c) {}
public void cadastrarPoupanca(PoupancaD p) {}
public void creditarConta(String numero,
double valor) {}
public void creditarPoupanca(String numero,
double valor) {}
// ...
}
4
Classe de Bancos: Descrição
public class BancoD {
private Conta[] contas;
private PoupancaD[] poupancas;
private int indiceP, indiceC;
public void cadastrarConta(Conta c) {
contas[indiceC] = c;
indiceC = indiceC + 1;
}
public void cadastrarPoupanca(PoupancaD p) {
poupancas[indiceP] = p;
indiceP = indiceP + 1;
}
5
private Conta procurarConta(String numero) {
int i = 0;
boolean achou = false;
Conta resposta = null;
while ((! achou) && (i < indiceC)) {
if (contas[i].getNumero().equals(numero))
achou = true;
else
i = i + 1;
}
if (achou) resposta = contas[i];
return resposta;
}
public void debitarConta(String numero,
double valor) {
Conta c;
c = this.procurarConta(numero);
if (c != null)
c.debitar(valor);
else
System.out.println(
"Conta inexistente!”
);
}
6
Problemas
• Duplicação desnecessária de código:
– a definição de PoupançaD é uma simples
extensão da definição de Conta
– clientes de Conta que precisam trabalhar
também com PoupançaD terão que ter código
especial para manipular poupanças
• Falta refletir relação entre tipos do “mundo
real”
Subtipos e Subclasses
Poupança
Conta
7
Herança
• Necessidade de extender classes
– alterar classes já existentes e adicionar
propriedades ou comportamentos para
representar outra classe de objetos
– criar uma hierarquia de classes que “herdam”
propriedades e comportamentos de outra classe
e definem novas propriedades e
comportamentos
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
15
Subclasses
• Comportamento
objetos da subclasse comportam-se
como
os objetos da superclasse
• Substituição
objetos da subclasse podem ser usados
no
lugar de objetos da superclasse
8
Herança
• Reuso de Código
a descrição da superclasse pode ser
usada para definir a subclasse
• Extensibilidade
algumas operações da superclasse
podem ser redefinidas na subclasse
Classe de Poupanças: Assinatura
public class Poupanca extends Conta {
public Poupanca (String numero) {}
public void renderJuros(double taxa) {}
}
9
Classe de Poupanças: Descrição
public class Poupanca extends Conta {
public Poupanca (String numero) {
super (numero);
}
public void renderJuros(double taxa) {
this.creditar(this.getSaldo()*taxa);
}
}
Extends
• subclasse extends superclasse
• Mecanismo para definição de herança e
subtipos
• Herança simples: só se pode herdar uma classe
por vez
10
Extends: Restrições
• Atributos e métodos privados são herdados,
mas não podem ser acessados diretamente
• Qualificador protected: visibilidade restrita
ao pacote e as subclasses de outros pacotes
• Construtores não são herdados
• Construtor default só é disponível se também
for disponível na superclasse
Usando Poupanças
...
Poupanca poupanca;
poupanca = new Poupanca(“21.342-7”);
poupanca.creditar(500.87);
poupanca.debitar(45.00);
System.out.println(poupanca.getSaldo());
...
11
Subtipos: Substituição
...
Conta conta;
conta = new Poupanca(“21.342-7”);
conta.creditar(500.87);
conta.debitar(45.00);
System.out.println(conta.getSaldo());
...
Subtipos: Verificação Dinâmica com
Casts
...
Conta conta;
conta = new Poupanca("21.342-7");
...
conta.renderJuros(0.01);
((Poupanca)
conta).renderJuros(0.01);
conta.imprimirSaldo();
...
12
Substituição e Casts
• Nos contextos onde contas são usadas, podemse usar poupanças
• Nos contextos onde poupanças são usadas,
podem-se usar contas com o uso explícito de
casts
• Casts correspondem à verificação dinâmica de
tipos e podem gerar exceções (Cuidado!)
• Casts não fazem conversão de tipos
Classe Banco: Assinatura
public class Banco {
public Banco () {}
public void cadastrar(Conta conta) {}
public void creditar(String numero,
double valor) {}
public void debitar(String numero,
double valor) {}
public double getSaldo(String numero) {}
public void transferir(String contaOrigem,
String contaDestino,
double valor) {}
}
13
Subtipos: Substituição
...
Banco banco = new Banco();
banco.cadastrar(new Conta("123-4"));
banco.cadastrar(new Poupanca(”567-8"));
banco.creditar(”123-4",129.34);
banco.transferir(”123-4",”567-8",9.34);
System.out.print(banco.getSaldo(”567-8"));
...
Exercício
• Modifique a classe Banco para que seja
possível render juros de uma poupança. Isto é,
adicione um novo método que rende os juros
da poupança cujo número é parâmetro deste
método; a taxa de juros corrente deve ser um
atributo de Banco.
14
Interface & Código
• Herança de interface significa que a classe que
herda recebe todos os métodos declarados pela
superclasse que não sejam privados.
• Herança de código significa que as
implementações desses métodos também são
herdadas. Além disso, os campos que não sejam
privados também são herdados.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
29
Visibilidade & Herança
Pelo que foi dito, membros públicos são
herdados, enquanto membros privados não são.
Às vezes precisamos algo intermediário: um
membro que não seja visto fora da classe mas que
possa ser herdado. As linguagens OO tipicamente
dão suporte a esse tipo de acesso.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
30
15
Mais Visibilidade em Java
• Java permite declararmos um membro que,
embora não seja acessível por outras classes, é
herdado por suas sub-classes.
• Para isso usamos o modificador de controle de
acesso protected.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
31
Resumo de Visibilidade em Java
• Resumindo todos os tipos de visibilidade:
– private: membros que são vistos só pelo própria
classe e não são herdados por nenhuma outra;
– package: membros que são vistos e herdados
pelas classes do pacote;
– protected: membros que são vistos pelas classes
do pacote e herdados por qualquer outra classe;
– public: membros são vistos e herdados por
qualquer classe.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
32
16
Herança de Membros
Pacote P1
A
B
int i;
int i;
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
33
Herança de Membros
Pacote P1
A
B
10/12/200
2
int i;
public int j;
int i;
public int j;
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
34
17
Herança de Membros
Pacote P1
A
B
int i;
public int j;
protected int k;
int i;
public int j;
protected int k;
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
35
Herança de Membros
Pacote P1
A
B
10/12/200
2
int i;
public int j;
protected int k;
private int l;
int i;
public int j;
protected int k;
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
36
18
Herança de Membros
Pacote P1
A
B
10/12/200
2
Pacote P2
P1.A
int i;
public int j;
protected int k;
private int l;
int i;
public int j;
protected int k;
C
public int j;
protected int k;
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
37
Herança em Java
• Quando uma classe A herda de B, diz-se que A é
a sub-classe e estende B, a superclasse.
• Uma classe Java estende apenas uma outra
classea essa restrição damos o nome de
herança simples.
• Para criar uma sub-classe, usamos a palavra
reservada extends.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
38
19
Exemplo de Herança
• Podemos criar uma classe que represente
um pixel a partir da classe Point. Afinal,
um pixel é um ponto colorido.
public class Pixel extends Point {
int color;
public Pixel(int x, int y, int c) {
super(x, y);
color = c;
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
39
Herança de Código
• A classe Pixel herda a interface e o código da
classe Point. Ou seja, Pixel passa a ter tanto os
campos quanto os métodos (com suas
implementações) de Point.
Pixel px = new Pixel(1,2,0); // Pixel de cor 0
px.move(1,0); // Agora px está em (2,2)
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
40
20
super
• Note que a primeira coisa que o construtor de
Pixel faz é chamar o construtor de Point, usando,
para isso, a palavra reservada super.
• Isso é necessário pois Pixel é uma extensão de
Point, ou seja, ela deve inicializar sua parte
Point antes de inicializar sua parte estendida.
• Se nós não chamássemos o construtor da
superclasse explicitamente, a linguagem Java
faria uma chamada ao construtor padrão da
superclasse automaticamente.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
41
Árvore × Floresta
• As linguagens OO podem adotar um modelo de
hierarquia em árvore ou em floresta.
• Árvore significa que uma única hierarquia
compreende todas as classes existentes, isto é,
existe uma superclasse comum a todas as
classes.
• Floresta significa que pode haver diversas
árvores de hierarquia que não se relacionam,
isto é, não existe uma superclasse comum a
todas as classes.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
42
21
Modelo de Java
• Java adota o modelo de árvore.
• A classe Object é a raiz da hierarquia de
classes à qual todas as classes existentes
pertencem.
• Quando não declaramos que uma classe
estende outra, ela, implicitamente, estende
Object.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
43
Superclasse Comum
• Uma das vantagens de termos uma superclasse
comum, é termos uma funcionalidade comum a
todos os objetos.
• Por exemplo, a classe Object define um método
chamado toString que retorna um texto
descritivo do objeto.
• Um outro exemplo é o método finalize usado na
destruição de um objeto, como já dito.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
44
22
Especialização × Extensão
• Uma classe pode herdar de outra para
especializá-la redefinindo métodos, sem
ampliar sua interface.
• Uma classe pode herdar de outra para estendêla declarando novos métodos e, dessa forma,
ampliando sua interface.
• Ou as duas coisas podem acontecer
simultaneamente...
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
45
Polimorfismo
• Polimorfismo é a capacidade de um objeto
tomar diversas formas.
• O capacidade polimórfica decorre diretamente
do mecanismo de herança.
• Ao estendermos ou especializarmos uma
classe, não perdemos compatibilidade com a
superclasse.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
46
23
Polimorfismo de Pixel
• A sub-classe de Point, Pixel, é compatível
com ela, ou seja, um pixel, além de outras
coisas, é um ponto.
• Isso implica que, sempre que precisarmos de
um ponto, podemos usar um pixel em seu
lugar.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
47
Exemplo de Polimorfismo
• Podemos querer criar um array de pontos.
O array de pontos poderá conter pixels:
Point[] pontos = new Point[5]; // um array de pontos
pontos[0] = new Point();
pontos[1] = new Pixel(1,2,0); // um pixel é um ponto
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
48
24
Mais sobre Polimorfismo
• Note que um pixel pode ser usado sempre que se
necessita um ponto. Porém, o contrário não é
verdade: não podemos usar um ponto quando
precisamos de um pixel.
Point pt = new Pixel(0,0,1); // OK! pixel é ponto.
Pixel px = new Point(0,0); // ERRO! ponto não é pixel.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
49
Conclusão
Polimorfismo é o nome formal para o fato de que
quando precisamos de um objeto de determinado
tipo, podemos usar uma versão mais
especializada dele. Esse fato pode ser bem
entendido analisando-se a árvore de hierarquia de
classes.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
50
25
Objetos Materiais
Animais
Vegetais
Mamíferos
Rosas
Humanos
Rosas da Maria
Dentistas
João
10/12/200
2
Floricultores
José
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
51
Ampliando o Exemplo
• Vamos aumentar a classe Point para fornecer
um método que imprima na tela uma
representação textual do ponto.
public class Point {
...
public void print() {
System.out.println(“Point (”+p.x+“,”+p.y+“)”);
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
52
26
Ampliando o Exemplo (cont.)
• Com essa modificação, tanto a classe Point
quanto a classe Pixel agora possuem um
método que imprime o ponto representado.
• Podemos voltar ao exemplo do array de pontos
e imprimir as posições preenchidas.
Point pt = new Point();
// ponto em (0,0)
Pixel px = new Pixel(0,0,0); // pixel em (0,0)
pt.print(); // Imprime: “Point (0,0)”
px.print(); // Imprime: “Point (0,0)”
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
53
Ampliando o Exemplo (cont.)
• Porém, a implementação desse método não é boa
para um pixel pois não imprime a cor.
• Vamos, então, redefinir o método em Pixel.
public class Pixel extends Point {
...
public void print() {
System.out.println(“Pixel (”+p.x+“,”+p.y+“,”+
p.color+“)”);
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
54
27
Ampliando o Exemplo (cont.)
• Com essa nova modificação, a classe
Pixel agora possui um método que
imprime o pixel de forma correta.
Point pt = new Point();
// ponto em (0,0)
Pixel px = new Pixel(0,0,0); // pixel em (0,0)
pt.print(); // Imprime: “Point (0,0)”
px.print(); // Imprime: “Pixel (0,0,0)”
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
55
Late Binding
Voltando ao exemplo do array de pontos, agora
que cada classe possui sua própria codificação
para o método print, o ideal é que, ao corrermos
o array imprimindo os pontos, as versões corretas
dos métodos fossem usadas. Isso realmente
acontece, pois as linguagens OO usam um
recurso chamado late binding.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
56
28
Late Binding na prática
• Graças a esse recurso, agora temos:
Point[] pontos = new Point[5];
pontos[0] = new Point();
pontos[1] = new Pixel(1,2,0);
pontos[0].print(); // Imprime: “Point (0,0)”
pontos[1].print(); // Imprime: “Pixel (1,2,0)”
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
57
Definição de Late Binding
Late Binding, como o nome sugere, é a capacidade
de adiar a resolução de um método até o momento
no qual ele deve ser efetivamente chamado. Ou
seja, a resolução do método acontecerá em tempo
de execução, ao invés de em tempo de compilação.
No momento da chamada, o método utilizado será o
definido pela classe real do objeto.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
58
29
Late Binding × Eficiência
O uso de late binding pode trazer perdas no
desempenho dos programas visto que a cada
chamada de método um processamento adicional
deve ser feito. Esse fato levou várias linguagens
OO a permitir a construção de métodos
constantes, ou seja, métodos cujas
implementações não podem ser redefinidas nas
sub-classes.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
59
Valores Constantes
• Java permite declarar um campo ou uma
variável local que, uma vez inicializada, tenha
seu valor fixo. Para isso utilizamos o
modificador final.
class A {
final int ERR_COD1 = -1;
final int ERR_COD2 = -2;
...
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
60
30
Métodos Constantes em Java
• Para criarmos um método constante em Java
devemos, também, usar o modificador final.
public class A {
public final int f() {
...
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
61
Classes Constantes em Java
• Uma classe inteira pode ser definida final.
Nesse caso, em particular, a classe não pode
ser estendida.
public final class A {
...
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
62
31
Conversão de Tipo
Como dito anteriormente, podemos usar uma
versão mais especializada quando precisamos de
um objeto de certo tipo mas o contrário não é
verdade. Por isso, se precisarmos fazer a
conversão de volta ao tipo mais especializado,
teremos que fazê-lo explicitamente.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
63
Type Casting
• A conversão explícita de um objeto de um tipo para
outro é chamada type casting.
Point pt = new Pixel(0,0,1); // OK! pixel é ponto.
Pixel px = (Pixel)pt; // OK! pt agora contém um pixel.
pt = new Point();
px = (Pixel)pt; // ERRO! pt agora contém um ponto.
pt = new Pixel(0,0,0);
px = pt; // ERRO! pt não é sempre um pixel.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
64
32
Mais Type Casting
Note que, assim como o late binding, o type
casting só pode ser resolvido em tempo de
execução: só quando o programa estiver rodando
é que poderemos saber o valor que uma dada
variável terá e, assim, poderemos decidir se a
conversão é válida ou não.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
65
Subtipos: Verificação Dinâmica com
instanceof
...
Conta c = this.procurar(”567-8");
if (c instanceof Poupanca)
((Poupanca) c).renderJuros(0.01);
else
System.out.print("Poupança inexistente!");
...
33
Verificação Dinâmica de Tipos
• Casts e instanceof:
– ((Tipo) variável)
– variável instanceof Tipo
– O tipo de variável deve ser supertipo de Tipo
– O Cast “((Tipo) variável)” gera uma exceção se
“variável instanceof Tipo” retornar false
– Casts são essenciais para verificação estática de
tipos (compilação)
Objeto Conta Especial
Crédito
Saldo
R. Bônus
Número
875,32
Bônus
21.342-7 11,60
Débito
34
Estados de uma Conta Especial
Crédito(20)
Crédito
Crédito
Crédito
Saldo
Saldo
R. Bônus
Número
Bônus
Número
R. Bônus
875,32 21.342-7 11,60
875,32 21.342-7
Saldo
Número
895,32
21.342-7
Bônus
11,80
Débito
Débito
Débito
Estados de uma Conta Especial
R. Bônus()
Crédito
Crédito
Crédito
Saldo
Saldo
R. Bônus
Número
Bônus
Número
875,32 21.342-7 11,80
875,32 21.342-7
Débito
R. Bônus
Saldo
Número
Bônus
887,12
21.342-7
0,00
Débito
Débito
35
Contas Especiais: Assinatura
public class ContaEspecial extends Conta {
public ContaEspecial(String numero) {}
public void renderBonus() {}
public double getBonus() {}
public void creditar(double valor) {}
}
Contas Especiais: Descrição
public class ContaEspecial extends Conta {
private double bonus;
public ContaEspecial(String numero) {
super (numero);
bonus = 0.0;
}
36
public void creditar(double valor) {
bonus = bonus + (valor * 0.01);
super.creditar(valor);
}
public void renderBonus() {
super.creditar(bonus);
bonus = 0;
}
public double getBonus() {
return bonus;
}
Redefinição de Métodos
• Preservação da assinatura: tipos dos
argumentos e resultados da redefinição têm
que ser iguais aos tipos da definição
• Semântica e Visibilidade dos métodos
redefinidos deve ser preservada
• Só é possível acessar a definição dos métodos
da superclasse imediata (via super)
37
Usando Contas Especiais
...
ContaEspecial contae;
contae = new ContaEspecial("21.342-7");
contae.creditar(200.00);
contae.debitar(100.00);
contae.renderBonus();
System.out.print(contae.getSaldo());
...
Ligações Dinâmicas
...
Conta conta;
conta = new ContaEspecial("21.342-7");
((Conta)conta).creditar(200.00);
conta.debitar(100.00);
((ContaEspecial) conta).renderBonus();
System.out.print(conta.getSaldo());
...
38
Ligações Dinâmicas
Conta conta;
conta = new ContaEspecial("21.342-7");
((Conta)conta).creditar(200.00);
“Como existe uma redefinição do método creditar na
classe ContaEspecial,o Cast serve para informar a Java
qual definição estamos interessados.”
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
77
Ligações Dinâmicas
Conta conta;
conta = new ContaEspecial("21.342-7");
conta.debitar(100.00);
“Já o método debitar só existe na classe Conta, então Java
acessa sua definição diretamente.”
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
78
39
Ligações Dinâmicas
Conta conta;
conta = new ContaEspecial("21.342-7");
((ContaEspecial) conta).renderBonus();
“Finalmente, o método renderBonus só existe na classe
ContaEspecial. Nesse caso, Java deve ser informado
através de um Cast onde localizar sua definição. Se isso
não for feito, uma exceção será gerada.”
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
79
Ligações Dinâmicas
• Dois métodos com o mesmo nome e tipo:
– definição e redefinição, qual usar?
• O código é escolhido dinamicamente (em
tempo de execução) e não estaticamente (em
tempo de compilação)
• Escolha se dá baseado na classe do objeto
associado à variável destino do método
40
Exercício
• Modifique a classe Banco para que seja
possível computar o bônus de uma conta
especial. Foi necessário redefinir algum
método de Banco? Justifique a sua resposta.
Classe Banco: Assinatura
public class Banco {
public Banco () {}
public void cadastrar(Conta conta) {}
public void creditar(String numero,
double valor) {}
public void debitar(String numero,
double valor) {}
public double getSaldo(String numero) {}
public void transferir(String contaOrigem,
String contaDestino,
double valor) {}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
82
41
Classes Abstratas
• Ao criarmos uma classe para ser estendida, às
vezes codificamos vários métodos usando um
método para o qual não sabemos dar uma
implementação, ou seja, um método que só subclasses saberão implementar.
• Uma classe desse tipo não deve poder ser
instanciada pois sua funcionalidade está
incompleta. Tal classe é dita abstrata.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
83
Classes Abstratas em Java
• Java suporta o conceito de classes abstratas:
podemos declarar uma classe abstrata usando o
modificador abstract.
• Além disso, métodos podem ser declarados
abstratos para que suas implementações
fiquem adiadas para as sub-classes. Para tal,
usamos o mesmo modificador abstract e
omitimos a implementação.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
84
42
Exemplo de Classe Abstrata
public abstract class Drawing {
public abstract void draw();
public abstract BBox getBBox();
public boolean contains(Point p) {
BBox b = getBBox();
return (p.x>=b.x && p.x<b.x+b.width &&
p.y>=b.y && p.y<b.y+b.height);
}
...
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
85
Objeto Conta Imposto
creditar
saldo
numero
875,32 21.342-7
debitar
43
Estados do Objeto Conta Imposto
debitar(20)
creditar
creditar
Crédito
Crédito
saldo
numero
getSaldo
Número
875,00 21.342-7
875,32
21.342-7
debitar
Débito
saldo
numero
getSaldo
Número
854,98 21.342-7
875,32
21.342-7
debitar
Débito
Conta Imposto: Assinatura
public class ContaImposto {
public ContaImposto (String numero) {}
public void creditar(double valor) {}
public void debitar(double valor) {}
public String getNumero() {}
public double getSaldo() {}
}
44
Conta Imposto: Assinatura
public class ContaImpostoM extends Conta {
public ContaImpostoM(String numero) {}
public void debitar(double valor) {}
}
Conta Imposto: Descrição
public class ContaImpostoM extends Conta {
private static final double taxa = 0.0038;
public ContaImpostoM (String numero) {
super (numero);
}
public void debitar(double valor) {
double imposto = (valor * taxa);
super.debitar(valor + imposto);
}
}
45
Subtipos e Subclasses
ContaImposto
Conta
Subclasses e Comportamento
• Objetos da subclasse comportam-se como os
objetos da superclasse
• Redefinições de métodos devem preservar o
comportamento (semântica) do método
original
• Grande impacto sobre manutenção/evolução
de software...
46
Revisão/Otimização de Código
...
double m(Conta c) {
c.creditar(x);
c.debitar(x);
return
c.getSaldo();
}
...
...
double m(Conta c) {
return
c.getSaldo();
}
...
Modificação é correta? Em que contextos?
Subclasses e Evolução
de Software
• Deveria ser possível raciocinar sobre o código
usando-se apenas a definição dos tipos das
variáveis envolvidas (Conta)
• O comportamento do código deveria ser
independente do tipo do objeto (Conta,
ContaEspecial, ContaImposto)
associado a uma dada variável em tempo de
execução
47
Reuso sem Subtipos
Conta
Poupança
ContaImpostoM
ContaEspecial
Reuso preservando Subtipos
ContaAbstrata
Conta
Poupanca
ContaImposto
ContaEspecial
48
Definindo Classes Abstratas
public abstract class ContaAbstrata {
private String numero;
private double saldo;
public ContaAbstrata (String numero) {
this.numero = numero;
saldo = 0.0;
}
public void creditar(double valor) {
saldo = saldo + valor;
}
Definindo Classes Abstratas
public double getSaldo() {
return saldo;
}
public String getNumeto() {
return numero;
}
public abstract void debitar(double valor);
protected void setSaldo(double saldo) {
this.saldo = saldo;
}
}
49
Classes Abstratas
• Possibilita herança de código preservando
comportamento (semântica)
• Métodos abstratos:
– geralmente existe pelo menos um
– são implementados nas subclasses
• Não se criam objetos:
– mas podem (devem) ter construtores, para reuso
– métodos qualificados como protected para
serem acessados nas subclasses
Contas: Descrição Modificada
public class Conta extends ContaAbstrata {
public Conta(String numero) {
super (numero);
}
public void debitar(double valor) {
this.setSaldo(getSaldo() - valor);
}
}
50
Poupanças: Descrição Original
public class Poupanca extends Conta {
public Poupanca(String numero) {
super (numero);
}
public void renderJuros(double taxa) {
this.creditar(getSaldo() * taxa);
}
}
Conta Especial: Descrição Original
public class ContaEspecial extends Conta {
public static final double TAXA = 0.01;
private double bonus;
public ContaEspecial (String numero) {
super (numero);
}
public void creditar(double valor) {
bonus = bonus + (valor * TAXA);
super.creditar(valor);
}
...
}
51
Conta Imposto: Descrição
public class ContaImposto
extends ContaAbstrata {
public static final double TAXA = 0.0038;
public ContaImposto (String numero) {
super (numero);
}
public void debitar(double valor) {
double imposto = valor * TAXA;
double total = valor + imposto;
this.setSaldo(getSaldo() – total);
}
}
Substituição e Ligações Dinâmicas
...
ContaAbstrata ca, ca’;
ca = new ContaEspecial(¨21.342-7¨);
ca’ = new ContaImposto(¨21.987-8¨);
ca.debitar(500);
ca’.debitar(500);
System.out.println(ca.getSaldo());
System.out.println(ca’.getSaldo());
...
52
Classes Abstratas: Utilização
• Herdar código sem quebrar noção de subtipos,
preservando o comportamento do supertipo
• Generalizar código, através da abstração de
detalhes não relevantes
• Projetar sistemas, definindo as suas
arquiteturas e servindo de base para a
implementação progressiva dos mesmos
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
105
Contas: Projeto OO
public abstract class ContaProjeto {
private String numero;
private double saldo;
public abstract void creditar(double valor);
public abstract void debitar(double valor);
public String getNumero() {
return numero;
protected setSaldo(double saldo) {
this.saldo = saldo;
}
...
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
106
53
Cliente: Projeto OO
public abstract class Cliente {
private String nome;
private RepositorioContatos contatos;
...
public void incluirContato(Contato contato) {
contatos.incluir(contato);
}
public abstract Endereco getEndereco();
public abstract Contato getContato(String tipo);
...
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
107
Contato: Reuso e Subtipos
Contato
Endereco
Telefone
EndEletronico EndPostal
54
Contato: Projeto OO
public abstract class Contato {
private String tipo;
public Contato (String tipo) {
this.tipo = tipo;
}
...
public abstract String getInfoRotulo();
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
109
Endereço: Projeto OO
public abstract class Endereco extends Contato {
public Endereco (String tipo) {
super (tipo);
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
110
55
Endereço Eletrônico: Projeto OO
public class EnderecoEletronico extends Endereco {
private String email;
public EnderecoEletronico(String email) {
super (“EnderecoEletronico”);
this.email = email;
}
public String getInfoRotulo() {
return (“Email: ” + email);
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
111
Endereço Residencial: Projeto
public class EnderecoPostal extends Endereco {
private String rua;
private String cidade;
...
public EnderecoPostal(String cidade,
String rua, ...) {
super (“EnderecoPostal”);
this.cidade = cidade;
this.rua = rua;
...
}
public String getInfoRotulo() {
return (“Rua: ” + rua + ...);
}
10/12/200
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
112
}
2
56
Telefone: Projeto
public class Telefone extends Contato {
private String ddd;
private String numero;
public Telefone(String ddd, String numero) {
super (“Telefone”);
this.numero = numero;
this.ddd = ddd;
}
public String getInfoRotulo() {
return (“DDD: ” + ddd +
“Numero: “ + numero);
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
113
Pessoa: Reuso e Subtipos
Pessoa
PessoaJuridica
PessoaFisica
57
Pessoa: Projeto OO
public abstract class Pessoa {
private String nome;
...
public abstract String getCodigo();
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
115
Pessoa Física: Projeto OO
public class PessoaFisica
extends Pessoa {
private String cpf;
...
public String getCodigo() {
return cpf;
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
116
58
Pessoa Jurídica: Projeto OO
public class PessoaJuridica
extends Pessoa {
private String cnpj;
...
public String getCodigo() {
return cnpj;
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
117
public class RepositorioPessoasArray {
private Pessoa[] pessoas;
...
public Pessoa procurar(String codigo) {
Pessoa p = null;
boolean achou = false;
for (int i=0; i<indice && !achou; i++) {
p = pessoas[i];
if (p.getCodigo().equals(codigo))
achou = true;
else
p = null;
}
return p;
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
118
59
Exercícios
• Modifique a classe Banco para que seja
possível armazenar todos os tipos de contas
vistos em aula.
Classes Abstratas
Resumo
• Importância de redefinir métodos
preservando a semântica dos métodos
originais
• Cláusula abstract para classes
• Cláusula abstract para métodos
• Classes abstratas e projeto e estruturação de
sistemas
60
Interfaces
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
121
Herança: Simples × Múltipla
• O tipo de herança que usamos até agora é
chamado de herança simples pois cada classe
herda de apenas uma outra.
• Existe também a chamada herança múltipla
onde uma classe pode herdar de várias classes.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
122
61
Herança Múltipla
• Herança múltipla não é suportada por todas as
linguagens OO.
• Esse tipo de herança apresenta um problema
quando construímos hierarquias de classes
onde uma classe herda duas ou mais vezes de
uma mesma superclasse. O que, na prática,
torna-se um caso comum.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
123
Problemas de Herança Múltipla
• O problema de herdar duas vezes de uma
mesma classe vem do fato de existir uma
A
herança de código.
B
C
D
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
124
62
Compatibilidade de Tipos
Inúmeras vezes, quando projetamos uma
hierarquia de classes usando herança múltipla,
estamos, na verdade, querendo declarar que a
classe é compatível com as classes herdadas. Em
muitos casos, a herança de código não é
utilizada.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
125
Interfaces
• Algumas linguagens OO incorporam o
conceito de duas classes serem compatíveis
através do uso de compatibilidade estrutural ou
da implementação explícita do conceito de
interface.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
126
63
Em Java
• Java não permite herança múltipla com
herança de código.
• Java implementa o conceito de interface.
• É possível herdar múltiplas interfaces.
• Em Java, uma classe estende uma outra classe
e implementa zero ou mais interfaces.
• Para implementar uma interface em uma
classe, usamos a palavra implements.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
127
Exemplo de Interface
• Ao implementarmos o TAD Pilha, poderíamos
ter criado uma interface que definisse o TAD e
uma ou mais classes que a implementassem.
interface Stack {
boolean isEmpty();
void push(int n);
int pop();
int top();
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
128
64
Membros de Interfaces
• Uma vez que uma interface não possui
implementação, devemos notar que:
– seus campos devem ser públicos, estáticos e
constantes;
– seus métodos devem ser públicos e abstratos.
• Como esses qualificadores são fixos, não
precisamos declará-los (note o exemplo
anterior).
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
129
Membros de Interfaces (cont.)
• Usando os modificadores explicitamente,
poderíamos ter declarado nossa interface
da seguinte forma:
interface Stack {
public abstract
public abstract
public abstract
public abstract
}
10/12/200
2
boolean isEmpty();
void push(int n);
int pop();
int top();
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
130
65
Pilha revisitada
class StackImpl implements Stack {
private int[] data;
private int top_index;
Stack(int size) {
data = new int[size];
top_index = -1;
}
public boolean isEmpty() { return (top_index < 0); }
public void push(int n) { data[++top_index] = n; }
public int pop() { return data[top_index--]; }
public int top() { return data[top_index]; }
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
131
Auditor de Banco
public class AuditorB {
private final static double MINIMO = 500.00;
private String nome;
/* ... */
public boolean auditarBanco(Banco banco) {
double saldoTotal, saldoMedio;
int numeroContas;
saldoTotal = banco.saldoTotal()
numeroContas = banco.numeroContas();
saldoMedio = saldoTotal/numeroContas;
return (saldoMedio < MINIMO);
}
}
66
Auditor de Banco Modular
public class AuditorBM {
private final static double MINIMO = 500.00;
private String nome;
/* ... */
public boolean auditarBanco(BancoModular banco){
double saldoTotal, saldoMedio;
int numeroContas;
saldoTotal = banco.saldoTotal()
numeroContas = banco.numeroContas();
saldoMedio = saldoTotal/numeroContas;
return (saldoMedio < MINIMO);
}
}
Problema
• Duplicação desnecessária de código
• O mesmo auditor deveria ser capaz de
investigar qualquer tipo de banco que possua
operações para calcular
– o número de contas, e
– o saldo total de todas as contas.
67
Auditor Genérico
public class Auditor {
private final static double MINIMO = 500.00;
private String nome;
/* ... */
public boolean auditarBanco(QualquerBanco banco){
double saldoTotal, saldoMedio;
int numeroContas;
saldoTotal = banco.saldoTotal()
numeroContas = banco.numeroContas();
saldoMedio = saldoTotal/numeroContas;
return (saldoMedio < MINIMO);
}
}
Definindo Interfaces
public interface QualquerBanco {
double saldoTotal();
int numContas();
}
68
Interfaces
• Caso especial de classes abstratas...
– todos os métodos são abstratos
• provêem uma interface para serviços e
comportamentos
• são qualificados como public por default
– não definem atributos
• definem constantes
• por default todos os “atributos” definidos em uma
interface são qualificados como public, static
e final
– não definem construtores
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
137
Interfaces
• Não se pode criar objetos
• Definem tipo de forma abstrata, apenas
indicando a assinatura dos métodos
• Os métodos são implementados pelos subtipos
(subclasses)
• Mecanismo de projeto
– podemos projetar sistemas utilizando interfaces
– projetar serviços sem se preocupar com a sua
implementação (abstração)
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
138
69
Subtipos sem Herança de Código
public class Banco implements QualquerBanco {
/* ... */
}
public class BancoModular
implements QualquerBanco {
/* ... */
}
implements
• classe implements
interface1, interface2, ...
• subtipo implements
supertipo1, supertipo2, ...
• Múltiplos supertipos:
– uma classe pode implementar mais de uma
interface (contraste com classes abstratas...)
70
implements
• Classe que implementa uma interface deve
definir os métodos da interface:
– classes concretas têm que implementar os
métodos
– classes abstratas podem simplesmente conter
métodos abstratos correspondentes aos métodos
da interface
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
141
Usando Auditores
Banco b = new Banco();
BancoModular bm = new BancoModular();
Auditor a = new Auditor();
/* ... */
boolean r = a.auditarBanco(b);
boolean r’ = a.auditarBanco(bm);
/* ... */
71
Interfaces e Reusabilidade
• Evita duplicação de código através da
definição de um tipo genérico, tendo como
subtipos várias classes não relacionadas
• Tipo genérico pode agrupar objetos de várias
classes definidas independentemente, sem
compartilhar código via herança, tendo
implementações totalmente diferentes
• Classes podem até ter mesma semântica...
Definição de Classes: Forma Geral
class C’
extends C
implements I1, I2, ..., In {
/* ... */
}
I1 I2 C
... In
C’
72
Subtipos com Herança Múltipla de
Assinatura
interface I
extends I1, I2, ..., In {
/*... assinaturas de novos
métodos ...
*/
}
O que usar? Quando?
Classes (abstratas)
• Agrupa objetos com
implementações
compartilhadas
• Define novas classes
através de herança
(simples) de código
• Só uma pode ser
supertipo de outra classe
Interfaces
• Agrupa objetos com
implementações
diferentes
• Define novas interfaces
através de herança
(múltipla) de assinaturas
• Várias podem ser
supertipo do mesmo tipo
73
Cadastro de Contas:
Parametrização
public class CadastroContas {
private RepositorioContas contas;
public CadastroContas (RepositorioContas r) {
if (r != null) contas = r;
}
/* ... */
}
A estrutura para armazenamento das contas é
fornecida na inicialização do cadastro,
e pode depois ser trocada!
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
147
Repositório: Definição
public interface RepositorioContas {
void inserir(Conta conta);
Conta procurar(String numero);
boolean existe(String numero);
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
148
74
Repositório: Implementações
public class ConjuntoContas
implements RepositorioContas {...}
public class ListaContas
implements RepositorioContas {...}
public class ArrayContas
implements RepositorioContas {...}
public class VectorContas
implements RepositorioContas {...}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
149
Cadastro de Contas:
Parametrização
public void cadastrar(Conta conta) {
if (conta != null) {
String numero = conta.getNumero();
if (!contas.existe(numero)) {
contas.inserir(conta);
}
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
150
75
Cadastro de Contas:
Parametrização
public void debitar(String numero, double valor){
Conta conta;
conta = contas.procurar(numero);
if (conta != null) {
conta.debitar(val);
}
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
151
Exercícios
• Que outros mecanismos de Java poderiam ter
sido usados para definir o tipo
RepositorioContas?
• Explique como o mecanismo de interfaces
favorece reusabilidade e extensibilidade.
Justifique.
76
Interfaces
Resumo
• Cláusula interface
• Cláusula implements
• Herança de código versus herança de
assinaturas
• Interfaces e parametrização de sistemas
Parametrização de Tipos
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
154
77
Limites de Herança
O mecanismo de herança que analisamos não
resolve alguns problemas. Considere o TAD
Pilha que implementamos: Ele define uma pilha
de números inteiros mas isso não devia ser (e não
é) necessário. Por exemplo, poderia ser útil ter
uma pilha de inteiros e uma outra de Point.
Podemos criar pilhas específicas mas não
podemos criar todas as possíveis...
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
155
Herança × Parametrização
• Uma alternativa a criar novas classes para cada
diferente tipo de pilha que iremos usar é
parametrizar a própria classe que implementa
a pilha.
• Várias linguagens OO suportam
parametrização de tipos.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
156
78
Parametrização de Tipos
• Parametrizar um tipo significa passar o tipo a
ser usada em alguma operação como um
parâmetro.
• No caso da pilha, poderíamos passar o tipo dos
elementos que pilha deveria conter como um
parâmetro do construtor, por exemplo.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
157
Tipos de Parametrização
• Existem dois tipos de parametrização:
– Irrestrita quando o tipo a ser usado é recebido
e nada é assumido sobre esse tipo;
– Restrita quando assume-se que o tipo recebido
atende a propriedade qualquer como, por
exemplo, possuir uma função de comparação
entre seus valores.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
158
79
Parametrização em Java
• Java não provê suporte direto à construção de
classes parametrizadas.
• Como Java adota o modelo de hierarquia em
árvore, com uma superclasse comum a todas as
classes, e, além disso, mantém as informações
de tipo em tempo de execução, podemos
simular um TAD paramétrico usando
conversão de tipos.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
159
Verificação de Tipos
• Para simularmos parametrização em Java
podemos vir a precisar alguma forma de
verificação de tipos em tempo de execução.
• Java mantém informações de tipo em tempo de
execução e nos permite consultá-las.
Point pt = new Point();
// pt contém um ponto
boolean b = pt instanceof Pixel; // b = false
pt = new Pixel(1,2,3);
// pt contém um pixel
b = pt instanceof Pixel;
// b = true
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
160
80
Simulando Parametrização
• Podemos mudar a definição do nosso
TAD para especificar pilhas de objetos
genéricos.
interface Stack {
boolean isEmpty();
void push(Object obj);
Object pop();
Object top();
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
161
Aninhamento de Classes
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
162
81
Aninhamento de Classes
• Em diversas circunstâncias precisamos criar
classes cujo único objetivo é auxiliar na
implementação de uma outra classe. Nesses
casos, podemos declarar uma classe aninhada,
ou seja, declarar uma nova classe como um
membro de uma outra.
• Diversas linguagens OO suportam esse
recurso.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
163
Aninhamento em Java
• Java permite dois tipos diferentes de
aninhamento de tipos:
– Aninhamento estático;
– Aninhamento dinâmico.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
164
82
Aninhamento Estático
• Gera classes e interfaces normais, cuja única
singularidade é o nome, que passa a ser
qualificado pelo nome da classe que as declara.
• Em particular, sendo um membro de uma classe,
uma interface ou classe aninhada está sujeita aos
modificadores de controle de acesso: public,
private, protected e package.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
165
Exemplo de Aninhamento Estático
package p;
public class A {
public static class B {
...
}
}
p.A a = new p.A();
p.A.B b = new p.A.B();
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
166
83
Aninhamento Dinâmico
• Gera classes associadas a objetos.
• Cada instância da classe aninhada possui uma
referência para o objeto a partir do qual ela é
criada.
• Como ela está associada a um objeto, ela tem
acesso a todos os membros desse objeto.
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
167
Exemplo de Aninhamento Dinâmico
class A {
int i;
class B {
void g() {...}
}
void f() {...}
}
A
void f() {
B b = new B();
b.g();
}
B
void g() {
i = 1;
}
10/12/200
2
4 -Conceitos OO em Java Prof. Anselmo Cardoso de Paiva
168
84