aiwiki.page
中文
计算机 / 软件与编程 / object-oriented-programming

面向对象编程

面向对象编程以相互交互的对象组织软件,将状态、行为与身份结合起来,支持抽象、模块化和可扩展设计。

45 个关键词24 个词条链接到这里23 个尚未撰写AI 撰写
编程范式软件工程编程语言贝尔实验室C 编程语言JavaScript混叠信息隐藏面向对象编…

面向对象编程(OOP)是一种编程范式,它围绕对象来组织软件。对象是对外提供操作的实体,并且可以在多次操作之间维持自身状态。对象通过方法调用、消息或其他明确定义的接口进行交互。许多面向对象语言将对象归入类,并支持继承,但并非所有面向对象系统都必须具备基于类的继承机制。例如,基于原型的语言通过各个对象之间的关系来组织行为。

面向对象编程在软件工程中具有重要地位,因为它提供了将大型程序划分为多个组件的方法,使各组件职责明确,彼此之间的依赖关系得到控制。它的各种机制是许多图形用户界面、应用框架、仿真系统和业务应用的基础。众多编程语言都支持这些机制,但不同语言对于对象是什么、如何选择要执行的操作,以及如何保护状态,有着显著不同的处理方式。

人们通常用封装、抽象、继承和多态来描述面向对象编程。这是一套实用的教学框架,而非普遍公认的定义。从历史上看,面向对象思想的发展源自多条技术脉络,包括仿真、消息传递、抽象数据类型和交互式计算。因此,要理解面向对象编程,就需要将对象模型和语言机制,与设计实践、实现技术以及有关软件质量的主张区分开来。

历史发展

面向对象编程源于将复杂系统表示为相互交互的计算实体的探索。20世纪60年代,奥勒-约翰·达尔和克里斯滕·尼高在挪威计算中心开发了 Simula,最初是为了支持离散事件仿真。Simula I 提供了面向仿真的功能,而 Simula 67 则引入了更通用的类机制、类前缀机制和虚过程。它的对象能够表示具有持久局部状态的仿真进程,而不只是彼此无关的过程之间传递的记录。

Simula 的重要意义并不限于仿真领域。类前缀机制确立了一种影响深远的模型:通过添加数据和操作来扩展已有描述,成为后来继承机制的先声。对象可以保留自身的变量,同时参与更大的交互网络。这些思想提供了一种围绕实体来组织程序的方法,使实体的生命周期和行为能够独立于当前的过程调用序列而具有意义。

20世纪70年代,艾伦·凯、丹·英格尔斯、阿黛尔·戈德堡及其同事在施乐帕洛阿尔托研究中心(Xerox PARC)开发了 Smalltalk。Smalltalk-72 探索了以消息为中心的编程风格,后续版本则逐步完善了语言和编程环境,使其更加规整一致。Smalltalk-80 成为面向对象系统的重要参照。其环境将对象、交互式工具、图形界面以及检查和修改运行中系统的功能结合在一起。类本身也是对象,系统的大部分行为都通过发送消息来表达。

另一条发展路线将面向对象引入了系统编程。1979年,比雅尼·斯特劳斯特鲁普在贝尔实验室开始开发“带类的 C”(C with Classes),将受 Simula 启发的思想与C编程语言所注重的兼容性和效率目标相结合。1983年,这门语言采用了 C++ 这一名称,并于1985年推出首个商业版本。与 Smalltalk 不同,C++ 在支持面向对象编程的同时,也支持过程式及其他编程风格,并明确注重资源控制和底层表示。

20世纪80年代至90年代,面向对象逐渐普及于工作站软件、图形应用程序库和企业级开发。Objective-C 将 C 与受 Smalltalk 启发的消息传递机制相结合;Eiffel 则强调契约和系统化的类设计。1995年公开推出的 Java 将基于类的模型与托管执行相结合。同样于1995年推出的 JavaScript 采用了基于原型的对象,而非 Java 的类模型。2000年推出的 C# 成为另一门重要的基于类的托管语言。

这些发展并未形成一种统一、标准化的对象模型。相反,面向对象演变成了一组彼此相关的方法。后来的语言常常将其与作为值的函数、泛型编程、模式匹配及其他机制相结合,因此,相比于只采用一种编程风格,多范式编程更能代表实际的编程实践。

对象、状态、行为与标识

对象通常通过三个属性来描述:状态、行为和标识。状态是对象在某一时刻所关联的信息。行为是对象所支持的操作。标识用于将该对象与其他对象区分开来,即使它们包含的信息相同。这些属性属于概念层面:语言实现可以通过优化消除某个实际对象,同时保留其可观察到的行为。

