首页 理论 架构 工程 文档 白皮书 著作 研究 案例 下载 博客 关于 开始使用 →
首页 › 第五篇　方法理论› 第30章　方法实例化

第30章　方法实例化

📅 2026年09月03日 👤 东塬一老翁 📂 第五篇　方法理论

第30章　方法实例化

方法选择确定的是：

当前应该采用什么方法。

但“选中了方法”并不等于方法已经成为当前执行对象。

一个方法通常只是一个抽象的、可复用的处理结构。例如：

Method Template
      ↓
“移动到目标位置”

它本身并没有说明：

  • 当前移动的是哪个对象；
  • 当前对象在哪里；
  • 目标位置在哪里；
  • 当前速度是多少；
  • 当前环境是什么状态；
  • 使用哪些具体参数；
  • 当前条件是否允许执行。

因此，在方法选择之后，还需要一个重要过程：

Method Selection
       ↓
Method Instantiation
       ↓
Method Instance
       ↓
Behavior
       ↓
Action
       ↓
Execution

方法实例化就是把抽象方法转换成当前认知场景中的具体方法实例。

30.1 方法实例化的定义

Method Instantiation（方法实例化）是指：

将一个通用方法模板，根据当前目标、当前对象、当前状态、当前场景以及具体参数进行绑定和映射，形成一个具有明确执行上下文的 Method Instance。

基本结构：

方法模板
   +
参数映射
   +
当前对象
   +
当前状态
   +
当前场景
   ↓
Method Instance

因此：

Method Template
=
“如何完成某类任务”

Method Instance
=
“当前这个对象，在当前状态下，按照这些具体参数执行这个方法”

这是抽象方法进入现实执行空间的关键一步。

30.2 方法模板

方法模板（Method Template）是方法的抽象定义。

它描述方法的基本结构，但不绑定某一个具体对象或某一次具体执行。

例如：

Method Template
│
├── Method Identity
├── Method Type
├── Goal
├── Target Type
├── Input Definition
├── Parameter Definition
├── Preconditions
├── Constraints
├── Processing Rules
├── Expected Output
└── Evaluation Rules

可以表示：

MethodTemplate
=
{
    Goal,
    TargetType,
    Inputs,
    Parameters,
    Conditions,
    Constraints,
    Processing,
    ExpectedOutput
}

例如一个抽象方法：

Method:
MoveToTarget

它只表示：

对象
 ↓
移动
 ↓
目标位置

但它还不知道：

当前对象 = ?
目标位置 = ?
当前速度 = ?
移动方向 = ?
移动距离 = ?
环境状态 = ?

因此方法模板本身不是一次执行。

30.3 方法模板与方法定义

方法模板与前面第26章的 Method Definition 存在密切关系，但二者关注层次不同。

Method Definition
       ↓
定义方法“是什么”
       ↓
Method Template
       ↓
提供可复用的方法结构
       ↓
Method Instance
       ↓
形成当前具体方法

可以理解为：

Method Definition
=
方法的概念与规则

Method Template
=
可被实例化的方法结构

Method Instance
=
当前具体方法

因此：

模板是实例化的来源，实例是模板在当前认知环境中的具体化。

30.4 参数映射

方法模板中的参数通常是抽象参数。

例如：

MoveToTarget(
    Object,
    TargetPosition,
    Speed,
    Direction
)

这里的：

Object
TargetPosition
Speed
Direction

只是参数定义。

真正执行时，需要将这些抽象参数映射到当前认知状态中的实际对象和数值。

因此：

Abstract Parameter
        ↓
Parameter Mapping
        ↓
Current Value

例如：

Object
   ↓
Object_001

TargetPosition
   ↓
Position_042

Speed
   ↓
CurrentSpeed

Direction
   ↓
CalculatedDirection

形成：

MoveToTarget(
    Object_001,
    Position_042,
    CurrentSpeed,
    CalculatedDirection
)

这就是参数映射。

30.5 参数映射的本质

参数映射实际上建立了：

方法空间
   ↓
当前认知空间

之间的联系。

可以表示为：

Method Parameter
       ↓
Semantic Mapping
       ↓
Cognitive Object / State / Value

例如：

Method Parameter:
TargetObject

        ↓

Cognitive Object:
Object#1024

又例如：

Method Parameter:
CurrentPosition

        ↓

Current State:
Position = (x,y,z)

因此参数映射并不是简单的数据赋值。

它实际上是在回答：

这个抽象方法中的变量，在当前认知世界中究竟对应什么？

30.6 参数映射的来源

参数并不一定来自同一个地方。

它们可能来自：

