25% de imposto

Oi Samir, na minha opinião o imposto não é responsabilidade da implementação do investimento em si. Até pq o tempo do investimento, para alguns investimentos, pode influenciar no imposto a ser cobrado... Se vc não acopla, você consegue mexer nos impostos sem alterar nada das classes...

Caso você realmente queira delegar isso para o investimento, vc podia ter uma classe responsável por isso e fazia com que o investimento recebesse um objeto deste tipo como argumento no construtor.

Imaginei algo assim:

    public interface Investimento
    {
        double Calculo(Conta conta);
        double CalculaImposto(double valor);
    }

    public class Conservador : Investimento
    {
        public double Calculo(Conta conta)
        {
            double resultado = 0;
            double saldo = 0;
            double valor = conta.Saldo;

            saldo = valor * 0.008;  //-- 0,8 %

            resultado = valor + saldo;

            return resultado;
        }
        public double CalculaImposto(double valor)
        {
            double valorImposto = 0;

            valorImposto = valor * 0.25;   //-- Imposto de 25%

            return valorImposto;
        }
    }

Assim, todo tipo de investimento vai carregar consigo o calculo de imposto também, e caso algum imposto mude de valor não é preciso começar a fazer uma cascata de ifs...

O problema aí é que vc pode passar qualquer valor como argumento do método CalculaImposto... A operação tinha que ser uma só...

Não entendi o que você quer dizer Alberto, no caso o problema seria usar uma variável do tipo double ao invés de uma classe para calcular esse valor?

Imaginei que seria assim:

    public class RealizadorDeInvestimentos
    {
        public double Calculo(Conta conta, Investimento perfilInvestimento)
        {
            double valorInvestimento = perfilInvestimento.Calculo(conta);

            valorInvestimento -= perfilInvestimento.CalculaImposto(valorInvestimento);

            conta.Deposita(valorInvestimento);

            return valorInvestimento;
        }
    }

É bem esse código que vc postou.. parece obvio que o double que eu vou passar para o método CalculaImposto é o valor que foi retornado pelo método Calculo.. O problema é que não tem obrigatoriedade... Isso deveria ser uma operação só.

Mas como poderia ser uma operação só, se o imposto fosse diferente para cada investimento?

O imposto poderia ser parâmetro do método que calcula em si...

Não entendi, seria parâmetro de qual classe? RealizadorDeInvestimentos, Conservador/Moderado/Arrojado?

public double Calculo(Conta conta,CalculadorImposto calculador)
        {
            double resultado = 0;
            double saldo = 0;
            double valor = conta.Saldo;

            saldo = valor * 0.008;  //-- 0,8 %

            resultado = valor + saldo;

            return calculador.cobraImposto(resultado);
        }

Nesse caso, seria então das classes dos tipos de investimento, certo?

Teria que criar uma classe a mais para cada tipo de investimento e passaria a poder criar um novo investimento sem criar o calculadorImposto correspondente e ainda poderia passar o calculador de imposto de outro tipo de investimento....

Acredito que minha solução seria mais simples...

Bom, tava achando que vc teria categorias de imposto... Então vc pode fazer assim:

public double Calculo(Conta conta,double imposto)
        {
            double resultado = 0;
            double saldo = 0;
            double valor = conta.Saldo;

            saldo = valor * 0.008;  //-- 0,8 %

            resultado = valor + saldo;

            return resultado * (1 - imposto);
        }

Dado que o imposto seria 15% ou algo assim. Tudo depende do nível de proteção que vc quer mesmo.

Mas teria categoria de imposto, uma para cada tipo de investimento, e setar como parâmetro e calcular não seria "pior" ou ao menos similar do que executar o comando de calcular o Imposto ?

Para mim não seria pior. Para mim tem poucas coisas que sao piores do que código onde o programador tem que saber uma sequência exata de métodos dentro da mesma classe que precisam ser invocados.

Do jeito que vc sugeriu, eu teria que saber que o Double esperado no segundo método eh o resultado do primeiro. Toda solução de código tem ponto fraco e forte.. A que eu estou sugerindo tem a parte de criar mais classes.. em compensação faz com que vc possa reaproveitar os cálculos ebtre investimentos diferentes e também garante que o cálculo eh feita numa sequencia só.

Para mim eh isso... Não tem a melhor e a pior... Tem as possibilidades e o tradeoff de cada uma.

Concordo que não tem um modo de definir que o resultado de um local vai ser passado para o outro método, assim como não teria como definir que o resultado final deve subtrair do total:

return resultado * (1 - imposto);

Então, só para constar aqui :). Estamos falando de coisas diferentes.. o meu exemplo é de uma pessoa não familiarizada com a api tentando usar uma classe... O exemplo que vc deu é da pessoa implementando uma regra de negócio e fazendo isso de forma errada... Contra essa segunda, não tem nada que se possa fazer.. a pessoa esquecer de implementar a lógica é algo que só um teste poderia pegar.

São duas coisas muito interligadas né, a necessidade de passar o resultado também poderia ser encarado como implementação da lógica certo... Mas, para melhorar essa implementação acredito que deveria ser criado um atributo a ser acessado pelos 2 métodos e substituir o uso da variável, teria como definir uma variável double que possa ser acessado pelas 2 classes para assim não necessitar mais da variável valorInvestimento

Alberto, obrigado pela ajuda, deu para entender que é algo muito abstrato, vou finalizar o tópico.