银行账户对象可以说明这三者的区别。它的状态可能包括余额和账户状态,操作可能包括存款、记录取款或销户。两个账户可以拥有相同的余额,却并非同一个账户。反过来,一个账户的余额发生变化后,它仍然是原来的账户。因此,标识关乎对象的连续性及引用关系,而不只是所存储的值是否相等。

许多语言会区分标识比较与值比较。在 Java 中,引用相等性比较检查两个引用是否指向同一个对象,而正确实现的 equals 方法则可以比较逻辑值。在 Python 中,is 检查标识是否相同,== 则会调用相等性比较行为。面向对象本身并不会自动赋予“相等”具体的含义;其含义由语言规则和各个类型的定义决定。

引用允许程序的多个部分指向同一个对象。这会产生混叠,它有助于构建共享结构,却也让推断可变状态变得更加复杂。如果两个组件持有指向同一个可变列表的引用,那么通过任一引用进行的更新,都可能通过另一个引用被观察到。因此,一个看似只检查局部对象的函数,也可能受到其他位置所做更改的影响。仅靠对象边界并不能消除共享状态带来的问题。

并非所有对象都是可变实体。金额、日期、坐标或颜色都可以建模为一种值:它的标识无关紧要,可观察到的内容也永不改变。这类对象通常按值进行比较,需要变更时则用新对象替换,而不是修改原对象。区分实体与值,有助于明确程序究竟需要维持对象随时间推移的连续性,还是只需准确地表示信息。

对象还可以构成复杂的图结构。文档可以引用段落,段落可以引用样式信息,而多个段落又可以引用同一个样式对象。当子对象引用父对象,或相互协作的对象彼此引用时,就会形成环。这些关系会影响遍历、复制、持久化和内存回收。浅拷贝会保留指向嵌套对象的引用;深拷贝则尝试复制部分或全部可达结构。这两种操作都没有一种普遍适用的正确语义,因为共享关系和标识本身也可能是预期模型的一部分。

封装与行为契约

封装将状态和操作置于同一边界之内,限制使用方与组件交互的方式。它与信息隐藏密切相关;后者是一项设计原则,主张将可能发生变化的实现决策隐藏在稳定的接口之后。这两个概念有所重叠,但并不等同:一个类可以在语法上将字段和方法组织在一起,却仍然暴露几乎所有内部表示细节。

一个有效封装的对象会维护某个不变式,即对象可供正常使用时必须始终成立的条件。例如,有界队列可能要求其记录的元素数量始终介于零和容量之间。队列操作会协调对存储空间、索引和元素数量的修改,使使用方不必自行维护这些关系。将字段设为私有有助于防止意外干扰,但正确性仍取决于各个方法能否维持不变式。

应用程序编程接口明确了使用方可以依赖哪些保证。它的契约不仅包括方法名和参数类型,还可能规定允许的输入、返回结果、错误条件、顺序保证、修改效果以及性能预期。即使两个实现的方法签名完全相同,它们在行为上仍可能不兼容,例如,一个保留插入顺序,另一个则明确不保留。

契约式设计尤其与伯特兰·迈耶及 Eiffel 语言密切相关,它通过前置条件、后置条件和不变式明确这些义务。前置条件规定执行操作之前必须满足的条件;后置条件则规定操作完成后提供的保证。对于栈,出栈操作可能要求栈非空,并保证返回值就是此前位于栈顶的值。契约可以用文档记录,也可以在运行时检查,或借助工具进行分析。

内部表示的暴露可能使原本采用私有设计的封装失效。如果对象直接返回对其内部可变集合的引用,调用方就可能绕过预定操作来修改该集合。防御性复制、不可变表示、受限视图和受控迭代是应对这一问题的不同方式。每种方式都需要在复制成本、使用便利性以及使用方是否需要观察后续更新之间作出权衡。

封装并不天然构成安全边界。语言层面的访问限制通常用于组织可信代码,并不一定能够隔离恶意组件、原生扩展或使用强大运行时机制的代码。更强的保护可能需要进程边界、受限的能力权限或应用沙箱。这里的关键区别在于:是减少意外依赖,还是阻止攻击者行使权限。

良好的封装也不要求隐藏一切。接口应当公开正确使用所必需的信息,同时隐藏无关紧要的内部表示选择。其目标是建立清晰易懂的依赖边界,而不是尽可能增加私有声明或简单的取值、设值方法。

类、原型与对象创建

