Entrar Ainda não tem acesso?
Solucionado (ver solução)
Solucionado
(ver solução)
3
respostas

Dúvida no Ex. 4 da Aula 5 - Herança e o Liskov Substitutive Principle

Referente ao curso SOLID com C#: Orientação a Objetos com C#, no capítulo Herança e o Liskov Substitutive Principle e atividade Mão na massa!

por Juan Coutinho
| 42.9k xp | 4 posts

Eu quebro o princípio de Liskov se estabelecer um contrato através de uma interface?

Deste modo eu continuaria usando o polimorfismo mas não estipularia nenhuma pré ou pós condição. Não consigo encontrar nenhum outro modo para implementar a composição neste exercício. Até posso compor as classes, mas não faria sentido.

Modo tosco de implementação:

 public class ProcessadorDeInvestimentos
    {
        static void Main(string[] args)
        {
            IList<Conta> contas = ContasDoBanco();

            foreach (Conta conta in contas)
            {
                conta.SomaInvestimento();

                Console.WriteLine("Novo saldo: " + conta.Saldo);
            }

            Console.ReadLine();
        }

        private static IList<Conta> ContasDoBanco()
        {
            List<Conta> contas = new List<Conta>();
            contas.Add(umaContaComum(100));
            contas.Add(umaContaComum(150));
            contas.Add(umaContaEstudante(300));
            return contas;
        }

        private static ContaEstudante umaContaEstudante(double saldo)
        {
            ContaComum conta = new ContaComum();
            conta.ContaEstudante.Deposita(saldo);
            return conta.ContaEstudante;
        }

        private static ContaComum umaContaComum(double saldo)
        {
            ContaComum conta = new ContaComum();
            conta.Deposita(saldo);
            return conta;
        }

    }
3 respostas
solução!
por Rodrigo Turini
| 190.4k xp | 468 posts
Instrutor Lider de desenvolvimento da Alura e VRaptor

Oi Juan, tudo bem?

Pelo contrário, usar interfaces é uma alternativa bastante viável pra evitar o problema de acoplamento da herança.

Você pode usar interfaces em conjunto com composição de classes pra evitar isso. Uma conta de estudante pode ser composta com uma conta comum, por exemplo.

por Juan Coutinho
| 42.9k xp | 4 posts

Obrigado por sanar esta dúvida.

por Israel Machado
| 81.8k xp | 4 posts

Esta seria uma boa implementação para o problema proposto?

using System; using System.Collections; using System.Collections.Generic;

namespace ConsoleApplication1 { public class ProcessadorDeInvestimentos { static void Main(string[] args) { IList contas = ContasDoBanco();

foreach (IContas conta in contas) { conta.SomaInvestimento();

Console.WriteLine("Novo saldo da {0}: " + conta.LeSaldo(), conta.GetType().Name); }

Console.ReadLine(); }

private static IList ContasDoBanco() { List contas = new List(); contas.Add(umaContaComum(100)); contas.Add(umaContaComum(150)); contas.Add(umaContaEstudante(100));

return contas; }

private static ContaEstudante umaContaEstudante(double saldo) { ContaEstudante conta = new ContaEstudante(); conta.Deposita(saldo); return conta; }

private static ContaComum umaContaComum(double saldo) { ContaComum conta = new ContaComum(); conta.Deposita(saldo); return conta; } }

public interface IContas { void Deposita(double valor); void Saca(double valor); void SomaInvestimento(); double LeSaldo(); }

public class ContaEstudante : IContas { public double Saldo { get; private set; } public int Milhas { get; private set; }

public void Deposita(double valor) { this.Milhas += (int)valor; }

public void Saca(double valor){}

public void SomaInvestimento(){}

public double LeSaldo() { return this.Saldo; } }

public class ContaComum : IContas { public double Saldo { get; private set; }

public ContaComum() { this.Saldo = 0; }

public void Deposita(double valor) { this.Saldo += valor; }

public void Saca(double valor) { if (this.Saldo > valor) this.Saldo -= valor; else throw new ArgumentException(); }

public void SomaInvestimento() { this.Saldo += this.Saldo * 0.01; }

public double LeSaldo() { return this.Saldo; } } }