面向对象:三大特性、设计原则与组合优于继承

2946 字
15 分钟
面向对象:三大特性、设计原则与组合优于继承

面向过程与面向对象#

  • 面向过程:把问题拆成一个个步骤(函数),数据和处理数据的函数是分开的。
  • 面向对象:把问题拆成一个个对象,每个对象把数据和操作这些数据的方法放在一起,对象之间通过消息(方法调用)协作。

面向对象的目标不是”用了 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)#

对扩展开放,对修改关闭。 新增功能时,通过增加代码实现,而不是修改已有的代码。

// 违反:每加一种技能,都要改这个 switch
void 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)#

不应强迫一个类依赖它用不到的方法。接口要小而专一。

// 违反:木箱不会移动,却要实现 Move
interface 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 本身没有行为,功能由挂载的组件组合而成。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

面向对象:三大特性、设计原则与组合优于继承
https://xslab.cloud/posts/csharp/oop/object-oriented/
作者
LuxFire
发布于
2026-10-10
许可协议
CC BY-NC-SA 4.0
相关文章 智能推荐
1
设计模式在 Unity 中的应用:单例、观察者、命令、状态、工厂、策略等
C#底层/面向对象 游戏开发中最常用的设计模式及其在 Unity 中的实现与陷阱:单例的几种写法和滥用问题;观察者与事件中心;命令模式实现输入、撤销与回放;状态模式;对象池;工厂;策略;模板方法;享元与 ScriptableObject;外观;服务定位器与依赖注入;以及 UI 中的 MVC、MVP、MVVM。
2
C# 继承与多态关键字:virtual、override、new、abstract、sealed
C#底层/关键字 virtual 与 override 如何实现运行时多态,override 与 new 的本质区别,abstract 与 sealed 的用法,base 和 this,构造函数的执行顺序与构造函数中调用虚方法的陷阱,以及 Unity 中 Awake、Update 等消息方法的继承写法。
3
C# 关键字速查
C#底层/关键字 按类别整理 C# 常用关键字,每个一两句话说明用途和要点,复杂的关键字链接到专题文章。适合复习时快速过一遍。
4
C# 访问修饰符与类型修饰符
C#底层/关键字 六种访问级别的可见范围对比,protected internal 与 private protected 的区别,各种成员的默认访问级别;以及 static、sealed、abstract、partial 修饰类型时的含义和限制,附 Unity 中 asmdef 与静态字段的注意点。
5
C# 常量与只读:const、readonly 与 static readonly
C#底层/关键字 const 与 readonly 的本质区别(编译期常量与运行时只读),为什么修改 const 要重新编译引用方,readonly 引用类型字段的误区,readonly struct、readonly 成员与防御性复制,以及 init 访问器。
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录