JAVA Classes Abstratas e Interfaces

Prévia do material em texto

208Java Básico
Classes Abstratas e Interfaces
209Java Básico
numerosaldo
21.342-7 875,32
creditarcreditar
debitardebitar
Objeto Conta Imposto
210Java Básico
 Número getSaldo
 21.342-7 875,32
Crédito
numerosaldo
 21.342-7 875,00
debitar(20)creditar
 Número getSaldo
 21.342-7 875,32
Crédito
numerosaldo
 21.342-7 854,98
creditar
debitardebitar
Desconta 0,1% sobre o saque
Estados do Objeto Conta 
Imposto
211Java Básico
Classe ContaImposto
public class ContaImposto extends public class ContaImposto extends Conta Conta {{
 
 public static final double TAXA = 0.001; //0,1%public static final double TAXA = 0.001; //0,1%
 
 
 
 public ContaImposto (String npublic ContaImposto (String n,Cliente c,Cliente c) { ) { 
 
 super (nsuper (n,c,c););
 
 } } 
 
 public void debitar(double valor){ public void debitar(double valor){ 
 
 double imposto = valor * TAXA;double imposto = valor * TAXA;
 
 super.debitar(valor + imposto)super.debitar(valor + imposto)
 
 }}
}}
212Java Básico
� Objetos da subclasse devem se comportar 
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 e 
evolução de software
Subclasses e Comportamento
213Java Básico
Subclasses e Evolução de 
Software
Conta
Poupança ContaImposto
 ContaEspecial
Não recomendado! Não 
preserva o comportamento da 
superclasse.
214Java Básico
Subclasses e Evolução de 
Software
ContaAbstrata
ContaImposto
Conta
Poupanca
ContaBonificada
SIM! ContaAbstrata 
não implementa o 
método debitar. 
Portanto, não podemos 
dizer que ContaImposto 
fere a semântica do 
supertipo.
ContaBonificada define um método para 
render bônus. O bônus só é incorporado ao 
saldo após a execução dele. O método 
creditar, portanto, respeita a definição do 
supertipo.
215Java Básico
Classes Abstratas
� Devem ser declaradas com a palavra-chave 
abstract
� Podem declarar métodos abstratos
− Métodos sem implementação
− Implementação fornecida na subclasse
� Podem declarar métodos concretos
− Métodos com implementação
216Java Básico
Definição de Classes Abstratas
� Uma classe abstrata é declarada com o modificador abstract
� Um método é definido abstrato também usando o modificado 
abstract
publicpublic abstract abstract class class Nome_da_ClasseNome_da_Classe { { 
 
 atributo1atributo1;; 
 
 atributo2atributo2;; 
 
 ......
 
 public void metodo1(){public void metodo1(){
 
 // código do método 1// código do método 1
 
 }}
 
 ......
 
 public abstract void public abstract void metodoAbstratometodoAbstrato();();
 
 
}}
publicpublic abstract abstract class class Nome_da_ClasseNome_da_Classe { { 
 
 atributo1atributo1;; 
 
 atributo2atributo2;; 
 
 ......
 
 public void metodo1(){public void metodo1(){
 
 // código do método 1// código do método 1
 
 }}
 
 ......
 
 public abstract void public abstract void metodoAbstratometodoAbstrato();();
 
 
}}
217Java Básico
public abstract class ContaAbstrata {
private String numero;
private double saldo;
private Cliente cliente;
public ContaAbstrata(String num, Cliente c) {
 numero = num;
 cliente = c;
}
public ContaAbstrata(String num, double s, Cliente c) 
{
 numero = num;
 saldo = s;
 cliente = c;
}
Definindo uma Conta abstrata
218Java Básico
public Cliente getCliente(){
 return cliente;
}
public String getNumero() {
 return numero;
}
public double getSaldo() {
 return saldo;
}
public void setCliente(Cliente cliente) {
 this.cliente = cliente;
}
public void setNumero(String num) {
 this.numero = num;
}
public void setSaldo(double valor) {
 saldo = valor;
}
Definindo uma Conta abstrata 
(cont…)
219Java Básico
public void creditar(double valor){
 saldo = saldo + valor;
}
public abstract void debitar(double valor) ;
public void transferir(ContaAbstrata c, double v){
this.debitar(v);
 c.creditar(v);
}
}
Definindo uma Conta abstrata 
(cont…)
220Java Básico
public class Conta extendspublic class Conta extends ContaAbstrata ContaAbstrata { {
 
 
 
