首页 > Python设计模式 > 第二章: 常用设计模式 > 2.4节: 工厂模式

2.4节: 工厂模式

薯条老师 2021-10-01 16:46:11 215181 0

编辑收藏

广州番禺Python, Java小班周末班培训

薯条老师在广州做Python和Java的小班培训，一个班最多10人，学员的平均就业薪资有11K。不在广州的同学可以报名线上直播班，跟线下小班的同学们同步学习。培训的课程有Python爬虫，Python后端开发，Python办公自动化，Python大数据分析，Python量化投资，Python机器学习，Java中高级后端开发。授课详情请点击：http://www.chipscoco.com/?cate=6

2.4.1 工厂模式

现实中的工厂用来生产产品，设计模式中的"工厂"用来生产对象。工厂模式封装了对象的创建过程，将对象的创建和使用进行解耦。客户端在使用对象时无需关心对象是怎么创建的。

2.3.2 三种实现

工厂模式按抽象程度的不同，可分为以下三种实现方式：

(1) 简单工厂模式 (2) 工厂方法模式 (3) 抽象工厂模式

读者接下来可通过源码中的代码注释来理解每一种模式的实现原理和局限性。

2.3.3 源码实现

简单工厂模式：

Python

# __author__ = 薯条老师
"""
(1)  工厂模式封装了对象的创建过程，将对象的创建和使用进行解耦
"""

import abc


"""
(2) 定义一个抽象基类Cat。Python中的抽象基类，需继承于abc模块的ABC类。
"""
class Cat(abc.ABC):
    @abc.abstractmethod
    def cry(self):
        """ cat's cry is not cry"""
        
        
"""
(3) 定义Moggy类表示家猫，WildCat类表示野猫，分别继承于Cat
"""
class Moggy(Cat):
    def cry(self):
        print("moggy cry always be tender like a girl")
        
        
class WildCat(Cat):
    def cry(self):
        print("wild cat cry always be crazy like a widow")
        
        
# 定义猫的类型，避免硬编码
class CatType:
    MOGGY = 0
    WILDCAT = 1
    
    
"""
(4) 定义简单工厂SimpleCatFactory来构建Cat子类。所谓简单工厂是指直接根据
客户端传递的参数来创建不同的对象
"""
class  SimpleCatFactory:
    @staticmethod
    def breed_cat(cat_type=CatType.MOGGY):
        cat_ = None
        """
        (5) 工厂模式的缺点在于一旦新增需要创建的对象，那么必须修改工厂方法，违反了开闭原则
        """
        if cat_type == CatType.MOGGY:
            cat_ = Moggy()
        elif cat_type == CatType.WILDCAT:
            cat_ = WildCat()
        return cat_
        
        
if __name__ == "__main__":
    # 客户端在使用对象时无需关心对象是怎么创建的
    cat = SimpleCatFactory.breed_cat()
    cat.cry()
    cat = SimpleCatFactory.breed_cat(CatType.WILDCAT)
    cat.cry()

工厂方法模式：

Python

# __author__ = 薯条老师，微信公众号：薯条编程
"""
一、理解工厂方法模式的结构：
(1) 抽象工厂 ：只提供创建对象的接口
(2) 具体工厂:  继承于抽象工厂，实现抽象工厂中的抽象方法
(3) 抽象产品 : 定义了使用产品的抽象接口
(4) 具体产品： 继承于抽象产品，实现了抽象产品中的抽象方法
工厂方法模式很好理解：某一个具体的产品由某一个具体的工厂创建，这样在新增产品时
无需修改原有的代码。缺点是一个工厂只负责创建一类产品，会带来子类过多的问题
"""

import abc


"""
(1) 定义一个抽象产品类Cat 
"""
class Cat(abc.ABC):
    @abc.abstractmethod
    def cry(self):
        """ cat's cry is not cry"""
        
        
"""
(2) 定义Moggy类表示家猫，WildCat类表示野猫，分别继承于Cat
"""
class Moggy(Cat):
    def cry(self):
        print("moggy cry always be tender like a girl")
        
        
class WildCat(Cat):
    def cry(self):
        print("wild cat cry always be crazy like a widow")
        
        
"""
(3) 定义CatFactory表示繁育猫的抽象工厂 
"""
class CatFactory(abc.ABC):
    @staticmethod
    def breed_cat():
        pass
        
        
