第三章 方法调用
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= MethodV1...Vn= Object中的Attribute ValueP= Method ParametersVresult= 运算结果
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 StateM= MethodP= ParametersC= ContextQ= RuleS₂= 调用后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 IdentityP= ParametersPre= PreconditionsOp= OperationOut= OutputEffect= EffectsRule= RulesContext= 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
因此,方法调用理论完全可以在不依赖大型语言模型的情况下独立成立和运行。