Go语言interface初印象——从豌豆射手到樱桃炸弹

#include <iostream>
#include <string>
using namespace std;

class Plant {
public:
    virtual ~Plant() = default;
    virtual void attack() const = 0;  // 纯虚函数
};

// 豌豆射手
class PeaShooter : public Plant {
protected:
    string bullet = "豌豆";
public:
    void attack() const override {
        cout << "发射一颗" << bullet << "！\n";
    }
};

// 寒冰射手（继承自豌豆射手，修改子弹类型）
class IceShooter : public PeaShooter {
public:
    IceShooter() {
        bullet = "冰冻豌豆";  // 在构造函数中修改子弹类型
    }
};

// 樱桃炸弹（直接继承植物）
class CherryBomb : public Plant {
public:
    void attack() const override {
        cout << "Boom！爆炸！\n";
    }
};

// 多态演示
void plantAttack(const Plant& plant) {
    plant.attack();
}

int main() {
    PeaShooter pea;
    IceShooter ice;
    CherryBomb bomb;

    plantAttack(pea);   // 输出：发射一颗豌豆！
    plantAttack(ice);   // 输出：发射一颗冰冻豌豆！
    plantAttack(bomb);  // 输出：Boom！爆炸！

    return 0;
}

package main

import "fmt"

// Plant 接口，所有植物必须实现 Attack()和Type() 方法
type Plant interface {
	Attack() string
	Type() string
}

type BasePlant struct {
	name string
}

// 默认实现 Type()
func (p BasePlant) Type() string {
	return "plant"
}

// 豌豆射手
type PeaShooter struct {
	BasePlant      // 嵌入 BasePlant（继承 Type() 方法）
	Bullet  string // 子弹类型
}

func (p PeaShooter) Attack() string {
	return fmt.Sprintf("发射一颗%s！", p.Bullet)
}

// 寒冰射手
type IceShooter struct {
	PeaShooter     // 嵌入 PeaShooter
}

// 樱桃炸弹
type CherryBomb struct {
	BasePlant      // 嵌入 BasePlant（继承 Type() 方法）
}

func (c CherryBomb) Attack() string {
	return "Boom！爆炸！"
}

func main() {
	// 初始化植物
	pea := PeaShooter{
		BasePlant: BasePlant{name: "豌豆射手"},
		Bullet:    "豌豆",
	}
	ice := IceShooter{
		PeaShooter: PeaShooter{
			BasePlant: BasePlant{name: "寒冰射手"},
			Bullet:    "冰冻豌豆",
		},
	}
	bomb := CherryBomb{
		BasePlant: BasePlant{name: "樱桃炸弹"},
	}

	// 统一调用 Plant 接口方法
	plants := []Plant{pea, ice, bomb}
	for _, plant := range plants {
		fmt.Printf("[%s] %s\n", plant.Type(), plant.Attack())
	}
}