Parameter Source
│
├── Current Object
├── Current State
├── Scene
├── Goal
├── Knowledge
├── Experience
├── Environment
├── Sensor Data
├── Previous Method Output
└── Other Capability

因此：

Method Template
       ↓
Parameter Requirements
       ↓
Current Cognitive State
       ↓
Parameter Mapping
       ↓
Concrete Parameters

例如一个方法需要：

TargetPosition

它可能来自：

Goal

而：

CurrentPosition

可能来自：

Current State

而：

SafeDistance

可能来自：

Knowledge + Experience

所以方法实例化实际上依赖整个认知系统。

30.7 当前对象

当前对象（Current Object）是方法实例化中的核心元素。

抽象方法可能定义：

TargetObject

但是实际执行必须确定：

TargetObject = Object#001

因此：

Generic Method
      ↓
Object Binding
      ↓
Current Object

例如：

Method Template
Move()

Target Type:
Object

当前认知场景：

Object A
Object B
Object C

经过目标匹配：

Target Object
      ↓
Object B

形成：

Move(Object B)

这意味着方法已经从：

“移动一个对象”

变成：

“移动 Object B”

30.8 当前对象不是静态对象

当前对象不仅仅是一个 Object ID。

它还包含当前对象的认知状态。

例如：

Current Object
│
├── Object Identity
├── Attributes
├── Position
├── Velocity
├── State
├── Relations
├── Capability
└── Availability

因此：

Current Object
=
Object Identity
+
Current Attributes
+
Current State
+
Current Relations

方法实例化必须绑定的是：

当前对象的当前认知表示。

而不是仅仅绑定一个对象名称。

30.9 当前状态

方法模板通常要求某些前置状态。

例如：

Method:
Open(Object)

它可能要求：

Object.State = Closed

如果当前状态是：

Object.State = Open

那么该方法可能已经没有必要执行。

因此方法实例化必须读取：

Current State

并验证：

Current State
      ↓
Method Preconditions
      ↓
Compatibility

形成：

State Compatible
      ↓
可以实例化

State Incompatible
      ↓
不能实例化 / 重新选择方法

30.10 当前状态的动态性

当前状态不是固定值。

可以表示为：

State(t)

而执行过程中：

State(t)
   ↓
Action
   ↓
State(t+1)

因此：

MethodInstance(t)

实际上也是一个时间相关结构。

如果：

State(t) ≠ State(t+1)

则原来的 Method Instance 可能需要：

Update
Re-Instantiation
Method Adaptation
Method Re-Selection

因此方法实例并不是绝对静态的。

30.11 方法实例

Method Instance 是方法模板经过当前上下文绑定后的具体实例。

可以形式化为：

MethodInstance
=
MethodTemplate
+
ObjectBinding
+
StateBinding
+
ParameterBinding
+
SceneBinding
+
ConstraintBinding

进一步表示：

Method Instance
│
├── Method Identity
├── Template Reference
├── Current Object
├── Current State
├── Current Scene
├── Input Values
├── Parameter Values
├── Active Conditions
├── Active Constraints
├── Risk State
├── Expected Output
└── Execution Context

它已经不再是单纯的“方法定义”。

而是：

当前个体准备在当前场景中执行的具体方法结构。

30.12 方法模板到实例的转换

完整转换：

Method Template
       ↓
Read Parameter Requirements
       ↓
Find Current Object
       ↓
Read Current State
       ↓
Read Current Scene
       ↓
Resolve Inputs
       ↓
Map Parameters
       ↓
Apply Conditions
       ↓
Apply Constraints
       ↓
Create Method Instance

可以进一步表示为：

Generic Method
      ↓
Object Binding
      ↓
State Binding
      ↓
Parameter Binding
      ↓
Condition Binding
      ↓
Constraint Binding
      ↓
Method Instance

30.13 方法实例化与方法选择的区别

第29章解决：

选择哪个方法？

第30章解决：

这个方法如何变成当前具体方法？

因此：

Method Selection
=
选择

Method Instantiation
=
具体化

例如：

Method A
Method B
Method C
      ↓
Method Selection
      ↓
Method B
      ↓
Method Instantiation
      ↓
Method B + Object X + State Y + Parameters Z
      ↓
Method Instance

所以：

第29章：
Which Method?

第30章：
Which Object + Which State + Which Parameters?

30.14 方法实例化与能力实例化

第18章讨论过能力实例化。

两者不能混淆。

Capability Instance
=
当前能够做什么

而：

Method Instance
=
当前准备如何做

关系为：

Capability Instance
       ↓
Available Methods
       ↓
Method Selection
       ↓
Method Instantiation
       ↓
Method Instance

因此：

Capability
回答：
“我能做什么？”

Method
回答：
“我可以怎么做？”