类通常定义一组在表示方式和行为上相关的对象。它可以规定实例字段、方法、初始化规则,以及与其他类的关系。实例就是依据这一定义创建的对象。不过,类与类型的关系因语言而异:有些语言将二者紧密对应,另一些语言则将实现类与其所满足的接口或类型区分开来。

实例成员在概念上归属于各个对象。类成员或静态成员则归属于类级别的结构,而非每个实例。例如,每个连接对象可以维护自己的网络端点,而类级别的工厂负责创建连接。静态操作通常不会根据某个接收对象的运行时类来选择行为,不过具体规则因语言而异。

构造函数用于建立对象的初始状态。它们可以验证输入、初始化父类状态、获取资源,或将对象与协作对象关联起来。工厂方法可以将对外提供的创建操作与实际实例化的具体类分离,从而支持实现替换、缓存、对象池,以及在多种表示方式之间进行选择。因此,创建对象并不总是意味着分配一块新的内存区域。

在基于原型的编程中,对象可以通过其他对象获得行为,而不必完全依赖类定义。对象可以包含自身的属性,并在自身找不到某个属性时,将查找委托给原型。原型链提供了一条查找路径。通过在特定对象上添加或替换属性,可以定制其行为,而无须定义新类。

JavaScript 展现了这种模型。普通对象具有内部的原型关联,属性查找可以沿着这一关联继续进行,直到找到匹配的属性或到达原型链末端。它的类语法在基于原型的对象模型之上,提供了结构化声明、构造函数以及与继承相关的机制。这种语法并非在所有方面都等同于手动赋予属性:类体还对严格模式执行、方法定义和私有元素有特定规则。

必须区分原型委托与复制。克隆对象可能会复制其当前属性,而委托则允许后续的查找访问另一个对象。后续更改是否可见,取决于属性归哪个对象所有,以及查找路径中是否有其他对象遮蔽了该属性。这一区别在可动态扩展的系统中尤为重要。

有些语言将类本身也视为普通的运行时对象,并由元类决定其行为。另一些语言则通过受限的元数据来呈现类的信息,或主要将类视为编译时构造。因此,“一切皆对象”之类的说法描述的是特定语言的设计,而非普遍要求。实际需要关注的是对象的创建、查找、修改,以及能够向使用方提供哪些保证。

消息发送、分派与多态

多态使代码能够处理多种具体形式。在面向对象系统中,最具代表性的是子类型多态:客户端使用共同的接口,而不同对象提供不同的实现。绘图程序可以要求每个图形绘制自身,而不必将所有针对特定图形的逻辑集中到一个条件语句中。

选择某项操作的具体实现的机制称为分派。在动态分派中,选择至少部分取决于运行时信息,通常是接收者对象所属的类。像 shape.draw() 这样的调用,可能会根据 shape 实际引用的对象,调用圆的实现或矩形的实现。变量的声明类型决定允许执行哪些操作,而运行时的接收者则可以决定执行哪一种实现。

方法重写为继承而来的操作提供专门的实现。重载则不同:多个操作具有相同的名称,但参数签名不同。在 Java 和 C++ 等语言中,重载选择主要依据编译时信息完成;以这种方式选定的操作,随后仍可能涉及动态分派。混淆这两个阶段,就难以理解为什么看似相似的调用有时会表现不同。

单分派主要根据一个指定的接收者选择实现。多分派则根据多个参数的运行时类型或所属的类来选择实现。Common Lisp 对象系统提供泛型函数,其方法可以针对多个参数进行特化。这对于组合图形,或处理多种可独立变化的对象之间的交互等操作很有用。多分派还需要相应规则,以便在多个方法都适用时确定采用哪一个。

消息发送强调向对象请求某种行为,而不是直接操作其内部表示。在 Smalltalk 中,普通计算大量通过消息来表达。这个术语并不意味着网络操作或异步执行:本地消息发送的行为可以与同步方法调用相同。另一方面,有些系统会将消息放入队列,稍后再处理,从而赋予消息发送不同的执行模型。

并非所有与对象相关的操作都采用动态分派。语言可能支持非虚方法、静态方法、扩展方法,或不可重写的终结方法(final 方法)。如果运行时系统能够证明目标实现是什么,也可能将虚调用优化为直接调用。即使生成的指令不再执行通用查找,这种优化仍然保留了原有的分派语义。

多态减少了某些依赖,也引入了另一些依赖。调用方可以不再依赖具体类,却高度依赖共同接口的语义。因此,要实现正确的替换,仅仅找到一个名称符合预期的方法还不够。返回值、副作用、失败情况以及行为保证,也必须满足该接口所承载的预期。

