首页 理论 架构 工程 规划 文档 白皮书 著作 研究 案例 下载 博客 关于 联系 开始使用 →

第五卷 第三章 方法调用

第三章 方法调用

3.1 方法调用的提出

前面的理论已经建立:

Class 是对一类对象共同结构、属性、方法、关系和规则的定义。

并建立:

Object 是Class经过实例化形成的具体对象实例。

同时建立:

Attribute是Object的结构成员,Value是Attribute当前对应的具体值或状态。

因此,一个关键问题随之产生:

Class中定义的Method如何真正作用于具体Object?

Method虽然定义在Class中,但Method本身只是一个可调用运算结构的定义。

它必须进入具体Object,读取该Object当前的Attribute Value,并在该Object的实例状态、Context、Rule和Relation基础上执行,才能产生实际结果。

因此,本理论建立:

Class
   ↓
Method Definition
   ↓
Object
   ↓
Method Call
   ↓
Operation
   ↓
Result / Value Change / State Change

核心关系为:

Object → Method Call

进一步完整表示为:

Object → Method Call → Operation → Result

如果方法改变对象内部状态,则形成:

Object → Method Call → Operation → Value Change → State Change

因此:

Method不是脱离Object独立运行的抽象行为,而是定义于Class、通过具体Object实例被调用,并作用于该Object实际结构和实例状态的可执行结构。


3.2 Method与Method Call的区别

必须首先严格区分:

Method

与:

Method Call

Method是定义。

Method Call是调用行为。

例如:

Class Product
    ↓
Method sell(quantity)

这里:

sell(quantity)

是Method定义。

而:

ProductA.sell(3)

才是Method Call。

因此:

Method ≠ Method Call

可以表示为:

Class
  ↓
Method Definition
  ↓
Callable Method
  ↓
Object
  ↓
Method Call
  ↓
Operation

Method解决:

“对象能够执行什么?”

Method Call解决:

“哪个具体Object现在执行这个Method?”

Operation解决:

“这个Method在这个Object上实际执行了什么运算?”

因此三者必须保持理论区分。


3.3 方法属于Class定义

在面向对象结构中,Method通常由Class定义。

例如:

Class Product
├── Attribute
│   ├── price
│   └── inventory
│
└── Method
    ├── sell()
    ├── restock()
    └── calculateTotal()

Class定义:

Product
    ↓
共同Method

因此:

Method(Product, sell)

属于Class层面的结构定义。

但是:

ProductA.sell()

属于Object层面的实际调用。

因此:

Class
    ↓
定义Method
    ↓
Object
    ↓
调用Method

这是方法从抽象结构进入具体运行的基本过程。


3.4 Object是Method调用的具体载体

Method虽然定义在Class中,但是它不能仅凭Class定义产生某一个具体实例的运行结果。

例如:

Class Product
Method sell(quantity)

Class只规定:

Product具有sell方法

但是:

ProductA

和:

ProductB

可能具有不同库存。

例如:

ProductA.inventory = 50
ProductB.inventory = 10

当调用:

ProductA.sell(3)

系统读取:

ProductA.inventory = 50

然后执行:

50 - 3 = 47

得到:

ProductA.inventory = 47

而:

ProductB.sell(3)

读取的是:

ProductB.inventory = 10

执行:

10 - 3 = 7

得到:

ProductB.inventory = 7

因此:

同一个Method
        ↓
不同Object
        ↓
读取不同Value
        ↓
产生不同Operation Result
        ↓
形成不同State

这证明:

Object是Method进入具体实例运行环境的载体。


3.5 Object → Method Call的基本结构

方法调用的最基本结构可以表示为:

Object
   ↓
Method Call
   ↓
Method
   ↓
Operation
   ↓
Result

例如:

ProductA
   ↓
sell(3)
   ↓
sell Method
   ↓
inventory - 3
   ↓
Result

完整结构:

ProductA
├── inventory = 50
│
└── Method Call: sell(3)
          ↓
     Read inventory
          ↓
       50 - 3
          ↓
      inventory = 47
          ↓
     State Change

因此Method Call不是简单的“调用名称”。

它实际上建立了一条:

Object与Method之间的运行关系。

可以定义:

Method Call是将Class中定义的Method绑定到具体Object,并在该Object的当前实例状态、参数、Context和Rule条件下触发Operation执行的结构过程。


3.6 方法调用的基本组成

一个完整Method Call至少包括:

