第20章　方法调用匹配

20.1 方法调用匹配的提出背景

方法匹配解决的是两个已经形成的方法之间是否存在对应关系。

但是，在实际认知过程中，仅仅找到一个对应方法还不能直接进入执行。

系统还必须判断：

当前为什么调用这个方法？

调用哪个方法？

方法作用于哪个对象？

输入什么参数？

当前条件是否满足？

当前对象状态是否允许调用？

当前调用环境是否正确？

因此，在方法匹配之后，还必须建立一个专门针对实际调用过程的匹配机制。

这个机制就是方法调用匹配。

其基本关系为：

目标 → 方法识别 → 方法匹配 → 方法调用请求 → 方法调用匹配 → 方法调用 → 动作 → 行为 → 状态变化

方法匹配解决：

“这个方法与另一个方法是否对应？”

方法调用匹配解决：

“当前这个调用请求是否正确地对应这个方法？”

因此，方法调用匹配是从方法认知进入方法执行之间的重要连接层。

20.2 方法调用的定义

方法调用（Method Invocation）是指认知系统针对特定目标，在特定条件下，以指定对象和参数请求一个已经存在的方法进入执行过程的认知操作。

一个方法：

经过调用形成：

I(M,O,P,C,S)

其中：

M：Method，方法；
O：Object，目标对象；
P：Parameter，调用参数；
C：Condition，调用条件；
S：State，当前状态；
I：Invocation，方法调用。

因此：

方法 → 调用请求 → 方法调用

方法本身是稳定的认知结构，而方法调用是方法在具体场景中的一次实例化使用。

20.3 方法调用匹配的定义

方法调用匹配（Method Invocation Matching）是指认知系统将当前方法调用请求与目标方法及其调用条件进行对应判断，以确定该调用是否能够正确进入指定方法执行过程的认知机制。

设：

I₁ = 当前调用请求

M₂ = 目标方法

则：

I₁ ↔ M₂

表示当前调用请求与目标方法之间的匹配关系。

进一步可以表示：

I = (M,O,P,C,S,T,R)

其中：

M：被调用方法；
O：目标对象；
P：调用参数；
C：调用条件；
S：调用前状态；
T：调用上下文；
R：调用结果。

因此方法调用匹配实际上需要判断：

M ↔ O ↔ P ↔ C ↔ S ↔ T

是否形成合法调用结构。

20.4 方法调用匹配与方法匹配的区别

方法匹配属于方法知识层。

方法调用匹配属于具体运行层。

例如存在两个方法：

M₁ = MoveObject

M₂ = CarryObject

方法匹配判断：

M₁ ↔ M₂

这是方法之间的关系判断。

但是出现一个实际调用：

MoveObject(ObjectA, PositionB)

此时系统面对的不是另一个抽象方法，而是一个具体调用请求：

I = (MoveObject,ObjectA,PositionB,Condition,State,Context)

系统需要判断这个调用是否有效。

因此：

方法匹配 → 方法之间的关系

方法调用匹配 → 调用请求与方法之间的关系

两者不能混合。

20.5 方法调用匹配的基本结构

一个完整的方法调用可以表示为：

I = (M,O,P,C,S,T,R)

其中：

表示调用哪个方法。

表示方法作用于哪个对象。

表示向方法提供什么参数。

表示调用需要满足什么条件。

表示调用发生前对象和环境处于什么状态。

表示调用发生的上下文。

表示调用最终产生的结果。

因此：

方法调用 = 方法 + 对象 + 参数 + 条件 + 状态 + 上下文 + 结果

20.6 方法标识匹配

方法调用首先必须找到明确的目标方法。

例如：

I.Method = MoveObject

系统必须能够在方法集合中找到：

M = MoveObject

如果：

Find(M)=0

则：

MethodMatch=0

调用不能进入执行。

因此第一条调用匹配规则是：

调用方法必须存在。

形成：

调用请求 → 方法查找 → 方法存在性判断

如果方法不存在：

调用失败

如果方法存在：

进入后续匹配

20.7 方法类型匹配

方法不仅具有名称，还具有方法类型。

例如：

ObjectMethod

ClassMethod

SceneMethod

SystemMethod

不同类型的方法具有不同的调用对象和调用规则。

因此需要判断：

Type(I.Method) ↔ Type(TargetMethod)

如果方法类型不匹配，则调用不能直接执行。

例如一个要求对象实例的方法，不能直接使用不存在对应实例的方式调用。

