介绍

依然使用植物大战僵尸举例

适配器模式

假如你现在开发植物大战僵尸，已经开发好了植物和僵尸的受伤逻辑，植物实现了一个接口叫做被啃咬bitten，僵尸实现了一个接口叫做被攻击attacked，他们都是接收一个参数，这个参数就是伤害。你现在突发奇想，开发了一个僵尸魅惑功能。敌对僵尸要啃咬友方僵尸了，那该怎么办呢？你在僵尸攻击的代码中调用的是entity->bitten(this->damage)，并没有考虑过僵尸的代码啊。那么就可以用适配器，将attacked转换成bitten接口即可。

对象适配器

classDiagram
class Entity{
 	<<Interface>>
	-HP
}

Entity<|..PlantEntity
class PlantEntity{
	-HP
	+bitten(damage)
}

Entity<|..ZombieEntity
class ZombieEntity{
	-HP
	-damage
	+attacked(damage)
	+attack(entity)
}

%%Entity<|..FriendZombiePlantAdapter
FriendZombiePlantAdapter-->PlantEntity
FriendZombiePlantAdapter --> ZombieEntity
class FriendZombiePlantAdapter{
	-Zombie
	+bitten(damage)
}

下面是C++示例代码：

class Entity{
protected:
    int HP;
}

class PlantEntity:public Entity{
private:
    void bitten(int damage){  // 被啃咬
        if(damage > HP) HP -= damage;
        else dead();
    }
}

class ZombieEntity:public Entity{
private:
    int damage;
public:
    void attacked(int damage){   // 被攻击
        if(damage > HP - 30) HP -= damage; // 僵尸小于30血量就会死
        else dead();
    }
    void attack(Entity* entity){  // 攻击其他实体
		entity->bitten(this->damage); // 这样就无法攻击僵尸实体了，因为僵尸没有 bitten 函数
    }
};

class FriendZombiePlantAdapter{
private:
	ZombieEntity zombieEntity;
public:
    void bitten(int damage){   // 被啃咬
        zombieEntity.attacked(damage);
    }
};


auto PlantEntity = new PlantEntity();
auto enemyZombie = new ZombieEntity();
enemyZombie.attack(PlantEntity); // 敌方僵尸攻击友方植物
    
auto frientZombie = new FriendZombiePlantAdapter();
enemyZombie.attack(frientZombie); // 敌方僵尸攻击友方僵尸

类适配器

类适配器需要编程语言有多继承功能

classDiagram

class Entity{
	-HP
}

Entity<|..PlantEntity
class PlantEntity{
	-HP
	+bitten(damage)
}

Entity<|..ZombieEntity
class ZombieEntity{
	-HP
	-damage
	+attacked(damage)
	+attack(entity)
}

%%Entity<|..FriendZombiePlantAdapter
%%FriendZombiePlantAdapter-->PlantEntity
%%FriendZombiePlantAdapter --> ZombieEntity
PlantEntity<|..FriendZombiePlantAdapter
ZombieEntity<|..FriendZombiePlantAdapter
class FriendZombiePlantAdapter{
	+bitten(damage)
}

下面是C++示例代码：

class Entity{
protected:
    int HP;
}

class PlantEntity:public Entity{
private:
    void bitten(int damage){  // 被啃咬
        if(damage > HP) HP -= damage;
        else dead();
    }
}

class ZombieEntity:public Entity{
private:
    int damage;
public:
    void attacked(int damage){   // 被攻击
        if(damage > HP - 30) HP -= damage; // 僵尸小于30血量就会死
        else dead();
    }
    void attack(Entity* entity){  // 攻击其他实体
		entity->bitten(this->damage); // 这样就无法攻击僵尸实体了，因为僵尸没有 bitten 函数
    }
};

class FriendZombiePlantAdapter: public PlantEntity, public ZombieEntity{
public:
    void bitten(int damage) {   // 被啃咬
        attacked(damage);  // 直接转换成被攻击逻辑即可
    }
};

