Solucionado (ver solução)
Solucionado
(ver solução)
3
respostas

Eu não consigo instanciar o depósito corretamente depois que inclui os exceptions. Alguém pode me ajudar!?

Estava fazendo um teste para instanciar os métodos no programa. Ocorreu um problema, que é quando eu instancio o depósito não aparece o valor que será depositado na outra conta. Porém, quando instancio a transferência aparece o valor que sera transferido e depositado igualmente na outra conta.

public abstract class Conta {
    protected double saldo;
    private int agencia;
    private int numero;
    private Cliente titular = new Cliente(null, null, null);
    private static int total;

    public Conta(int agencia, int numero) {    
        if(agencia  < 0 || numero < 0) {
            throw new ContaException("O número e agência da sua conta deve ser positivo.");
        }
        this.agencia = agencia;
        this.numero = numero;
        total++;        
    }

    public abstract void depositar(double valor, Conta destino);

    public void sacar(double valor) {
        if(this.saldo < valor) {
            throw new SaldoInsuficienteException("Saldo: " + this.saldo + ", Valor: " + valor );
        }
        else if(valor < 0) {
            throw new IllegalArgumentException("Apenas números positivos...");
        }
        this.saldo -= valor;
    }

    public void transfere(double valor, Conta destino) {
        this.sacar(valor);
        destino.depositar(valor, destino);
    }

    public void setSaldo(double saldo) {
        if(saldo < 0) {
            throw new IllegalArgumentException("Apenas números positivos...");
        }
        this.saldo = saldo;
    }
    public void setNumero(int numero) {
        this.numero = numero;
    }
    public void setAgencia(int agencia) {
        this.agencia = agencia;
    }
    public double getSaldo() {
        return this.saldo;
    }
    public int getNumero() {
        return numero;
    }
    public int getAgencia() {
        return agencia;
    }

    public void setTitular(Cliente titular) {
        this.titular = titular;
    }
    public Cliente getTitular() {
        return this.titular;
    }
    public static int getTotal() {
        return total;
    }
}
public class ContaCorrente extends Conta {

    public ContaCorrente(int agencia, int numero) {
        super(agencia, numero);
    }

    @Override
    public void sacar(double valor) {
        super.sacar(valor);
    }

    @Override
    public void transfere(double valor, Conta destino) {
        super.transfere(valor, destino);
    }

    @Override
    public void depositar(double valor, Conta destino) {
        super.saldo += valor;
    }
}
public class TestaConta4 {

    public static void main(String[] args) {

        ContaCorrente ccArthur = new ContaCorrente(123,123123);
        ContaCorrente ccRicardo = new ContaCorrente(233,423123);

        ccArthur.setSaldo(2000);
        //ccRicardo.setSaldo(250);
        ccArthur.depositar(250, ccArthur);

        System.out.println("Arthur: " + ccArthur.getSaldo()); // ok!

        ccArthur.sacar(133); // ok!

        System.out.println("Arthur depois de sacar: " + ccArthur.getSaldo());

        ccArthur.transfere(100, ccRicardo); // nao transfere valor para outra Conta!

        System.out.println("Ricardo c/ transferencia: " + ccRicardo.getSaldo());

        ccArthur.depositar(300, ccRicardo); // nao deposita valor para outra Conta!

        System.out.println("Ricardo c/ deposito recebido: " + ccRicardo.getSaldo());
    }

}
3 respostas
solução!

Fala, Arthur! Tudo bem contigo?

Fiz alguns teste e vamos por partes

Sendo que o Arthur começou com um saldo de 2000e depositamos mais 250, rodou perfeitamente

        ccArthur.setSaldo(2000);
        ccArthur.depositar(250, ccArthur);

        System.out.println("Arthur: " + ccArthur.getSaldo()); // ok!

Só uma observação inicial: veja que seu método deposita está bastante parecido com o transfereporém, questiono se há a necessidade de colocar o destino como argumento sendo que para chamar o método você já pode informar para quem é o depósito (acho que aí está o comportamento que está estranhando), mas vi que dentro do método transfereexiste o deposita. Vale a reflexão!!!

ccArthur.depositar(250, ccArthur);

Mas vamos continuar!

Depois houve um saque

ccArthur.sacar(133);

Perfeito!

Agora chamei o saldo dos dois para confirmar os valores

        System.out.println("Arthur depois de sacar: " + ccArthur.getSaldo());
        System.out.println("Ricardo Saldo: " + ccRicardo.getSaldo());
        System.out.println("---------------------------------------");

Resultado

Arthur depois de sacar: 2117.0
Ricardo Saldo: 0.0
---------------------------------------

Depositei um valor na Conta do Ricardo e puxei o saldo novamente para confirmar a operação, mas veja que estamos chamando a conta que será depositada, o método e depois o valor e a conta novamente. Aquilo que apontei lá no início!

        ccRicardo.depositar(100,ccRicardo);
        System.out.println("Ricardo Saldo: " + ccRicardo.getSaldo());
        System.out.println("---------------------------------------");
Ricardo Saldo: 100.0
---------------------------------------

Agora vou fazer a transferência do Arthur para o Ricardo e bater os dois saldos

        ccArthur.transfere(100, ccRicardo);
        System.out.println("Arthur depois de transferir: " + ccArthur.getSaldo());
        System.out.println("Ricardo c/ transferencia: " + ccRicardo.getSaldo());
Arthur depois de transferir: 2017.0
Ricardo c/ transferencia: 200.0

Rodou! \o/

E agora vem sua questão sobre o Arthur depositar na conta do Ricardo

        ccArthur.depositar(300, ccRicardo);
        System.out.println("Ricardo c/ deposito recebido: " + ccRicardo.getSaldo());

Pergunto: dessa forma não seria melhor o transfere? ;-)

Eu entendo quando diz que o Arthur está depositando na conta do Ricardo, porém esse método está mais desenhado como transferedo que como deposita

O método depositapoderia ter a seguinte estrutura

ccRicardo.depositar(300);

Assim saberei que seria um depósito simples na conta do Ricardo.

Observe a estrutura do método deposita que está sendo chamado

    public void depositar(double valor, Conta destino) {
        super.saldo += valor;
    }

Ele poderia receber somente o double valorsó para não confundir com o método tranfere, que já tem outro tipo de comportamento

    public void transfere(double valor, Conta destino) {
        this.sacar(valor);
        destino.depositar(valor, destino);
    }

Não está errado, viu Arthur! Tanto é que rodou normalmente quando fiz os testes, porém, pode te confundir um pouco.

Espero ter ajudado!

Mais uma vez, vale a reflexão!

Um abraço e bons estudos!!!

Eu estava teimando em querer utilizar o método depositar como abstrato pra chamar ela dentro do método transfere, mas eu vou deixar do jeito que tu fez. É realmente melhor e mais expressivo de entender o código!

Valeu ai mano!

Opa! Que isso, Arthur!!!

Qualquer dúvida, estamos a disposição!!!

Um abraço!!!

Quer mergulhar em tecnologia e aprendizagem?

Receba a newsletter que o nosso CEO escreve pessoalmente, com insights do mercado de trabalho, ciência e desenvolvimento de software