因此：

方法标识匹配 → 方法类型匹配

是方法调用匹配的前置过程。

20.8 调用对象匹配

方法确定之后，必须确定方法作用于哪个对象。

设：

Oᵢ = 调用对象

Oₘ = 方法要求对象

则：

Oᵢ ↔ Oₘ

是调用对象匹配。

例如：

MoveObject(ObjectA)

如果MoveObject要求：

Object.Type = MovableObject

而ObjectA：

Type(ObjectA)=MovableObject

则：

ObjectMatch=1

如果ObjectA不属于允许对象类型：

ObjectMatch=0

因此：

方法正确 ≠ 调用正确

还必须保证目标对象正确。

20.9 对象实例匹配

对象类型匹配之后，还必须判断对象实例。

例如：

DoorClass

可能存在：

DoorA

DoorB

方法：

OpenDoor

当前调用：

OpenDoor(DoorA)

此时必须判断：

DoorA

是否是当前需要操作的目标对象。

因此：

ClassMatch

不能代替：

InstanceMatch

完整过程为：

对象类型 → 对象类 → 对象实例 → 当前对象

20.10 参数匹配

方法调用通常包含参数。

设：

Pᵢ = 调用参数

Pₘ = 方法参数定义

则需要判断：

Pᵢ ↔ Pₘ

参数匹配包括：

参数数量

参数类型

参数顺序

参数取值

参数范围

例如：

MoveObject(ObjectA, PositionB)

方法定义：

MoveObject(Object, Position)

则：

ObjectA ↔ Object

PositionB ↔ Position

只有参数结构正确，调用才具有有效性。

20.11 参数数量匹配

设方法要求参数数量：

调用实际提供：

如果：

n ≠ m

并且方法没有规定允许缺省参数，则：

ParameterCountMatch=0

因此：

参数数量不匹配 → 调用不匹配

该规则用于避免方法调用结构不完整。

20.12 参数类型匹配

参数数量正确并不代表参数正确。

设：

Type(Pᵢ)=Tᵢ

Type(Pₘ)=Tₘ

如果：

Tᵢ = Tₘ

则参数类型匹配。

如果两个类型存在允许的继承、转换或者对应关系，也可以形成兼容匹配。

否则：

ParameterTypeMatch=0

因此：

参数数量匹配 → 参数类型匹配 → 参数值匹配

20.13 参数值匹配

参数类型正确之后，还需要判断实际参数值是否满足方法要求。

例如方法：

MoveObject(ObjectA, PositionB)

如果PositionB是：

有效位置

则调用可以继续。

如果：

PositionB = InvalidPosition

则：

ParameterValueMatch=0

因此：

类型正确 ≠ 参数有效

参数值必须满足方法规定的范围和条件。

20.14 调用条件匹配

方法具有方法条件：

Cₘ

实际调用具有调用条件：

Cᵢ

需要判断：

Cᵢ ↔ Cₘ

如果方法要求：

Object.State = Closed

而当前对象状态为：

Object.State = Open

则：

ConditionMatch=0

因此：

调用条件不满足 → 方法不能调用

20.15 当前状态匹配

方法调用必须发生在允许的状态下。

设：

Sᵢ = 当前状态

Sₘ = 方法允许状态

则：

Sᵢ ↔ Sₘ

例如：

OpenDoor

要求：

Door.State = Closed

如果：

Door.State = Open

则当前调用条件不成立。

因此：

状态匹配是方法调用匹配的重要组成部分。

20.16 前置状态判定

方法执行之前通常存在前置状态。

表示为：

S₀ → Method → S₁

其中：

S₀：调用前状态；
S₁：调用后状态。

如果方法要求：

S₀ = Closed

而实际：

S₀ = Open

则不能正常进入方法执行。

因此：

前置状态 → 方法调用匹配

属于方法调用的重要约束。

20.17 调用上下文匹配

方法调用不仅受到对象和状态影响，还受到上下文影响。

上下文可以表示为：

T = (Scene, Actor, Time, Relation, Environment)

其中：

Scene：场景；
Actor：调用主体；
Time：时间条件；
Relation：相关关系；
Environment：环境条件。

例如某方法只能由特定对象或者特定主体调用。

因此：

ContextMatch(I,M)

也是方法调用匹配的一部分。

20.18 调用主体匹配

方法可能要求特定主体执行。

例如：

ActorA → MethodX

而当前调用主体：

ActorB

