Como evito usar os totais de execução no meu código?

Question

Estou aprendendo programas e design de software e Java na escola agora. A classe que está me misturando é o design de software. Estamos usando o Word para executar o código VB simples para fazer programas simples. Meu instrutor diz que estou perdendo a coesão usando os totais de corrida. Estou tendo dificuldade em pensar em uma maneira de evitá -los. Aqui está um exemplo de algum pseudocódigo de que estou falando (os módulos são chamados de um módulo de driver que não é mostrado):

CaluculateDiscountPrice module
    DiscountPrice = (FloorPrice * (1 – DiscountRate))
End module

CalculateDeliveryPrice module
    If DeliveryFee = “Yes” Then
        DeliveryPrice = DiscountPrice + 20  
    ElseIf DeliveryFee = “No” Then
        DeliveryPrice = DiscountPrice
    End If
End module

CalculateTradeInCredit module
    If TradeInCredit = “Yes” Then
        CreditedPrice = DeliveryPrice – 5
    ElseIf TradeInCredit = “No” Then
        CreditedPrice = DeliveryPrice
    End If
End module

CaluculateCostOfBed module
    CostOfBed = CreditedPrice
End module

Basicamente DiscountPrice é usado para ingressar nos dois primeiros módulos e depois DeliveryPrice os dois segundos. Supostamente, o último módulo pode nem precisar ser que eu resolva esse problema. Alguma ajuda para o iniciante?

Answer 1

Quando olho para o seu exemplo, o que salta para mim é um problema com acoplamento entre módulos. (Se você ainda não estudou esse conceito, provavelmente em breve.) No entanto, muito acoplamento e pouca coesão geralmente se juntam, então espero que eu ainda possa lhe dar uma resposta útil. (Definições simplificadas, mas adequadas por aqui: os módulos coesos fazem uma coisa focada em vez de várias coisas não relacionadas, e os módulos acoplados dependem um do outro para fazer o que eles fazem. Geralmente queremos outros módulos.)

Deduro do seu pseudocódigo que você deseja calcular o preço de uma cama assim:

* start with the floor price
* discount it
* add in a delivery fee
* subtract a trade-in credit
* the result is the cost of the bed

Quando você expressa assim, você pode notar que essas operações são (ou podem ser) bastante independentes uma da outra. Por exemplo, a taxa de entrega não depende realmente do preço com desconto, apenas se uma taxa de entrega deve ou não ser cobrada.

Agora, a maneira como você estruturou seu design, sua variável 'DeliveryPrice' é realmente um preço "como entregue" que faz dependem do preço com desconto. Esse é o tipo de coisa da qual queremos nos livrar. Podemos dizer que seus módulos estão muito bem acoplados porque dependem um do outro de maneiras que não são realmente necessárias para resolver o problema. Podemos dizer que eles não têm coesão porque estão realmente fazendo mais de uma coisa - ou seja, o módulo de preço de entrega é Adicionando a taxa de entrega ao preço com desconto em vez de apenas calculando a taxa de entrega.

É difícil ver com exemplos de brinquedos, mas isso importa à medida que os designs ficam mais complexos. Com apenas algumas linhas de pseudocódigo, parece perfeitamente natural ter um "total em execução" roscado entre elas. Mas e se a taxa de entrega depender de um cálculo complexo que envolve a distância da casa do cliente, do peso da compra e do dia da semana? Agora, tendo isso também Envolva o que o preço com desconto ficaria realmente confuso.

Então, com tudo isso em mente, considere este design alternativo:

CalculateDeliveryFee module                                  
    If DeliveryFeeCharged = “Yes” Then                                  
        DeliveryFee = 20                                    
    End If                                  
End module                                  

CalculateTradeInCredit module                                  
    If TradeInCreditApplied = “Yes” Then                                  
        TradeInCredit = 5                                  
    End If                                  
End module                                  

CaluculateCostOfBed module 
    DiscountPrice = (FloorPrice * (1 – DiscountRate))  
    AsDeliveredPrice = DiscountPrice + DeliveryFee   
    WithTradeInPrice = AsDeliveredPrice - TradeInCredit                             
    CostOfBed = WithTradeInPrice 
End module                                  

Agora, o acoplamento é reduzido - os módulos de entrega e troca não sabem nada sobre os preços da cama. Isso também melhora sua coesão, pois eles estão fazendo algo mais focado - calcular taxas, não resumir preços e taxas. O cálculo real de preços depende dos outros módulos, mas isso é inerente ao problema. E o cálculo é coeso - a "uma coisa" que está fazendo é calcular o preço da cama!