用Unity游戏案例5分钟掌握C#继承与多态的精髓

在Unity游戏开发中，面向对象编程（OOP）的概念如继承和多态不仅是理论上的抽象概念，更是构建灵活、可扩展游戏系统的基石。想象一下，当你需要设计一个包含多种敌人类型的游戏时，如果为每种敌人都从头编写代码，不仅效率低下，而且维护起来会是一场噩梦。这正是继承和多态大显身手的地方。

1. 从零构建怪物工厂：继承的实战应用

在Unity中创建一个简单的2D游戏场景，我们将设计一个怪物生成系统。首先需要定义所有怪物的共同特征：

public class Monster : MonoBehaviour { protected int health; protected float moveSpeed; public virtual void TakeDamage(int damage) { health -= damage; if (health <= 0) Die(); } protected virtual void Die() { Destroy(gameObject); } public virtual void Move() { transform.Translate(Vector2.left * moveSpeed * Time.deltaTime); } }

这个Monster基类包含了所有怪物共有的属性和行为：

• health：生命值
• moveSpeed：移动速度
• TakeDamage()：受到伤害时的处理
• Die()：死亡逻辑
• Move()：基础移动方式

现在，我们可以轻松创建特定类型的怪物：

public class Goblin : Monster { void Start() { health = 50; moveSpeed = 2f; } public override void Move() { // 哥布林移动时会左右摇摆 float sway = Mathf.Sin(Time.time * 5f) * 0.1f; transform.Translate(new Vector2(-1, sway) * moveSpeed * Time.deltaTime); } }

通过继承，Goblin类自动获得了Monster的所有功能，同时可以定制特殊行为。这种设计模式带来了几个显著优势：

1. 代码复用：避免重复编写基础功能
2. 易于维护：修改基类会影响所有派生类
3. 扩展性强：添加新怪物类型只需关注差异部分

2. 多态实现动态战斗系统

多态的真正威力在于它允许我们以统一的方式处理不同类型的对象。让我们扩展怪物系统，实现不同的攻击行为：

public abstract class AttackBehavior : MonoBehaviour { public abstract void PerformAttack(Transform target); } public class MeleeAttack : AttackBehavior { public float damage = 10f; public float range = 1.5f; public override void PerformAttack(Transform target) { if (Vector3.Distance(transform.position, target.position) <= range) { // 近战攻击逻辑 Debug.Log($"造成 {damage} 点近战伤害"); } } } public class RangedAttack : AttackBehavior { public float damage = 7f; public float range = 5f; public GameObject projectilePrefab; public override void PerformAttack(Transform target) { if (Vector3.Distance(transform.position, target.position) <= range) { // 远程攻击逻辑 var projectile = Instantiate(projectilePrefab, transform.position, Quaternion.identity); Debug.Log($"发射远程攻击，造成 {damage} 点伤害"); } } }

在怪物类中使用这些攻击行为：

public class Orc : Monster { public AttackBehavior attackBehavior; void Start() { health = 100; moveSpeed = 1.5f; attackBehavior = GetComponent<MeleeAttack>(); } public void Attack(Transform target) { attackBehavior.PerformAttack(target); } }

这种设计的关键优势在于：

• 可以运行时更换攻击行为（如拾取武器后）
• 添加新攻击类型不影响现有代码
• 攻击逻辑集中管理，便于平衡调整

3. 抽象类与接口：构建技能系统框架

游戏中的技能系统是另一个展示OOP威力的完美场景。我们可以使用抽象类和接口来创建灵活的框架：

public interface ICooldown { float CooldownTime { get; } float CurrentCooldown { get; set; } bool IsReady { get; } } public abstract class Skill : MonoBehaviour, ICooldown { public float cooldownTime = 3f; public float currentCooldown { get; set; } public bool IsReady => currentCooldown <= 0; void Update() { if (currentCooldown > 0) { currentCooldown -= Time.deltaTime; } } public abstract void Activate(GameObject caster); protected void ResetCooldown() { currentCooldown = cooldownTime; } } public class FireballSkill : Skill { public GameObject fireballPrefab; public float damage = 25f; public override void Activate(GameObject caster) { if (!IsReady) return; var fireball = Instantiate(fireballPrefab, caster.transform.position, caster.transform.rotation); // 设置火球伤害等属性 ResetCooldown(); } }

这个设计模式的特点：

4. 高级技巧：组合优于继承

虽然继承强大，但在复杂系统中，组合模式往往更灵活。让我们看看如何用组件构建游戏对象：

public interface IDamageable { void TakeDamage(int amount); int CurrentHealth { get; } int MaxHealth { get; } } public class HealthComponent : MonoBehaviour, IDamageable { [SerializeField] private int maxHealth = 100; private int currentHealth; public int CurrentHealth => currentHealth; public int MaxHealth => maxHealth; void Start() { currentHealth = maxHealth; } public void TakeDamage(int amount) { currentHealth = Mathf.Max(0, currentHealth - amount); if (currentHealth == 0) { // 触发死亡事件 } } } public class Enemy : MonoBehaviour { private IDamageable damageable; void Awake() { damageable = GetComponent<IDamageable>(); } public void Hit(int damage) { damageable.TakeDamage(damage); } }

这种架构的优势对比：

传统继承方式

• 类层次结构固定
• 难以复用部分行为
• 容易产生"菱形继承"问题

组件模式

• 行为可自由组合
• 更易复用单个功能
• 运行时动态调整
• 更适合ECS架构

在Unity中实际应用时，可以创建各种组件：

[RequireComponent(typeof(HealthComponent))] public class CombatEntity : MonoBehaviour { private List<Skill> skills = new List<Skill>(); public void AddSkill(Skill newSkill) { skills.Add(newSkill); } void Update() { foreach (var skill in skills) { // 处理技能输入和冷却 } } }

这种设计让游戏对象像积木一样灵活组装，特别适合需要频繁调整和扩展的游戏系统。