如果ActorB不具有调用MethodX的能力或者权限关系，则：

ActorMatch=0

因此调用结构可以进一步表示为：

主体 → 方法 → 对象

即：

Actor → Method → Object

这是方法调用中的基本三元关系。

20.19 方法与能力匹配

方法调用还需要考虑主体是否具有执行该方法的能力。

设：

Capability(A,M)

表示主体A是否具有执行方法M的能力。

如果：

Capability(A,M)=1

则允许进入调用匹配。

如果：

Capability(A,M)=0

则：

MethodInvocationMatch=0

因此形成：

主体 → 能力 → 方法 → 调用

能力不是方法本身，但它是方法调用的重要约束。

20.20 方法调用目标匹配

一个目标可能对应多个方法。

例如：

目标：移动对象

可能存在：

方法A：直接移动

方法B：抓取后移动

方法C：机械搬运

因此调用时不能只判断：

GoalMatch=1

而需要进一步确定：

当前调用选择的方法

是否满足当前对象、状态、条件和能力。

形成：

目标 → 候选方法 → 方法匹配 → 调用条件匹配 → 方法调用

20.21 方法选择与方法调用匹配

方法匹配可以得到多个候选方法：

M₁

M₂

M₃

但最终调用只能进入符合当前条件的方法。

因此：

目标 → 候选方法集合

↓

方法匹配

↓

调用条件过滤

↓

状态过滤

↓

对象过滤

↓

参数过滤

↓

形成调用方法

这说明：

方法匹配负责建立候选关系

而：

方法调用匹配负责确定当前调用是否合法。

20.22 方法调用匹配的判定规则

方法调用匹配必须建立明确的判定规则。

设：

I = (M,O,P,C,S,T)

如果满足：

MethodMatch = 1

且：

ObjectMatch = 1

且：

ParameterMatch = 1

且：

ConditionMatch = 1

且：

StateMatch = 1

且：

ContextMatch = 1

则：

InvocationMatch(I,M)=1

即：

当前调用请求与目标方法匹配。

20.23 方法调用匹配的否决规则

如果出现核心调用冲突，则调用匹配失败。

例如：

方法不存在

→ 调用失败

方法类型错误

→ 调用失败

目标对象错误

→ 调用失败

参数数量错误

→ 调用失败

参数类型错误

→ 调用失败

必要条件不满足

→ 调用失败

前置状态错误

→ 调用失败

主体能力不足

→ 调用失败

调用上下文不允许

→ 调用失败

因此：

任一核心调用条件失败 → 方法调用匹配失败

20.24 方法调用匹配的完整判定链

完整过程可以表示为：

调用请求

↓

方法存在性判断

↓

方法类型匹配

↓

目标对象匹配

↓

参数匹配

↓

调用条件匹配

↓

当前状态匹配

↓

调用主体匹配

↓

能力匹配

↓

上下文匹配

↓

方法调用匹配

↓

允许调用 / 拒绝调用

20.25 方法调用匹配结果

方法调用匹配结果可以分为：

完全匹配

所有必要调用条件均满足。

条件匹配

方法和对象正确，但部分非核心条件需要进一步处理。

参数匹配失败

参数结构或参数值不满足要求。

状态匹配失败

当前对象状态不允许调用。

对象匹配失败

调用目标错误。

主体匹配失败

当前主体不能调用该方法。

上下文匹配失败

当前场景不允许调用。

完全不匹配

调用请求与方法基本结构不对应。

20.26 方法调用对象模型

在工程认知模型中，可以建立：

MethodInvocation
├── invocationId
├── method
├── actor
├── target
├── parameters
├── conditions
├── state
├── context
├── status
└── result

其中：

invocationId

表示调用实例。

method

表示目标方法。

actor

表示调用主体。

target

表示调用对象。

parameters

表示调用参数。

conditions

表示调用条件。

state

表示调用时状态。

context

表示调用上下文。

status

表示调用状态。

result

表示调用结果。

20.27 方法调用匹配器

可以建立独立的：

MethodInvocationMatcher

其职责包括：

matchMethod()
matchActor()
matchTarget()
matchParameters()
matchConditions()
matchState()
matchContext()
matchCapability()
matchInvocation()

整体关系为：

InvocationRequest → MethodInvocationMatcher → Method → MatchResult

匹配器只负责判断调用是否成立，不负责创建方法，也不负责执行动作。

因此：

MethodBuilder

负责：

方法构建

MethodMatcher

