Python：设计模式之工厂模式
【摘要】 工厂： 表示负责创建其他类型对象的类
优点： 1、松耦合，对象的创建可以独立于类的实现 2、客户端无需了解创建对象的类，但是可以使用它来创建对象。只需要知道需要传递的接口，方法和参数 3、工厂中添加其他类来创建其他类型的对象，无需更改客户端代码 4、工厂可以重用现有对象
分类 1、简单工厂模式 允许接口创建对象，但不会暴露对象的创建逻辑 2、工厂方法模式 允许接口创...
工厂：
表示负责创建其他类型对象的类
优点：
1、松耦合，对象的创建可以独立于类的实现
2、客户端无需了解创建对象的类，但是可以使用它来创建对象。只需要知道需要传递的接口，方法和参数
3、工厂中添加其他类来创建其他类型的对象，无需更改客户端代码
4、工厂可以重用现有对象
分类
1、简单工厂模式
允许接口创建对象，但不会暴露对象的创建逻辑
2、工厂方法模式
允许接口创建对象，但使用哪个类来创建对象，则交由子类决定
3、抽象工厂模式
抽象工厂是一个能创建一系列相关对象，而无需指定/公开具体类的接口，
该模式能够提供其他工厂的对象，在其内部创建对象
简单工厂模式
# -*- coding: utf-8 -*-
from abc import ABC, abstractmethod
class Animal(ABC): @abstractmethod def say_hi(self): pass
class Dog(Animal): def say_hi(self): print("汪汪汪...")
class Cat(Animal): def say_hi(self): print("喵喵喵...")
class Factory(object): def make_sound(self, animal): eval(animal)().say_hi()
if __name__ == '__main__': factory = Factory() factory.make_sound("Dog") factory.make_sound("Cat") """ 汪汪汪... 喵喵喵... """
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
工厂方法模式
1、定义一个接口来创建对象，工厂本身并不负责创建对象，由子类完成
2、工厂方法的创建通过继承而不是实例化完成
3、工厂方法使得设计更加具有可定制性，返回相同的实例或子类，而不是某种类型的对象（类似简单工厂方法）
# -*- coding: utf-8 -*-
from abc import ABC, abstractmethod
# 组件部分
class Section(ABC): @abstractmethod def describe(self): pass
class PersonalSection(Section): def describe(self): print("PersonalSection")
class AlbumSection(Section): def describe(self): print("AlbumSection")
class PatentSection(Section): def describe(self): print("PatentSection")
class PublicationSection(Section): def describe(self): print("PublicationSection")
# 工厂部分
class Profile(ABC): def __init__(self): self.sections = [] self.create_profile() @abstractmethod def create_profile(self): pass def show_sections(self): for section in self.sections: section.describe() def add_section(self, section): self.sections.append(section)
class LinkedIn(Profile): def create_profile(self): self.add_section(PersonalSection()) self.add_section(PatentSection()) self.add_section(PublicationSection())
class FaceBook(Profile): def create_profile(self): self.add_section(PersonalSection()) self.add_section(AlbumSection())
if __name__ == '__main__': linkedin = LinkedIn() linkedin.show_sections() """ PersonalSection PatentSection PublicationSection """ facebook = FaceBook() facebook.show_sections() """ PersonalSection AlbumSection """
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
抽象工厂方法
提供一个接口来创建一系列相关对象，而无需指定具体的类
# -*- coding: utf-8 -*-
from abc import ABC, abstractmethod
class FruitPizza(ABC): @abstractmethod def prepare(self): pass
class MeatPizza(ABC): @abstractmethod def serve(self): pass
class ApplePizza(FruitPizza): def prepare(self): print("ApplePizza")
class PeachPizza(FruitPizza): def prepare(self): print("PeachPizza")
class PorkPizza(MeatPizza): def serve(self): print("PorkPizza")
class BeefPizza(MeatPizza): def serve(self): print("BeefPizza")
# 抽象工厂
class PizzaFactory(ABC): @abstractmethod def create_meat_pizza(self): pass @abstractmethod def create_fruit_pizza(self): pass
class IndianPizzaFactory(PizzaFactory): def create_meat_pizza(self): return PorkPizza() def create_fruit_pizza(self): return ApplePizza()
class USPizzaFactory(PizzaFactory): def create_meat_pizza(self): return BeefPizza() def create_fruit_pizza(self): return PeachPizza()
class PizzaStore(object): def make_pizza(self): for factory in [IndianPizzaFactory(), USPizzaFactory()]: meat_pizza = factory.create_meat_pizza() fruit_pizza = factory.create_fruit_pizza() meat_pizza.serve() fruit_pizza.prepare()
if __name__ == '__main__': pizza_store = PizzaStore() pizza_store.make_pizza() """ PorkPizza ApplePizza BeefPizza PeachPizza """
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
区别
| 工厂方法 | 抽象工厂方法 |
|---|---|
| 向客户端开放了一个创建对象的方法 | 包含一个或多个工厂方法来创建一个系列的相关对象 |
| 使用继承和子类决定创建哪个对象 | 使用组合将创建对象的任务委托给其他类 |
| 用于创建一个产品 | 用于创建相关产品的系列 |
总结：
1、简单工厂：可以在运行时根据客户端传入的参数类型来创建相应的实例
2、工厂方法：定义一个接口来创建对象，但是创建对象由子类完成
3、抽象工厂方法：提供一个接口，无需指定具体的类，就能创建一系列相关的对象
参考
《Python设计模式第2版》第三章 工厂模式
文章来源: pengshiyu.blog.csdn.net，作者：彭世瑜，版权归原作者所有，如需转载，请联系作者。
原文链接：pengshiyu.blog.csdn.net/article/details/91817823
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）