第五章 属性值运算
5.1 属性值运算的提出
在前面的理论中,已经建立了:
Class → 实例化 → Object → Attribute → Value
并进一步建立了:
Class → Method Definition → Object → Method Call → Self Binding → Object自身状态
由此,Object已经不再只是一个具有属性和值的静态结构,而成为能够通过Method对自身属性值进行处理、判断和改变的动态结构。
因此,必须进一步研究一个核心问题:
Method如何读取Object的Attribute Value,并对这些Value执行加工、比较、判断、转换、计算和更新?
这就是属性值运算理论。
在WSaiOS结构智能(WSaiOS-SI)中,属性值运算不是单纯的数据计算,也不是脱离Object的数学运算,而是:
Method在具体Object实例上,通过对象自身引用访问Attribute及其Value,并依据Method定义、Rule、Condition和Operation,对Value执行结构化处理的过程。
其基本链条为:
Object
↓
Method Call
↓
Self Object Reference
↓
Attribute
↓
Value
↓
Operation
↓
Result
↓
Value / State / Relation / Structure Update
因此:
属性值运算是Object从“具有状态”进入“能够改变状态”的关键机制。
如果没有属性值运算,Attribute和Value只能表达对象当前是什么;有了属性值运算,Object才能进一步表达:
- 当前是什么;
- 是否满足条件;
- 应该如何处理;
- 计算结果是什么;
- 应该转换成什么状态;
- 应该如何更新自身;
- 更新之后又产生什么新的结构关系。
这使Object从静态实例进入动态运行过程。
5.2 Attribute与Value必须保持严格区分
属性值运算首先必须保持:
Attribute ≠ Value
Attribute是Object的结构成员,Value是Attribute当前对应的具体值。
因此:
Object
└── Attribute
└── Value
例如:
Object: ProductA
Attribute:
price
Value:
100
这里:
price ≠ 100
price是Attribute,100是Value。
Method并不是直接“运算属性”,而是:
读取Attribute所对应的Value,并对Value进行Operation。
因此更加准确的结构是:
Object
↓
Attribute
↓
Value
↓
Operation
例如:
ProductA.price = 100
ProductA.quantity = 3
Method执行:
price × quantity
真正参与运算的是:
100 × 3
而不是:
price × quantity
后者只是Operation所引用的结构成员。
因此:
Attribute提供运算对象的结构身份,Value提供运算所需要的具体状态。
5.3 Method读取Attribute Value
Method的第一个核心能力,是读取Object中的Attribute Value。
建立:
Object → Method Call → Self Reference → Attribute → Value
例如:
Object ProductA
price = 100
quantity = 3
Method:
calculateTotal()
调用时:
ProductA.calculateTotal()
Method通过当前Object自身引用访问:
$this → ProductA
进一步访问:
$this.price
$this.quantity
对应:
ProductA.price → 100
ProductA.quantity → 3
因此:
Read(ProductA.price) = 100
Read(ProductA.quantity) = 3
然后Method才能继续执行Operation。
形成:
Method
↓
Self Reference
↓
Attribute
↓
Read Value
↓
Operation
这里必须明确:
Method不是脱离Object独立读取数据。
Method必须在具体的Object Method Call中获得当前Object上下文。
因此:
Method M
单独存在时只是一个Method Definition。
真正产生属性值运算的是:
Object O
+
Method M
+
Current Attribute Values
即:
Invoke(O, M)
5.4 属性值运算的基本模型
定义属性值运算:
属性值运算,是Method在具体Object实例上,根据Method所定义的Operation、Condition和Rule,对Object的一个或多个Attribute Value进行读取、加工、比较、判断、转换、计算或更新,并产生Result、Value、State、Relation或Structure变化的过程。
形式化表示:
AVO = Operation(Method, Object, Attribute Values, Context, Rules)
其中:
AVO= Attribute Value OperationMethod= 运算方法Object= 当前对象实例Attribute Values= 被访问的属性值Context= 当前上下文Rules= 运算规则
更完整地表示:
Result =
Execute(
Method,
Self(Object),
Attribute Values,
Parameters,
Context,
Conditions,
Rules
)
因此属性值运算并不只有一种形式。
本章建立六种基本属性值运算:
加工
比较
判断
转换
计算
更新
它们既可以独立存在,也可以连续组合。
5.5 属性值加工
5.5.1 加工的定义
属性值加工是指:
Method根据特定规则对Attribute Value进行处理,使Value获得新的表达形式、内容形式或可继续运算的状态。
例如:
name = " Product A "
Method可以对Value进行:
去除空格
统一格式
大小写转换
字符清理
内容规范化
结构化处理
例如:
" Product A "
↓
Trim
↓
"Product A"
这里:
Attribute = name
Value₁ = " Product A "
Operation = Trim
Value₂ = "Product A"
因此:
Value₁ → Operation → Value₂
5.5.2 加工不是简单替换
属性值加工必须保持Value的语义。
例如:
price = "100"
不能仅仅因为字符串形式是:
"100"
就把它当作普通文本。
如果该Value在Object结构中承担:
Product.price
的语义角色,则它具有:
金额
价格
数值
货币单位
等结构语义。
因此加工必须遵循:
Value
+
Attribute Semantic
+
Context
+
Constraint
→
Valid Processing
而不是:
Raw String → Arbitrary Processing
5.6 属性值比较
5.6.1 比较的定义
属性值比较是:
Method对两个或多个Value进行结构和数值意义上的比较,以确定它们之间的关系。
例如:
price = 100
limit = 80
Method执行:
price > limit
得到:
100 > 80 = true
这里形成:
Value₁
↓
Comparison
↓
Value₂
↓
Comparison Result
5.6.2 比较不局限于数字
Value比较可以包括:
数值比较
文本比较
时间比较
状态比较
对象比较
结构比较
集合比较
范围比较
条件比较
例如:
inventory > 0
是数值比较。
status == "paid"
是状态值比较。
dateA < dateB
是时间比较。
更复杂的情况:
ProductA.price == ProductB.price
是两个Object之间的属性值比较。
因此:
属性值比较必须根据Value的语义类型和Attribute上下文解释,而不能仅根据Value的表面表示进行比较。
5.7 属性值判断
比较产生结果,而判断进一步根据比较结果进入Condition和Rule。
建立:
Value
↓
Comparison
↓
Condition
↓
Judgment
↓
Rule
↓
Operation
例如:
inventory = 10
Method判断:
inventory > 0
结果:
true
Rule:
IF inventory > 0
THEN allowSale
于是:
Value
→ Comparison
→ Condition
→ Judgment
→ Rule
→ Operation
这说明:
Value本身不是Decision,Value经过比较和规则判断之后,才能参与决策结构。
5.8 判断与对象状态
判断不仅可以产生:
true / false
还可以产生更复杂的状态分类。
例如:
inventory = 0
Method可以判断:
inventory == 0
然后形成:
State = OutOfStock
或者:
inventory > 0
形成:
State = Available
因此:
Attribute Value
↓
Condition
↓
Judgment
↓
State
对象状态可能由多个Attribute Value共同决定:
inventory > 0
AND
paymentStatus = paid
AND
orderStatus = confirmed
最终:
OrderState = ReadyToShip
因此:
Object State不是简单储存在一个Value中,而可以由多个Attribute Value经过Condition、Rule和Operation共同形成。
5.9 属性值转换
5.9.1 转换的定义
属性值转换是:
Method按照目标语义、类型、单位、结构或上下文要求,将Value从一种有效表示或状态转换为另一种有效表示或状态。
例如:
100 USD
转换为:
735 CNY
形成:
Value₁
↓
Conversion Rule
↓
Value₂
又例如:
"2026-10-07"
可以转换成:
Date Object
因此:
String Value
↓
Date Conversion
↓
Date Value
5.9.2 转换必须保持语义
转换不能仅仅改变形式。
例如:
100 kg
转换成:
100000 g
Value发生变化,但语义仍然表示同一重量。
因此:
Value₁
→ Conversion
→ Value₂
必须满足相应的:
Semantic Constraint
Unit Constraint
Type Constraint
Context Constraint
否则转换结果可能成为错误Value。
5.10 属性值计算
计算是属性值运算中最直接的Operation形式。
例如:
price = 100
quantity = 3
Method:
calculateTotal()
执行:
price × quantity
得到:
total = 300
完整结构:
Object
│
├── price = 100
│
├── quantity = 3
│
└── total = ?
↑
│
Method
│
Operation
│
price × quantity
形式化:
Vtotal = Operation(Vprice, Vquantity)
即:
300 = 100 × 3
5.11 运算结果可以形成新的Value
计算并不一定只是返回一个临时结果。
如果Method将计算结果绑定到一个Attribute:
total = price × quantity
那么:
Vprice
+
Vquantity
+
Operation
→
Vtotal
形成:
Attribute₁ → Value₁
Attribute₂ → Value₂
Attribute₃ → Value₃
例如:
price = 100
quantity = 3
total = 300
因此:
Operation不仅可以消费Value,也可以产生新的Value。
进一步:
Value
→ Operation
→ New Value
→ New Attribute State
→ New Object State
5.12 属性值更新
属性值运算最终可以改变Object自身状态。
例如:
inventory = 10
调用:
sell(3)
Method读取:
inventory = 10
执行:
inventory - 3
得到:
7
然后更新:
inventory = 7
完整过程:
Object
↓
Method Call
↓
Self Reference
↓
inventory Attribute
↓
Value = 10
↓
Operation: 10 - 3
↓
Result = 7
↓
Update Attribute Value
↓
inventory = 7
因此:
Value更新是属性值运算从“计算”进入“对象状态变化”的关键步骤。
5.13 Value更新不是Attribute更新
必须严格区分:
Attribute
与:
Value
例如:
inventory = 10
执行:
inventory = inventory - 3
改变的是:
Value: 10 → 7
而:
Attribute: inventory
仍然存在。
因此:
Attribute不变
Value改变
形成:
Attribute
│
├── Value₁ = 10
│
↓ Operation
│
└── Value₂ = 7
这也是Object能够保持结构稳定,同时持续改变自身状态的基础。
5.14 属性值运算与State Transition
Value更新进一步可能导致Object State变化。
例如:
inventory = 1
执行:
sell(1)
得到:
inventory = 0
那么:
inventory > 0
由:
true
变成:
false
于是:
State₁ = Available
变成:
State₂ = OutOfStock
完整过程:
Value₁
↓
Operation
↓
Value₂
↓
Condition Re-evaluation
↓
State Transition
因此:
属性值运算不仅改变Value,还可能改变Object State。
5.15 属性值运算与Relation变化
Object的Attribute Value变化还可能改变Object与其他Element/Object之间的Relation。
例如:
Order.paymentStatus = unpaid
对应关系:
Order --payment_pending→ Payment
Method执行支付:
pay()
使:
paymentStatus:
unpaid → paid
随后Relation可能改变:
Order --payment_pending→ Payment
变为:
Order --payment_completed→ Payment
因此:
Value Update
→ State Change
→ Relation Change
→ Structure Change
这说明属性值运算并不是局限于一个字段内部。
它能够向更高层结构传播。
5.16 属性值运算与Structure变化
当Value变化导致State、Relation、Rule条件或Operation条件变化时,整个Object所在的Structure也可能发生变化。
形成:
Attribute Value
↓
Operation
↓
Value Update
↓
State Change
↓
Relation Change
↓
Structure Change
例如:
库存 = 0
导致:
ProductState = OutOfStock
进一步导致:
Product --unavailable_for_sale→ SalesStructure
原来的销售结构:
Product
+
Order
+
Payment
+
Inventory
→
Saleable
可能变成:
Product
+
Order
+
Payment
+
Inventory
→
NotSaleable
因此:
Object内部Value的变化可以传播到更高层Structure。
5.17 多属性联合运算
Method不一定只操作一个Attribute Value。
一个Method可以同时读取多个Value。
例如:
price
quantity
discount
tax
形成:
subtotal = price × quantity
discountAmount = subtotal × discount
taxAmount = (subtotal - discountAmount) × tax
total = subtotal - discountAmount + taxAmount
因此:
多个Attribute Value
↓
Method
↓
多个Operation
↓
多个Intermediate Values
↓
最终Value
这说明Method可以形成一个内部的运算结构。
因此:
Method本身可以看作由多个Operation、Condition、Rule和Value引用构成的可调用运算结构。
5.18 属性值运算的组合
六类基本运算可以组合:
读取
↓
加工
↓
转换
↓
比较
↓
判断
↓
计算
↓
更新
例如订单处理:
读取:
inventory = 10
读取:
quantity = 3
比较:
inventory >= quantity
判断:
true
计算:
10 - 3
更新:
inventory = 7
状态判断:
inventory > 0
状态保持:
Available
也可以形成更复杂的:
Read
→ Transform
→ Compare
→ Judge
→ Calculate
→ Update
→ Re-evaluate
→ State Transition
→ Relation Update
→ Structure Update
因此:
属性值运算不是六个孤立功能,而是一组能够组合形成完整Method执行过程的基本Operation。
5.19 Method对不同Object执行相同运算
同一个Class可以产生多个Object。
例如:
Class Product
实例化:
ProductA
ProductB
其中:
ProductA.price = 100
ProductA.quantity = 3
ProductB.price = 200
ProductB.quantity = 5
两个Object共享同一个Method:
calculateTotal()
但是:
ProductA.calculateTotal()
得到:
300
而:
ProductB.calculateTotal()
得到:
1000
因此:
Same Class
↓
Same Method
↓
Different Object
↓
Different Attribute Values
↓
Different Operation Results
这进一步证明:
Method定义可以是共同的,而属性值运算结果属于具体Object实例。
5.20 $this与属性值运算
上一章已经建立:
$this的理论意义,是Method执行环境对当前Object实例的自身引用。
因此本章的属性值运算可以进一步表示:
Object
↓
Method Call
↓
$this
↓
$this.Attribute
↓
$this.Attribute.Value
↓
Operation
例如:
$this->price
理论上表示:
CurrentObject.price
而:
$this->price × $this->quantity
表示:
CurrentObject.price.Value
×
CurrentObject.quantity.Value
因此:
Self Reference是Method访问当前Object属性值并执行属性值运算的结构入口。
5.21 Method可以读取、计算和更新自身Value
形成完整Object Method运行模型:
Object
↓
Method Call
↓
Self Binding
↓
Read Attribute
↓
Read Value
↓
Operation
↓
Result
↓
Update Value
↓
State Re-evaluation
↓
Object State
例如:
$this->inventory
读取:
inventory.Value
然后:
$this->inventory =
$this->inventory - $quantity
理论上就是:
Vnew = Vcurrent - Vparameter
再将:
Vnew
重新绑定到:
Object.inventory
形成:
Value₁ → Operation → Value₂
5.22 属性值运算的参数
Method不仅可以读取Object自身的Attribute Value,还可以接收外部Parameter。
例如:
sell(quantity)
Object自身:
inventory = 10
Method Parameter:
quantity = 3
形成:
Object Value
+
Method Parameter
→
Operation
即:
10 - 3 = 7
因此Method运算输入可以包括:
Object Attribute Values
+
Method Parameters
+
Other Object Values
+
Context Values
+
External Values
最终形成:
Operation Inputs
→
Operation
→
Result
5.23 属性值运算与其他Object
Method还可以访问Relation所连接的其他Object。
例如:
Order
│
└── Product
Order Method可以读取:
Product.price
形成:
Order
↓
Relation
↓
Product Object
↓
price Attribute
↓
Value
然后进行:
quantity × Product.price
因此属性值运算可以跨Object执行。
形成:
Object A
↓
Relation
↓
Object B
↓
Attribute
↓
Value
↓
Operation
这也是多Object Structure能够运行的基础。
5.24 属性值运算与规则
Value运算必须受到Rule约束。
例如:
inventory = 10
quantity = 15
虽然数学上:
10 - 15 = -5
但如果Rule规定:
inventory >= 0
则:
-5
不是合法Value。
因此:
Value
→ Operation
→ Candidate Result
→ Rule Validation
→ Valid Result / Rejected Result
所以:
能够计算出来的结果,不一定是结构上允许存在的结果。
属性值运算必须同时满足:
Semantic Constraint
Type Constraint
Value Constraint
State Constraint
Rule Constraint
Context Constraint
5.25 属性值运算与异常结果
如果运算产生非法结果,则不能简单写入Object。
例如:
quantity = 0
执行:
price / quantity
可能产生:
Division By Zero
此时:
Operation
→ Invalid Result
必须进入:
Error Handling
而不是:
Invalid Result
→ Object Value
因此:
Operation
↓
Result Validation
↓
┌─────┴─────┐
↓ ↓
Valid Invalid
↓ ↓
Update Reject / Error / Alternative
这使属性值运算成为可验证的结构运行机制。
5.26 属性值历史
Value更新之后,理论上不能只关注当前Value。
例如:
inventory:
10 → 7 → 4 → 0
这些变化形成:
Value History
因此:
Attribute
├── Current Value
└── Value History
历史Value可以参与:
- 趋势分析;
- 状态判断;
- 反馈;
- 规则判断;
- 知识形成;
- 学习;
- 结构演化。
例如:
inventory
10 → 7 → 4 → 0
可以进一步形成:
Inventory Depletion Pattern
成为新的Knowledge Structure。
因此:
Value变化本身也可以成为结构智能的学习材料。
5.27 属性值运算与知识形成
属性值运算产生的不只是新Value。
经过多次运行后,可以形成:
Value
→ Operation
→ Result
→ State
→ Relation
→ Structure
→ Pattern
→ Knowledge
例如:
价格 × 数量 → 销售金额
经过大量Object运行,可以形成:
Price × Quantity → Sales Amount
进一步:
Sales Amount
+
Time
+
Product
+
Customer
→
Sales Pattern
最终形成Knowledge Structure。
因此:
Method执行产生的属性值运算过程,可以成为结构智能形成知识的运行数据。
5.28 属性值运算与Capability
当某一组Method和Operation能够被稳定复用时,可以形成Capability。
例如:
Read Price
+
Read Quantity
+
Multiply
+
Validate
+
Update Total
形成:
Calculate Total Capability
因此:
Attribute Values
→
Method
→
Operation
→
Reusable Method Structure
→
Capability
Capability不是简单保存一个结果,而是保存:
能够通过结构化Method对Object属性值执行一组确定操作的能力结构。
5.29 属性值运算与Decision
多个Value经过Method、Condition和Rule后,可以形成Decision。
例如:
inventory > 0
paymentStatus = paid
orderStatus = confirmed
经过:
Comparison
+
Judgment
+
Rule
得到:
Decision = Ship Order
因此:
Attribute Value
→
Comparison
→
Judgment
→
Rule
→
Decision
更完整地:
Object State
→
Method
→
Attribute Value Operation
→
Condition
→
Rule
→
Decision
→
Execution
5.30 属性值运算与结构智能
由此可以看到,属性值运算并不是普通程序中的局部数据操作。
它位于整个结构智能运行链的核心位置:
Information
↓
WSaiOS-SI自主语义理解
↓
Element
↓
Relation
↓
Structure
↓
Class
↓
Instantiation
↓
Object
↓
Attribute
↓
Value
↓
Method
↓
Attribute Value Operation
↓
Result
↓
State
↓
Relation
↓
Structure
↓
Knowledge
↓
Capability
↓
Cognition
↓
Decision
↓
Execution
↓
Feedback
↓
Learning
↓
Structure Evolution
因此:
属性值运算是连接Object实例与高层结构智能过程的重要运行层。
5.31 属性值运算不是独立于语义的数学计算
WSaiOS-SI必须特别区分:
数学运算
与:
结构智能中的属性值运算
例如:
100 + 20 = 120
从数学角度成立。
但在结构智能中,必须首先确定:
100是什么?
20是什么?
二者是否可以相加?
单位是否一致?
Context是什么?
Operation是否被Rule允许?
Result应该属于哪个Attribute?
因此:
Value₁ + Value₂
只有在:
Semantic
+
Type
+
Unit
+
Context
+
Rule
+
Operation
均满足条件时,才形成有效结构运算。
所以:
WSaiOS-SI的属性值运算不是脱离语义的裸计算,而是具有结构语义约束的运算。
5.32 WSaiOS-SI自主语义理解与属性值运算
属性值运算的前提仍然是WSaiOS-SI自己的自主语义理解能力。
完整路径为:
原始信息
↓
WSaiOS-SI自主语义理解
↓
Object Recognition
↓
Attribute Recognition
↓
Value Recognition
↓
Method Recognition
↓
Operation Recognition
↓
Attribute Value Operation
因此系统必须能够自主识别:
谁是Object
什么是Attribute
什么是Value
哪个Value属于哪个Attribute
哪个Method可以访问它
应该执行什么Operation
Operation受到什么Rule约束
Result应该进入哪里
这一过程不以LLM作为理论前提。
如果系统接入大型语言模型,其输出也只能作为外部辅助信息:
External AI / LLM
↓
Optional Information
↓
WSaiOS-SI自主语义理解
↓
Semantic Validation
↓
Element / Relation / Structure
↓
Object / Attribute / Value / Method
↓
Operation
因此:
属性值运算的成立不依赖LLM。
5.33 属性值运算的形式化模型
定义Object:
O = <I, A, V, S, R, M, Q, C, L>
其中:
I= IdentityA= AttributeV= ValueS= StateR= RelationM= MethodQ= RuleC= ContextL= Lifecycle
定义Method:
M = <I, P, Input, Precondition, Operation, Condition, Output, Effect, Rule>
属性值读取:
Read(O,A) = V
属性值运算:
V' = Operation(M, V, P, C, Q)
属性值更新:
Update(O,A,V')
状态变化:
S' = StateTransition(S, V, V', Q, C)
关系变化:
R' = RelationTransition(R, S, S', Q, C)
结构变化:
Structure' =
Reorganize(Structure, V', S', R', Q)
因此完整模型为:
O
→ M
→ Read(A,V)
→ Operation(V,P,C,Q)
→ Result
→ Validate
→ Update(V)
→ State Transition
→ Relation Transition
→ Structure Change
5.34 属性值运算的六种基本形式
本章建立的六种基本运算可以统一表示为:
一、加工
V₁ → Process → V₂
二、比较
V₁ + V₂ → Compare → Relation
三、判断
Comparison → Condition → Judgment
四、转换
V₁ → Convert → V₂
五、计算
V₁ + V₂ + ... + Vn → Calculate → Vresult
六、更新
V₁ → Operation → V₂
六者可以组合:
Read
→ Process
→ Convert
→ Compare
→ Judge
→ Calculate
→ Validate
→ Update
最终形成:
Object State Transition
5.35 属性值运算的结构原则
属性值运算建立以下基本理论原则。
第一,Attribute身份原则
Attribute定义运算对象的结构身份。
第二,Value具体化原则
Value提供当前具体运算状态。
第三,Method调用原则
属性值运算必须通过可调用Method结构执行,或由结构运行机制明确触发。
第四,Self Binding原则
Instance Method执行时必须绑定当前Object。
第五,读取原则
Method可以读取当前Object的Attribute Value。
第六,加工原则
Method可以对Value进行结构化加工。
第七,比较原则
Method可以比较多个Value并形成比较关系。
第八,判断原则
比较结果可以进入Condition和Rule形成判断。
第九,转换原则
Value可以在语义、类型、单位或结构允许的情况下转换。
第十,计算原则
多个Value可以按照Operation形成新的Value。
第十一,更新原则
Method可以根据Operation结果更新Object Attribute Value。
第十二,状态传播原则
Value更新可以引发Object State变化。
第十三,关系传播原则
State和Value变化可以引发Relation变化。
第十四,结构传播原则
Relation和State变化可以进一步引发Structure变化。
第十五,约束原则
任何Value Operation必须受到Semantic、Type、Context和Rule约束。
第十六,实例独立原则
同一个Method在不同Object上执行时,使用各自Object的Attribute Value。
第十七,历史原则
Value变化可以形成Value History,并参与后续Knowledge与Learning。
第十八,知识形成原则
重复、稳定和可验证的属性值运算过程可以形成Knowledge Structure。
第十九,能力形成原则
可复用的Method与Operation组合可以形成Capability。
第二十,自主语义原则
属性值运算的语义识别由WSaiOS-SI自身语义理解层完成,不以LLM作为必要基础。
5.36 属性值运算的完整运行模型
最终可以建立:
Class
│
↓
Method Definition
│
↓
Object Instantiation
│
↓
Object
│
Method Call
│
↓
Self Object Reference
│
┌─────────────┴─────────────┐
↓ ↓
Attribute A Attribute B
↓ ↓
Value A Value B
└─────────────┬─────────────┘
↓
Operation
│
┌─────────────┼─────────────┐
↓ ↓ ↓
加工 比较 判断
│ │ │
└─────────────┼─────────────┘
↓
转换 / 计算
↓
Result
↓
Validation
↓
Value Update
↓
State Transition
↓
Relation Change
↓
Structure Change
↓
Knowledge
↓
Capability
↓
Cognition
↓
Decision
这说明:
Method不是简单“执行一段代码”,而是在Object实例内部,通过访问Attribute Value并执行结构化Operation,使Object从一个状态进入另一个状态。
5.37 理论成果
经过本章,可以建立完整的属性值运算理论:
Class
↓
Method
↓
Object
↓
Attribute
↓
Value
↓
Read
↓
Process
↓
Compare
↓
Judge
↓
Convert
↓
Calculate
↓
Update
↓
State
↓
Relation
↓
Structure
↓
Knowledge
↓
Capability
↓
Cognition
↓
Decision
因此,本章的核心理论可以概括为:
Attribute定义Object中的属性结构,Value表示Attribute当前的具体值,Method通过当前Object自身引用读取这些Value,并依据Operation、Condition、Rule和Context对Value执行加工、比较、判断、转换、计算和更新。
进一步:
属性值运算不是孤立的数据处理,而是Object内部结构运行的基本机制。Value的变化可以引发State变化,State变化可以引发Relation变化,Relation变化可以进一步引发Structure变化,并最终进入Knowledge、Capability、Cognition和Decision过程。
最终建立:
Object
→ Method Call
→ Self Reference
→ Attribute
→ Value
→ Operation
→ Result
→ Value Update
→ State Transition
→ Relation Change
→ Structure Change
→ Knowledge
→ Capability
→ Cognition
→ Decision
→ Execution
→ Feedback
→ Learning
→ Evolution
由此,WSaiOS-SI中的Object不再是单纯的数据容器,而成为能够通过Method对自身属性值进行结构化运算、改变自身状态、影响关系和推动结构演化的可运行结构实例。
这也使:
Class → Object → Attribute → Value → Method → Operation
成为WSaiOS-SI对象结构理论中从“定义”走向“运行”的完整基础链条。