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.

Scala
Copy to clipboard
1@main def main(): Unit =
2  var simpleCoffee: Coffee = SimpleCoffee()
3  var milkCoffee: Coffee = MilkDecorator(simpleCoffee)
4  var milkAndSugarCoffee: Coffee = SugarDecorator(milkCoffee)
5
6  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.

Start by defining an abstract Coffee trait. This trait includes a getDescription method and a cost method. Then, we implement the SimpleCoffee class extending Coffee, providing an implementation for the cost method.

Scala
Copy to clipboard
1trait Coffee:
2  def getDescription(): String = "Coffee"
3  def cost(): Double
4
5class SimpleCoffee extends Coffee:
6  def cost(): Double = 2.0

Next, implement a CoffeeDecorator abstract class extending the Coffee trait. It takes an instance of Coffee and delegates the calls to getDescription and cost to the wrapped instance.

Scala
Copy to clipboard
1abstract class CoffeeDecorator(coffee: Coffee) extends Coffee:
2  override def getDescription(): String = coffee.getDescription()
3  override def cost(): Double = coffee.cost()

Follow up by extending CoffeeDecorator to create a MilkDecorator class that overrides the getDescription and cost methods to enhance the original coffee with milk's description and cost.

Scala
Copy to clipboard
1class MilkDecorator(coffee: Coffee) extends CoffeeDecorator(coffee):
2  override def getDescription(): String = super.getDescription() + ", Milk"
3  override def cost(): Double = super.cost() + 0.5

Similarly, extend the CoffeeDecorator class to create a SugarDecorator. This decorator adds sugar's description and cost.

Scala
Copy to clipboard
1class SugarDecorator(coffee: Coffee) extends CoffeeDecorator(coffee):
2  override def getDescription(): String = super.getDescription() + ", Sugar"
3  override def cost(): Double = super.cost() + 0.2

Let’s piece together these components in the main method to see them at work:

1. Creating a SimpleCoffee instance: Begin with a basic SimpleCoffee, representing the core functionality.

   Scala
   Copy to clipboard
   1var myCoffee: Coffee = SimpleCoffee()
   2println(s"${myCoffee.getDescription()} $$${myCoffee.cost()}")
   3// Output: Coffee $2.0

2. Decorating with Milk: Wrap the SimpleCoffee with a MilkDecorator. This adds the milk description and cost to the coffee.

   Scala
   Copy to clipboard
   1myCoffee = MilkDecorator(myCoffee)
   2println(s"${myCoffee.getDescription()} $$${myCoffee.cost()}")
   3// Output: Coffee, Milk $2.5

3. Decorating with Sugar: Finally, wrap the milk-decorated coffee with a SugarDecorator, which adds sugar's description and cost to the already enhanced coffee.

   Scala
   Copy to clipboard
   1myCoffee = SugarDecorator(myCoffee)
   2println(s"${myCoffee.getDescription()} $$${myCoffee.cost()}")
   3// Output: Coffee, Milk, Sugar $2.7

This demonstration shows how to start from a base component (SimpleCoffee) and dynamically add functionalities by overlaying decorators. Each decorator extends its own behavior while maintaining the core functionality.

Understanding the Decorator Pattern is vital as it lets you dynamically extend the functionalities of objects without making changes to their structure. This keeps your code more modular and maintainable compared to subclassing for each new feature. Much like constructing a richly flavored coffee by layering milk and sugar, you can layer decorators to enhance functionalities flexibly and elegantly. The Decorator Pattern serves as a powerful solution in various domains, from UI components to graphical renderers. 🌟

Now, it's your turn! Head to the practice section, where you'll dive deeper into implementing and extending the Decorator Pattern step by step. Enjoy crafting your code just like you would your favorite coffee! ☕