Method Instance
回答：
“当前这个对象、当前这个状态下，我具体怎么做？”

30.15 方法实例化与行为

方法实例化完成之后，方法才可以进一步进入行为系统。

完整链条：

Capability
   ↓
Method
   ↓
Method Selection
   ↓
Method Instantiation
   ↓
Method Instance
   ↓
Behavior
   ↓
Action
   ↓
Execution

这里发生了一个重要转换：

Abstract Method
      ↓
Concrete Method Instance
      ↓
Dynamic Behavior
      ↓
Concrete Action

因此 Method Instance 是：

方法系统向行为系统输出的直接结构。

30.16 方法实例化中的对象—状态—参数三元关系

方法实例化可以进一步抽象为：

Object
  +
State
  +
Parameter
  ↓
Method Instance

其中：

Object
=
对谁执行

State
=
在什么状态下执行

Parameter
=
按照什么具体条件执行

因此：

Method Instance
=
Method
(Object, State, Parameters)

例如：

Method:
MoveToTarget

Object:
Robot_A

State:
Position=P1
Velocity=V1
Battery=80%

Parameters:
Target=P2
Speed=V2
SafetyDistance=D

最终：

MoveToTarget(
    Robot_A,
    P2,
    V2,
    D
)

这才成为真正的当前方法实例。

30.17 方法实例化与场景

方法实例化还必须考虑场景。

因为同一个对象、同一个方法，在不同场景下可能形成完全不同的实例。

例如：

Object A
Method M

在：

Scene 1

可能得到：

MethodInstance M1

在：

Scene 2

可能得到：

MethodInstance M2

因此：

Method Instance
=
Method
+
Object
+
State
+
Scene
+
Parameters

这说明方法实例具有明显的场景依赖性。

30.18 方法实例化的约束检查

方法实例创建之前，必须确认绑定结果仍然满足方法约束。

Method Template
       ↓
Parameter Mapping
       ↓
Constraint Validation
       ↓
┌───────────────┐
│               │
Valid         Invalid
│               │
↓               ↓
Instance       Re-Mapping

例如：

Speed = 100

而当前对象允许：

MaxSpeed = 50

则：

Speed > MaxSpeed

实例化失败。

可能产生：

Parameter Adjustment

或者：

Method Re-Evaluation

甚至：

Method Re-Selection

因此：

实例化不是无条件绑定，而是受约束的具体化过程。

30.19 方法实例化与实时认知

由于第25章已经建立实时认知，因此方法实例也必须具有实时更新能力。

基本过程：

Method Instance
      ↓
Execution Preparation
      ↓
Real-Time State Change
      ↓
Cognitive Update
      ↓
Parameter Update
      ↓
Instance Update

例如：

Target Position
      ↓
发生变化
      ↓
Parameter Mapping Update
      ↓
Method Instance Update

如果核心条件发生变化：

State Change
      ↓
Constraint Violation
      ↓
Method Instance Invalid
      ↓
Method Re-Evaluation

因此：

Method Instance

不是执行前一次性生成后永远不变的对象。

它可以随着认知状态进行更新。

30.20 方法实例生命周期

方法实例可以拥有自己的生命周期：

Created
   ↓
Bound
   ↓
Validated
   ↓
Ready
   ↓
Active
   ↓
Executing
   ↓
Completed
   ↓
Evaluated

失败路径：

Executing
   ↓
Failure
   ↓
Invalidated
   ↓
Re-Evaluation
   ↓
Re-Instantiation

或者：

Executing
   ↓
Failure
   ↓
Recovery Method
   ↓
New Method Instance

因此：

Method Template
      ↓
Instance
      ↓
Execution
      ↓
Result
      ↓
Evaluation
      ↓
Experience

方法实例也成为经验形成的重要载体。

30.21 方法实例与经验

执行结束以后，系统不仅需要记录：

Method = M

还应该记录：

Method Instance
+
Object
+
State
+
Parameters
+
Scene
+
Result
+
Feedback

例如：

MethodInstance
│
├── Object = A
├── State = S1
├── Scene = Scene01
├── Parameters = P1
├── Result = Success
└── Feedback = Stable

这些信息可以形成历史经验：

Method Instance
      ↓
Execution Result
      ↓
Experience
      ↓
Method Evaluation Update

因此，未来同类场景中的方法评价就不再完全依赖抽象方法统计，而可以参考：

这个方法在相似对象、相似状态、相似场景和相似参数下曾经发生过什么。

30.22 方法实例的认知意义

方法实例化实际上完成了一个非常重要的转换：

知识中的方法
      ↓
认知中的方法
      ↓
当前场景中的方法
      ↓
