Paulo Borba Centro de Informática Universidade Federal de Pernambuco Classes Abstratas e Interfaces.

Apresentação em tema: "Paulo Borba Centro de Informática Universidade Federal de Pernambuco Classes Abstratas e Interfaces."— Transcrição da apresentação:

1

2 Paulo Borba Centro de Informática Universidade Federal de Pernambuco Classes Abstratas e Interfaces

3 numerosaldo 21.342-7 875,32 Objeto Conta Imposto creditar debitar

4 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

5 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() {} }

6 Conta Imposto: Assinatura public class ContaImpostoM extends Conta { public ContaImpostoM(String numero) {} }

7 Conta Imposto: Descrição public 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); }

8 Subtipos e Subclasses ContaImposto Conta

9 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...

10 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(); }...

11 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

12 Reuso sem Subtipos Conta PoupançaContaImpostoM ContaEspecial

13 Reuso preservando Subtipos ContaAbstrata ContaImposto Conta PoupancaContaEspecial

14 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; } /*... */

15 Definindo Classes Abstratas /*... */ public abstract void debitar(double valor); protected void setSaldo(double saldo) { this.saldo = saldo; } public double getSaldo() { return saldo; } /*... */ }

16 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

17 Contas: Descrição Modificada public class Conta extends ContaAbstrata { public Conta(String numero) { super (numero); } public void debitar(double valor) { this.setSaldo(getSaldo() - valor); }

18 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); }

19 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); } /*... */ }

20 Conta Imposto: Descrição public 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); }

21 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());...

22 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

23 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; } /*... */ }

24 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); /*... */ }

25 Contato: Reuso e Subtipos Contato Telefone Endereco EndEletronico EndPostal

26 Contato: Projeto OO public abstract class Contato { private String tipo; public Contato (String tipo) { this.tipo = tipo; } public abstract String getInfoRotulo(); }

27 public abstract class Endereco extends Contato { public Endereco (String tipo) { super (tipo); } Endereço: Projeto OO

28 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); }

29 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 /*...*/); }

30 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); }

31 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); }

32 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); }

33 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.

34 Auditor Genérico public 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); }

35 Definindo Interfaces public interface QualquerBanco { double saldoTotal(); int numContas(); }

36 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

37 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)

38 Subtipos sem Herança de Código public class Banco implements QualquerBanco { /*... */ } public class BancoModular implements QualquerBanco { /*... */ }

39 implements classe implements interface1, interface2,... subtipo implements supertipo1, supertipo2,... Múltiplos supertipos: uma classe pode implementar mais de uma interface (contraste com classes abstratas...)

40 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

41 Usando Auditores Banco b = new Banco(); BancoModular bm = new BancoModular(); Auditor a = new Auditor(); /*... */ boolean r = a.auditarBanco(b); boolean r’ = a. auditarBanco(bm); /*... */

42 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...

43 Definição de Classes: Forma Geral class C’ extends C implements I1, I2,..., In { /*... */ } C’ C I1 I2... In

44 Subtipos com Herança Múltipla de Assinatura interface I extends I1, I2,..., In { /*... assinaturas de novos métodos... */ }

45 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

46 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!

47 Repositório: Definição public interface RepositorioContas { void inserir(Conta conta); Conta procurar(String numero); boolean existe(String numero); }

48 Repositório: Implementações public class ConjuntoContas implements RepositorioContas {...} public class ListaContas implements RepositorioContas {...} public class ArrayContas implements RepositorioContas {...} public class VectorContas implements RepositorioContas {...}

49 Cadastro de Contas: Parametrização public void cadastrar(Conta conta) { if (conta != null) { String numero = conta.getNumero(); if (!contas.existe(numero)) { contas.inserir(conta); }

50 Cadastro de Contas: Parametrização public void debitar(String numero, double valor){ Conta conta; conta = contas.procurar(numero); if (conta != null) { conta.debitar(val); }