Programação Orientada a
Objetos: Reuso
Alexandre César Muniz de Oliveira
Introdução
 Hierarquia de classes está associada a
forma como se distribui conceitos
(comportamentos) entre as unidades que
compõem o sistema (classes)
 O genérico reside em um nível superior
enquanto que o específico nos inferiores
 O genérico pode ser atribuído ao específico
(truncado), mas o contrário não (inventado)
 Descer a hierarquia retrata a diminuição do
grau de abstração
2
Introdução
Boolean
Character
Croneable
Class
ClassLoader
Compiler
Object
Math
Double
Float
Legenda:
Number
CLASSE
Integer
CLASSE ABSTRATA
Process
INTERFACE
Runtime
Long
extends
SecurityManager
implements
3
Classes Abstratas
 Servem de base para a construção de uma
hierarquia de classes
 Representam o comportamento tão
genérico quanto possível (métodos
genéricos)
 Não admitem objetos concretos com seu
comportamento (abstrato)
4
Classes Abstratas
 Não podem ser instanciadas
 Deixa a implementação mais específica de
métodos nas subclasses que não forem
abstratas
 Facilita o polimorfismo com métodos
sobrepostos
 Herança de código preservando
comportamento
5
Classes Abstratas
 Define uma interface comum a todos em uma
hierarquia
 Permite a implementação progressiva de classes
– Permite o acesso a:
• Construtores
• Métodos public e protected
 É utilizada a palavra reservada abstract para sua
definição
6
Classes Abstratas
 É obrigatório definir uma classe como
abstrata se houver um ou mais métodos
abstratos
 Métodos abstratos não apresentam
implementação
 As subclasses de classes abstratas devem
fornecer implementações para todos os
métodos abstratos (a não ser que a
subclasse também seja abstrata)
7
Classes Abstratas
public abstract class Mensagem {
private String remetente;
private int status;
public abstract void play();
public abstract void testaItens();
public abstract void aplicaItens();
public abstract boolean noPadrao();
public String getRemetente() {
return this.remetente;
}
public String Formata() {
this.testaItens();
if (this.noPadrao())
this.aplicaItens();
}}
8
Exercícios
public abstract class Empregado {
private String nome, sobrenome;
public Empregado(String n, String s) {
nome= n; sobrenome=s;
}
public String getNome() {
return nome;
}
public abstract double calcSalario();}
9
Exercícios
public final class Gerente extends Empregado {
private double salario;
public Gerente(String n, String s) {
super(n, s);
this.salario = 1000.0;
}
public double calcSalario() {
return salario;
}}
10
Exercícios
11
Exercícios
public abstract class ContaAbstrata {
private String numero;
private double saldo;
public ContaAbstrata(String numero) {
this.numero = numero;
saldo = 0.0;
}
public void depositar(double valor) {
saldo += valor;
}
public abstract void sacar(double valor);
protected void Saldo(double saldo) {
this.saldo = saldo;
}
public double Saldo() {
return saldo;
}}
12
Exercícios
public class Conta extends ContaAbstrata {
public Conta(String numero) {
super (numero);
}
public void sacar(double valor) {
this.Saldo(Saldo() - valor);
}
}
13
Exercícios
public class Poupanca extends Conta {
public Poupanca(String numero) {
super (numero);
}
public void renderJuros(double taxa) {
depositar( Saldo()*taxa);
}
}
14
Exercícios
public class ContaEspecial extends Conta {
public static final double TAXA = 0.01;
private double bonus;
public ContaEspecial (String numero) {
super (numero);
}
public void depositar(double valor) {
bonus = bonus + (valor * TAXA);
super.depositar(valor);
}
}
15
Exercícios
public class ContaImposto extends ContaAbstrata {
public static final double TAXA = 0.001;
public ContaImposto (String numero) {
super (numero);
}
public void sacar(double valor) {
double imposto = valor * TAXA;
double total = valor + imposto;
this.Saldo( Saldo() – total);
}
}
16
Exercícios
public class Programa {
public static void main(String [ ] args) {
ContaAbstrata conta1, conta2;
conta1 = new ContaEspecial(“21.342-7”);
conta2 = new ContaImposto(“21.987-8”);
conta1.sacar(500);
conta2.sacar(500);
System.out.println(conta1. Saldo());
System.out.println(conta2. Saldo());
}
}
17
Interfaces
 Herança múltipla pode causar conflitos de
