1
resposta

Com esta implementação continuo no padrão State?

public class TestaEstadoDeConta {

    public static void main(String[] args) {


        Conta conta = new Conta("Jose");

        System.out.println(conta);
         //Titular: Jose // Saldo: R$ 0,00 // Estado: Positiva


        conta.saca(1);

        System.out.println(conta);
        //Titular: Jose // Saldo: -R$ 1,00 // Estado: Negativa

        conta.deposita(100);

        System.out.println(conta);
        //Titular: Jose // Saldo: R$ 94,00 // Estado: Positiva
    }

}
public class Negativa extends EstadoDeConta {

    public Negativa(Conta conta) {

        super(conta, "Negativa");
    }

    @Override
    public EstadoDeConta deposita(double valor) {

        conta.processaDeposito(valor * 0.95);

        if(conta.getSaldo() < 0) {
            return this;
        }

        return new Positiva(conta);
    }

    @Override
    public EstadoDeConta saca(double valor) {

        throw new RuntimeException("Conta negativa não pode efetuar saque");
    }

}
public class Positiva extends EstadoDeConta {

    public Positiva(Conta conta) {
        super(conta, "Positiva");
    }

    @Override
    public EstadoDeConta saca(double valor) {

        conta.processaSaque(valor);

        if( conta.getSaldo() > 0) {

            return this;
        }

        return new Negativa(conta);
    }

    @Override
    public EstadoDeConta deposita(double valor) {

        conta.processaDeposito(valor * 0.98);

        return this;
    }

}
public abstract class EstadoDeConta {

    protected Conta conta;
    private String nomeEstado;


    public EstadoDeConta(Conta conta, String nomeEstado) {
        this.conta = conta;
        this.nomeEstado = nomeEstado;
    }

    public abstract EstadoDeConta deposita(double valor);

    public abstract EstadoDeConta saca(double valor);

    public String getNomeEstado() {
        return nomeEstado;
    }

}
public class Conta {

    // metodos com outras resposabilidades

    protected void processaDeposito(double valor) {
        saldo +=  valor;        
    }
    protected void processaSaque(double valor) {
        saldo -=  valor;        
    }
}
1 resposta

Oi Geraldo, acho que a resposta curta é sim. Você criou um mecanismo de troca de estado e conforme um comportamento acontece, há uma troca de estado no objeto. Indo além, preciso dizer que a solução poderia ser aperfeiçoada para não usar a herança, isso por que a herança gera um acoplamento muito alto. Veja, se você precisa ter mais um estado possível e uma transição, os pontos de alteração são vários: classe mãe e filhas.

Aqui também existe um problema de semântica/modelagem, acredito que métodos como saca e deposita, poderiam diretamente fazer a operação e alterar o estado do objeto conta. Veja que por exemplo, o estado da conta fica perguntando o saldo da conta para saber qual estado deve retornar. Isso não sugere que o estado da conta deveria ser manipulado pela própria conta, que sabe seu saldo e seu estado internamente?