当前对象上的方法
      ↓
当前状态下的方法
      ↓
具体参数的方法

因此：

Knowledge
   ↓
Method Template
   ↓
Method Selection
   ↓
Method Instantiation
   ↓
Method Instance

可以理解为：

从“知道怎么做”进入“当前具体怎么做”。

30.23 方法实例化的完整模型

可以建立完整的 Method Instantiation 模型：

MethodInstantiation
│
├── MethodTemplate
│
├── CurrentObject
│
├── CurrentState
│
├── CurrentScene
│
├── InputMapping
│
├── ParameterMapping
│
├── ConditionBinding
│
├── ConstraintBinding
│
├── RiskBinding
│
├── ExpectedOutput
│
├── Validation
│
└── MethodInstance

其核心输入：

Method Template
Current Object
Current State
Current Scene
Goal
Input
Knowledge
Parameters
Conditions
Constraints
Risk

核心输出：

Method Instance

30.24 方法实例化的完整计算链

Current Cognitive State
        ↓
Current Goal
        ↓
Capability Matching
        ↓
Method Selection
        ↓
Method Template
        ↓
Identify Current Object
        ↓
Read Current State
        ↓
Read Current Scene
        ↓
Resolve Inputs
        ↓
Parameter Mapping
        ↓
Condition Binding
        ↓
Constraint Binding
        ↓
Validation
        ↓
Method Instance
        ↓
Behavior Generation
        ↓
Action
        ↓
Execution
        ↓
Feedback
        ↓
Re-Cognition

因此第30章实际上完成了从：

“选择方法”

到：

“形成当前可执行方法”

的转换。

30.25 方法模板、方法实例与执行的三级结构

可以将整个方法系统进一步划分为三个层次：

第一层：Method Template

“通用方法是什么？”

        ↓

第二层：Method Instance

“当前具体怎么做？”

        ↓

第三层：Execution

“实际发生了什么？”

即：

Template
   ↓
Instance
   ↓
Execution

这三个层次不能混淆。

Method Template

抽象、通用、可复用。

Method Instance

当前对象、当前状态、当前参数下的具体方法。

Execution

方法实例真正进入现实过程后的实际执行结果。

因此：

Template ≠ Instance ≠ Execution

30.26 方法实例化与现实世界

方法实例化是连接内部认知模型与现实执行的重要边界。

Internal Cognitive Space
────────────────────────
Method Template
      ↓
Method Selection
      ↓
Parameter Mapping
      ↓
Method Instance
────────────────────────
        ↓
Behavior Space
        ↓
Action Space
────────────────────────
        ↓
Physical / External World

因此 Method Instance 可以被视为：

内部抽象方法进入现实行为之前的最后一个具体认知结构。

30.27 本章核心结论

方法选择之后，人工个体还不能直接执行抽象方法。

必须经过：

Method Template
      ↓
Parameter Mapping
      ↓
Current Object
      ↓
Current State
      ↓
Current Scene
      ↓
Constraint Validation
      ↓
Method Instance

方法模板解决：

这个方法通常如何工作？

参数映射解决：

抽象参数在当前认知世界中分别对应什么？

当前对象解决：

这个方法现在作用于谁？

当前状态解决：

这个方法现在处于什么状态下？

Method Instance 解决：

当前这个对象、当前这个状态、当前这个场景下，究竟形成了一个怎样的具体方法？

最终形成：

Cognition
   ↓
Goal
   ↓
Capability
   ↓
Method Selection
   ↓
Method Template
   ↓
Parameter Mapping
   ↓
Current Object
   ↓
Current State
   ↓
Current Scene
   ↓
Method Instance
   ↓
Behavior
   ↓
Action
   ↓
Execution
   ↓
Feedback
   ↓
Re-Cognition

因此：

Method 是“方法”，Method Template 是“可复用的方法结构”，Method Instance 是“当前个体针对当前对象、当前状态、当前场景和当前参数形成的具体方法”。

第29章完成了：

Candidate Methods
        ↓
Selected Method

第30章进一步完成：

Selected Method
        ↓
Method Template
        ↓
Object + State + Parameters
        ↓
Method Instance

至此，方法系统已经从方法定义、动态生成、方法评价、方法排序、方法竞争、方法组合、方法选择进一步进入方法实例化阶段。

下一层自然形成：

Method Instance
       ↓
Behavior
       ↓
Behavior State
       ↓
Dynamic Behavior
       ↓
Action
       ↓
Execution

这标志着理论体系正式从Method System（方法系统）进入Behavior System（行为系统）。

← 第29章　方法选择
第31章　Behavior 的定义 →

Leave a Reply

Your email address will not be published. Required fields are marked *