"""
(4) 定义具体工厂MoggyFactory,用来繁殖moggy 
"""
class MoggyFactory(CatFactory):
    @staticmethod
    def breed_cat():
        return Moggy()
        
        
"""
(5) 定义具体工厂MoggyFactory,用来繁殖wild  cat
"""
class WildCatFactory(CatFactory):
    @staticmethod
    def breed_cat():
        return WildCat()
        
        
if __name__ == "__main__":
    """
    客户端需指定具体的工厂来创建对象
    工厂方法模式的缺点是一个工厂只负责创建一类产品，这样会带来子类过多的问题
    """
    moggy = MoggyFactory.breed_cat()
    moggy.cry()
    lisa = WildCatFactory.breed_cat()
    lisa.cry()

抽象工厂模式：

Python

# __author__ = 薯条老师，微信公众号：薯条编程
"""
(1) 抽象工厂模式用来提供创建一系列相关或相互依赖对象的接口，无需指定它们具体的类，
这是抽象工厂有别于工厂方法模式的地方。
如果使用工厂方法模式, 那么每一类产品都需要指定一个具体的工厂类。
"""

import abc

"""
(2) 定义一个Cat基类，该基类提供cry接口。使用abc模块来定义抽象基类时需将基类指定
为abc.ABC,将方法使用abc.abstractmethod进行装饰
"""
class Cat(abc.ABC):
    @abc.abstractmethod
    def cry(self):
        """ cat's cry is not cry"""
        
        
# 实现cry方法的印度猫
class IndiaCat(Cat):
    def cry(self):
        print("india cat  always cry like a widow")
        
        
# 实现cry方法的美国猫
class AmericanCat(Cat):
    def cry(self):
        print("american  cat  always cry like a  bitch")
        
        
"""
(3) 定义一个Dog基类，该基类提供bark接口。使用abc模块来定义抽象基类时需将基类指定
为abc.ABC,将方法使用abc.abstractmethod进行装饰
"""
class Dog(abc.ABC):
    @abc.abstractmethod
    def bark(self):
        """ dog's cry is not cry"""
        
        
# 实现bark方法的印度犬
class IndiaDog(Dog):
    def bark(self):
        print("india dog  always bark  like a crazy man")
        
        
# 实现bark方法的美国犬
class AmericanDog(Dog):
    def bark(self):
        print("american  dog  always bark  like  a crazy woman")
        
        
"""
(4) 定义一个AnimalFactory基类，该基类提供创建一系列相关对象的抽象接口，比如繁育猫，繁育狗。
"""
class AnimalFactory(abc.ABC):
    @abc.abstractmethod
    def breed_cat(self):
        """ breed cat """
    @abc.abstractmethod
    def breed_dog(self):
        """ breed dog """
        
        
class IndiaAnimalFactory(AnimalFactory):
    def breed_cat(self):
        return IndiaCat()
    def breed_dog(self):
        return IndiaDog()
        
        
class AmericanAnimalFactory(AnimalFactory):
    def breed_cat(self):
        return AmericanCat()
    def breed_dog(self):
        return AmericanDog()
        
        
if __name__ == "__main__":
    animal_factory = IndiaAnimalFactory()
    kitty = animal_factory.breed_cat()
    kitty.cry()
    yolo = animal_factory.breed_dog()
    yolo.bark()
    animal_factory = AmericanAnimalFactory()
    lisa = animal_factory.breed_cat()
    lisa.cry()
    linda = animal_factory.breed_dog()
    linda.bark()

2.3.4 最具实力的小班培训

薯条老师在广州做Python和Java的小班培训，一个班最多10人。不在广州的同学可以报名线上直播班，跟线下小班的同学们同步学习。打算参加小班培训的同学，必须遵守薯条老师的学习安排，认真做作业和项目。把知识学好，学扎实，那么找到一份高薪的工作就是很简单的一件事。

(1) Python后端工程师高薪就业班，月薪11K-18K，免费领取课程大纲
(2) Python爬虫工程师高薪就业班，年薪十五万，包拿Offer
(3) 数据分析高薪就业班，月薪11K-15K, 免费领取课程大纲
(4) Python大数据挖掘，量化投资就业班，月薪12K-25K,免费领取课程大纲