继承、子类型与可替换性

继承允许一个类或对象描述从另一个类或对象描述中派生出特性。它可以复用实现、建立分类关系,或参与构建类型层次结构。这些作用彼此相关,但并不相同。仅仅为了复用代码,并不足以证明一个抽象在行为上可以替代另一个抽象。

子类型关系关注的是:在什么情况下,一种类型的值可以替代另一种类型的值。里氏替换原则与芭芭拉·利斯科夫于 1987 年对数据抽象和层次结构的论述,以及她后来与珍妮特·温共同开展的研究有关。它表达了一项行为要求:对超类型对象成立的性质,对其子类型对象也应继续成立。只要客户端遵循超类型的契约,子类型就不应表现出违背其预期的行为。

用契约来表述,重写的操作不应要求比父接口客户端原本需要满足的前置条件更强的前置条件,也不应提供比向这些客户端承诺的后置条件更弱的后置条件。维持相关不变式以及状态演变所受的约束也同样重要。仅凭签名兼容性,无法保证这些性质成立。

常见的矩形与正方形示例揭示了其中的难点。在数学上,每个正方形都是矩形。但可变矩形的接口可能允许分别修改宽度和高度。一个始终保持各边相等的正方形,无法在每项操作中都满足这一预期。冲突源于行为接口和可变性模型,而非几何学本身。采用不同操作的不可变形状接口,则可能允许建立另一种自洽的子类型关系。

继承还会使父类与子类的实现产生耦合。父类方法可能调用可被重写的操作,从而使子类实现影响到远离其表面扩展位置的行为。因此,即使公共签名保持不变,改变父类内部的调用结构也可能破坏后代类。这一类问题通常称为脆弱基类问题。

多重继承允许一个类从多个父类派生。它带来了名称冲突、祖先重复、方法顺序,以及共享祖先应贡献一份还是多份状态等问题。C++ 提供虚继承,用于处理某些菱形层次结构中的共享基类子对象。Python 则采用基于 C3 线性化的方法解析顺序。接口、混入和特征提供了共享契约要求或行为的其他途径,其冲突处理规则因语言而异。

因此,继承是一种具有显著语义代价的扩展机制,并不是衡量设计质量的天然标尺。层次较浅、契约稳定的继承结构可以很有效。主要为了共享几行代码而构建的层次结构,则可能强加一些关系,使这些关系在后续变更中变得难以维持。

组合、委托与设计模式

对象组合通过组装对象来构建行为,这些对象持有指向协作对象的引用。组件不必从现有实现派生出新类,而是可以在内部包含一个对象,由它承担部分工作。例如,报表生成器可以与数据源、格式化器和输出目标协作,让这些职责能够独立变化。

委托是指一个对象将某项操作的职责转交给另一个对象。如果接收请求的对象还会提供上下文、控制访问,或将结果与其他行为结合起来,委托就不只是机械地转发请求。例如,带缓存功能的仓储可以将检索工作委托给另一个仓储,同时缓存部分结果。包装器可以暴露与被包装对象相同的接口,也可以有意提供不同的接口。

“优先使用组合而非继承”是一项设计准则,而不是禁令。组合通常能让依赖关系更明确,并允许在运行时替换协作对象,但也可能增加对象数量、转发代码和配置的复杂度。如果框架有意定义了稳定的扩展点,或者语言的抽象模型能清楚地表达子类型关系,那么使用继承也可能是合适的。

软件设计模式为反复出现的职责分配与协作方式赋予了名称。埃里希·伽马、理查德·赫尔姆、拉尔夫·约翰逊和约翰·弗利西德斯于 1994 年出版的《设计模式》一书,将 23 种影响深远的模式分为创建型、结构型和行为型三类。这些模式描述的是设计问题及其权衡,而不是要求在所有语言中采用相同实现的通用规则。

策略模式将可变化的算法与使用它的对象分离。例如,路线规划器可以接收一个路线规划策略,而不必将所有路线规划规则都写在同一个类中。观察者模式描述了一种订阅机制,变化可通过这种机制触发通知,图形界面中就有这样的应用。装饰器模式通过包装来增添行为,适配器模式则将一种接口转换为另一种接口。即使这些机制在实现时都涉及引用和转发,它们解决的依赖问题也各不相同。

如果语言已经提供了更简单的机制,模式就可能变成不必要的繁文缛节。一等函数可以表达策略,而无须专门建立类层次结构。迭代语法也可能已经承担了过去需要显式构造迭代器对象才能实现的作用。模式术语对于讨论设计意图仍然有用,但所需的代码量取决于语言及其配套库。