métodos iguais com implementações diferentes Java não suporta
 Uma interface pode ser definida como um
“protocolo” que define o comportamento de um
determinado objeto
 Funciona como uma superclasse onde todos os
métodos não estão implementados
 Uma classe pode “implementar” vários serviços
(múltiplas interfaces) causando um efeito similar
à herança múltipla
18
Interfaces
 Interfaces são também conhecidas como classes
abstratas “puras”
 Não têm construtores
 Não contém atributos de dados (a não ser
constantes estáticas – public, static, final)
 Todos os métodos são implicitamente abstratos
 Provêm uma interface de serviços e
comportamentos
 Uma classe pode estender somente uma única
classe, mas pode implementar várias interfaces
19
Interfaces
 Implementar uma interface é semelhante à
estender uma classe, porém a classe não
herda comportamentos e sim os
implementa
 É possível chamar métodos que sejam
membros da interface em qualquer objeto
que implemente a interface
20
Interfaces
 Exemplo um veículo pode acelerar, frear e virar
para uma direção
public interface Veiculo {
public freiar();
public acelerar();
public virar(direcao);
}
 As classes caminhão, trator, carroça, ..., que
implementam a interface veículo é que dizem
como efetuar estas operações em cada classe
 Pode-se projetar sistemas e serviços utilizando
interfaces sem a preocupação com sua
implementação
21
Interfaces
 Provedora de serviços
– Forte separação entre funcionalidade e
implementação.
• Embora parâmetros e tipos de retorno sejam
obrigatórios.
– Clientes interagem independentemente da
implementação.
• Mas os clientes podem escolher implementações
alternativas.
22
Interfaces
23
Interfaces
class ParticipanteForum implements Leitor, Programador
interface Leitor {
{
String lendo();
String pensamento;
}
public String lendo() { return "Forum"; }
interface Programador {
public void pensando(char[] ideias) {
void pensando(char[] ideias);
pensamento = new String(ideias);
String digitando();
}
}
public String digitando() {
return pensamento;
}
// método exclusivo desta classe
private String aprendendo() {
return "Java";
}
}
24
Exercícios
public interface Funcionario {
public double calcularSalario();
public int bonus();
}
class Gerente implements Funcionario {
private static final int SALARIO = 40000;
private static final int BONUS = 0;
public double calcularSalario() {
return SALARIO;
}
public int getBonus( ) { return BONUS; }
}
25
Exercícios
class Programador implements Funcionario {
private static final double SALARIO = 50000;
private static final int BONUS = 10000;
public double calcularSalario() {
return SALARIO;
}
public int getBonus() { return BONUS; }
}
26
Exercícios
public class FolhaPagamento {
public double calcularFolhaPagamento(Funcionario emp) {
return emp.calcularSalario() + emp.bonus();
}
public static void main(String arg[]) {
FolhaPagamento fp = new FolhaPagamento();
Programador prg = new Programador();
Gerente mgr = new Gerente();
System.out.println("Salário do Programador " +
fp.calcularFolhaPagamento(prg));
System.out.println("Salário do Gerente " +
fp.calcularFolhaPagamento(mgr));
}
}
27
Exercícios
public interface Transacao {
public void depositar (double valor);
public boolean sacar (double valor);
}
public class Conta implements Transacao{
private double saldo;
private String numero;
public void depositar (double valor){ saldo += valor; }
public boolean sacar (double valor){
if (saldo >= valor){ saldo -= valor; return true; }
return false;
}
public String toString (){ return "" + numero + "-" + saldo; }
}
}
28
Exercícios
public class TesteConta {
static void teste (Transacao t){
t.depositar(500);
}
public static void main(String[] args) {
Transacao t;
Conta c = new Conta();
c.nomeia("Acmo e mia");
c.depositar(500);
System.out.println(c.toString());
c.sacar(200);
System.out.println(c.toString());
t = c;
teste(t);
System.out.println(((Conta) t).toString());
}}
29
Reuso de código
Boolean
Character
Croneable
Class
ClassLoader
Compiler
Object
Math
Double
Float
Legenda:
Number
CLASSE
Integer
CLASSE ABSTRATA
Process
INTERFACE
Runtime
Long
extends
SecurityManager
implements
30
Reuso de código
ThreadGroup
Runnable
Thread
System
Object
StringBuffer
String
Legenda:
Throwable
CLASSE
CLASSE ABSTRATA
INTERFACE
extends
implements
Error
java.lang-erros
Exception
java.lang-exceptions
ThreadDeath
31
Reuso de código
 Reuso da classe Exception