Method Call
├── Object
├── Method
├── Parameters
├── Context
├── Preconditions
├── Operation
├── Result
├── Effects
└── Postconditions

其中:

Object

确定:

谁执行这个Method。

Method

确定:

执行什么行为。

Parameters

确定:

本次调用提供什么输入。

Context

确定:

在什么上下文中执行。

Preconditions

确定:

什么条件下允许执行。

Operation

确定:

实际执行什么运算。

Result

确定:

运算产生什么结果。

Effects

确定:

Object的Value、State、Relation或Structure发生什么变化。

Postconditions

确定:

执行完成以后必须满足什么条件。

因此:

Method Call
=
Object
+
Method
+
Parameters
+
Context
+
Conditions
+
Operation
+
Result
+
Effects

3.7 方法调用不是简单函数调用

传统程序设计中,函数可以被理解为:

Input → Function → Output

但是WSaiOS-SI中的Method不能仅被定义为这一形式。

Object Method必须考虑:

Object
+
Attribute
+
Value
+
State
+
Relation
+
Rule
+
Context
+
Method

因此:

Method Call

可能同时:

  • 获取Attribute
  • 获取Value
  • 比较Value
  • 执行运算
  • 判断Condition
  • 修改Value
  • 修改State
  • 修改Relation
  • 创建Structure
  • 返回Result
  • 调用其他Method

所以:

Method Call是Object结构中的一次实际结构运算,而不仅是一个独立函数的执行。


3.8 方法调用与Attribute

Method最常见的作用之一,是访问Object的Attribute。

例如:

Object ProductA
├── price = 100
├── quantity = 3
└── Method calculateTotal()

调用:

ProductA.calculateTotal()

Method读取:

price = 100
quantity = 3

然后:

100 × 3 = 300

形成:

total = 300

因此:

Object
   ↓
Method Call
   ↓
Access Attribute
   ↓
Get Value
   ↓
Operation
   ↓
Result

这说明Method与Attribute之间存在直接结构联系。


3.9 方法调用与Value

Method真正参与运算的通常不是Attribute名称,而是Attribute对应的具体Value。

例如:

Attribute:
price

实际实例:

ProductA.price = 100

Method:

calculateDiscount()

可能执行:

100 × 0.9 = 90

这里真正参与运算的是:

100

而不是字符串:

price

因此:

Object
   ↓
Attribute
   ↓
Value
   ↓
Method Call
   ↓
Operation

可以形式化表示:

Vresult = Operation(M, V1, V2, ..., Vn, P)

其中:

  • M = Method
  • V1...Vn = Object中的Attribute Value
  • P = Method Parameters
  • Vresult = 运算结果

3.10 方法调用与参数

Method Call可以向Method提供参数。

例如:

ProductA.sell(3)

其中:

Object = ProductA
Method = sell
Parameter = 3

可以表示:

Call = Invoke(ProductA, sell, 3)

Method读取:

ProductA.inventory = 50

执行:

50 - 3

得到:

47

所以:

Method Call
=
Object
+
Method
+
Parameter

但参数不是Object本身的Attribute。

必须区分:

Object Attribute Value

与:

Method Call Parameter

例如:

ProductA.inventory = 50

是Object内部状态。

而:

sell(3)

中的:

3

是本次调用输入。


3.11 方法调用与条件判断

Method不一定直接进行数学运算。

它也可以判断Condition。

例如:

ProductA.inventory = 50

调用:

ProductA.isAvailable()

Method内部判断:

inventory > 0

得到:

true

因此:

Object
   ↓
Method Call
   ↓
Read Value
   ↓
Condition
   ↓
Decision
   ↓
Result

例如:

isAvailable()

可能形成:

inventory > 0
        ↓
      true

所以Method具有判断能力。


3.12 方法调用与Rule

Method执行并不一定无条件进行。

例如:

ProductA.sell(3)

执行前需要:

inventory >= 3

于是形成:

Precondition
    ↓
Rule Validation
    ↓
Method Call
    ↓
Operation

如果:

inventory = 10

则:

10 >= 3

成立。

允许执行:

sell(3)

如果:

inventory = 2

则:

2 >= 3

不成立。

Method Call不能正常执行。

因此:

Method Call必须受到Object当前State、Rule和Condition的约束。

这使Method Call成为结构化运行,而不是无条件执行。


3.13 方法调用与对象状态

Method Call最重要的作用之一,是改变Object状态。

