写一个鸟类：有一个多态函数：run
写一个企鹅类，继承自鸟类：重写 run 
写一个鸵鸟类，继承自鸟类，重写 run
写一个老鹰类，继承自鸟类，重写run
写一个鸟笼，能够存放 不同的鸟类对象
鸟笼是什么类型的自己想
鸟笼初始化的时候，4个不同的鸟类，至少有一个对象在鸟笼里面
写一个函数，叫做 open_cage
实现效果：放跑里面的所有鸟类,让所有鸟 run
使用观察者模式实现

from abc import ABC, abstractmethod
from typing import List# 鸟类接口
class Bird(ABC):@abstractmethoddef run(self) -> str:pass# 具体鸟类实现
class Penguin(Bird):def run(self) -> str:return "企鹅摇摆着逃走了"class Ostrich(Bird):def run(self) -> str:return "鸵鸟大步流星地跑开了"class Eagle(Bird):def run(self) -> str:return "老鹰展翅高飞，离开了鸟笼"# 观察者接口
class Observer(ABC):@abstractmethoddef update(self) -> None:pass# 鸟笼类 - 被观察对象
class BirdCage:def __init__(self):self._birds: List[Bird] = [Penguin(),Ostrich(),Eagle(),Penguin()  # 至少有一个重复的鸟类]self._observers: List[Observer] = []def add_observer(self, observer: Observer) -> None:self._observers.append(observer)def remove_observer(self, observer: Observer) -> None:self._observers.remove(observer)def notify_observers(self) -> None:for observer in self._observers:observer.update()def open(self) -> List[str]:"""打开鸟笼，放跑所有鸟类"""results = [bird.run() for bird in self._birds]self._birds.clear()self.notify_observers()  # 通知观察者鸟笼已空return results# 实现一个简单的观察者
class CageWatcher(Observer):def __init__(self, cage: BirdCage):self._cage = cageself._cage.add_observer(self)def update(self) -> None:print("观察者: 鸟笼现在空了!")# 释放鸟类的函数
def open_cage(cage: BirdCage) -> None:"""放跑鸟笼中的所有鸟类"""results = cage.open()for result in results:print(result)# 使用示例
if __name__ == "__main__":cage = BirdCage()watcher = CageWatcher(cage)print("打开鸟笼...")open_cage(cage)

使用 策略模式 + 简单工厂模式实现以下功能
有一个英雄类，拥有私有成员: hp ,atk,dep
英雄可以打怪掉落武器：怪物可以掉落3种武器：
长剑，匕首，斧头
英雄装备长剑，获得2点hp
英雄装备匕首，获得2点atk
英雄装备斧头，获得2点def
英雄装备不同的武器，使用策略模式去实现
注意：测试的时候，英雄在更换武器的时候，记得使用策略模式，将英雄之间装备的武器属性扣除后，再增加新属性
打败怪物掉落什么武器，自己设计，但是要求怪物掉落武器是一个简单工厂模式

方案一:

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;class Weapon;// 英雄类定义
class Hero {
private:int hp = 0;int atk = 0;int def = 0;Weapon* w = NULL;public:void setHp(int h) { hp = h; }void setAtk(int a) { atk = a; }void setDef(int a) { def = a; }int getHp() { return hp; }int getAtk() { return atk; }int getDef() { return def; }void choice_weapon(Weapon* w);void equip_weapon();void show() {cout << "hp = " << hp << endl<< "atk = " << atk << endl<< "def = " << def << endl<< "===========" << endl;}
};// 武器基类定义
class Weapon {
public:virtual void equip(Hero& hero) = 0;virtual void drop(Hero& hero) = 0;virtual ~Weapon() {}
};// 长剑类，继承自武器基类
class Sword : public Weapon {
public:void equip(Hero& hero) override {cout << "英雄装备了长剑" << endl;int hero_new_hp = hero.getHp() + 2;hero.setHp(hero_new_hp);}void drop(Hero& hero) override {int hero_new_hp = hero.getHp() - 2;hero.setHp(hero_new_hp);}
};// 短剑类，继承自武器基类
class Blade : public Weapon {
public:void equip(Hero& hero) override {cout << "英雄装备了短剑" << endl;int hero_new_atk = hero.getAtk() + 2;hero.setAtk(hero_new_atk);}void drop(Hero& hero) override {int hero_new_atk = hero.getAtk() - 2;hero.setAtk(hero_new_atk);}
};// 斧头类，继承自武器基类
class Axe : public Weapon {
public:void equip(Hero& hero) override {cout << "英雄装备了斧头" << endl;int hero_new_def = hero.getDef() + 2;hero.setDef(hero_new_def);}void drop(Hero& hero) override {int hero_new_def = hero.getDef() - 2;hero.setDef(hero_new_def);}
};// 怪物类，作为武器工厂，生成不同武器
class Monster {
public:Weapon* createWeapon() {int val = rand() % 3;// cout << "val = " << val << endl;if (val == 0) {return new Sword;} else if (val == 1) {return new Blade;} else if (val == 2) {return new Axe;}return nullptr;}
};// 英雄类中 choice_weapon 方法实现
void Hero::choice_weapon(Weapon* w) {if (this->w != NULL) {// 选择新武器，记得脱掉上一件武器this->w->drop(*this);  // 脱掉上一件武器delete this->w;  // 销毁上一件武器}this->w = w;  // 记录新的武器
}// 英雄类中 equip_weapon 方法实现
void Hero::equip_weapon() {this->w->equip(*this);
}// 主函数，程序入口
int main(int argc, const char** argv) {srand((unsigned int)time(0));  // 更改随机种子，以时间为依据种下随机种子Hero hero;Monster mon;while (1) {Weapon* w = mon.createWeapon();hero.choice_weapon(w);hero.equip_weapon();hero.show();// step(1);  // 该函数未定义，若需使用需补充实现，这里先注释}return 0;
}

方案二：

from abc import ABC, abstractmethod
from enum import Enum
import random# 武器策略接口
class WeaponStrategy(ABC):@abstractmethoddef equip(self, hero) -> None:pass@abstractmethoddef unequip(self, hero) -> None:pass# 具体武器策略
class LongswordStrategy(WeaponStrategy):def equip(self, hero) -> None:hero._hp += 2hero._current_weapon = selfdef unequip(self, hero) -> None:hero._hp -= 2hero._current_weapon = Noneclass DaggerStrategy(WeaponStrategy):def equip(self, hero) -> None:hero._atk += 2hero._current_weapon = selfdef unequip(self, hero) -> None:hero._atk -= 2hero._current_weapon = Noneclass AxeStrategy(WeaponStrategy):def equip(self, hero) -> None:hero._def += 2hero._current_weapon = selfdef unequip(self, hero) -> None:hero._def -= 2hero._current_weapon = None# 武器类型枚举
class WeaponType(Enum):LONGSWORD = "longsword"DAGGER = "dagger"AXE = "axe"# 武器工厂
class WeaponFactory:@staticmethoddef create_weapon(weapon_type: WeaponType) -> WeaponStrategy:if weapon_type == WeaponType.LONGSWORD:return LongswordStrategy()elif weapon_type == WeaponType.DAGGER:return DaggerStrategy()elif weapon_type == WeaponType.AXE:return AxeStrategy()else:raise ValueError(f"未知武器类型: {weapon_type}")@staticmethoddef from_monster_drop() -> WeaponStrategy:"""模拟怪物掉落武器"""weapon_type = random.choice(list(WeaponType))return WeaponFactory.create_weapon(weapon_type)# 英雄类
class Hero:def __init__(self, hp: int, atk: int, defense: int):self._hp = hpself._atk = atkself._def = defenseself._current_weapon: WeaponStrategy | None = Nonedef get_status(self) -> str:weapon_name = self._get_weapon_name()return f"HP: {self._hp}, ATK: {self._atk}, DEF: {self._def}, 武器: {weapon_name}"def _get_weapon_name(self) -> str:if self._current_weapon is None:return "无"elif isinstance(self._current_weapon, LongswordStrategy):return "长剑"elif isinstance(self._current_weapon, DaggerStrategy):return "匕首"elif isinstance(self._current_weapon, AxeStrategy):return "斧头"return "未知武器"def equip_weapon(self, weapon: WeaponStrategy) -> None:"""装备新武器，自动卸下当前武器"""if self._current_weapon:self._current_weapon.unequip(self)weapon.equip(self)print(f"装备了{self._get_weapon_name()}")def defeat_monster(self) -> WeaponStrategy:"""击败怪物，获得掉落武器"""weapon = WeaponFactory.from_monster_drop()print(f"击败怪物，掉落了{self._get_weapon_name_from_type(weapon)}")return weapondef _get_weapon_name_from_type(self, weapon: WeaponStrategy) -> str:if isinstance(weapon, LongswordStrategy):return "长剑"elif isinstance(weapon, DaggerStrategy):return "匕首"elif isinstance(weapon, AxeStrategy):return "斧头"return "未知武器"# 测试代码
if __name__ == "__main__":# 创建英雄hero = Hero(hp=10, atk=5, defense=3)print("初始状态:", hero.get_status())# 击败怪物获得武器并装备weapon1 = hero.defeat_monster()hero.equip_weapon(weapon1)print("当前状态:", hero.get_status())# 再次击败怪物获得新武器并装备weapon2 = hero.defeat_monster()hero.equip_weapon(weapon2)print("当前状态:", hero.get_status())# 手动更换武器weapon3 = WeaponFactory.create_weapon(WeaponType.AXE)hero.equip_weapon(weapon3)print("当前状态:", hero.get_status())