工厂模式

socket重名了
128 阅读3分钟

工厂模式(Factory Pattern) 是用来创建对象的一个工厂，不必我们亲自创建对象，我们无需去理解如何创建对象，只需要向工厂提出要求，返回相应的对象，提高代码的可扩展性。

为什么使用工厂模式

  1. 松耦合：对象的创建独立于类的实现。
  2. 扩展性强：可以轻松增加一个新的对象而不用改动太多，也不需要调用者改动。
  3. 复用性强：工厂可以复用现有对象，不用频繁创建新对象。

工厂模式的分类

  1. 简单工厂
  2. 工厂方法
  3. 抽象工厂

简单工厂

可以算作工厂方法的一种，允许工厂类直接创建对象，不会暴露对象的创建逻辑。

实现一个简单工厂类，通过 create 方法创建对象：

from abc import ABC, abstractmethod

class Phone(ABC):
    @abstractmethod
    def power_on(self):
        pass

    @abstractmethod
    def power_off(self):
        pass


class Iphone(Phone):
    def power_on(self):
        pass

    def power_off(self):
        pass


class HuaweiPhone(Phone):
    def power_on(self):
        pass

    def power_off(self):
        pass

class PhoneFactory:

    @staticmethod
    def create(phone_type):
        if phone_type == "iphone":
            return Iphone
        if phone_type == "huawei":
            return HuaweiPhone

# 对象统一通过 PhoneFactory 创建
huawei_phone = PhoneFactory().create("huawei")
iphone = PhoneFactory().create("iphone")

优点

简单清晰，最简单情况下直接传一个参数即可。

缺点

如果要新增很多手机，就得修改 create 中的内容，增加很多判断条件，略微违反开闭原则（逻辑简单时可使用）。

工厂方法

工厂方法模式将父工厂类抽象出来，由具体的子工厂类实现功能，从而通过具体的子工厂类创建相应的具体对象。

实现一个工厂方法：

class Computer(ABC):
    @abstractmethod
    def power_on(self):
        pass


class HuaweiComputer(Computer):
    def power_on(self):
        pass


class DellComputer(Computer):
    def power_on(self):
        pass


class ComputerFactory(ABC):
    @abstractmethod
    def create(self):
        pass


class HuaweiComputerFactory(ComputerFactory):
    def create(self):
        return HuaweiComputer


class DellComputerFactory(ComputerFactory):
    def create(self):
        return DellComputer

# 通过具体的子类来实现创建
huawei_pc = HuaweiComputerFactory().create()
dell_pc = DellComputerFactory().create()

优点

符合开闭原则，不需要修改原有代码，直接新增一个对象

缺点

代码改动较大，新增子类时，调用者同时需要改动代码

抽象工厂

在抽象工厂模式中，一个具体工厂类具备返回一系列相关对象的能力。

实现一个抽象工厂：

class Phone(ABC):
    @abstractmethod
    def power_on(self):
        pass

    @abstractmethod
    def power_off(self):
        pass

class Iphone(Phone):
    def power_on(self):
        pass

    def power_off(self):
        pass

class HuaweiPhone(Phone):
    def power_on(self):
        pass

    def power_off(self):
        pass

class Desktop(ABC):
    @abstractmethod
    def power_on(self):
        pass

    @abstractmethod
    def power_off(self):
        pass

class HuaweiDesktop(Desktop):
    def power_off(self):
        pass

    def power_on(self):
        pass

class MacBook(Desktop):
    def power_on(self):
        pass

    def power_off(self):
        pass

# 抽象工厂类
class BrandFactory(ABC):
    @abstractmethod
    def create_phone(self):
        pass

    @abstractmethod
    def create_desktop(self):
        pass


# 抽象工厂实现子类
class HuaweiFactory(BrandFactory):
    def create_desktop(self):
        return HuaweiDesktop

    def create_phone(self):
        return HuaweiPhone

# 抽象工厂实现子类
class AppleFactory(BrandFactory):
    def create_phone(self):
        return Iphone

    def create_desktop(self):
        return MacBook


# 具体的产品由工厂中具体的方法实现
huawei_factory = HuaweiFactory()
huawei_matebook = huawei_factory.create_desktop()
huawei_p50 = huawei_factory.create_phone()

apple_factory = AppleFactory()
iphone13 = apple_factory.create_phone()
macbook_pro = apple_factory.create_desktop()

总结

对工厂方法和抽象工厂方法做一个简单的总结：

工厂方法抽象工厂方法
主要通过继承的方式主要通过组合的方式
一个子类创建一个对象一个具体子类创建一系列相关对象

一般来说，使用简单工厂和工厂方法的场景比较多一些，抽象工厂平常遇到的就比较少了。

avatar
文章
阅读
粉丝