1
resposta

[Projeto] Refatoracao de codigo

package Pagamento;

public class Main {

    public static void main(String[] args) {
        Pagamento cartao = new Cartao(250);
        Pagamento boleto = new Boleto(500);
        Pagamento pix = new Pix(300);

        cartao.confirmarPagamento();
        boleto.confirmarPagamento();
        pix.confirmarPagamento();
    }
}
package Pagamento;

public abstract class Pagamento {

    double valor;

    public Pagamento(double valor) {
        this.valor = valor;
    }

    public double getValor() {
        return valor;
    }

    abstract void confirmarPagamento();

    abstract double calcularTaxa();

}
package Pagamento;

public class Cartao extends  Pagamento{

    public Cartao(double valor) {
        super(valor);
    }

    @Override
    void confirmarPagamento() {
        System.out.printf("Pagamento de R$%.2f confirmado no Cartão de Crédito (Taxa: R$%.2f)\n", getValor(), calcularTaxa());
    }

    @Override
    double calcularTaxa() {
        return (getValor() * 3) /100;
    }

}
package Pagamento;

public class Boleto extends Pagamento{

    public Boleto(double valor) {
        super(valor);
    }

    @Override
    void confirmarPagamento() {
        System.out.printf("Boleto de R$%.2f gerado com sucesso (Taxa: R$%.2f)\n", getValor(), calcularTaxa());
    }

    @Override
    double calcularTaxa() {
        return (getValor() * 1) /100;
    }

}
package Pagamento;

public class Pix extends Pagamento{

    public Pix(double valor) {
        super(valor);
    }

    @Override
    void confirmarPagamento() {
        System.out.printf("via Pix de R$%.2f confirmado\n", getValor());
    }

    @Override
    double calcularTaxa() {
        return 0;
    }
}
1 resposta

Olá, João! Como vai?

Parabéns pela resolução da atividade!

Observei que você explorou o abstract para estruturar uma hierarquia de pagamentos com Java, utilizou muito bem a herança para especializar cada forma de pagamento e ainda compreendeu a importância do polimorfismo para permitir que cada classe implemente o cálculo de taxa e a confirmação de forma distinta.

Uma dica interessante para o futuro é aplicar interfaces quando quiser definir contratos comuns entre diferentes formas de pagamento, sem depender de uma classe abstrata. Assim:

package Pagamento;

public interface MetodoPagamento {
    void confirmarPagamento();
    double calcularTaxa();
}

public class Cartao implements MetodoPagamento {
    private double valor;

    public Cartao(double valor) {
        this.valor = valor;
    }

    @Override
    public void confirmarPagamento() {
        System.out.printf("Pagamento de R$%.2f confirmado no Cartão (Taxa: R$%.2f)\n", valor, calcularTaxa());
    }

    @Override
    public double calcularTaxa() {
        return valor * 0.03;
    }
}

Isso faz com que diferentes métodos de pagamento possam seguir o mesmo contrato, mantendo flexibilidade e boas práticas de orientação a objetos.

Conteúdos relacionados

Alguns materiais podem estar em inglês, mas é possível compreendê-los usando o recurso de tradução de páginas do próprio navegador.

Fico à disposição! E se precisar, conte sempre com o apoio do fórum.

Abraço e bons estudos!

AluraConte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!