auto PlantEntity = new PlantEntity();
auto enemyZombie = new ZombieEntity();
enemyZombie.attack(PlantEntity); // 敌方僵尸攻击友方植物
    
auto frientZombie = new FriendZombiePlantAdapter();
enemyZombie.attack(frientZombie); // 敌方僵尸攻击友方僵尸

桥接模式

假如你现在开始搞植物大战僵尸僵尸杂交版

开始设计僵尸，设计了僵尸类型，如普通僵尸、舞王僵尸、小鬼僵尸
又设计僵尸的防具类型，如铁桶、路障、橄榄球帽子
并且基于这些，你已经实现了一些僵尸了，比如铁桶僵尸、橄榄球僵尸、普通的舞王僵尸
你觉得游戏不好玩了，能不能加点难度，就是让僵尸类型和防具类型自由组合，这样你一想，你得实现 $3\times 3=9$ 个类，而且他们逻辑其实都是防具和僵尸的基本逻辑。
也许现在只有9个类，但是一想到你之后可能会设计新的防具类型和新的僵尸类型，那每增加一种防具类型，需要增加多种僵尸类型。

所以，现在你开始设计一个桥接器，用来桥接僵尸和防具。

classDiagram
class ArmorType{
 	<<Interface>>
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..NoneArmor
class NoneArmor{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Barrel
class Barrel{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Roadblock
class Roadblock{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Rugbycap
class Rugbycap{
 	-HP
 	+attacked(damage)
 	+drop()
}

class ZombieType{
 	<<Interface>>
 	-ArmorType
 	-HP
 	+attacked(damage)
 	+dead()
}

ZombieType<|..NormalZombie
class NormalZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

ZombieType<|..DancingZombie
class DancingZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

ZombieType<|..ImpZombie
class ImpZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

假如不用桥接器，已经设计了铁桶僵尸，橄榄球僵尸，小鬼僵尸等

classDiagram
class BarrelNormalZombie{
	-HP
	-ArmorType = Barrel
 	+attacked(damage)
 	+dead()
}

class RugbycapZombie{
	-HP
	-ArmorType = Barrel
 	+attacked(damage)
 	+dead()
}

class NoneArmorImpZombie{
	-HP
	-ArmorType = Barrel
 	+attacked(damage)
 	+dead()
}

这多麻烦，不妨设计一个桥接器，称之为ArmorZemobie

classDiagram

class ZombieType{
 	<<Interface>>
 	-ArmorType
 	-HP
 	+attacked(damage)
 	+dead()
}

ZombieType<|..ArmorZemobie
class ArmorZemobie{
	<<Interface>>
 	-ArmorType
 	-HP
 	+attacked(damage)
 	+dead()
 	+setArmor(armory)
}

ArmorType --> ArmorZemobie
class ArmorType{
 	<<Interface>>
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..NoneArmor
class NoneArmor{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Barrel
class Barrel{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Roadblock
class Roadblock{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Rugbycap
class Rugbycap{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorZemobie<|..NormalZombie
class NormalZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

ArmorZemobie<|..DancingZombie
class DancingZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

ArmorZemobie<|..ImpZombie
class ImpZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

下面是C++代码：

class ArmorType{
private:
    int HP;
public:
    virtual void attacked(int damage){
        if(HP > damage) HP -= damage;
        else drop();
    }
    virtual void drop();
}

class NoneArmor:public ArmorType{}
class Barrel():public ArmorType{}
class Roadblock():public ArmorType{}
class Rugbycap():public ArmorType{}

class ZombieType{
private:
    ArmorType* armor;
    int HP;
public:
    virtual void attacked(int damage){
        if(HP > damage + 30) HP -= damage;
        else dead();
    }
    virtual void dead();
}

class ArmorZemobie: public ZombieType{
public:
    void setArmor(ArmorType* armor_){
        armor = armor_;
    }
}

class NormalZombie: public ArmorZemobie{};
class DancingZombie: public ArmorZemobie{};
class ImpZombie: public ArmorZemobie{};


// 设计新的僵尸

// 1. 舞王铁桶僵尸
auto zombie = new DancingZombie();
zombie->setArmor(new Barrel());

// 2. 小鬼铁桶僵尸
auto zombie = new ImpZombie();
zombie->setArmor(new Barrel());

// 3. 舞王路障僵尸
auto zombie = new ImpZombie();
zombie->setArmor(new Roadblock());

组合模式

对于上述桥接模式的问题，还可以这样：组合模式一般会是一个树形结构，甚至还可以深层次组合

classDiagram
class ZombieType{
 	<<Interface>>
 	-ArmorType
 	-HP
 	+attacked(damage)
 	+dead()
}
ZombieType<|..NormalZombie
class NormalZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

ZombieType<|..DancingZombie
class DancingZombie{
	-HP
 	+attacked(damage)
 	+dead()
}

ZombieType<|..ImpZombie
class ImpZombie{
	-HP
 	+attacked(damage)
 	+dead()
}


ZombieType --> ArmorZemobie
class ArmorZemobie{
	+ZombieType
	+ArmorType
}

ArmorType --> ArmorZemobie
class ArmorType{
 	<<Interface>>
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..NoneArmor
class NoneArmor{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Barrel
class Barrel{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Roadblock
class Roadblock{
 	-HP
 	+attacked(damage)
 	+drop()
}

ArmorType<|..Rugbycap
class Rugbycap{
 	-HP
 	+attacked(damage)
 	+drop()
}

下面是C++示例代码：

class ArmorType{
private:
    int HP;
public:
    virtual void attacked(int damage){
        if(HP > damage) HP -= damage;
        else drop();
    }
    virtual void drop();
}
class ZombieType{
private:
    int HP;
public:
    virtual void attacked(int damage){
        if(HP > damage + 30) HP -= damage;
        else dead();
    }
    virtual void dead();
}

class NormalZombie: public ArmorType{};
class DancingZombie: public ArmorType{};
class ImpZombie: public ArmorType{};

class NoneArmor:public ArmorType{}
class Barrel():public ArmorType{}
class Roadblock():public ArmorType{}
class Rugbycap():public ArmorType{}



class ArmorZemobie{
    ArmorType* armor;
    ZombieType* zombie;
public:
    ArmorZemobie(ArmorType* a = nullptr, ZombieType* z = nullptr):armor(a), zombie(z){}
  	void attacked(int damage){
        if(armor->isDrop()){
            zombie->attacked(damage);
        }else{
            armor->attacked(damage);
        }
    }  
};



// 设计新的僵尸

// 1. 舞王铁桶僵尸
auto zombie = new ArmorZemobie(
	new DancingZombie(),
    new Barrel()
);

// 2. 小鬼铁桶僵尸
auto zombie = new ArmorZemobie(
	new ImpZombie(),
    new Barrel()
);

// 3. 舞王路障僵尸
auto zombie = new ArmorZemobie(
	new DancingZombie(),
    new Roadblock()
);

感觉很像抽象工厂模式了，但是其实这个是不能破坏已有的结构的。

装饰器

现在，你开始设计子弹。你很会设计，对于一个豌豆子弹来说，普通豌豆你设计成10点伤害无减速，火焰豌豆你设计成20点伤害无减速，火焰冰豌豆你设计成20点伤害加减速。然后你还设计仙人掌子弹，也可以变成火焰仙人掌刺和冰火焰仙人掌刺。

classDiagram
class Bullet{
	<<Interface>>
	-damage
	+Hit(zombie)
}

Bullet<|..PeaBullet
class PeaBullet{
	-damage
	+Hit(zombie)
}

Bullet<|..CactusThornBullet
class CactusThornBullet{
	-damage
	+Hit(zombie)
}

%%Bullet<--BulletDecorator
Bullet<|..BulletDecorator
class BulletDecorator{
	<<Interface>>
	+bullet
}

BulletDecorator<|..FlameDecorator
class FlameDecorator{
	+bullet
}

BulletDecorator<|..IceflameDecorator
class IceflameDecorator{
	+bullet
}

下面是示例C++代码

class Bullet{
private:
    int damage;
public:
    virtual void Hit(Zombie* zombie){
        zombie->attacked(damage);
    }
};

class PeaBullet: Bullet{
public:
    virtual void Hit(Zombie* zombie) override{
        zombie->attacked(damage);
        drop();
    }
}

class CactusThornBullet: Bullet{
public:
    virtual void Hit(Zombie* zombie) override {
        zombie->attacked(damage);
    }
}

class BulletDecorator: Bullet{
private:
    Bullet* bullet;
public:
    virtual void Hit(Zombie* zombie) override{
        bullet->Hit(zombie);
    }
}

class FlameDecorator: BulletDecorator{
public:
    virtual void Hit(Zombie* zombie) override{
        bullet->Hit(zombie);
        zombie->attacked(10);  // 再加10点伤害
    }
}

class IceflameDecorator: BulletDecorator{
public:
    virtual void Hit(Zombie* zombie) override{
        bullet->Hit(zombie);
        zombie->slow(2);  // 减速2s
        zombie->attacked(10);  // 再加10点伤害
    }
}

外观模式

外观模式其实非常简单，你已经把游戏开发好了，只想提供运行接口来调用。不想理这么多细节，那么就是用外观模式。

classDiagram
class Zombies
class Plants
class Information
class Bullets

Zombies<--Run
Plants<--Run
Information<--Run
Bullets<--Run
class Run{
	+run()
}

class Zombies;
class Plants;
class Information;
class Bullets;

class Run{
private:
    Zombies* zs;
    Plants* ps;
    Information* info;
    Bullets* bs;
public:
    void run(){
        // 进行复杂的逻辑
    }
};

享元模式

享元是一种优化模式，如果开发一个植物大战僵尸，那么种植物的时候会播放一个音效，所有植物音效都是一样的，那么就没必要每个植物存储一个音效，直接把音效设置成静态方法即可。也就是说，把所有公共状态设置成静态成员变量或者静态方法的模式都可以看作是一种享元模式。

代理模式

代理模式也是非常简单，如果僵尸移动我们只关注它在地图上移动了多少距离，以及它移动的画面渲染。如果你此时设计了一种卡住僵尸的植物，即僵尸只能原地踏步，但是并没有被冰冻。那你需要对僵尸移动再进行封装，这就是代理了，移动代理类中，先判断僵尸是否被定住，然后再执行僵尸真正的移动代码。

总结

适配器模式：通过创建中间类，来适配两个不同的接口。希望复用某些类，或者使用某些类时，它的接口与已有接口不同，那么就可以再上面套一层。
桥接模式：在多个维度上拓展派生类，实现不同维度派生类的组合。
组合模式：在树形结构中，对每个子树希望能够复用树的处理代码。
装饰模式：希望能够动态添加功能，比继承更加灵活。封装某个不可被继承的类，再上面增加功能
外观模式：对复杂逻辑进行封装，简化调用接口
享元模式：优化处理重复对象的时间和空间；缓存系统等
代理模式：保证任务的粒度足够小，但是有希望进行功能扩展，比如鉴权，判空等等，那就对他进行再一层封装。

如果觉得文章对你有用，请随意赞赏

结构型模式

https://lmzyoyo.top/archives/b7a21800-b5ca-4381-9d7a-ad6d4d01f678

作者

Administrator

发布于

2025-03-28

更新于

2025-03-28

许可协议

CC BY 4.0

结构型模式

介绍

适配器模式

对象适配器

类适配器

桥接模式

组合模式

装饰器

外观模式

享元模式

代理模式

总结

作者

发布于

更新于

许可协议

评论