Cómo Evitar el uso de totales acumulados en mi código Do I?

Question

Estoy aprendiendo la programación y diseño de software de Java y en la escuela en este momento. La clase que es cada vez me confundí es software de diseño. Estamos utilizando la palabra para ejecutar código VB simple de hacer programas sencillos. Mi instructor dice que estoy perdiendo la cohesión mediante el uso de totales acumulados. Estoy teniendo un tiempo difícil pensar en una manera de evitarlos. Aquí está un ejemplo de algunos pseudocódigo que estoy hablando (los módulos se llaman forman un módulo de controlador que no se muestra):

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

Básicamente DiscountPrice se utiliza para unir los dos primeros módulos y luego DeliveryPrice el segundo dos. Supuestamente, el último módulo puede incluso no necesita estar allí es me fijo este problema. Cualquier ayuda para el principiante?

Answer 1

Cuando miro a su ejemplo, lo que me salta a un problema con acoplamiento entre los módulos. (Si aún no lo ha estudiado ese concepto, es probable que pronto va.) Sin embargo, el exceso de acoplamiento y demasiado poca cohesión a menudo van de la mano, así que espero que aún te puedo dar una respuesta útil. (Simplificado en exceso, pero suficiente-para-aquí las definiciones: módulos cohesivos hacer una enfocada cosa en lugar de varias cosas no relacionadas, y los módulos acoplados dependen uno del otro para hacer lo que sea que hacen por lo general quieren módulos para tener una fuerte cohesión interna, pero el acoplamiento débil para. otros módulos.)

deduzco de su pseudocódigo que se desea calcular el precio de una cama de este modo:

* 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

Cuando expresas de esa manera, se puede notar que esas operaciones son (o pueden ser) bastante independientes entre sí. Por ejemplo, el costo de entrega en realidad no depende del precio de descuento, sólo en si o no una cuota de entrega va a ser acusado.

Ahora, la forma en que ha estructurado su diseño, la variable 'DeliveryPrice' es realmente un precio "como se entrega" que hace dependen del precio con descuento. Este es el tipo de cosa que queremos eliminar. Podemos decir que sus módulos se acoplan con demasiada fuerza, ya que dependen unos de otros en formas que no son realmente necesarios para resolver el problema. Podemos decir que carecen de cohesión porque están haciendo realmente más de una cosa - es decir, el módulo de precio de entrega es añadir los gastos de envío para el precio con descuento en lugar de sólo el cálculo de la tarifa de entrega .

Es difícil ver ejemplos de juguete, pero esto es importante como conseguir diseños más complejos. Con sólo unas pocas líneas de pseudocódigo, parece perfectamente natural para tener una "total acumulado" roscada entre ellos. Pero ¿y si la tasa de entrega depende de un cálculo complejo que implica la distancia a la casa del cliente, el peso de la compra, y el día de la semana? Ahora, teniendo que también implican cualquiera que sea el precio con descuento podría conseguir realmente confuso.

Así que, con todo esto en mente, considere este diseño 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                                  

Ahora, el acoplamiento se reduce - la entrega y el comercio en los módulos no se sabe nada en absoluto acerca de los precios de la cama. Esto también mejora su cohesión, ya que están haciendo algo más centrado - el cálculo de las tasas, no sumando los precios y tarifas. El cálculo del precio real no depende de los otros módulos, pero eso es inherente al problema. Y el cálculo es coherente - lo "único" que está haciendo es el cálculo del precio de la cama