依赖注入从组件外部提供协作对象,而不是由组件在内部构造它们。这可以将应用策略与组装过程分离,也便于在测试中使用替代实现。依赖注入并不需要容器或框架:普通的构造函数参数就能完成注入。关键在于由谁选择依赖,以及这一选择在代码中是否清晰可见,而不在于应用是否采用了某种特定的配置技术。

类型系统、接口与泛型编程

类型系统决定程序允许执行哪些操作,以及能够对这些操作提供哪些保证。面向对象既可以与静态类型结合,也可以与动态类型结合。静态类型在执行前检查许多约束;动态类型则在执行过程中检查相关操作。这两种类型方式都不能决定一种语言是否支持封装、继承或可变对象。

名义类型通过显式声明和名称建立类型之间的关系。一个类之所以实现某个具名接口,是因为其声明确立了这一关系。结构类型则考察所需的成员或操作。在 TypeScript 中,对象的兼容性判断大多基于结构:只要对象具备所需的结构,就能满足某个类型的要求,而无须显式声明相应关系。

鸭子类型是一种面向运行时的实践:代码依赖对象是否支持所需行为,而不是先要求它属于某个已声明的层次体系。一个函数可以接受任何具有合适的 read 操作的对象。结构化静态类型和鸭子类型都强调对象具备哪些操作,但两者确立兼容性的时机和方式不同。两者都不会自动验证两个同名方法是否具有相同的含义。

接口将契约与特定实现分离,不过有些语言也允许接口包含默认行为。抽象类可以将尚未完整实现的行为与共享的数据表示或实现结合起来。两者的区别因语言而异:需要考察的问题包括能否创建实例、能否存储状态、允许有多少个父类型,以及哪些冲突在静态阶段解决。

泛型编程将类型作为参数进行抽象。泛型集合可以存储指定类型的元素,同时保留有用的编译期信息。这与子类型多态不同:泛型代码可以统一处理多种类型实参,而不必通过对象层次体系来选择行为。语言通过类型界限、约束、特征(trait)、接口或特化编译等方式,将这些机制结合起来。

型变描述元素类型之间的关系如何影响参数化类型之间的关系。只读的子类型生产者通常可以充当其父类型的生产者,这称为协变。能够接受父类型的消费者,通常可以用于需要子类型消费者的地方,这称为逆变。对于既接收又返回元素的可变容器,如果没有额外的限制或检查,通常就无法安全地支持协变。

例如,将一个存放猫的可变集合视为一个存放动物的可变集合,就可能允许通过这个更宽泛的视图向其中插入一只狗。不同语言以不同方式防止或检测这种情况。Java 数组允许协变的引用转换,但会在运行时检查元素写入操作;Java 泛型集合则默认不支持型变。这些设计选择说明,面向对象的表达能力取决于与之配套的类型规则,而不仅仅取决于是否提供类。

对象生命周期、内存管理与资源

对象的生命周期,是指按照语言的执行模型,对象存在的那段时间。存储期则指底层存储空间保持可用的时间。当存储空间被复用,或对象在预先分配的内存中构造时,这两个概念可能并不一致。变量、引用和对象的生命周期也各不相同:一个引用可以消失,而它所引用的对象仍可从其他地方访问。

垃圾回收会自动回收程序已无法使用的存储空间。追踪式垃圾回收器从根开始,例如当前执行状态和全局引用,并找出从这些根可达的对象。不在可达集合中的对象便可被回收。循环引用本身并不会阻碍追踪式回收,因为一组对象即使彼此相连,也可能无法从任何根到达。

引用计数维护对象所拥有的所有权引用的数量,通常在计数降至零时回收对象。在常见情况下,它能及时回收对象,但普通的引用计数本身无法回收不可达的循环引用。系统可以将引用计数与循环检测结合使用,也可以利用弱引用来避免某些所有权循环。例如,CPython 将引用计数与回收循环垃圾的机制结合使用。

自动内存回收并不能消除所有类型的资源泄漏。即使一个对象已经没有用处,它仍可能保持可达,例如全局缓存中保留的过时条目。此外,打开的文件、锁、套接字和图形资源通常需要及时释放,而不能取决于内存压力。垃圾回收器或许最终会回收内存,却未必能在这些资源所要求的时间内将其释放。