public class NoMatchingDetailsException extends
Exception
{
private String key;
public NoMatchingDetailsException(String key)
{
this.key = key;
}
public String getKey()
{
return key;
}
public String toString()
{
return "No details matching '" + key +
"' were found.";
}
32
Reuso de código
class pilha{ // Pilha genérica
int tam,
topo;
Object []vetor; // Vetor de elementos genéricos
pilha(int tam){ // Construtor
this.tam=tam;
topo=-1;
vetor=new Object[tam];
}
33
Reuso de código
public void insere(Object elemento){ // Insere um elemento na pilha
if(topo<(tam-1)){ // Verifica se pilha não está cheia
topo++;
vetor[topo]=elemento;
}
else System.out.println(“Pilha cheia!”);
}
public Object retira(){ // Retira um elemento da pilha
if(topo!=-1){ // Verifica se pilha não está vazia
Object elemento=vetor[topo];
topo--;
return(elemento);
}
else{
System.out.println(“Pilha vazia!”);
return(null);
}}}
34
Reuso de código
class exemplo{
public static void main(String args[]){
pilha p=new pilha(5);
p.insere(new String(“Um elemento”));
p.insere(new Float(1.5));
p.insere(new Integer(1));
p.insere(new Character(‘a’));
p.insere(new pilha(10));
p.remove();
for(int i=1;i<=p.tam;i++)
System.out.println(p.remove());
}
}
35
Reuso de código
 Reuso do código que implementa uma
pilha para gerar uma classe fila
– Fila.insere: aproveita Pilha.insere
– Fila.remove: Precisa ser reescrito usando outro
atributo chamado início que é incrementado
quando um elemento é removido
– Fila.vazia: Precisa ser reescrita
36
Reuso de código
 Sem herança
– Modificador final
– Classe String é vital para a normal operação da
JVM
• main (String args[])
– Sempre se pode confiar no comportamento de
uma classe final
37
Reuso de código
38
Reuso de código
public class Database
{
public void addItem(Item theItem)
{
...
}
}
Video video = new Video(...);
CD cd = new CD(...);
database.addItem(video);
database.addItem(cd);
39
Herança múltipla
 Simulador
40
Herança múltipla
 Simulador
41
Herança múltipla
 Simulador com visualização separada da
atuação
42
Herança múltipla
public interface Actor
{
/**
* Realiza o comportamento diário do ator.
* Transfere o ator para updatedField se ele for
* participar das etapas posteriores da simulação.
* @param currentField O estado atual do campo.
* @param location A posição do ator no campo.
* @param updatedField O estado atualizado do campo.
*/
void act(Field currentField, Location location,
Field updatedField);
}
43
Herança múltipla
public class Fox extends Animal implements Drawable
{
...
}
public class Hunter implements Actor, Drawable
{
...
}
44
Projeto Livraria
Virtual LeiaBem
...