例如:

ProductA.inventory = 50

调用:

ProductA.sell(3)

执行:

inventory = inventory - 3

形成:

50 → 47

于是:

State₁ → Method Call → Operation → State₂

完整表示:

Object
   ↓
Current State
   ↓
Method Call
   ↓
Operation
   ↓
Value Change
   ↓
State Transition

因此:

Method Call是对象实例状态发生结构化变化的重要机制。


3.14 方法调用可以不改变Object状态

并不是所有Method Call都会修改Object。

例如:

ProductA.getPrice()

如果:

price = 100

Method只读取Value并返回:

100

则:

ProductA State₁
        ↓
getPrice()
        ↓
Result = 100
        ↓
ProductA State₁

Object状态没有变化。

因此Method Call至少存在两类:

第一类:读取型调用

Object
→ Method Call
→ Read
→ Result

第二类:状态改变型调用

Object
→ Method Call
→ Operation
→ Value Change
→ State Change

还可以存在:

第三类:结构改变型调用

Object
→ Method Call
→ Operation
→ Relation Change
→ Structure Change

因此Method Call的影响范围可以不同。


3.15 方法调用可以返回Value

例如:

ProductA.getPrice()

返回:

100

则:

Method Call → Value

该Value可以继续进入其他Method:

ProductA.getPrice()
        ↓
100
        ↓
calculateDiscount(100)
        ↓
90

因此:

Method Call₁
    ↓
Result Value
    ↓
Method Call₂
    ↓
Result Value

形成Method组合。


3.16 方法调用可以返回Object

Method不仅可以返回简单Value,也可以返回Object。

例如:

Customer.findOrder()

可能返回:

OrderObject

于是:

Object A
   ↓
Method Call
   ↓
Object B

形成Object之间的动态连接。

例如:

CustomerA.findOrder()
       ↓
OrderA

之后可以:

OrderA.calculateTotal()

形成:

CustomerA
   ↓
findOrder()
   ↓
OrderA
   ↓
calculateTotal()
   ↓
Total

因此Method Call可以成为Object之间结构连接的运行机制。


3.17 方法调用可以返回Structure

Method也可以生成或返回一个新的Structure。

例如:

OrderA.generateInvoice()

可能形成:

Invoice Structure

于是:

OrderA
   ↓
Method Call
   ↓
Operation
   ↓
Invoice Structure

这说明Method不仅可以操作已有Object,也可以参与新Structure形成。

因此:

Method Call
→ Value
→ Object
→ Structure

都是可能的结果类型。


3.18 方法调用与Relation

Object的Method Call也可以改变Relation。

例如:

OrderA.pay()

执行前:

OrderA
status = unpaid

调用:

pay()

执行:

status = paid

同时可能建立:

OrderA
    ↓
paid

并进一步改变:

OrderA → can_ship → ShippingProcess

因此:

Method Call
   ↓
Value Change
   ↓
State Change
   ↓
Relation Change
   ↓
Structure Change

所以Method是Object结构运行的重要驱动机制。


3.19 方法调用的上下文

同一个Method在不同Context中可能产生不同结果。

例如:

ProductA.calculatePrice()

如果Context为:

Retail

可能使用:

Retail Price

如果Context为:

Wholesale

可能使用:

Wholesale Price

因此:

Method Call
=
Object
+
Method
+
Parameters
+
Context

Method执行不能完全脱离Context。

这与前面的结构理论保持一致:

结构意义不是孤立存在的,而是在Context、Relation、Condition和Organization中确定。


3.20 方法调用与时间

Method Call也是一个发生在具体时间点的结构事件。

例如:

10:00
ProductA.sell(3)

11:00
ProductA.sell(5)

Object状态:

10:00
inventory = 50

11:00
inventory = 47

12:00
inventory = 42

因此:

Method Call
   ↓
Operation Event
   ↓
State Transition
   ↓
State History

方法调用可以因此成为Object生命周期和State History的一部分。


3.21 方法调用的事件性质

一次Method Call可以被视为一个结构事件:

Method Call Event
├── Object
├── Method
├── Parameters
├── Time
├── Context
├── Initial State
├── Operation
├── Result
└── Final State

例如:

ProductA.sell(3)

可以记录:

Object = ProductA
Method = sell
Parameter = 3
Initial inventory = 50
Operation = inventory - 3
Result = success
Final inventory = 47

因此:

Method Call不仅产生Result,也可以形成Object State Transition的可追踪结构。