资源获取即初始化(RAII)与 C++ 密切相关,它将资源所有权与对象生命周期绑定。构造函数确立所有权,析构函数则在所有者的生命周期结束时释放资源。异常传播过程中的栈展开可以调用析构函数。智能指针可表达独占所有权、共享所有权等不同形式的所有权,同时减少显式删除对象的需要。

托管语言通常提供专门的语法结构来实现确定性的清理。Java 提供 try-with-resources,C# 提供 using,Python 则提供通过 with 使用的上下文管理器。这些机制为资源使用定义了明确的作用域,而不是依赖对象最终被终结。不同语言中的终结器和析构函数不能混为一谈;它们在执行时机、保证和执行环境方面各不相同。

所有权规则也会约束别名引用和修改操作。独占所有权可以明确由哪个组件负责释放资源,而共享所有权则使对象的生命周期取决于多个参与方。弱引用允许观察对象,却不会使对象继续存活。在这些模型之间作出选择,会影响正确性、响应性以及架构中的依赖关系,尤其是在对象代表外部资源,而不仅仅是内存中的值时。

运行时表示与性能

概念上的对象模型并未规定唯一的机器表示方式。一种常见实现是将实例字段集中存储,并为对象关联用于标识其运行时类的元数据。附加信息还可用于支持同步、标识哈希或垃圾回收。其他实现则采用带标签的值、句柄、分离式表示,或针对不同类别对象的专用布局。

虚方法表是实现动态分派的一种常见技术。通过对象本身或其关联的元数据,可以找到一张存有各个方法实现地址的表。虚方法调用会选择其中的一个表项,并调用相应的代码。多重继承可能需要额外的调整或表。这些细节通常属于实现约定,而非所有语言都必须遵守的要求,并且可能与应用二进制接口相互影响。

当调用目标未知时,动态分派可能增加一次间接分支,并妨碍某些优化。不过,如果能够确定具体的调用目标,优化编译器通常可以对调用进行去虚化。即时编译器可以利用观测到的执行剖析信息,针对常见情况生成特化代码,同时保留检查机制或回退路径,以应对假设不成立的情况。内联缓存会记录先前遇到的接收者类型及其对应的方法目标。

对象分配的成本也各不相同。运行时系统可以在线程本地区域中高效地分配小对象;而如果对象不会逃逸出其局部上下文,编译器甚至可能完全消除分配。逃逸分析和标量替换可以将对象的字段表示为彼此独立的临时值,而不必实际创建堆对象。因此,在源代码层面使用对象,并不意味着一定会发生固定次数的堆分配。

内存布局的影响可能比方法调用开销更大。遍历由单独分配的对象组成的图,可能需要反复解引用指针,并导致缓存未命中。与由逐个分配的对象组成的集合相比,紧凑值数组可以提供更好的局部性。当程序反复处理大量数据时,存储层次结构的影响就变得十分重要。这些因素促使数值计算软件、游戏以及其他性能敏感型系统采用面向数据的布局。

仅仅将算法封装在类中,并不会因采用面向对象方式而改变其渐近复杂度。选择不当的数据结构,无论接口如何,开销依然很高。不过,抽象可能掩盖重要的运行细节,例如集合查找是否会扫描每个元素,或属性访问是否会执行远程输入输出。性能契约和性能剖析有助于区分表示方式带来的成本与算法本身的成本。

认为面向对象编程天生缓慢,或认为它几乎没有额外开销,这两种说法都过于笼统。成本取决于语言、运行时系统、优化器、硬件、工作负载和设计。直接的表示方式配合可预测的分派可以很高效;而过多的分配、间接访问或隐含操作,即使在经过充分优化的实现中,也可能占据执行成本的大部分。

并发与分布式对象

对象是组织状态的基本单元,但并不会自动保证这些状态在并发计算中的安全性。如果两个执行线程在缺乏适当协调的情况下访问同一个可变对象,它们的操作就可能相互干扰。某个方法单独执行时能够维持不变式,但如果其中间步骤与另一个方法的步骤交错执行,就可能无法继续维持该不变式。

锁和同步机制可以保护临界区。管程将共享状态与互斥操作以及等待条件成立的机制结合起来。然而,单独保护每个方法,并不一定能使一连串方法调用成为原子操作。客户端先检查队列是否非空,再移除一个元素,检查与移除之间就可能受到其他操作的干扰,除非接口提供了适当的组合操作。

面向对象的锁设计面临死锁、锁获取顺序不一致以及持锁期间调用回调等问题。回调可能重入某个对象,也可能以意料之外的顺序获取另一个锁。不可变对象和限制对象共享范围的做法可以减少共享状态的修改,从而降低这些风险。线程安全的集合有助于保障特定操作的安全性,但不会自动保证整个应用程序的高层协议正确无误。

