Upload
internet
View
111
Download
2
Embed Size (px)
Citation preview
Paulo BorbaCentro de Informática
Universidade Federal de Pernambuco
Classes Abstratase
Interfaces
numerosaldo
21.342-7 875,32
Objeto Conta Imposto
creditar
debitar
Número getSaldo
21.342-7 875,32
Crédito
Débito
Estados do Objeto Conta Imposto
numerosaldo
21.342-7 875,00
debitar(20)
creditar
debitar
Número getSaldo
21.342-7 875,32
Crédito
Débito
numerosaldo
21.342-7 854,98
creditar
debitar
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() {}}
Conta Imposto: Assinatura
public class ContaImpostoM extends Conta {
public ContaImpostoM(String numero) {}}
Conta Imposto: Descriçãopublic class ContaImpostoM extends Conta {
private static final double taxa = 0.001;
public ContaImpostoM (String numero) { super (numero); } public void debitar(double valor) { double imposto = (valor * taxa); super.debitar(valor + imposto); }}
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...
Revisão/Otimização de Código
...double m(Conta c) { c.creditar(x); c.debitar(x); return c.getSaldo();}...
Modificação é correta? Em que contextos?
...double m(Conta c) { return c.getSaldo();}...
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
Reuso sem Subtipos
Conta
Poupança ContaImpostoM
ContaEspecial
Reuso preservando Subtipos
ContaAbstrata
ContaImposto Conta
Poupanca ContaEspecial
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 abstract void debitar(double valor);
protected void setSaldo(double saldo) {
this.saldo = saldo;
}
public double getSaldo() {
return saldo;
}
/* ... */
}
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 cria-se 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); } }
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 (n); } public void creditar(double valor) { bonus = bonus + (valor * taxa); super.creditar(valor); } /* ... */}
Conta Imposto: Descriçãopublic class ContaImposto extends ContaAbstrata {
public static final double taxa = 0.001;
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());...
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
Contas: Projeto OOpublic 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; } /* ... */}
Cliente: Projeto OO
public abstract class Cliente { private String nome; private ConjuntoContato contatos; /* ... */ public void incluirContato(Contato contato) { contatos.incluir(contato); } public abstract Endereco getEndereco(); public abstract Contato getContato(String tipo); /* ... */}
Contato: Reuso e Subtipos Contato
Telefone Endereco
EndEletronico EndPostal
Contato: Projeto OO
public abstract class Contato { private String tipo; public Contato (String tipo) { this.tipo = tipo; } public abstract String getInfoRotulo();}
public abstract class Endereco extends Contato { public Endereco (String tipo) { super (tipo); }}
Endereço: Projeto OO
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); }}
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 /*...*/); }}
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); }}
Auditor de Bancopublic 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); }}
Auditor de Banco Modularpublic 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.
Auditor Genéricopublic class AuditorGenerico { 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();}
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
Interfaces Não pode-se criar objetos Definem tipo de forma abstrata,
apenas indicando a assinatura dos métodos
Os métodos são implementados pelos subtipos (subclasses)
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...)
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
Usando Auditores
Banco b = new Banco(); BancoModular bm = new BancoModular(); Auditor a = new Auditor(); /* ... */ boolean r = a.auditarBanco(b); boolean r’ = a. auditarBanco(bm); /* ... */
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 de forma independente, 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 { /* ... */ }
C’
CI1 I2 ... In
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
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!
Repositório: Definição
public interface RepositorioContas { void inserir(Conta conta); Conta procurar(String numero); boolean existe(String numero);}
Repositório: Implementações
public class ConjuntoContas implements RepositorioContas {...}
public class ListaContas implements RepositorioContas {...}
public class ArrayContas implements RepositorioContas {...}
public class VectorContas implements RepositorioContas {...}
Cadastro de Contas: Parametrização
public void cadastrar(Conta conta) { if (conta != null) { String numero = conta.getNumero(); if (!contas.existe(numero)) { contas.inserir(conta); } }}
Cadastro de Contas: Parametrização
public void debitar(String numero, double valor){ Conta conta; conta = contas.procurar(numero); if (conta != null) { conta.debitar(val); }}