JAVA heranca, polimorfismo e ligação dinamica

Prévia do material em texto

154Java Básico
Herança, polimorfismo 
e ligação dinâmica
155Java Básico
 Número Saldo
 21.342-7 875,32
creditar
debitardebitar
renderJurosrenderJuros
Objeto poupança
156Java Básico
creditar(20.00)
 Número Saldo
 21.342-7 875,32
creditar
debitardebitar
renderJurosrenderJuros
 Número Saldo
 21.342-7 895,32
creditar
debitardebitar
renderJurosrenderJuros
Estados do Objeto Poupança
157Java Básico
renderJuros(0.01)
 Número Saldo
 21.342-7 875,32
creditar
debitardebitar
renderJurosrenderJuros
 Número Saldo
 21.342-7 884,07
creditar
debitardebitar
renderJurosrenderJuros
Estados do Objeto Poupança
158Java Básico
class Conta {
 public Conta(String n) {} 
 public void creditar(double valor) {}
 public void debitar(double valor) {}
 public String getNumero() {}
 public double getSaldo() {}
}
Classe de Contas: Assinatura
159Java Básico
class Poupanca {
 public Poupanca(String n) {} 
 public void creditar(double valor) {}
 public void debitar(double valor) {}
 public String getNumero() {}
 public double getSaldo() {}
 public void renderJuros(double t) {}
}
Classe de Poupanças: Assinatura
160Java Básico
class Poupanca {
 private String numero;
 private double saldo;
 
 void creditar(double valor) {
 saldo = saldo + valor;
 } 
 String getNumero() {
 return numero;
 }
 ...
 void renderJuros(double t) {
 this.creditar(saldo * t);
 }
}
Classe de Poupanças: Descrição
161Java Básico
� Duplicação desnecessária de código:
− A definição de Poupanca é uma simples 
extensão da definição de Conta
− Clientes de Conta que precisam trabalhar 
também com Poupanca terão que ter código 
especial para manipular poupanças
� Falta refletir relação entre tipos do “mundo 
real”: uma poupança também é uma conta!
Problemas
162Java Básico
� O mecanismo de herança permite reutilizar 
o código de classes existentes
� Apenas novos atributos ou métodos precisam 
ser definidos
� Herança introduz os conceitos de:
− Superclasse e Subclasse
− Redefinição de Métodos
− Polimorfismo de subtipo
Herança
163Java Básico
class Poupanca class Poupanca extendsextends Conta { Conta {
 
 
 
 public Poupanca (String numpublic Poupanca (String num, Cliente c, Cliente c) {) {
 
 super(numsuper(num, c, c););
 
 }}
 
 public void renderJuros(double taxa) { public void renderJuros(double taxa) { 
 
 double saldoAtual = getSaldo();double saldoAtual = getSaldo();
 
 creditar(saldoAtual * taxa);creditar(saldoAtual * taxa);
 
 }}
 
 //E nada mais!//E nada mais!
}}
subclasse subclasse extendsextends superclasse superclasse
Nova classe Poupança 
(com herança)
164Java Básico
� Reuso de Código:
− tudo que a superclasse tem, a subclasse também 
tem
− o desenvolvimento pode se basear em o que já 
está pronto
� Extensibilidade:
− algumas operações da superclasse podem ser 
redefinidas na subclasse
Herança
165Java Básico
� Comportamento: 
− objetos da subclasse comportam-se como os 
objetos da superclasse 
� Princípio da Substituição: 
− objetos da subclasse podem ser usados no lugar 
de objetos da superclasse
− Toda Poupanca é uma Conta mas nem toda conta 
é uma Poupança
Herança
166Java Básico
......
Poupanca p;Poupanca p;
p = new Poupanca(“21.342-7”);p = new Poupanca(“21.342-7”);
p.creditar(500.87);p.creditar(500.87);
p.debitar(45.00);p.debitar(45.00);
System.out.println(p.getSaldo());System.out.println(p.getSaldo());
......
......
Conta c;Conta c;
c = new Poupanca(“21.342-7”);c = new Poupanca(“21.342-7”);
c.creditar(500.87);c.creditar(500.87);
c.debitar(45.00);c.debitar(45.00);
System.out.println(c.getSaldo());System.out.println(c.getSaldo());
......
Os métodos 
creditar e 
debitar são 
herdados de 
Conta 
Uma poupança
pode ser usada 
no lugar de uma 
conta
Princípio da substituição
167Java Básico
� Nos contextos onde contas são usadas pode-
se usar poupanças
− Onde Conta é aceita, Poupanca também será
� Nos contextos onde poupanças são usadas 
pode-se usar contas com o uso explícito de 
casts 
Substituição e Casts
168Java Básico
......
Conta c;Conta c;
c = new Poupanca(“21.342-7”); c = new Poupanca(“21.342-7”); 
... ... 
(((Poupanca)(Poupanca) c).renderJuros(0.01); c).renderJuros(0.01);
System.out.println(c.getSaldo());System.out.println(c.getSaldo());
......
cast
renderJuros só está disponível 
na classe Poupança. Por isso o 
cast para Poupança é essencial.
Casts
169Java Básico
......
Conta c = procura("123.45-8");Conta c = procura("123.45-8");
if (c if (c instanceofinstanceof Poupanca) Poupanca) 
 
 ((Poupanca) c).renderJuros(0.01);((Poupanca) c).renderJuros(0.01);