 public Conta(String npublic Conta(String n, Cliente c, Cliente c) {) {
 
 super (nsuper (n,c,c); ); 
 
 }}
 
 public void debitar(double valor){public void debitar(double valor){
 
 double saldo = getSaldo();double saldo = getSaldo();
 
 
 
 if(valor <= saldo){if(valor <= saldo){
 
 setSaldo(saldo - valor);setSaldo(saldo - valor);
 
 } else {} else {
 
 System.out.println("Saldo insuficiente");System.out.println("Saldo insuficiente");
 
 }}
 
 }}
}}
Modificando a classe Conta
221Java Básico
public class ContaImposto extends public class ContaImposto extends ContaAbstrataContaAbstrata { {
 
 public static final double TAXA = 0.001;public static final double TAXA = 0.001;
 
 
 
 public ContaImposto(String npublic ContaImposto(String n,Cliente c,Cliente c) { ) { 
 
 super (nsuper (n,c,c););
 
 } } 
 
 public void debitar(double valor) {public void debitar(double valor) {
 
 double imposto = valor * TAXA;double imposto = valor * TAXA;
 
 double saldo = this.getSaldo();double saldo = this.getSaldo();
 
 if (valor + imposto <= saldo) {if (valor + imposto <= saldo) {
 
 setSaldo(saldo - (valor + imposto));setSaldo(saldo - (valor + imposto));
 
 } else {} else {
 
 System.out.printlnSystem.out.println("Saldo Insuficiente");("Saldo Insuficiente");
 
 }}
 
 }}
}}
Modificando a classe 
ContaImposto
222Java Básico
Classes abstratas: propriedades 
� Uma classe abstrata não pode ser instanciada
� Mesmo sem poder ser instanciada, pode definir 
construtores para permitir reuso
� Qualquer classe com um ou mais métodos abstratos 
é automaticamente uma classe abstrata
� Se uma classe herdar de uma classe abstrata, deve 
redefinir todos os métodos abstratos. Caso 
contrário, deve ser declarada como abstrata.
223Java Básico
Classes abstratas: propriedades
� Métodos private, static e final não podem ser 
abstratos. 
− Métodos declarados com estes modificadores não podem 
ser redefinidos
� Uma classe final não pode conter métodos abstratos
− Métodos definidos em classes declaradas com este 
modificador não podem ser redefinidos
� Uma classe pode ser declarada como abstract, 
mesmo se não tiver métodos abstratos
− Permite somente o reuso, mas não permite instanciações 
dessa classe
224Java Básico
public static void main(String args[]){public static void main(String args[]){
 
 ......
 
 ContaAbstrata ca1, ca2;ContaAbstrata ca1, ca2;
 
 ca1 = ca1 = newnew ContaBonificada("21.342-7"); ContaBonificada("21.342-7");
 
 ca2 = ca2 = newnew ContaImposto("21.987-8"); ContaImposto("21.987-8");
 
 ca1.debitar(500);ca1.debitar(500);
 
 ca2.debitar(500);ca2.debitar(500);
 
 System.out.println(ca1.getSaldo());System.out.println(ca1.getSaldo());
 
 System.out.println(ca2.getSaldo());System.out.println(ca2.getSaldo());
......
}}
Classes abstratas: polimorfismo
225Java Básico
Classes abstratas: utilização
� Ajudam a estruturar sistemas definindo 
hierarquias consistentes de classes. 
� Simplificam o reuso de código
� Definem "contratos" a serem realizados por 
subclasses
� Tornam o polimorfismo mais claro
226Java Básico
Interfaces
227Java BásicoAuditor de Banco de 
Investimentos
class AuditorBI {class AuditorBI {
 
 final static double MINIMO = 500.00;final static double MINIMO = 500.00;
 
