抽象工厂

创建一系列复杂对象

每个工厂生产一套对象

可以给一套系统做限制

有利于产品的一致性

难以支持新种类的抽象产品

---

抽象产品

class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self):
        pass

class CPU(metaclass=ABCMeta):
    @abstractmethod
    def show_cpu(self):
        pass

class OS(metaclass=ABCMeta):
    @abstractmethod
    def show_os(self):
        pass

---

抽象工厂

class PhoneFactory(metaclass=ABCMeta):

    @abstractmethod
    def make_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass

---

具体产品

class SmallShell(PhoneShell):
    def show_shell(self):
        print('普通手机小手机壳')


class BigShell(PhoneShell):
    def show_shell(self):
        print('普通手机大手机壳')


class AppleShell(PhoneShell):
    def show_shell(self):
        print('苹果手机壳')


class SnapDragonCPU(CPU):
    def show_cpu(self):
        print('骁龙CPU')


class MediaTekCPU(CPU):
    def show_cpu(self):
        print('联发CPU')


class AppleCPU(CPU):
    def show_cpu(self):
        print('苹果CPU')


class Android(OS):
    def show_os(self):
        print('Android系统')


class IOS(OS):
    def show_os(self):
        print('iOS系统')

---

具体工厂

小米手机

class MiFactory(PhoneFactory):

    def make_cpu(self):
        return SnapDragonCPU()

    def make_os(self):
        return Android()

    def make_shell(self):
        return BigShell()

苹果手机

class IPhoneFactory(PhoneFactory):

    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return IOS()

    def make_shell(self):
        return AppleShell()

---

客户端

class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os = os
        self.shell = shell

    def show_info(self):
        print('手机信息:')
        self.cpu.show_cpu()
        self.os.show_os()
        self.shell.show_shell()

def make_phone(factory):
    cpu = factory.make_cpu()
    os = factory.make_os()
    shell = factory.make_shell()
    return Phone(cpu, os, shell)

# 生成 小米手机
p1 = make_phone(MiFactory())
p1.show_info()

# 生成 苹果手机
p2 = make_phone(IPhoneFactory())
p2.show_info()

---

角色创建

from abc import ABC, abstractmethod

# 抽象产品类1：武器类，定义所有武器的接口
class Weapon(ABC):
    @abstractmethod
    def attack(self):
        pass

# 抽象产品类2：技能类，定义所有技能的接口
class Skill(ABC):
    @abstractmethod
    def cast(self):
        pass

# 具体产品类：剑，继承自Weapon类，并实现attack方法
class Sword(Weapon):
    def attack(self):
        return "Swinging sword!"  # 剑的攻击方式

# 具体产品类：火球术，继承自Skill类，并实现cast方法
class Fireball(Skill):
    def cast(self):
        return "Casting fireball!"  # 火球术的施放方式

# 具体产品类：弓箭，继承自Weapon类，并实现attack方法
class Bow(Weapon):
    def attack(self):
        return "Shooting an arrow!"  # 弓箭的攻击方式

# 具体产品类：治愈术，继承自Skill类，并实现cast方法
class Heal(Skill):
    def cast(self):
        return "Casting heal!"  # 治愈术的施放方式

# 抽象工厂类：角色工厂类，定义创建武器和技能的接口
class CharacterFactory(ABC):
    @abstractmethod
    def create_weapon(self) -> Weapon:
        pass

    @abstractmethod
    def create_skill(self) -> Skill:
        pass

# 具体工厂类：战士工厂，继承自CharacterFactory，负责创建战士的武器和技能
class WarriorFactory(CharacterFactory):
    def create_weapon(self) -> Weapon:
        return Sword()  # 战士使用剑作为武器

    def create_skill(self) -> Skill:
        return Heal()  # 战士的技能是治愈术

# 具体工厂类：法师工厂，继承自CharacterFactory，负责创建法师的武器和技能
class MageFactory(CharacterFactory):
    def create_weapon(self) -> Weapon:
        return Bow()  # 法师使用弓箭作为武器

    def create_skill(self) -> Skill:
        return Fireball()  # 法师的技能是火球术

# 角色类：表示一个具体的角色，包含武器和技能
class Character:
    def __init__(self, weapon: Weapon, skill: Skill):
        self.weapon = weapon
        self.skill = skill

    def use_weapon(self):
        return self.weapon.attack()

    def use_skill(self):
        return self.skill.cast()

# 工厂方法：用于创建角色对象，并返回该对象
def create_character(factory: CharacterFactory) -> Character:
    weapon = factory.create_weapon()  # 通过工厂创建武器
    skill = factory.create_skill()  # 通过工厂创建技能
    return Character(weapon, skill)  # 返回角色对象

# 客户端代码
# 创建一个战士，并使用其武器和技能
warrior_factory = WarriorFactory()
warrior = create_character(warrior_factory)
print(warrior.use_weapon())  # 输出：Swinging sword!
print(warrior.use_skill())   # 输出：Casting heal!

# 创建一个法师，并使用其武器和技能
mage_factory = MageFactory()
mage = create_character(mage_factory)
print(mage.use_weapon())  # 输出：Shooting an arrow!
print(mage.use_skill())   # 输出：Casting fireball!