Design Patterns with Swift: Decorator Pattern Explained

By /

Design Patterns with Swift: Decorator Pattern Explained

Design Patterns are essential tools in software development. They provide a way to solve common problems in an efficient and reusable way, allowing developers to focus on the bigger picture instead of individual tasks. One such pattern is the Decorator Pattern, which is used to add extra functionality to existing objects without modifying their code. This article will explain how to implement the Decorator Pattern in Swift.

The Decorator Pattern allows us to extend the functionality of an object without changing its code. It works by wrapping the original object in a “decorator”, which adds additional features. This means that we can keep the original object intact while adding new functionality. This is especially useful when dealing with legacy code, as we can easily add new features without making any changes to the existing code.

Let’s look at an example of how we can use the Decorator Pattern in Swift. Suppose we have a class called Car that represents a basic car object. We want to add some additional features to the car, such as air conditioning and a sunroof. To do this, we can create a decorator class called CarDecorator. This class will take an instance of Car and add the extra features on top of it. 

class Car {
    var make: String
    var model: String

    init(make: String, model: String) {
        self.make = make
        self.model = model
    }
}

class CarDecorator {
    private let car: Car

    init(car: Car) {
        self.car = car
    }

    func getMakeAndModel() -> String {
        return "\(car.make) \(car.model)"
    }
}

class AirConditionedCar: CarDecorator {
    override func getMakeAndModel() -> String {
        return super.getMakeAndModel() + " with air conditioning"
    }
}

class SunroofCar: CarDecorator {
    override func getMakeAndModel() -> String {
        return super.getMakeAndModel() + " with a sunroof"
    }
}

let myCar = Car(make: "Toyota", model: "Corolla")
let myAirConditionedCar = AirConditionedCar(car: myCar)
let mySunroofCar = SunroofCar(car: myAirConditionedCar)

print(mySunroofCar.getMakeAndModel()) // Toyota Corolla with air conditioning with a sunroof

In this example, we have a Car class that represents a basic car object. We then created a CarDecorator class that wraps the Car object and adds additional features. We then created two subclasses of CarDecorator, AirConditionedCar and SunroofCar, which each add their own additional features. Finally, we created an instance of Car and wrapped it in our AirConditionedCar and SunroofCar decorators, giving us a car with both air conditioning and a sunroof.

The Decorator Pattern is an incredibly useful pattern for adding extra features to existing classes. It allows us to add features without having to modify the code of the original class. This can be especially helpful when dealing with legacy code, as it allows us to add new features without making any changes to the existing code.

The Decorator Pattern is a great way to add additional features to existing objects in a clean and efficient way. By using the pattern, we can easily extend the functionality of existing classes without changing their code. This makes it a great tool for dealing with legacy code, as we can add new features without having to make any changes to the existing code. So if you ever find yourself needing to add extra features to an existing class, consider using the Decorator Pattern.

Scroll to Top