elseelse
 
 System.out.print(“Poupança inexistente!”)System.out.print(“Poupança inexistente!”)
......
• O operador instanceof verifica a classe de um 
objeto (retorna true ou false)
• Recomenda-se o uso de instanceof antes de se 
realizar um cast para evitar erros
instanceof
170Java Básico
Herança e a classe Object
� Toda classe que você define tem uma superclasse
� Se não for usado "extends", a classe estende a 
classe "Object" de Java.
� A classe Object é a única classe de Java que não 
estende outra classe
class Cliente class Cliente extends Objectextends Object {} {}
class Cliente {}class Cliente {}
São equivalentes!
171Java Básico
Construtores e subclasses
class ContaBonificada class ContaBonificada extendsextends Conta { Conta {
 
 private double bonus;private double bonus;
 
 ......
 
 public contaBonificada(String num,Cliente c) {public contaBonificada(String num,Cliente c) {
 
 supersuper(num,c);(num,c);
 
 }}
}}
super chama o construtor da superclasse
se super não for chamado, 
o compilador acrescenta 
uma chamada ao construtor 
default: super()
se não existir um 
construtor default na 
superclasse, haverá 
um erro de compilação
172Java Básico
Overriding
173Java Básico
 Número Saldo
 21.342-7 875,32
Bônus
11,80
creditar
debitardebitar
renderBonusrenderBonus
Objeto Conta Bonificada
174Java Básico
creditar(20.0)
 Número Saldo
 21.342-7 875,32
Bônus
11,80
creditar
debitardebitar
renderBonusrenderBonus
 Número Saldo
 21.342-7 895,32
Bônus
12.00
creditar
debitardebitar
renderBonusrenderBonus
Estados de uma Conta 
Bonificada
175Java Básico
Estados de uma Conta 
Bonificada
renderBonus()
 Número Saldo
 21.342-7 875,32
Bônus
11,80
creditar
debitardebitar
 Número Saldo
 21.342-7 887,12
Bônus
0,00
creditar
debitardebitar
renderBonusrenderBonusrenderBonusrenderBonus
176Java Básico
class ContaBonificada extends Conta {class ContaBonificada extends Conta {
 
 public void renderBonus() {}public void renderBonus() {}
 
 public double getBonus() {}public double getBonus() {}
 
 public void creditar(double valor) {} public void creditar(double valor) {} 
 
 public ContaBonificada(String numpublic ContaBonificada(String num, , 
Cliente cCliente c) {}) {}
}}
Contas Bonificadas: Assinatura
177Java Básico
class ContaBonificada extends Conta {class ContaBonificada extends Conta {
 
 private double bonus; private double bonus; 
 
 
 
 public ContaBonificada(String numpublic ContaBonificada(String num, Cliente c, Cliente c) {) {
 
 super(numsuper(num,c,c););
 
 }}
 
 
 
 public void creditar(double valor) {public void creditar(double valor) {
 
 bonus = bonus + (valor * 0.01);bonus= bonus + (valor * 0.01);
 
 super.creditar(valor);super.creditar(valor);
 
 }}
 
