Introduction to the Decorator Pattern in Scala

Welcome to the third lesson of the "Structural Patterns in Scala" course! 🎉 Now that you’ve mastered the Adapter and Composite Patterns, it’s time to tackle another fundamental structural design pattern: the Decorator Pattern. Recognized for its ability to dynamically and transparently enhance the functionalities of objects, the Decorator Pattern is your friend when you want to expand an object's behavior without altering its core code. By wrapping an object with additional responsibilities, this pattern offers a flexible and reusable approach to extending object functionality elegantly. In this lesson, you'll learn how to use this pattern to extend the functionality of objects in a clean and maintainable manner. Let's go!

Think of a coffee shop where customization is the name of the game. You start with a simple coffee and upgrade it with add-ons like milk, sugar, or even whipped cream. Each add-on enhances the coffee’s description and cost. Through this example, we can describe the core concepts of this pattern:

• Simple Coffee (Core Component): Start with a fundamental component — the basic coffee with its essential properties, such as description and cost.
• Milk (Decorator): Add milk to enhance the description ("Milk") and cost.
• Sugar (Decorator): Similarly, sugar adds its own description and cost.

With the Decorator Pattern, you can easily layer these add-ons to build a delightful coffee experience!

Layering decorators is as easy as stacking your favorite toppings on a sundae! Let's see how you can combine them in Scala.

@main def main(): Unit =
  var simpleCoffee: Coffee = SimpleCoffee()
  var milkCoffee: Coffee = MilkDecorator(simpleCoffee)
  var milkAndSugarCoffee: Coffee = SugarDecorator(milkCoffee)

  println(s"${milkAndSugarCoffee.getDescription()} $$${milkAndSugarCoffee.cost()}")

In this structure, each decorator enhances the functionality of the core component dynamically. Begin with plain coffee and craft complex orders by wrapping it with various decorators.

The Decorator Pattern allows you to dynamically add or remove functionality to objects without altering their structure. This leads to more modular and maintainable code compared to subclassing for every possible combination of enhancements. In our coffee shop example, you can easily extend the coffee's behavior at runtime by adding decorators like milk, sugar, or any other ingredients.