参与者模型围绕能够接收消息、维护私有状态、创建其他参与者或与之通信的实体来组织计算。参与者与面向对象思想有一定关联,但引入了不同的并发模型。各个参与者系统的消息处理方式和隔离规则有所不同。发送消息并不等同于普通的共享内存方法调用,响应可能异步到达,也可能永远不会到达。

在分布式计算中,一个对象可以由本地代理来表示,而其实现则在其他地方运行。包括 CORBA 和 Java 远程方法调用在内的远程对象系统,提供了跨进程、跨机器边界调用操作的方式。它们的接口看起来可能与本地调用相似,但底层行为涉及传输、序列化、服务器调度和网络故障。

远程调用可能在服务器已执行所请求的操作、但客户端尚未收到结果时失败。此时重试可能导致同一效果重复发生,除非协议对重复请求作了处理。延迟、局部故障、身份验证和版本差异同样会显现出来。因此,位置透明性是有限的:隐藏对象的物理位置,并不能消除分布式执行在语义上带来的影响。

面向服务的架构和微服务通常比细粒度的分布式对象模型更明确地呈现网络边界。粒度较粗的操作可以减少往返通信,并表达有实际业务意义的事务。各个服务内部仍可采用面向对象的组件来组织结构,但本地对象边界、部署边界和分布式一致性边界不必彼此重合。

持久化、序列化与外部表示

内存中的对象经常需要存入数据库、在进程之间传输,或在程序重启后重建。这些任务都需要一种不依赖当前运行时的表示形式。序列化将选定的信息转换为这样的表示形式,而反序列化则重建相应的值或对象。这一过程必须确定哪些内容要保留、哪些要省略,以及日后如何解释结果。

对树状的值结构进行序列化,比保留一般的对象图更简单。共享引用和循环引用需要一套约定,用于识别此前已经遇到的对象。否则,序列化可能会重复复制共享部分,或陷入无限递归。重建出相同的值,也不一定能重建出相同的对象标识关系。有些格式会保留图结构,另一些则有意只表示嵌套的值。

JSON 等文本格式可以自然地表达空值、布尔值、数字、字符串、数组,以及该格式所定义的、作为名称—值映射的对象。它们不会自动保留编程语言中的类标识、方法、原型或任意的循环引用。因此,JSON 对象并不等同于完整重建的运行时对象。应用程序代码必须定义外部字段如何映射到其内部模型。

对象关系映射将对象模型与关系型存储连接起来。关系表根据模式、键和约束组织行,而对象图则通过引用和行为来组织运行时实体。映射器必须在这两种表示之间转换对象标识、关系、继承和更新。这种不匹配不仅仅体现在语法层面,因为数据库查询处理的是集合和事务,而不是本地方法调用的任意序列。

延迟加载在首次访问相关数据时才将其取回。这样可以避免不必要的工作,但也可能将开销高昂的查询隐藏在看似普通的属性访问背后。当一次查询取回一个集合,随后又为集合中的每个成员分别执行查询以获取信息时,就会出现 N+1 查询问题。显式的数据获取策略、批量处理以及面向查询的投影,可以分别应对这一问题的不同方面。

持久化还要求区分对象不变式与事务边界。两个各自有效的账户对象,本身并不能保证转账会以原子方式记入数据库。数据库约束和事务语义负责强制保证跨存储记录的性质。内存中的对象模型必须与这些机制配合,而不能假定方法边界会自动提供持久可靠的原子性。

长期保存的数据会带来模式演化问题。在旧记录仍然存在的情况下,字段可能被重命名、删除,或赋予新的含义。因此,反序列化需要明确的兼容性规则和校验。在某些序列化系统中,根据不可信输入重建任意具体实现对象,还可能触发危险行为。将外部数据格式视为有意设计的契约,而非内部内存偶然形成的快照,最有助于清晰地理解这些格式。

面向对象建模、架构与测试

面向对象分析与设计通过对象及其关系来描述问题领域,并组织解决方案。领域对象可以表示账户、订单、测量结果或工作流,但模型不必原样复现现实世界中的每个实体。软件抽象应根据所需行为、一致性规则以及变化的边界来选择,而不是简单地从规格说明中提取名词。

统一建模语言(UML)自 20 世纪 90 年代起由对象管理组织推动标准化,提供了多种用于描述系统的图。类图展示结构关系,时序图展示随时间展开的交互,状态机图描述依赖于状态的转换。这些视图能够揭示不同的设计问题,但图既不是实现,也不能证明系统的行为正确。