 public void renderBonus() {public void renderBonus() {
 
 super.creditar(bonus); super.creditar(bonus); 
 
 bonus = 0;bonus = 0;
 
 }}
 
 public double getBonus() {public double getBonus() {
 
 return bonus;return bonus;
 
 }}
 
 
}}
Redefinição do
método creditar
Contas Bonificadas: Descrição
178Java Básico
public static void main(String args[]){public static void main(String args[]){
 
 ContaBonificada cb;ContaBonificada cb;
 
 cb = new ContaBonificada("21.342-7");cb = new ContaBonificada("21.342-7");
 
 cb.creditar(200.00); cb.creditar(200.00); 
 
 cb.debitar(100.00);cb.debitar(100.00);
 
 cb.renderBonus();cb.renderBonus();
 
 System.out.print(cb.getSaldo());System.out.print(cb.getSaldo());
}}
Usando Contas Bonificadas
179Java Básico
Overrinding
� Redefinição de métodos herdados da superclasse
� Para que haja a redefinição de métodos, o novo 
método deve ter a mesma assinatura (nome e 
parâmetros) que o método da super classe
� Se o nome for o mesmo, mas os parâmetros forem 
de tipos diferentes haverá overloading e não 
redefinição
� Redefinições de métodos devem preservar o 
comportamento (semântica) do método original
− a semântica diz respeito ao estado inicial e estado final do 
objeto quando da execução do método
180Java Básico
� Dois métodos com o mesmo nome e tipo: 
− qual versão do método usar?
� O método é escolhido dinamicamente (em 
tempo de execução), não estaticamente (em 
tempo de compilação)
� A escolha é baseada no tipo do objeto que 
recebe a chamada do método e não da 
variável
Polimorfismo e Ligações 
Dinâmicas
181Java Básico
......
Conta c1, c2;Conta c1, c2;
c1 = new ContaBonificada("21.342-7");c1 = new ContaBonificada("21.342-7");
c2 = new Conta("12.562-8");c2 = new Conta("12.562-8");
c1.creditar(200.00); c1.creditar(200.00); 
c2.creditar(100.00);c2.creditar(100.00);
c1.debitar(100.00);c1.debitar(100.00);
c2.debitar(60.00);c2.debitar(60.00);
(((ContaBonificada)(ContaBonificada) c1).renderBonus();c1).renderBonus();
System.out.println(c1.getSaldo());System.out.println(c1.getSaldo());
System.out.println(c2.getSaldo());System.out.println(c2.getSaldo());
......
Ligações Dinâmicas
Qual é o creditar
 chamado?
182Java Básico
Overloading
183Java Básico
Overloading
� Quando se define um método com mesmo nome, 
mas com parâmetros de tipos diferentes, não há 
redefinição e sim
overloading ou sobrecarga
� Overloading permite a definição de vários métodos 
com o mesmo nome em uma classe. O mesmo vale 
para construtores
� A escolha do método a ser executado é baseada no 
tipo dos parâmetros passados
184Java Básico
Overloading
class Formatacao {class Formatacao {
 
 static String formatar(double d, int static String formatar(double d, int 
precisao){...}precisao){...}
 
 static String formatar(double d) {...}static String formatar(double d) {...}
 
 static String formatar(int d) {...}static String formatar(int d) {...}
 
 ......
}}
Aqui o método formatar
tem três versões
 "overloaded"
//chama o primeiro método//chama o primeiro método
String s1 = formatar(10.0, 2);String s1 = formatar(10.0, 2);
//chama o terceiro método//chama o terceiro método
String s2 = formatar(99);String s2 = formatar(99);
185Java Básico
Herança e 
Modificadores
186Java Básico
Uso de protected e private em 
Herança
� Atributos e métodos com o modificador 
protected podem ser acessados na classe 
em que são declarados e nas suas subclasses
� Os membros private de uma superclasse 
são acessíveis apenas em métodos dessa 
superclasse
187Java Básico
Classes e métodos final
� Classes declaradas com o modificador final não 
podem ter subclasses
− Usado por segurança
− String são exemplos de classes final
� Um método que é declarado final não pode ser 
redefinido em uma subclasse
finalfinal class GeradorSenhas { class GeradorSenhas {
}}