负责：

方法匹配

MethodInvocationMatcher

负责：

方法调用匹配

MethodExecutor

负责：

方法执行

四者形成清晰的职责分离。

20.28 方法、方法匹配、方法调用的完整关系

到这里可以形成四层结构：

动作

↓

方法构建

↓

方法

↓

方法匹配

↓

候选方法

↓

方法调用匹配

↓

具体方法调用

↓

方法执行

↓

动作执行

↓

行为产生

↓

状态变化

因此：

方法构建解决方法形成问题

方法匹配解决方法对应问题

方法调用匹配解决调用合法性问题

方法执行解决方法实际运行问题

四个层次不能混合。

20.29 方法调用与行为的关系

方法调用本身不是行为。

方法调用是导致行为产生的前置认知操作。

其关系可以表示为：

方法调用 → 方法执行 → 动作执行 → 行为产生

例如：

调用MoveObject

↓

执行MoveObject

↓

抓取

↓

移动

↓

放置

↓

对象发生移动行为

因此：

调用 ≠ 行为

而是：

调用 → 执行 → 行为

20.30 方法调用与状态变化

方法调用最终可能产生状态变化。

可以表示为：

S₀ → MethodInvocation → MethodExecution → S₁

其中：

S₀：调用前状态；
S₁：调用后状态。

例如：

Door.State = Closed

↓

OpenDoor()

↓

Door.State = Open

因此方法调用匹配不仅需要检查调用前状态，还可以通过调用结果检查状态变化是否符合方法定义。

20.31 方法调用结果匹配

方法调用完成之后，会形成结果：

Rᵢ

方法本身规定预期结果：

Rₘ

因此需要判断：

Rᵢ ↔ Rₘ

如果：

Rᵢ = Rₘ

则说明调用结果与方法预期一致。

如果：

Rᵢ ≠ Rₘ

则需要形成：

调用成功但结果异常

或者：

方法执行失败

的认知状态。

因此方法调用匹配不仅存在调用前匹配，还可以形成调用后的结果验证。

20.32 方法调用匹配的动态过程

方法调用匹配可以分为三个阶段。

第一阶段：

调用前匹配

判断：

方法、对象、参数、条件、状态、主体、上下文

是否满足。

第二阶段：

调用过程匹配

判断：

方法是否按照规定进入执行。

第三阶段：

调用结果匹配

判断：

实际结果是否与方法预期结果一致。

完整结构：

调用前 → 调用匹配 → 方法执行 → 调用结果 → 结果匹配

20.33 方法调用匹配的形式模型

设：

I = (M,O,P,C,S,T,R)

定义：

IM(I,M)

为Method Invocation Matching。

则：

IM = F(M,O,P,C,S,T,R)

其中：

M：方法；
O：对象；
P：参数；
C：条件；
S：状态；
T：上下文；
R：结果。

调用前匹配可以表示为：

PreMatch = F(M,O,P,C,S,T)

调用后匹配：

PostMatch = F(R,S’)

完整调用匹配：

InvocationMatch = PreMatch + Execution + PostMatch

这里的“+”表示过程组合，而不是简单的数值加法。

20.34 方法调用匹配的核心判定公式

可以定义：

IM(I,M)=1

当且仅当：

Mm ∧ Om ∧ Pm ∧ Cm ∧ Sm ∧ Tm ∧ Capm = 1

其中：

Mm：方法匹配；
Om：对象匹配；
Pm：参数匹配；
Cm：条件匹配；
Sm：状态匹配；
Tm：上下文匹配；
Capm：能力匹配。

如果任一必要条件为0，则：

IM(I,M)=0

即：

任一核心调用条件不满足 → 方法调用不匹配

20.35 方法调用匹配的认知意义

方法调用匹配将静态方法知识转变为动态调用关系。

它解决了一个重要问题：

“知道一个方法存在”并不等于“当前可以调用这个方法”。

例如系统知道：

OpenDoor

但是当前：

Door.State = Open

那么：

OpenDoor()

并不一定成立。

因此：

方法存在 → 方法匹配 → 调用条件 → 状态条件 → 调用成立

这种结构使认知系统具有动态条件判断能力。

20.36 方法调用匹配在认知体系中的位置

整个认知匹配链可以进一步扩展为：

对象匹配

↓

属性匹配

↓

关系匹配

↓

行为匹配

↓

动作匹配

↓

方法构建匹配

↓

方法匹配

↓

方法调用匹配