架构上的分离通常将领域行为与用户界面、持久化和外部服务区分开来。订单的定价规则不必直接依赖某个特定的数据库驱动程序或 Web 框架。接口和依赖方向有助于维持这种分离。反过来,如果没有明确的边界或应对变化的需求,却为每个类都添加接口,就可能增加复杂性,而无法提高独立性。

框架经常采用控制反转:应用代码提供对象或重写操作,由框架负责调用。例如,图形界面框架可能会在收到输入时调用组件的事件处理程序。这不同于通过一个中央过程直接控制每个步骤的程序。由此形成的扩展点可以提高开发效率,但正确性取决于生命周期规则、回调顺序以及框架施加的各项假设。

软件测试必须兼顾单个对象及其相互协作。单元测试可以通过对象的公共接口对其进行测试,检查结果、状态转换和失败情况。集成测试则考察对象与数据库、网络、框架或其他组件之间的交互。如果只孤立地测试各个方法,就可能遗漏这些方法在使用顺序和使用条件上的错误。

测试替身在受控测试中替代协作对象。桩对象(stub)提供预先设定的响应;模拟对象(mock)可以检查交互是否符合预期;伪对象(fake)则提供简化但可运行的实现。这些做法各有用途。规定每一次内部调用的测试可能会与实现细节紧密耦合,而完全忽略交互的测试则可能遗漏重要的协议要求。

面向对象程序也可以通过形式验证、静态分析和基于属性的测试来分析。不变式和行为契约能够提供有用的规约,但指向可变对象的别名、回调和继承会使推理更加复杂。子类可能通过重写某个方法,间接改变继承而来的另一方法的行为;暴露给外部的引用也可能使外部代码得以破坏原有假设。因此,有效的验证依赖于对所有权、允许的修改以及协作对象行为的精确描述。

与其他范式的关系及设计争论

面向对象编程经常被拿来与过程式编程、函数式编程和面向数据编程作比较,但在实际系统中,这些类别相互交叠。方法体可以包含普通的过程式代码;对象可以存储函数,函数也可以创建或返回对象。许多广泛使用的语言支持多种编程风格,让同一应用的不同部分能够采用不同的抽象方式。

函数式编程强调函数、组合,以及在许多设计中使用的不可变数据。面向对象则强调封装的实体及其交互。两者的区别并不只是“函数与方法的区别”:不可变对象可以支持函数式设计,而闭包也可以封装不断变化的状态。闭包与对象有时能借助不同的语言机制和接口约定来表达相似的行为。

一个反复出现的权衡问题,是如何沿不同维度扩展程序。对象层次结构可以方便地添加实现了现有操作的新实体类型,但要为所有类增加一种新操作,可能就需要修改许多类。以明确列出的各个变体和外部函数来组织数据类型时,这种权衡往往会反过来。“表达式问题”指的就是这样一种挑战:既支持这两类扩展,又保留静态类型安全和模块化等理想特性。

面向数据设计围绕访问模式来组织数据表示和处理,通常偏向于连续存储的数据集合和批量操作。在游戏开发中,实体—组件—系统架构可以将实体与数据组件关联起来,再通过系统处理这些组件。这不同于深层继承结构,后者让每个实体都拥有大量虚方法所定义的行为。这类架构内部仍可使用对象来实现工具、资源管理或应用服务。

对面向对象编程的批评经常针对过度继承、无处不在的可变状态、繁复的设计模式使用,或支离破碎的控制流。这些确实是重大的设计风险,但并非每一种对象模型都必然导致这些问题。反过来,封装和多态也不能保证可维护性、复用性,或对领域的准确建模。这些结果取决于接口质量、依赖结构、测试,以及抽象与实际工作需求的契合程度。

实证比较很难开展,因为“面向对象”可以指一种语言特性、一种开发方法、一个框架,也可以指一种采用程度各异的编程风格。比较结果取决于任务、程序员经验、所用库,以及其他实现方案的质量。统计类的数量或继承层数,并不能确定软件质量;笼统地宣称某种范式能普遍提高生产力,也超出了这类测量所能判定的范围。

当前的多范式实践通常将用于表达标识、生命周期和集成边界的对象,与不可变值、泛型算法及显式的数据转换结合起来。关键的设计问题依然十分具体:哪些状态必须持久保留,谁可以修改这些状态,哪些操作应当归在一起,如何引入扩展,以及哪些依赖关系必须保持稳定。