3.22 方法调用的嵌套

一个Method可以调用另一个Method。

例如:

OrderA.checkout()

内部可能:

validate()
calculateTotal()
pay()
generateInvoice()

于是:

checkout()
   ↓
validate()
   ↓
calculateTotal()
   ↓
pay()
   ↓
generateInvoice()

形成Method Call Chain:

M₁
 ↓
M₂
 ↓
M₃
 ↓
M₄

因此Method本身可以形成新的结构。

更完整:

Object
   ↓
Method Call₁
   ↓
Method Call₂
   ↓
Method Call₃
   ↓
Method Call₄
   ↓
Composite Operation

这与结构组合理论直接连接。


3.23 方法调用的组合

多个Method Call可以组合成更高层的Operation Structure。

例如:

OrderA.checkout()

实际上由:

checkInventory()
calculateTotal()
createPayment()
confirmPayment()
updateStatus()

共同形成。

因此:

Method Call₁
+
Method Call₂
+
Method Call₃
+
Method Call₄
+
Relation
→
Composite Method Operation

这说明:

方法调用本身也可以被组合成为更高层结构。


3.24 方法调用与对象之间的关系

不同Object可以互相调用Method。

例如:

CustomerA
    ↓
placeOrder()
    ↓
OrderA

或者:

OrderA
    ↓
ProductA.checkAvailability()

于是形成:

Object A
   ↓
Method Call
   ↓
Object B
   ↓
Method

因此:

Object → Method Call不仅可以形成Object内部运行,也可以形成Object之间的动态结构关系。

这种关系可以进一步形成:

Object Interaction Structure

3.25 方法调用与结构运算

前面已经建立:

Operation Relation是描述结构之间运算关系的重要机制。

Method Call则是使这些Operation真正发生的执行入口。

例如:

price × quantity → total

可以由:

calculateTotal()

执行。

因此:

Method
   ↓
定义Operation Structure
   ↓
Method Call
   ↓
具体Object
   ↓
获取Value
   ↓
执行Operation Relation
   ↓
Result

所以:

Method定义可执行的运算结构,Method Call将该运算结构绑定到具体Object并使其实际运行。


3.26 方法调用与对象实例化的关系

实例化建立Object。

Method Call使Object开始运行。

因此:

Class
   ↓
Instantiation
   ↓
Object
   ↓
Method Call
   ↓
Operation

可以理解为两个不同阶段:

第一阶段:结构具体化

Class → Object

第二阶段:结构运行

Object → Method Call → Operation

因此:

实例化解决“对象如何存在”,方法调用解决“对象如何运行”。

这两个机制共同构成Object理论的基础。


3.27 方法调用与Object State的关系

完整运行过程可以表示为:

Object
   ↓
Current State
   ↓
Method Call
   ↓
Precondition Check
   ↓
Read Attributes
   ↓
Get Values
   ↓
Operation
   ↓
Rule Evaluation
   ↓
Result
   ↓
State Update

如果没有状态变化:

State₁
 ↓
Method Call
 ↓
Result
 ↓
State₁

如果发生状态变化:

State₁
 ↓
Method Call
 ↓
Operation
 ↓
State₂

因此:

Method Call是Object State之间进行结构转移的重要机制。


3.28 方法调用与知识结构

Method Call产生的结果可以进入Knowledge Structure。

例如:

ProductA.getInventory()

得到:

50

再结合:

inventory > 0

可以形成:

ProductA is available

于是:

Method Call
   ↓
Result
   ↓
Relation
   ↓
Rule
   ↓
Knowledge Structure

因此:

Method Call不仅改变Object,还能够为结构智能系统提供新的知识运行结果。


3.29 方法调用与能力结构

如果某一Method能够被稳定调用并产生可重复结果,那么它可以成为Capability Structure的一部分。

例如:

calculateTotal()

可以被多个Order Object调用:

OrderA.calculateTotal()
OrderB.calculateTotal()
OrderC.calculateTotal()

虽然Object不同:

A ≠ B ≠ C

但Method定义相同:

calculateTotal()

因此形成:

Class Method
   ↓
Reusable Operation Structure
   ↓
Multiple Object Calls
   ↓
Capability

所以:

Method是能力结构的重要来源,Method Call则是能力在具体Object上的实际运行。


3.30 方法调用与结构学习