 private String nome;private String nome;
 
 /* ... *//* ... */
 
 public boolean investigaBanco(public boolean investigaBanco(BancoInvest bBancoInvest b){){
 
 double sm;double sm;
 
 sm = b.sm = b.saldoTotal()saldoTotal()/b./b.numContas()numContas(); ; 
 
 return (sm return (sm >> MINIMO); MINIMO);
 
 }}
}}
228Java Básico
class AuditorBS {class AuditorBS {
 
 final static double MINIMO = 500.00;final static double MINIMO = 500.00;
 
 private String nome;private String nome;
 
 /* ... *//* ... */
 
 public public boolean investigaBanco(boolean investigaBanco(BancoSegurosBancoSeguros b) b)
 
 {{
 
 double sm;double sm;
 
 sm = b.sm = b.saldoTotal()saldoTotal()/b./b.numContas()numContas(); ; 
 
 return (sm return (sm >> MINIMO); MINIMO);
 
 }}
}}
Auditor de Banco de Seguros
229Java Básico
� 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 no banco, e 
− o saldo total de todas as contas
� Casos em que as classes envolvidas não estão 
relacionadas através de uma hierarquia de herança
Problema
230Java Básico
� Caso especial de classes abstratas
� Definem tipo de forma abstrata, apenas indicando a 
assinatura dos métodos suportados pelos objetos 
do tipo
− Os métodos declarados em uma interface não têm 
implementação
� Os métodos são implementados pelos subtipos 
(classes que implementan interfaces) 
� Não têm construtores. Não se pode criar objetos já 
que métodos não estão implementados
Uma interface define um “contrato” a ser seguido
Interfaces
231Java Básico
Definição de Interfaces
interface interface Nome_InterfaceNome_Interface { {
 
 /*... /*... assinaturasassinaturas de novos métodosde novos métodos... */... */
}}
interfaceinterface QualquerBanco { QualquerBanco {
 
 double saldoTotal();double saldoTotal();
 
 int numContas();int numContas();
}}
interfaceinterface QualquerBanco { QualquerBanco {
 
 double saldoTotal();double saldoTotal();
 
 int numContas();int numContas();
}}
232Java Básico
Utilização de Interfaces
class Nome_classe class Nome_classe implementsimplements Nome_InterfaceNome_Interface 
{{
 
 /*... /*... Implementação dos métodosImplementação dos métodos
 
 declarados na interfacedeclarados na interface
 
 ... ... 
 
 */*/
}}
233Java Básico
Utilização de Interfaces
class BancoInvest class BancoInvest implements QualquerBancoimplements QualquerBanco { {
 
 ......
 
 double saldoTotal()double saldoTotal(){{
 
 /* código específico para BancoInvest*//* código específico para BancoInvest*/
 
 }}
 
 
 
 int numContas()int numContas(){{
 
 /* código específico para BancoInvest *//* código específico para BancoInvest */
 
 }}
 
 ......
}}
234Java Básico
Utilização de Interfaces
class Bancoclass BancoSegurosSeguros implements QualquerBancoimplements QualquerBanco { {
 
 ......
 
 double saldoTotal()double saldoTotal(){{
 
 /* código específico para BancoSeguros *//* código específico para BancoSeguros */
 
 }}
 
 
 
 int numContas()int numContas(){{
 
 /* código específico para BancoSeguros *//* código específico para BancoSeguros */
 
 }}
 
 ......
}}
235Java Básico
class Auditor {class Auditor {
 
 final static double MINIMO = 500.00;final static double MINIMO = 500.00;
 
 private String nome;private String nome;
 
 /* ... *//* ... */
 
 boolean investigaBanco(boolean investigaBanco(QualquerBanco bQualquerBanco b){){
 
 double sm;double sm;
 
 sm = b.sm = b.saldoTotal()saldoTotal()/b./b.numContas()numContas(); ; 
 
 return (sm return (sm >> MINIMO); MINIMO);
 
 }}
}}
Auditor Genérico
236Java Básico
 
 QualquerBancoQualquerBanco bi = new BancoInvest(); bi = new BancoInvest();
 
 QualquerBancoQualquerBanco bs = new BancoSeguros(); bs = new BancoSeguros();
 
 Auditor a = new Auditor();Auditor a = new Auditor();
 
 
 
 /* ... *//* ... */
 
 boolean res1 = a.investigaBanco(bi);boolean res1 = a.investigaBanco(bi);
 
 boolean res2 = a.investigaBanco(bs);boolean res2 = a.investigaBanco(bs);
 
 /* ... *//* ... */
