What are some examples of the factory design pattern?

What are some examples of the factory design pattern?

The factory design pattern is a creational pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. For example, in a game, you might have a CharacterFactory that creates different types of characters like Warrior, Mage, or Archer.

Can you give me a code example of a factory pattern?

Sure! Here's a simple example in Python:

class Character:
    def attack(self):
        pass

class Warrior(Character):
    def attack(self):
        return "Warrior attacks with sword!"

class Mage(Character):
    def attack(self):
        return "Mage casts a fireball!"

class CharacterFactory:
    @staticmethod
    def create_character(character_type):
        if character_type == 'warrior':
            return Warrior()
        elif character_type == 'mage':
            return Mage()
        else:
            raise ValueError("Unknown character type")

# Usage
character = CharacterFactory.create_character('warrior')
print(character.attack())  # Output: Warrior attacks with sword!

What are the benefits of using the factory pattern?

The factory pattern promotes loose coupling in your code, making it easier to manage and extend. It allows you to introduce new types of objects without modifying existing code, which adheres to the Open/Closed Principle.

Are there any drawbacks to using the factory pattern?

Yes, one drawback is that it can introduce additional complexity to your codebase. If overused, it may lead to a situation where the code becomes harder to understand due to the indirection of object creation.