WSaiOS-SI中的学习不仅可以学习Value,也可以学习:

  • 哪个Method适合哪个Object
  • 什么条件下调用Method
  • Method调用顺序
  • Method之间的依赖
  • Method产生什么结果
  • Method如何改变State
  • Method如何影响Relation
  • Method如何形成新Structure

因此可以形成:

Feedback
   ↓
Method Call Analysis
   ↓
Result Analysis
   ↓
State Transition Analysis
   ↓
Successful Call Structure
   ↓
Method / Operation Knowledge
   ↓
Capability Update

学习的对象因此不仅是数据,还包括:

对象如何通过Method进行结构运行。


3.31 方法调用与反馈

一次Method Call执行以后,可以得到Result。

例如:

OrderA.pay()

结果:

success

或者:

failed

系统可以根据Result形成反馈:

Method Call
   ↓
Execution
   ↓
Result
   ↓
Feedback
   ↓
Structure Evaluation

如果失败:

Method Call
   ↓
Failure
   ↓
Reason Analysis
   ↓
Rule / Condition / Method Analysis
   ↓
Structure Reorganization

因此:

Method Call是反馈学习机制中的实际运行节点。


3.32 方法调用失败

Method Call并不保证一定成功。

可能因为:

  • Object不存在
  • Method不存在
  • 参数不合法
  • Attribute不存在
  • Value无效
  • Precondition不满足
  • Rule禁止
  • Context不匹配
  • Object状态不允许
  • Relation不存在
  • Operation无法执行

例如:

ProductA.inventory = 2

调用:

ProductA.sell(5)

如果规则:

inventory >= quantity

则:

2 >= 5

不成立。

因此:

Method Call
   ↓
Condition Validation
   ↓
Failed

Object State不应错误地变成:

inventory = -3

除非Class Rule明确允许这种状态。

因此:

Method Call必须受到Structure Rule和Object State约束。


3.33 方法调用的安全边界与结构边界

Method并不能无限制地修改Object。

Class可以定义:

哪些Attribute可以访问
哪些Value可以修改
哪些State可以转换
哪些Relation可以建立
哪些Operation允许执行

因此Method Call必须在结构边界内运行。

例如:

Method
   ↓
Access Constraint
   ↓
Operation Constraint
   ↓
State Constraint
   ↓
Result

这保证Object不会因为任意Method Call而失去结构一致性。

因此:

Method Call既是对象运行机制,也是对象结构约束机制。


3.34 方法调用与对象结构完整性

如果Method修改:

price

那么可能影响:

total

如果Method修改:

inventory

可能影响:

availability

如果Method修改:

status

可能影响:

Order Relation

因此Method Call之后需要进行结构一致性检查:

Method Call
   ↓
Value Change
   ↓
State Change
   ↓
Relation Check
   ↓
Rule Check
   ↓
Structure Validation

如果发现结构冲突,则需要:

Rollback

或者:

Correction

或者:

Reorganization

具体机制由结构规则确定。


3.35 方法调用与结构转换

Method不仅能够修改Value,还可以使Object从一种结构状态进入另一种结构状态。

例如:

Order
status = pending

调用:

confirm()

之后:

status = confirmed

可以表示:

S_pending
    ↓
confirm()
    ↓
S_confirmed

因此Method Call可以被定义为:

一种结构状态转换操作。

形式化:

S₂ = Transform(S₁, M, P, C, Q)

其中:

  • S₁ = 调用前Object State
  • M = Method
  • P = Parameters
  • C = Context
  • Q = Rule
  • S₂ = 调用后Object State

3.36 方法调用与新结构形成

某些Method Call会产生新的结构。

例如:

OrderA.generateInvoice()

调用以后:

InvoiceA

被创建。

于是:

OrderA
   ↓
generateInvoice()
   ↓
Invoice Object

形成:

Order Structure
+
Invoice Structure
+
Relation
→
Billing Structure

因此:

Method Call不仅可以改变已有Object,也可以成为新Object、新Relation和新Structure形成的触发机制。

这使Object具有结构生成能力。


3.37 方法调用与对象关系网络

当系统中存在多个Object时,Method Call会形成动态Interaction Network。

例如:

CustomerA
    ↓ placeOrder()
OrderA
    ↓ calculate()
ProductA
    ↓ checkInventory()
InventoryA

于是:

CustomerA
   ↓
OrderA
   ↓
ProductA
   ↓
InventoryA

这些Object之间通过Method Call形成动态关系。

因此:

Method Call可以被视为Object之间动态结构关系形成的重要机制。


3.38 方法调用的形式化模型

定义Method:

M = <I, P, Pre, Op, Out, Effect, Rule, Context>

其中:

  • I = Method Identity
  • P = Parameters
  • Pre = Preconditions
  • Op = Operation
  • Out = Output
  • Effect = Effects
  • Rule = Rules
  • Context = Context Requirements

定义Object:

O = <I_o, C, A, V, S, R, Q>

Method Call:

Call = Invoke(O, M, P, C)

执行过程:

Precondition(O, M, P, C)
        ↓
       True
        ↓
Operation(O, M, P)
        ↓
Result
        ↓
State Transition

如果:

Precondition = False

则:

Call → Failed

因此:

CallResult =
{
    Success,
    Failure,
    Result,
    StateChange,
    RelationChange,
    StructureChange
}

3.39 方法调用的完整运行模型

综合本章,可以建立:

Object
   ↓
Select Method
   ↓
Method Call
   ↓
Bind Object
   ↓
Bind Parameters
   ↓
Check Context
   ↓
Check Preconditions
   ↓
Read Attribute
   ↓
Get Value
   ↓
Execute Operation
   ↓
Apply Rule
   ↓
Generate Result
   ↓
Update Value
   ↓
Update State
   ↓
Update Relation
   ↓
Validate Structure
   ↓
Generate Feedback

如果需要:

   ↓
Create Object / Structure

最终:

Method Call
→ Operation
→ Result
→ State Transition
→ Structure Change
→ Knowledge Update
→ Capability Update

3.40 Object → Method Call的核心理论关系

本章最核心的理论关系不是:

Class → Method

而是:

Object → Method Call

因为:

Class → Method

只是定义关系。

而:

Object → Method Call

才是运行关系。

完整区分:

Class
  ↓
Method Definition

Object
  ↓
Method Call

Method Call
  ↓
Operation

Operation
  ↓
Result / State Change

因此:

Class定义Method,Object调用Method,Operation执行Method,Result体现执行结果,State Change体现对象状态变化。


3.41 方法不是独立运行结构

本章必须明确一个重要原则:

Method不是独立运行的。

Method在Class中定义:

Class
   ↓
Method

但是Method只有绑定到具体Object以后,才具有具体实例运行对象:

Object
   ↓
Method Call

例如:

sell(3)

不能脱离Object直接回答:

谁的库存减少3?

必须明确:

ProductA.sell(3)

还是:

ProductB.sell(3)

因为:

ProductA.inventory ≠ ProductB.inventory

因此:

Method提供共同的运算结构,Object提供具体的运算对象。

两者结合:

Object + Method Call

才形成具体运行。


3.42 方法调用不是简单的名称匹配

系统不能仅仅看到:

sell

就认为已经发生Method Call。

真正的Method Call必须确定:

Object = ?
Method = ?
Parameters = ?
Context = ?
Current State = ?
Precondition = ?
Operation = ?

因此:

"sell"

只是Method名称或Method标识。

而:

ProductA.sell(3)

才是完整的Method Call结构。

这体现了WSaiOS-SI的结构原则:

语义必须进入结构,结构必须进入运行。


3.43 自主语义理解与方法调用识别

在WSaiOS-SI中,Method Call也必须经过自身的自主语义理解。

例如输入信息:

“让产品A卖出3件。”

系统不能简单依赖文字模式识别。

WSaiOS-SI自主语义理解层需要识别:

Object = ProductA
Action / Method = sell
Parameter = 3
Target Attribute = inventory
Operation = inventory - 3
Expected State Change = inventory decrease

形成:

Object
   ↓
Method
   ↓
Parameter
   ↓
Method Call Structure

然后才执行:

Invoke(ProductA, sell, 3)

因此:

原始信息
→ WSaiOS-SI自主语义理解
→ Object识别
→ Method识别
→ Parameter识别
→ Method Call Structure
→ Validation
→ Operation

大型语言模型不是这一过程的必要组成部分。

如果系统使用外部LLM,其结果仍必须经过:

LLM Output
   ↓
WSaiOS-SI自主语义理解
   ↓
Semantic Validation
   ↓
Object / Method / Parameter
   ↓
Method Call

才能进入结构运行。


3.44 方法调用与PHP面向对象逻辑

PHP面向对象逻辑可以清晰体现:

class Product
{
    public $inventory;

