Factory Method Design Pattern in Swift

The Factory Method pattern is a creational pattern that provides an interface for creating objects. It lets subclasses decide which class to instantiate. In other words, it provides a way to defer the instantiation of an object to its subclasses.

The Factory Method pattern is useful when you need to create objects that share common behaviors or properties but have different implementations. For example, you may have a class hierarchy of shapes, where each shape has a different implementation for calculating its area. With the Factory Method pattern, you can define an interface for creating shapes, and let subclasses decide which shape to create based on the parameters passed to the method.

Let's take a look at an example of implementing the Factory Method pattern in Swift. We will create a class hierarchy of vehicles, where each vehicle has a different implementation for accelerating and braking. We will then define a VehicleFactory interface that provides a way to create vehicles, and let subclasses decide which vehicle to create based on the type of vehicle requested.

Here's what the vehicle hierarchy looks like:

class Vehicle {
    func accelerate() {
        fatalError("Not implemented")
    }
    
    func brake() {
        fatalError("Not implemented")
    }
}

class Car: Vehicle {
    override func accelerate() {
        print("Car is accelerating")
    }
    
    override func brake() {
        print("Car is braking")
    }
}

class Bike: Vehicle {
    override func accelerate() {
        print("Bike is accelerating")
    }
    
    override func brake() {
        print("Bike is braking")
    }
}

Next, let's define the VehicleFactory interface:

protocol VehicleFactory {
    func createVehicle() -> Vehicle
}

Now, let's implement the VehicleFactory interface in two different classes: CarFactory and BikeFactory. The CarFactory creates instances of the Car class, while the BikeFactory creates instances of the Bike class:

class CarFactory: VehicleFactory {
    func createVehicle() -> Vehicle {
        return Car()
    }
}

class BikeFactory: VehicleFactory {
    func createVehicle() -> Vehicle {
        return Bike()
    }
}

Finally, let's use the VehicleFactory to create instances of vehicles:

let carFactory = CarFactory()
let bikeFactory = BikeFactory()

let car = carFactory.createVehicle()
let bike = bikeFactory.createVehicle()

car.accelerate()
car.brake()

bike.accelerate()
bike.brake()

In the above code, we create instances of CarFactory and BikeFactory, and use them to create instances of Car and Bike. We then call the accelerate() and brake() methods on the Car and Bike instances, which calls the appropriate implementation of these methods based on the type of vehicle.

The Factory Method pattern is a creational pattern that provides an interface for creating objects but lets subclasses decide which class to instantiate. In this article, we explored the Factory Method pattern and provided an example of its implementation in Swift. The Factory Method pattern is useful when you need to create objects that share common behaviors or properties but have different implementations.

Disadvantage

1. Complexity: The Factory Method pattern can add complexity to a project, especially if the factory class is complex or if there are many different types of objects that need to be created.
2. Overhead: The Factory Method pattern introduces additional overhead in the form of the factory class, which may not be necessary for simple projects.
3. Increased Code Complexity: While the Factory Method pattern helps in encapsulating the creation of objects, it can also increase the code complexity if the factory class is not designed properly.

Advantage

1. Encapsulation: The Factory Method pattern encapsulates the creation of objects within a factory class, which reduces the amount of code needed in the client code that uses the objects.
2. Flexibility: The Factory Method pattern provides a flexible way to create objects. By delegating object creation to a separate factory class, it is possible to customize or extend the creation process without modifying the client code.
3. Decoupling: The Factory Method pattern decouples the client code from the details of object creation. This makes it easier to change the implementation of the object creation process without affecting the client code.

Best Practise

1. Use protocols: Use protocols to define the interface for the objects that will be created by the factory. This allows for flexibility and easy substitution of different concrete implementations.
2. Make the Factory Method static: By making the factory method static, you don't need to create an instance of the factory to create objects. This can simplify the code and make it more efficient.
3. Use an enum to define the types: Use an enum to define the different types of objects that the factory can create. This makes it easy to add new types in the future and helps prevent mistakes.
4. Use dependency injection: Use dependency injection to pass the factory object to the classes that need it. This allows for better decoupling of the classes and makes testing easier.
5. Keep it simple: Keep the factory method simple and focused on creating objects. Avoid adding unnecessary logic or business rules to the factory method.
6. Provide default values: Provide default values for the factory method parameters to make it easier to use and reduce the likelihood of errors.
7. Document the factory method: Document the factory method and its parameters to make it clear what it does and how to use it.

Please 👏🏻 if you like this post. It will motivate me to continue creating high-quality content like this one.

Support Me

Thank you for taking the time to read my blog post! If you found it valuable, I would greatly appreciate it if you could share the post on Twitter and LinkedIn, etc. Your support in spreading the word about my content means a lot to me. Thank you again!

Follow me

I hope you found this post helpful. If you want to stay up-to-date with my latest work, be sure to follow me on my page or my Twitter.