Implementação com interfaces

Pessoal fiz a implementação tentando usar composição e ainda assim tendo polimorfismo com base em interfaces. O que vcs acham?

package br.com.schimidtsolutions.estudo.solid.lsp;

import java.util.Arrays;
import java.util.List;

public class ProcessadorDeInvestimentos {

    public static void main(String[] args) {

        contasComunsDoBanco().forEach(c->{
            c.render();
            System.out.printf("Saldo: %,.2f\n", c.getSaldo());
        });

        contasEstudantesDoBanco().forEach(c->{
             System.out.printf("Saldo: %,.2f - Milhas: %d\n", c.getSaldo(), c.getMilhas());
        });
    }

    private static List<ContaNaoRentavel> contasEstudantesDoBanco() {
        return Arrays.asList(contaDeEstudanteCom(100), contaDeEstudanteCom(150));
    }

    private static List<ContaRentavel> contasComunsDoBanco() {
        return Arrays.asList(umaContaCom(100), umaContaCom(150));
    }

    private static ContaNaoRentavel contaDeEstudanteCom(double amount) {
        ContaNaoRentavel contaEstudante = new ContaDeEstudante();
        contaEstudante.depositar(amount);

        return contaEstudante;
    }

    private static ContaRentavel umaContaCom(double valor) {
        ContaRentavel contaComum = new ContaComum();
        contaComum.depositar(valor);

        return contaComum;
    }
}

package br.com.schimidtsolutions.estudo.solid.lsp;

public interface Conta {

    void depositar(double valor);

    void sacar(double valor);

    double getSaldo();
}

package br.com.schimidtsolutions.estudo.solid.lsp;

public interface ContaNaoRentavel extends Conta {

    int getMilhas();
}

package br.com.schimidtsolutions.estudo.solid.lsp;

public interface ContaRentavel extends Conta{

    void render();
}

package br.com.schimidtsolutions.estudo.solid.lsp;

public class ContaComum implements ContaRentavel {
    private ManipuladorSaldo manipuladorSaldo;

    public ContaComum() {
        manipuladorSaldo = new ManipuladorSaldoPadrao();
    }

    @Override
    public void depositar(double valor) {
        manipuladorSaldo.deposita(valor);
    }

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

    @Override
    public void render() {
        manipuladorSaldo.rende(0.01);
    }

    @Override
    public double getSaldo() {
        return manipuladorSaldo.getSaldo();
    }
}

package br.com.schimidtsolutions.estudo.solid.lsp;

public class ContaDeEstudante implements ContaNaoRentavel{
    private ManipuladorSaldo manipuladorSaldo;
    private int milhas;

    public ContaDeEstudante() {
        manipuladorSaldo = new ManipuladorSaldoPadrao();
    }

    @Override
    public void depositar(double valor) {
        manipuladorSaldo.deposita(valor);
        this.milhas += (int)valor;
    }

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

    @Override
    public double getSaldo() {
        return manipuladorSaldo.getSaldo();
    }

    @Override
    public int getMilhas() {
        return milhas;
    }
}

package br.com.schimidtsolutions.estudo.solid.lsp;

public interface ManipuladorSaldo {

    void deposita(double valor);

    void saca(double valor);

    void rende(double percentualRendimento);

    double getSaldo();

}

package br.com.schimidtsolutions.estudo.solid.lsp;

public class ManipuladorSaldoPadrao implements ManipuladorSaldo {
    private double saldo;

    public ManipuladorSaldoPadrao() {
        this.saldo = 0;
    }

    @Override
    public void deposita(double valor) {
        this.saldo += valor;
    }

    @Override
    public void saca(double valor) {
        if (valor <= this.saldo) {
            this.saldo -= valor;
        } else {
            throw new IllegalArgumentException();
        }
    }

    @Override
    public void rende(double percentualRendimento) {
        this.saldo += this.saldo * percentualRendimento;
    }

    @Override
    public double getSaldo() {
        return saldo;
    }
}