↓

状态匹配

↓

场景匹配

其中方法调用匹配是方法认知向执行认知转换的关键节点。

完整执行链可以表示为：

目标 → 方法匹配 → 方法选择 → 方法调用匹配 → 方法调用 → 动作 → 行为 → 状态 → 场景

20.37 方法调用匹配与方法选择

方法匹配可以产生多个候选方法。

例如：

目标G

↓

M₁

M₂

M₃

↓

方法匹配

得到：

CandidateMethods = {M₁,M₂,M₃}

之后必须根据：

对象

条件

状态

参数

能力

上下文

进一步筛选。

最终：

CandidateMethods → InvocationMatching → SelectedMethod

因此：

方法匹配产生候选

方法调用匹配确定可调用对象

这使方法匹配和方法调用匹配形成连续但独立的认知过程。

20.38 方法调用匹配的工程意义

从认知工程角度看，方法调用匹配是连接：

知识结构

与：

运行结构

的重要模块。

方法作为知识对象可以长期存在：

Method

而方法调用属于一次具体运行实例：

MethodInvocation

因此：

Method → MethodInvocation

不是对象复制关系，而是：

稳定方法结构 → 动态调用实例

通过这种方式，可以同时保持：

方法知识稳定性

和：

方法调用动态性

20.39 本章核心模型

方法调用匹配最终可以归纳为：

目标

↓

候选方法

↓

方法匹配

↓

方法选择

↓

方法调用请求

↓

方法存在性

↓

方法类型

↓

对象

↓

参数

↓

条件

↓

状态

↓

主体与能力

↓

上下文

↓

方法调用匹配

↓

方法调用

↓

方法执行

↓

动作

↓

行为

↓

状态变化

↓

场景变化

这构成了从目标到实际行为产生的完整认知—执行链。

20.40 本章小结

方法调用匹配是方法认知体系中的动态匹配层。

它不同于方法构建匹配，也不同于方法匹配。

方法构建匹配解决：

方法如何形成。

方法匹配解决：

两个方法是否对应。

方法调用匹配解决：

当前调用请求是否能够正确对应并调用某个方法。

方法调用可以表示为：

I = (M,O,P,C,S,T,R)

方法调用匹配的核心条件包括：

方法匹配

对象匹配

参数匹配

条件匹配

状态匹配

主体匹配

能力匹配

上下文匹配

其核心判定关系为：

方法 → 对象 → 参数 → 条件 → 状态 → 能力 → 上下文 → 方法调用匹配

最终：

匹配成功 → 方法调用

匹配失败 → 拒绝调用

由此形成完整的方法认知链：

动作 → 方法构建 → 方法 → 方法匹配 → 候选方法 → 方法调用匹配 → 方法调用 → 方法执行 → 行为 → 状态 → 场景

方法至此完成了从形成、对应、选择、调用到执行的完整理论结构，并成为连接认知匹配与行为执行的重要中间层。

第20章 方法调用匹配

第20章 方法调用匹配

20.1 方法调用匹配的提出背景

20.2 方法调用的定义

20.3 方法调用匹配的定义

20.4 方法调用匹配与方法匹配的区别

20.5 方法调用匹配的基本结构

20.6 方法标识匹配

20.7 方法类型匹配

20.8 调用对象匹配

20.9 对象实例匹配

20.10 参数匹配

20.11 参数数量匹配

20.12 参数类型匹配

20.13 参数值匹配

20.14 调用条件匹配

20.15 当前状态匹配

20.16 前置状态判定

20.17 调用上下文匹配

20.18 调用主体匹配

20.19 方法与能力匹配

20.20 方法调用目标匹配

20.21 方法选择与方法调用匹配

20.22 方法调用匹配的判定规则

20.23 方法调用匹配的否决规则

20.24 方法调用匹配的完整判定链

20.25 方法调用匹配结果

20.26 方法调用对象模型

20.27 方法调用匹配器

20.28 方法、方法匹配、方法调用的完整关系

20.29 方法调用与行为的关系

20.30 方法调用与状态变化

20.31 方法调用结果匹配

20.32 方法调用匹配的动态过程

20.33 方法调用匹配的形式模型

20.34 方法调用匹配的核心判定公式

20.35 方法调用匹配的认知意义

20.36 方法调用匹配在认知体系中的位置

20.37 方法调用匹配与方法选择

20.38 方法调用匹配的工程意义

20.39 本章核心模型

20.40 本章小结