Usando do Auditor Genérico
237Java Básico
Tipos e Subtipos
� Classes e Interfaces sãoClasses e Interfaces são tipostipos
� Os termos subtiposubtipo e supertiposupertipo também são usados
− supertipo : interface
− subtipo: classe que implementa a interface ou interface 
que estende outra interface
� Interfaces utilizam o conceito de herança múltipla
− Herança múltipla de assinatura
238Java Básico
interface interface II extends extends I1, I2, ..., InI1, I2, ..., In { {
 
 /*... /*... assinaturasassinaturas de novos métodosde novos métodos... */... */
}}
Interfaces podem estender
 várias interfaces
Herança múltipla de assinatura
239Java Básico
Múltiplos supertipos
� Classe que implementa uma interface deve 
definir os métodos da interface
− classes concretas têm que implementar todos os 
métodos da interface
− caso algum método da interface não seja 
implementado, a classe deve ser declarada 
abstract
� Apesar de não suportar herança múltipla de 
classes, uma classe pode implementar mais de 
uma interface (pode ter vários supertipos)
class XXX implements interface1, interface2 { 
 
 ...
}
240Java Básico
class class C’C’ 
 
 extends extends CC 
 
 implements implements I1, I2, ..., InI1, I2, ..., In { {
 
 /* ... *//* ... */
}}
C’
C
I1 I2 ... In
A classe C´ é subtipo de 
C, I1, I2, ...., In
Definição de classes: forma 
geral
241Java Básico
Interfaces e métodos
� Todos os métodos de uma interface são implicitamente 
abstratos e públicos
� métodos de interfaces não podem ser :
− static
− final
− private
− protected
242Java Básico
Interfaces e atributos
� Interfaces não podem conter atributos 
� A única exceção são os atributos
static final (constantes).
� Interfaces são excelentes repositórios para 
constantes
public interface CoresBasicas {public interface CoresBasicas {
 
 public static final int AZUL = 0;public static final int AZUL = 0;
 
 public static final int VERMELHO = 1;public static final int VERMELHO = 1;
 
 public static final int VERDE = 2;public static final int VERDE = 2;
 
 public static final int PRETO = 3;public static final int PRETO = 3;
 
 public static final int AMARELO = 4; public static final int AMARELO = 4; 
}}
janela.alterarCor(janela.alterarCor(CoresBasicas.AZULCoresBasicas.AZUL););janela.alterarCor(janela.alterarCor(CoresBasicas.AZULCoresBasicas.AZUL););
243Java Básico
� 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
� Uma interface agrupa objetos de várias 
classes definidas independentemente, sem 
compartilhar código via herança, tendo 
implementações totalmente diferentes
Interfaces e Reusabilidade
244Java Básico
Subtipos e instanceof
class Circulo extends Forma implements class Circulo extends Forma implements 
Selecao, Rotacao, Movimentacao {Selecao, Rotacao, Movimentacao {
 
 ......
}}
......
Circulo c = new Circulo();Circulo c = new Circulo();
res1 = c instanceof Circulo;res1 = c instanceof Circulo;
res2 = c instanceof Selecao;res2= c instanceof Selecao;
res3 = c instanceof Rotacao;res3 = c instanceof Rotacao;
res4 = c instanceof Movimentacao;res4 = c instanceof Movimentacao;
......
res1, res2, res3 e res4 são res1, res2, res3 e res4 são truetrue!!
245Java Básico
Classes (abstratas)
� Agrupa objetos com 
implementações 
compartilhadas 
� Define novas classes 
através de herança 
(simples) de código
� Só uma classe 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 interfaces 
podem ser supertipo 
do mesmo tipo
Classes abstratas X Interfaces