Conta Corrente - DAO e Observer

Exercício

Dadas as quatro classes a seguir, elabore uma classe abstrata Transacao que permita representá-las, generalizando todas as operações possíveis:



In [1]:

    
public class Debito {
    private float valor;
    public Debito(float valor) {
        this.valor = valor;
    }
    public float operacao(float saldo) {
        return saldo - valor;
    }
}

public class Credito {
    private float valor;
    public Credito(float valor) {
        this.valor = valor;
    }
    public float operacao(float saldo) {
        return saldo + valor;
    }
}

public class Rendimento {
    private float valor;
    public Rendimento(float valor) {
        this.valor = valor;
    }
    public float operacao(float saldo) {
        return saldo * (1 + valor/100);
    }
}

public class Depreciacao {
    private float valor;
    public Depreciacao(float valor) {
        this.valor = valor;
    }
    public float operacao(float saldo) {
        return saldo * (1 - valor/100);
    }
}

Solução



In [2]:

    
public abstract class Transacao {
   protected float valor;

   public Transacao(float valor) {
      this.valor = valor;
   }

   public abstract float operacao(float saldo);
}

public class Debito extends Transacao {
   public Debito(float valor) {
      super(valor);
   }
   public float operacao(float saldo) {
      return saldo - valor;
   }
}

public class Credito extends Transacao {
   public Credito(float valor) {
      super(valor);
   }
   public float operacao(float saldo) {
       return saldo + valor;
   }
}

public class Rendimento extends Transacao {
   public Rendimento(float valor) {
      super(valor);
   }
   public float operacao(float saldo) {
      return saldo * (1 + valor/100);
   }
}

public class Depreciacao extends Transacao {
   public Depreciacao(float valor) {
      super(valor);
   }
   public float operacao(float saldo) {
      return saldo * (1 - valor/100);
   }
}

float saldo = 500;
Transacao d = new Debito(20);
saldo = d.operacao(saldo);
System.out.println(saldo);
Transacao c = new Credito(30);
saldo = c.operacao(saldo);
System.out.println(saldo);
Transacao r = new Rendimento(10);
saldo = r.operacao(saldo);
System.out.println(saldo);
Transacao dp = new Depreciacao(20);
saldo = dp.operacao(saldo);
System.out.println(saldo);

Exercício

Implemente uma classe Conta aplicar uma série de movimentos em uma conta bancária de um cliente, capaz de realizar as seguintes operações:

construtor - recebe como parâmetro do saldo inicial da conta;
novaTransacao - aplica a transação (classe Transacao) recebida como parâmetro sobre o saldo e mostra o saldo atualizado na tela.

Crie uma interface para abstrair a operação de movimento.

Solução



In [3]:

    
public interface IMovimento {
   public void novaTransacao(Transacao tr);
}

public class Conta implements IMovimento {
   private float saldo;
    
   public float getSaldo() {
      return saldo;
   }
    
   public Conta(float saldo) {
      this.saldo = saldo;
   }
    
   public void novaTransacao(Transacao tr) {
      saldo = tr.operacao(saldo);
      System.out.println(saldo);
   }
}

IMovimento cc = new Conta(500);
Transacao d = new Debito(20);
cc.novaTransacao(d);
Transacao c = new Credito(30);
cc.novaTransacao(c);
Transacao r = new Rendimento(10);
cc.novaTransacao(r);
Transacao dp = new Depreciacao(20);
cc.novaTransacao(dp);

Exercício

Considere que caixas bancários, caixas eletrônicos e o site do banco na internet (dentre outros) são Pontos de Transação. Esse tipo de ponto gera transações.

Tomando como base o pattern Observer, escreva uma interface IPontoTransacao que permita que diversos objetos IMovimento sejam capazes de monitorar cada objeto de Ponto de Transação. Cada vez que for executada uma transação no Ponto de Transação ela é enviada para todas as contas assinantes, que a aplicam nas respectivas contas.

Para fins de simplificação, considere que todas as transações sempre se destinarão à conta assinante.

Resolução



In [4]:

    
public interface IPontoTransacao {
   public void attach(IMovimento assinante);
   public void notify(Transacao trans);
   public void activate();
}

public abstract class PontoTransacao implements IPontoTransacao {
   private ArrayList<IMovimento> assinantes = new ArrayList<IMovimento>();
   
   public void attach(IMovimento assinante) {
      assinantes.add(assinante);
   }
    
   public void notify(Transacao trans) {
      for (IMovimento ass: assinantes)
          ass.novaTransacao(trans);
   }
    
   public abstract void activate();
}

public class CaixaEletronico extends PontoTransacao {
   Transacao transacoesUsuario[] = {
      new Debito(20),
      new Credito(30),
      new Rendimento(10),
      new Depreciacao(20)
   };
   
   public void activate() {
      for (Transacao tr: transacoesUsuario)
         notify(tr);
   }
}

IPontoTransacao caixa = new CaixaEletronico();
Conta cc1 = new Conta(500);
caixa.attach(cc1);

Conta cc2 = new Conta(200);
caixa.attach(cc2);

caixa.activate();