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

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