Abstraktes Fabrikmuster in Python

Question

Ich habe heute über das Abstract Factory Pattern gelesen und versucht, die folgende Implementierung vorzunehmen.

Ich habe viele Implementierungen im Internet gesehen, wo sie switchAnweisungen verwenden, aber ich muss sagen, dass mir das nicht so gut gefallen hat, da es mir scheint, dass es sehr schwierig wird, neue Produkte hinzuzufügen, je mehr Fabriken Sie machen, wenn benötigt.

Wie auch immer, ich hatte gehofft, dass Sie einen Blick darauf werfen und mir Ihre Meinung mitteilen würden. Vielen Dank im Voraus, dass Sie sich die Zeit genommen haben, es zu überprüfen.

Fabriken

from abc import ABC, abstractmethod


class PlayerFactory(ABC):
    """
    This class is meant to be an interface
    """
    @abstractmethod
    def create_goalkeeper(self):
        pass

    @abstractmethod
    def create_defender(self):
        pass


class FootballPlayerFactory(PlayerFactory):
    def create_goalkeeper(self):
        return FootballGoalkeeper()

    def create_defender(self):
        return FootballDefender()


class HockeyPlayerFactory(PlayerFactory):
    def create_goalkeeper(self):
        return HockeyGoalkeeper()

    def create_defender(self):
        return HockeyDefender()

Fussballspieler

class FootballPlayer:
    def __init__(self, uses_hands):
        self.uses_hands = uses_hands

    def play(self):
        print("I'm playing football!")


class FootballGoalkeeper(FootballPlayer):
    def __init__(self):
        super(FootballGoalkeeper, self).__init__(uses_hands=True)


class FootballDefender(FootballPlayer):
    def __init__(self):
        super(FootballDefender, self).__init__(uses_hands=False)

Hockeyspieler ( meine Kreativität hat hier aufgehört, also habe ich keinen Unterschied zwischen Torhütern und Verteidigern gemacht )

class HockeyPlayer:
    def play(self):
        print("I'm playing hockey!")


class HockeyGoalkeeper(HockeyPlayer):
    pass


class HockeyDefender(HockeyPlayer):
    pass

Answer 1

So wie Ihr Code derzeit aussieht, benötigen Sie die abgeleiteten Factory-Klassen nicht. Sie unterscheiden sich nicht voneinander, sodass sie alle von einer konkreten Basisklasse behandelt werden können.

class PlayerFactory:

    def __init__(self, goal_keeper_class, defender_class):
        self._goal_keeper_class = goal_keeper_class
        self._defender_class = defender_class

    def create_goalkeeper(self):
        return self._goal_keeper_class()

    def create_defender(self):
        return self._defender_class()

player_factory = {
    "Football": PlayerFactory(FootballGoalkeeper, FootballDefender),
    "Hockey": PlayerFactory(HockeyGoalkeeper, HockeyDefender),
}

Beispielnutzung:

>>> player = player_factory["Hockey"].create_defender()
>>> type(player)
<class '__main__.HockeyDefender'>
>>> player.play()
I'm playing hockey!
>>>

Wenn es einen Aspekt der Fabriken gibt, der tatsächlich etwas anderes macht und daher getrennte abgeleitete Klassen erfordert, müssen Sie dies in Ihre Frage aufnehmen.