    public function sell($quantity)
    {
        $this->inventory -= $quantity;
    }
}

实例化:

$productA = new Product();
$productB = new Product();

不同实例:

ProductA.inventory = 50
ProductB.inventory = 10

分别调用:

$productA->sell(3);
$productB->sell(3);

结果:

ProductA.inventory = 47
ProductB.inventory = 7

这里最重要的理论关系就是:

Class
   ↓
Method Definition
   ↓
Object
   ↓
Method Call
   ↓
Operation
   ↓
Object State Change

其中PHP的:

$productA->sell(3)

可以作为:

Object → Method Call

这一理论关系的具体实现例子。

但WSaiOS-SI研究的不是PHP语法本身,而是其背后的结构关系:

Method属于Class定义,Method Call属于Object运行,Operation属于实际执行。


3.45 方法调用与方法重用

同一个Method可以被多个Object调用。

例如:

Class Product
    sell()

可以:

ProductA.sell()
ProductB.sell()
ProductC.sell()
ProductD.sell()

因此:

One Method Definition
        ↓
Multiple Object Calls

每次调用的:

Object State

可能不同。

因此:

Same Method
+
Different Object State
→
Different Execution Result

这正是Class与Object结构复用能力的重要体现。


3.46 方法调用与Method多态结构

当不同Class具有相同Method语义时,不同Object可以分别执行自己的Method实现。

例如:

Animal
    speak()

不同Class:

Dog
    speak()

Cat
    speak()

分别实例化:

DogA
CatA

调用:

DogA.speak()
CatA.speak()

虽然:

Method Name = speak

相同,但:

Method Structure

可以不同。

因此:

Object
   ↓
Method Call
   ↓
Resolve Method Structure
   ↓
Execute

这说明Method Call必须根据Object所属Class确定实际Method结构。

因此:

Method Call不仅需要知道调用名称,还必须知道调用对象及其Class结构。


3.47 方法调用与继承

如果:

Parent Class
   ↓
Child Class

子Class继承父Class的Method:

Parent Method
   ↓
Inherited Method
   ↓
Child Object
   ↓
Method Call

因此:

ChildObject.method()

可能实际执行:

Inherited Method

或者:

Overridden Method

所以Method Call还涉及:

Class Hierarchy

以及:

Method Resolution

这进一步说明Method Call是结构解析与运行过程,而不是简单名称执行。


3.48 方法调用的结构验证

Method Call执行之前,应进行结构验证:

Object Exists?
        ↓
Method Exists?
        ↓
Parameter Valid?
        ↓
Context Valid?
        ↓
State Valid?
        ↓
Rule Valid?
        ↓
Relation Valid?
        ↓
Operation Valid?

只有验证通过:

→ Execute

否则:

→ Reject / Fail

因此:

Method Call是受结构约束的执行行为。


3.49 方法调用与结构智能运行闭环

最终,Method Call进入完整的结构智能闭环:

需求
 ↓
结构匹配
 ↓
选择Object
 ↓
选择Method
 ↓
Method Call
 ↓
Operation
 ↓
Result
 ↓
Object State Change
 ↓
Structure Change
 ↓
Decision
 ↓
Execution
 ↓
Feedback
 ↓
Learning
 ↓
Method / Structure Optimization

如果执行结果不符合需求:

Feedback
   ↓
Method Call Analysis
   ↓
Object State Analysis
   ↓
Structure Analysis
   ↓
Method / Rule / Relation Adjustment
   ↓
New Method Call

由此形成循环:

Call
→ Result
→ Feedback
→ Learning
→ Reorganization
→ New Call

3.50 方法调用理论的完整形式

综合本章,建立以下完整关系:

Class
   ↓
Method Definition
   ↓
Object
   ↓
Method Call
   ↓
Parameter Binding
   ↓
Context Binding
   ↓
Precondition
   ↓
Attribute Access
   ↓
Value Retrieval
   ↓
Operation
   ↓
Rule Evaluation
   ↓
Result
   ↓
Value Change
   ↓
State Change
   ↓
Relation Change
   ↓
Structure Change
   ↓
Knowledge Update
   ↓
Capability Update
   ↓
Decision / Execution

形式化:

Call = Invoke(Object, Method, Parameters, Context)

执行:

Result = Execute(Call, State, Rules, Relations)

状态转换:

S₂ = Transition(S₁, Call)

结构变化:

Structure₂ = Transform(Structure₁, Call, Result)

因此:

