面向对象:三大特性、设计原则与组合优于继承
面向过程与面向对象
- 面向过程:把问题拆成一个个步骤(函数),数据和处理数据的函数是分开的。
- 面向对象:把问题拆成一个个对象,每个对象把数据和操作这些数据的方法放在一起,对象之间通过消息(方法调用)协作。
面向对象的目标不是”用了 class 就算”,而是让代码在需求变化时改得少、改得安全。下面的三大特性和设计原则,都是围绕这个目标的。
三大特性
封装
把数据和操作它的方法放在一起,隐藏内部细节,只暴露必要的接口。
// 不好:任何人都能直接改,HP 可能被设成负数,也没人知道它变了public class Player { public int hp; }
// 好:修改只能通过方法,规则集中在一处public class Player{ public int Hp { get; private set; } = 100; public event Action<int> OnHpChanged;
public void TakeDamage(int damage) { if (damage <= 0) return; Hp = Math.Max(0, Hp - damage); OnHpChanged?.Invoke(Hp); }}封装带来的好处:
- 保护不变量:HP 永远不会小于 0,这个规则只需要在
TakeDamage里保证。 - 降低耦合:外部只依赖
TakeDamage这个接口,内部怎么实现可以随便改。 - 便于追踪:所有修改都经过同一个入口,加日志、加事件、加断点都很容易。
C# 中实现封装的手段是访问修饰符和属性,见 访问修饰符与类型修饰符。
继承
子类自动获得父类的成员,并可以扩展或修改。 表达的是 “is-a” 关系:剑是一种武器。
- 优点:复用父类代码;让不同子类可以被当作父类统一处理(为多态打基础)。
- 缺点:
- 强耦合:子类依赖父类的实现细节,父类一改,所有子类都可能受影响(脆弱基类问题)。
- 层级僵化:继承关系在编译时就固定了,运行时不能改变。
- C# 只支持单继承,一个类只能有一个父类。
多态
同一个调用,作用在不同类型的对象上,产生不同的行为。
List<Weapon> weapons = new() { new Sword(), new Bow(), new Staff() };foreach (var w in weapons) w.Attack(); // 每种武器执行各自的攻击逻辑调用方只依赖 Weapon,不需要知道具体是哪种武器。以后新增一种武器,这段代码完全不用改。
多态分两种:
| 类型 | 实现方式 | 什么时候确定调用哪个方法 |
|---|---|---|
| 编译时多态(静态多态) | 方法重载、泛型 | 编译时 |
| 运行时多态(动态多态) | 虚方法重写、接口实现 | 运行时,根据对象的实际类型 |
平时说的”多态”一般指运行时多态。它在 C# 中怎么实现(virtual、override、虚方法表),以及 override 和 new 的区别,见 继承与多态关键字。
有些资料把抽象也列为一个特性(四大特性):提取共同的本质特征,忽略具体细节。抽象类和接口就是抽象的工具。
抽象类与接口
| 抽象类 | 接口 | |
|---|---|---|
| 表达的关系 | 是什么(is-a):剑是一种武器 | 能做什么(can-do):能被攻击、能被拾取 |
| 数量 | 只能继承一个 | 可以实现多个 |
| 成员 | 可以有字段、构造函数、已实现的方法 | 只定义契约,没有实例字段和构造函数 |
| 适合 | 一组紧密相关的类,共享部分实现 | 不相关的类具有同一种能力 |
// 不相关的类都能被攻击:玩家、敌人、木箱public interface IDamageable { void TakeDamage(int damage); }
public class Player : MonoBehaviour, IDamageable { ... }public class Crate : MonoBehaviour, IDamageable { ... }
// 攻击方只依赖接口if (hit.collider.TryGetComponent(out IDamageable target)) target.TakeDamage(10);选择的经验:
- 优先考虑接口:它对实现方的约束最少,一个类可以组合多种能力。
- 多个类之间确实有大量共享的实现,并且是明确的 is-a 关系时,再考虑抽象类。
- 两者也可以一起用:接口定义契约,抽象类提供默认实现,具体类继承抽象类。
设计原则
国内常说的”七大原则”,包括 SOLID 五个加上迪米特法则和合成复用原则。
单一职责原则(SRP)
一个类只负责一件事,只有一个引起它变化的原因。
反例:一个 Player 类同时负责移动、战斗、背包、存档、UI 显示。任何一块需求变化都要改它,几千行,多人协作时频繁冲突。
改法:拆成 PlayerMovement、PlayerCombat、Inventory、SaveSystem、PlayerHUD,各自独立。
开闭原则(OCP)
对扩展开放,对修改关闭。 新增功能时,通过增加代码实现,而不是修改已有的代码。
// 违反:每加一种技能,都要改这个 switchvoid Cast(SkillType type){ switch (type) { case SkillType.Fireball: ...; break; case SkillType.Heal: ...; break; }}
// 符合:新增技能只需新增一个类abstract class Skill { public abstract void Cast(); }class Fireball : Skill { public override void Cast() { ... } }class Heal : Skill { public override void Cast() { ... } }开闭原则是目标,多态是实现它的主要手段。
里氏替换原则(LSP)
子类必须能够替换父类使用,而不破坏程序的正确性。
经典反例:正方形继承长方形。长方形可以分别设置宽和高,但正方形改宽必须同时改高。一段代码”把宽设为 5、高设为 4,期望面积为 20”,传进正方形就出错了。数学上”正方形是一种长方形”,但在行为上它不能替换长方形。
判断继承是否合理,不能只看”是不是一种”,还要看子类能否完全遵守父类的行为约定。如果子类需要重写方法然后抛出 NotSupportedException,通常就说明继承关系用错了。
接口隔离原则(ISP)
不应强迫一个类依赖它用不到的方法。接口要小而专一。
// 违反:木箱不会移动,却要实现 Moveinterface IEntity { void Move(); void Attack(); void TakeDamage(int d); }
// 符合:拆成小接口,按需实现interface IMovable { void Move(); }interface IAttacker { void Attack(); }interface IDamageable { void TakeDamage(int d); }依赖倒置原则(DIP)
高层模块不应该依赖低层模块,两者都应该依赖抽象。
// 违反:业务逻辑直接依赖具体的存储实现,换成云存档就要改它class SaveSystem { LocalFileStorage _storage = new LocalFileStorage(); }
// 符合:依赖接口,具体实现从外部传入interface IStorage { void Write(string key, string data); }class SaveSystem{ readonly IStorage _storage; public SaveSystem(IStorage storage) { _storage = storage; }}这样换存储方式、写单元测试(传入一个假的存储)都不需要改 SaveSystem。把依赖从外部传进来,就是依赖注入。
迪米特法则(最少知道原则)
一个对象只和它的直接朋友通信,不要和”朋友的朋友”打交道。
// 违反:调用方知道了太多内部结构player.GetInventory().GetBag(0).GetSlot(3).GetItem().Use();
// 符合:让 player 提供需要的操作player.UseItem(bagIndex: 0, slot: 3);一长串点号调用,意味着调用方依赖了一整条链上的结构,任何一环改动都会影响它。
合成复用原则
优先使用组合(has-a)来复用代码,而不是继承(is-a)。 下一节单独展开。
这些原则在具体场景中的套路,就是设计模式,见 设计模式在 Unity 中的应用。
组合优于继承
继承层级的问题
游戏中很容易写出这样的继承树:
Enemy├── MeleeEnemy│ └── MeleeFlyingEnemy ← 会飞的近战怪└── RangedEnemy └── RangedFlyingEnemy ← 会飞的远程怪,"飞行"的代码又写了一遍需求一旦出现交叉组合(会飞 × 近战/远程 × 会隐身 × 会分裂……),继承树就会爆炸,大量代码重复。而且一只怪想在运行时”失去飞行能力”,继承做不到。
用组合解决
把每种能力做成独立的部件,对象需要什么就装上什么:
Enemy(GameObject)├── Health├── FlyMovement ← 换成 GroundMovement 就不会飞了├── RangedAttack ← 换成 MeleeAttack 就是近战└── Stealth- 能力可以任意搭配,不会出现组合爆炸。
- 运行时可以添加、移除、替换部件。
- 每个部件职责单一,可以独立开发和测试。
Unity 本身就是组合的设计
Unity 的 GameObject + Component 就是组合优于继承的典型:GameObject 本身几乎什么都不做,它的行为完全由挂载的组件(Transform、Rigidbody、Collider、你写的脚本)决定。
在 Unity 中写代码时,对应的实践是:
- 少用深层继承:继承一般不超过两三层,比如
MonoBehaviour → BaseEnemy → Boss。 - 一个脚本只做一件事,通过挂多个脚本组合功能。
- 用接口定义交互:比如
IDamageable,配合TryGetComponent查找,不关心对方具体是什么类。 - 用 ScriptableObject 做数据:同一套行为脚本,配置不同的数据,产生不同的怪物。
Unity 的 ECS / DOTS 把这个思路推到了极致:实体只是一个 ID,数据(Component)和逻辑(System)完全分离,这已经不是面向对象,而是面向数据的设计。
继承仍然有用
组合优于继承不是”不要继承”。以下情况继承依然合适:
- 有明确且稳定的 is-a 关系,并且子类完全符合里氏替换原则。
- 需要复用一套固定的流程框架,子类只填充其中的步骤(模板方法模式)。
- 框架要求必须继承,比如
MonoBehaviour、ScriptableObject。
类之间的关系
UML 中常用的六种关系,按耦合度从弱到强:
| 关系 | 含义 | 例子 |
|---|---|---|
| 依赖 | 临时用到,比如作为方法参数 | Attack(Enemy target) |
| 关联 | 长期持有对方的引用 | 玩家持有当前的目标 |
| 聚合 | 整体与部分,部分可以独立存在 | 队伍和队员,队伍解散队员还在 |
| 组合 | 整体与部分,部分随整体一起销毁 | 角色和它的背包 |
| 实现 | 类实现接口 | Player : IDamageable |
| 继承(泛化) | 子类继承父类 | Sword : Weapon |
常见追问
面向对象的三大特性是什么?分别解决什么问题? 封装:隐藏细节、保护数据、降低耦合;继承:复用代码、建立 is-a 关系;多态:让调用方依赖抽象,新增类型时调用方不用修改。
抽象类和接口有什么区别?怎么选? 抽象类表达”是什么”,只能单继承,可以有字段和实现;接口表达”能做什么”,可以多实现,只定义契约。优先用接口,有大量共享实现且是明确的 is-a 关系时再用抽象类。
SOLID 分别是什么? 单一职责、开闭、里氏替换、接口隔离、依赖倒置。
什么是里氏替换原则?举个违反的例子。 子类必须能替换父类而不破坏程序。正方形继承长方形:单独设置宽高的行为对正方形不成立。
依赖倒置和依赖注入是什么关系?
依赖倒置是原则:都依赖抽象。依赖注入是实现手段:把依赖的具体实现从外部传进来,而不是在内部 new。
为什么说组合优于继承? 继承是编译时确定的强耦合关系,能力交叉组合时会导致继承树爆炸、代码重复,运行时也不能改变。组合把能力拆成独立部件,可以任意搭配、运行时替换。
Unity 的组件系统体现了什么设计思想? 组合优于继承。GameObject 本身没有行为,功能由挂载的组件组合而成。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!