Decorator Design Pattern: Enhancing Functionality without Altering Structure

The Decorator Design Pattern is a powerful tool in the world of software development, allowing developers to add new functionality to existing classes without altering their structure. This is particularly useful in object-oriented languages like Swift, where classes are the building blocks of our programs.

At its core, the Decorator Design Pattern is all about creating a new class that wraps an existing one. This new class is called the decorator, and it provides additional functionality on top of the original class. The original class is called the component.

To start, let's create a `Beverage` protocol that provides its cost and its ingredients

Next, we will create the beverage class and use `Coffee` as an example, which is the component class that implements the `Beverage` protocol.

Next, we need to create the `CoffeeDecorator` class, which is the abstract decorator class that implements the `Beverage` protocol and contains a reference to an instance of the `Beverage` protocol.

The `Milk` and `Sugar` classes are concrete decorator classes that extend the `CoffeeDecorator` class and add the desired behavior to the component class.

Finally, we can use this design pattern to create various types of coffee by composing objects of the component class and decorator classes:

In conclusion, the Decorator design pattern is a useful pattern for dynamically adding behavior to objects. By using the Decorator pattern, you can create objects with a rich set of behaviors by composing objects of the component class and decorator classes. This pattern provides a flexible alternative to using inheritance to add behavior to objects and can be especially useful in cases where the behavior of an object needs to be changed dynamically at runtime. With its modular and reusable design, the Decorator pattern is a valuable tool for software development in Swift.