Method Call是连接Object结构与Operation结构的核心运行机制。


3.51 方法调用的基本原则

本章建立以下方法调用原则。

第一,Object绑定原则

Method Call必须绑定具体Object。

第二,Class定义原则

Method由Class定义或继承。

第三,调用原则

Method只有通过Call才能进入具体实例运行。

第四,实例状态原则

Method Call必须基于Object当前实例状态运行。

第五,Attribute访问原则

Method可以访问Object的Attribute。

第六,Value运算原则

Method可以获取Attribute Value并参与运算。

第七,Parameter原则

Method Call可以携带具体Parameters。

第八,Condition原则

Method Call受到Condition约束。

第九,Rule原则

Method Call受到Class Rule和Object运行规则约束。

第十,Operation原则

Method Call必须能够映射到实际Operation。

第十一,Result原则

Method Call可以产生Value、Object、Structure、状态或其他结果。

第十二,状态转移原则

Method Call可以使Object从State₁进入State₂。

第十三,Relation变化原则

Method Call可以导致Object Relation发生变化。

第十四,Structure变化原则

Method Call可以导致Structure发生变化或产生新Structure。

第十五,组合原则

多个Method Call可以组合成为更高层Operation Structure。

第十六,可重用原则

同一个Method可以被多个Object调用。

第十七,实例差异原则

同一个Method作用于不同Object时,可以因为Object State不同而产生不同结果。

第十八,验证原则

Method Call必须经过Object、Parameter、State、Rule和Operation验证。

第十九,反馈原则

Method Call的执行结果可以进入Feedback。

第二十,自主语义原则

Method Call的Object、Method、Parameter和语义关系必须能够由WSaiOS-SI自身自主语义理解和验证,不依赖LLM作为最终语义依据。


3.52 本章理论成果

本章建立了:

Object → Method Call

这一核心理论关系。

进一步建立:

Class
→ Method Definition
→ Object
→ Method Call
→ Operation
→ Result
→ Value Change
→ State Change
→ Relation Change
→ Structure Change

其中最核心的理论区分为:

Method
=
可调用运算结构的定义

Method Call
=
将Method绑定到具体Object并触发运行的过程

Operation
=
Method Call实际执行的运算

Result
=
Operation产生的结果

State Change
=
Operation对Object实例状态产生的变化

因此,本章最终确立:

Method不是独立运行的结构。Method属于Class定义,只有通过具体Object上的Method Call,才能进入实例运行环境。

进一步:

Object提供具体运行对象,Method提供共同运算结构,Method Call建立Object与Method之间的运行关系,Operation完成实际运算,Result体现运算结果,而Value和State的变化体现Method Call对Object产生的实际结构影响。

最终形成:

Class
   ↓
Method
   ↓
Object
   ↓
Method Call
   ↓
Operation
   ↓
Result
   ↓
Value / State
   ↓
Relation
   ↓
Structure
   ↓
Knowledge
   ↓
Capability
   ↓
Cognition
   ↓
Decision
   ↓
Execution
   ↓
Feedback
   ↓
Learning
   ↓
Evolution

因此:

Object → Method Call 是WSaiOS-SI对象结构进入动态运行状态的基本入口。

而在整个结构智能体系中,方法调用并不是普通的程序调用概念,而是:

一个以Object为具体运行主体、以Method为运算结构定义、以Attribute Value为运算对象、以Rule和Condition为约束、以Operation为执行过程、以Result和State Transition为结果的结构运行机制。

同时保持WSaiOS-SI的自主性:

原始信息
   ↓
WSaiOS-SI自主语义理解
   ↓
Object识别
   ↓
Method识别
   ↓
Parameter识别
   ↓
Method Call Structure
   ↓
结构验证
   ↓
Operation
   ↓
Result

因此,方法调用理论完全可以在不依赖大型语言模型的情况下独立成立和运行。

Leave a Reply

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

客服咨询
● 欢迎咨询与合作
您好!欢迎咨询。 我可以帮助您了解人工智能技术研发、智能软件系统开发、网站建设、搜索优化及项目定制等相关信息。 请问有什么可以帮您?
免费申请
请填写以下信息,方便我们进一步沟通。
欢迎咨询 AI 系统开发、网站建设、搜索优化、项目定制合作
电话:15089196448
邮箱:1602401899@qq.com
地址:陕西省渭南市
服务时间:周一至周五 09:00 - 18:00 | 7×24小时技术值守