第四章 $this与对象自身状态
4.1 $this逻辑的提出
上一章已经建立:
Method不是独立运行的结构,而是在具体Object实例上通过Method Call被调用。
形成:
Class
↓
Method Definition
↓
Object
↓
Method Call
↓
Operation
↓
Result / State Change
但是,这一过程还存在一个更加基础的问题:
当一个Method在Object上执行时,它究竟访问的是哪个Object的Attribute和Value?
例如同一个Class:
Product
可以产生:
ProductA
ProductB
并且:
ProductA.inventory = 50
ProductB.inventory = 10
Class中定义同一个Method:
sell(quantity)
当执行:
ProductA.sell(3)
Method必须访问:
ProductA.inventory
而当执行:
ProductB.sell(3)
同一个Method必须访问:
ProductB.inventory
因此,Method执行时必须存在一个明确的机制,使Method能够确定:
当前正在被调用的具体Object是谁。
在PHP面向对象逻辑中,这一机制通过:
$this
表达。
例如:
class Product
{
public $inventory;
public function sell($quantity)
{
$this->inventory -= $quantity;
}
}
这里的:
$this
不是一个普通的数据字段,也不是另一个Object。
它表示:
当前Method正在其上执行的那个Object实例本身。
因此,本章不把 $this 简单理解为PHP语法,而是抽象其背后的结构逻辑:
Method执行时,需要具有对当前Object自身的确定性引用,以访问该Object自身的Attribute、Value、State、Relation和其他结构。
WSaiOS-SI将这一逻辑定义为:
对象自身引用(Self-Object Reference)
并建立:
Object
↓
Method Call
↓
Current Object Reference
↓
Access Own Attribute / Value / State
↓
Operation
↓
Object State Change
4.2 $this的理论抽象
PHP中的:
$this
表示当前Object实例。
因此可以将其抽象为:
$this = Current Object
但在WSaiOS-SI中,需要进一步扩大这一概念。
因为当前Object不仅包含Attribute,还包含:
- Identity
- Attribute
- Value
- State
- Relation
- Rule
- Method
- Context
- Lifecycle
因此:
对象自身引用,是Method执行过程中指向当前Object实例及其当前实例状态的结构引用。
形式化表示:
Self(O) = O
当Method M在Object O上被调用:
Call(O, M, P)
则Method执行环境中存在:
CurrentObject = O
也就是:
$this → O
于是:
$this->Attribute
表示:
CurrentObject.Attribute
而:
$this->Attribute.Value
表示:
CurrentObject.Attribute.Value
因此,$this的真正理论意义不是:
一个特殊变量。
而是:
Method运行环境与当前Object实例之间的结构绑定关系。
4.3 Object自身引用与Method Call
上一章建立:
Object → Method Call
本章进一步展开:
Object
↓
Method Call
↓
Self Reference
↓
Method Execution Context
例如:
ProductA.sell(3)
可以展开为:
Object = ProductA
Method = sell
Parameter = 3
进入Method执行环境:
Current Object = ProductA
因此:
$this
所指向的就是:
ProductA
于是:
$this->inventory
实际对应:
ProductA.inventory
如果:
ProductA.inventory = 50
则:
$this->inventory = 50
Method执行:
$this->inventory -= 3
实际结构运算就是:
ProductA.inventory
=
ProductA.inventory - 3
得到:
ProductA.inventory = 47
因此完整结构为:
ProductA
↓
sell(3)
↓
$this = ProductA
↓
$this.inventory = ProductA.inventory
↓
50 - 3
↓
47
4.4 $this不是新的Object
这是理解对象自身引用最重要的理论边界之一。
$this
不能被理解为:
new Object
也不能被理解为:
Object Copy
更不能被理解为:
另一个对象
正确关系是:
$this = 当前Object的引用
例如:
ProductA
被调用:
ProductA.sell(3)
则:
$this → ProductA
此时:
$this
与:
ProductA
指向同一个Object实例。
因此:
Identity($this) = Identity(ProductA)
而不是:
Identity($this) ≠ Identity(ProductA)
所以:
对象自身引用不会产生新的Object,而是使Method能够访问当前已经存在的Object。
4.5 为什么Method需要对象自身引用
如果Method没有当前Object引用,就无法确定:
应该读取谁的Attribute?
应该修改谁的Value?
应该改变谁的State?
应该建立谁的Relation?
例如:
ProductA.inventory = 50
ProductB.inventory = 10
Class中只有:
sell(quantity)
当调用:
ProductA.sell(3)
Method必须知道:
当前Object = ProductA
才能执行:
ProductA.inventory -= 3
如果调用:
ProductB.sell(3)
则:
当前Object = ProductB
执行:
ProductB.inventory -= 3
所以:
同一个Method
+
不同Current Object
=
不同Instance Operation
这正是对象自身引用存在的根本原因。
4.6 Self Reference与对象身份
每一个Object具有独立Identity。
例如:
ProductA
Identity = O1
ProductB
Identity = O2
当调用:
ProductA.sell(3)
Method执行环境:
$this → O1
当调用:
ProductB.sell(3)
Method执行环境:
$this → O2
因此:
Call(ProductA, sell)
→ Self = O1
而:
Call(ProductB, sell)
→ Self = O2
所以对象自身引用实际上承担了:
将Method Call与具体Object Identity绑定起来的作用。
形成:
Object Identity
↓
Method Call
↓
Self Reference
↓
Object Structure
4.7 Self Reference与Attribute
Object自身引用最直接的作用是访问Object自身的Attribute。
例如:
Object ProductA
├── price = 100
├── quantity = 3
└── inventory = 50
Method:
calculateTotal()
执行:
$this->price * $this->quantity
其结构意义为:
Self.Price.Value
×
Self.Quantity.Value
↓
Result
即:
ProductA.price
×
ProductA.quantity
=
ProductA.total
因此:
$this->Attribute
可以抽象为:
SelfObject.Attribute
进一步:
$this->Attribute.Value
抽象为:
SelfObject.Attribute.Value
所以:
Self Reference是Method访问Object内部Attribute结构的直接路径。
4.8 Self Reference与Value
Attribute只是结构成员,真正参与运行的通常是Attribute对应的Value。
例如:
$this->price
如果当前Object为:
ProductA
则:
$this->price
实际取得:
ProductA.price.Value
如果:
ProductA.price = 100
则:
$this->price = 100
如果另一个Object:
ProductB.price = 200
那么同一个Method:
$this->price
在不同Object上分别得到:
100
和:
200
因此:
Same Method
+
Same Self Attribute
+
Different Self Object
→
Different Value
这进一步证明:
Method本身不保存某一个具体Object的Value;Method通过Self Reference访问当前Object的实际Value。
4.9 Self Reference与对象状态
对象实例状态理论已经建立:
Object
↓
Attribute
↓
Value
↓
State
现在加入Self Reference:
Object
↓
Method Call
↓
Self Reference
↓
Attribute
↓
Value
↓
State
例如:
ProductA
inventory = 50
status = available
调用:
ProductA.sell(3)
Method通过:
$this
访问:
$this->inventory
得到:
50
执行:
50 - 3 = 47
之后可能进一步判断:
47 > 0
所以:
status = available
最终:
ProductA
inventory = 47
status = available
因此:
$this
→ Object
→ Attribute
→ Value
→ State
是一个连续结构。
4.10 Self Reference与Object自身修改
$this不仅能够读取Object,还能够使Method修改Object自身。
例如:
$this->inventory -= $quantity;
结构意义是:
Self.inventory
↓
Read Value
↓
Operation
↓
Write Value
↓
Self.inventory
即:
V₁
↓
Operation
↓
V₂
其中:
V₁ = Self.Inventory.Value
V₂ = New Inventory Value
因此:
$this->inventory
既可以作为:
读取对象自身状态
也可以作为:
修改对象自身状态
的结构路径。
4.11 Self Reference与State Transition
如果Method修改Object自身Value,则Object状态发生转移。
例如:
State₁:
inventory = 50
调用:
sell(3)
通过:
$this->inventory
执行:
50 → 47
形成:
State₁
↓
Method Call
↓
$this
↓
Attribute Value Operation
↓
State₂
所以:
Self Reference是Object状态转移的内部访问入口之一。
完整表示:
Object
↓
Method Call
↓
Self Reference
↓
Current Attribute Value
↓
Operation
↓
New Attribute Value
↓
New Object State
4.12 Self Reference与多个Object
这是 $this理论最能够体现Object实例独立性的地方。
假设:
Class Product
sell()
产生:
ProductA
ProductB
ProductC
状态:
ProductA.inventory = 50
ProductB.inventory = 20
ProductC.inventory = 5
调用:
ProductA.sell(3)
ProductB.sell(3)
ProductC.sell(3)
虽然Method相同:
sell()
但三个Method Call中的Self不同:
Call₁:
$this → ProductA
Call₂:
$this → ProductB
Call₃:
$this → ProductC
因此读取:
$this->inventory
分别得到:
50
20
5
结果:
47
17
2
所以:
Self Reference使同一个Method能够在多个Object实例上保持Method结构不变,同时针对各自Object的实际状态执行不同运算。
4.13 Self Reference与Method复用
这说明Method可以被Class统一定义,而无需为每个Object重新定义。
例如:
Class Product
sell(quantity)
可以被:
ProductA
ProductB
ProductC
共同调用。
每次:
$this
自动对应当前Object。
因此:
One Class
↓
One Method Definition
↓
Multiple Objects
↓
Multiple Method Calls
↓
Different Self References
↓
Different Object States
这是面向对象结构能够实现行为复用的重要原因。
4.14 Self Reference与Method内部结构
Method可以被看作:
Method
├── Input
├── Parameter
├── Operation
├── Self Reference
├── Rule
├── Condition
└── Output
其中:
Self Reference
不是Method的普通参数。
它是:
Method运行时自动绑定的当前Object结构上下文。
因此:
Method Definition
可以保持:
sell(quantity)
不变。
而实际运行时:
$this
分别绑定:
ProductA
ProductB
ProductC
形成不同的具体运行环境。
4.15 Self Reference不是普通Parameter
必须严格区分:
$this
与:
$quantity
例如:
public function sell($quantity)
{
$this->inventory -= $quantity;
}
这里:
$this
表示:
当前Object
而:
$quantity
表示:
本次Method Call提供的Parameter
所以:
$this ≠ Parameter
二者结构角色不同。
可以表示:
Method Call
├── Self Object
└── Explicit Parameters
即:
Call
=
Self Binding
+
Parameter Binding
4.16 Self Binding
由此可以建立一个新的理论概念:
Self Binding(对象自身绑定)
当:
Object → Method Call
发生时,系统将当前Object绑定到Method执行环境:
Current Object
↓
Self Binding
↓
Method Execution
例如:
Call(ProductA, sell, 3)
产生:
Self = ProductA
Parameter = 3
于是Method内部:
$this → ProductA
$quantity → 3
形成:
Self Binding
+
Parameter Binding
→
Method Execution Context
因此:
Self Binding是Object Method Call能够访问当前实例状态的基础机制。
4.17 Method Execution Context
由Self Binding进一步建立:
Method Execution Context(方法执行上下文)
一个Method真正运行时,可以抽象为:
Method Execution Context
├── Current Object
├── Self Reference
├── Method
├── Parameters
├── Current State
├── Context
├── Rules
└── Operation Environment
例如:
ProductA.sell(3)
形成:
Execution Context
├── Self = ProductA
├── Method = sell
├── quantity = 3
├── inventory = 50
└── Rule = inventory >= quantity
然后执行:
50 - 3
因此:
Method不是在真空中运行,而是在一个包含当前Object、当前状态、参数、Context和Rule的执行结构中运行。
4.18 Self Reference与Context
Self Reference不仅确定Object,还确定Method的实例Context。
例如:
ProductA
可能属于:
Warehouse A
而:
ProductB
可能属于:
Warehouse B
即使调用相同Method:
checkInventory()
其运行Context也可能不同。
因此:
$this
首先确定:
Current Object
而Current Object又携带:
Context
State
Relations
Attributes
Values
所以:
Self Reference
↓
Object
↓
Object Context
由此影响Method执行。
4.19 Self Reference与Relation
Object不仅有Attribute,还存在Relation。
因此Method通过Self Reference也可以访问当前Object的Relation。
例如:
OrderA
↓ contains
ProductA
Method:
getProduct()
通过当前Object:
$this
可以访问:
$this->product
其结构意义为:
CurrentObject
↓
Relation
↓
RelatedObject
因此:
$this
可以成为Object Relation访问的入口。
完整结构:
$this
↓
Object
├── Attribute
├── Value
├── State
├── Relation
├── Rule
└── Structure
4.20 Self Reference与其他Object
通过当前Object的Relation,Method可以访问其他Object。
例如:
OrderA
↓ contains
ProductA
Method:
OrderA.calculateTotal()
可以通过:
$this
找到:
OrderA
再通过Relation找到:
ProductA
然后读取:
ProductA.price
形成:
$this
↓
OrderA
↓
Relation
↓
ProductA
↓
price
↓
Value
因此Self Reference可以成为:
Object自身出发的结构遍历入口。
4.21 Self Reference与结构运算
如果当前Object拥有多个Attribute:
price
quantity
discount
Method可以通过Self Reference取得:
$this->price
$this->quantity
$this->discount
然后形成:
price × quantity × discount
因此:
Self Object
↓
Self Attributes
↓
Self Values
↓
Operation Relation
↓
Result
所以Self Reference直接连接:
Object
→ Attribute
→ Value
→ Operation
4.22 Self Reference与对象内部结构
Object本身可以被看成一个具体Structure:
Object
├── Identity
├── Attribute
├── Value
├── State
├── Relation
├── Rule
├── Method
└── Lifecycle
Self Reference实际上是Method访问这个Object Structure的入口。
因此:
$this
↓
Object Structure
↓
Internal Components
它可以访问:
$this.Attribute
$this.Value
$this.State
$this.Relation
从而形成:
对象内部结构访问机制。
4.23 Self Reference与对象封装
从结构理论角度看,Self Reference还体现了对象的结构边界。
Object拥有:
内部结构
Method则是Object内部定义的运行机制。
因此:
Object Boundary
│
├── Attribute
├── Value
├── State
├── Relation
└── Method
↓
Self Reference
Method通过Self Reference访问当前Object自身结构。
这意味着:
Method的运行主体首先是当前Object,而不是系统中任意一个无关联的结构。
这构成对象结构的一种边界约束。
4.24 Self Reference与对象自身方法调用
Object还可以通过自身引用调用自己的其他Method。
例如:
$this->calculateTotal();
结构意义是:
Current Object
↓
Call Own Method
例如:
OrderA.checkout()
内部:
$this->validate();
$this->calculateTotal();
$this->pay();
这里每一个Method Call都保持:
$this = OrderA
因此形成:
OrderA
↓
checkout()
↓
$this.validate()
↓
$this.calculateTotal()
↓
$this.pay()
这说明:
Self Reference不仅用于访问Object Attribute,也用于在同一Object内部继续调用Object自身的Method。
4.25 Self Method Call与状态连续性
假设:
OrderA.checkout()
内部:
$this->validate()
验证:
State = pending
然后:
$this->calculateTotal()
获得:
total = 500
然后:
$this->pay()
修改:
status = paid
整个过程中的:
$this
始终指向:
OrderA
因此:
OrderA
↓
checkout()
├── validate()
├── calculateTotal()
└── pay()
形成连续Object内部运行结构。
4.26 Self Reference与Method Chain
由此可以形成:
$this
↓
Method₁
↓
Method₂
↓
Method₃
例如:
$this->validate()
↓
$this->calculate()
↓
$this->save()
由于Self Reference始终保持当前Object:
$this = O
因此:
M₁(O)
→ M₂(O)
→ M₃(O)
形成:
同一Object上的Method Chain。
4.27 Self Reference与对象状态连续变化
Method Chain可以连续改变同一个Object的状态。
例如:
State₁
↓
$this->validate()
↓
State₁
↓
$this->pay()
↓
State₂
↓
$this->ship()
↓
State₃
因此:
Self Reference
保证整个Method Chain作用于:
同一个Object
形成:
O
↓
M₁(O)
↓
M₂(O)
↓
M₃(O)
而不是:
O₁
↓
M₁
↓
O₂
↓
M₂
除非Method显式建立了Object之间的Relation。
4.28 Self Reference与Object自身状态读取
Method可以通过Self Reference读取当前State。
例如:
$this->status
可能得到:
paid
然后:
if ($this->status === 'paid')
其结构意义为:
Self
↓
Status Attribute
↓
Current Value
↓
Condition
↓
Decision
因此:
Self Reference是Method读取Object自身状态并进行条件判断的重要机制。
4.29 Self Reference与Object状态修改
同样:
$this->status = 'paid';
可以表示:
Self.Status.Value
↓
Value Update
↓
State Transition
因此:
State₁
↓
$this
↓
Attribute Update
↓
State₂
这是Object内部状态改变的基本结构。
4.30 Self Reference与状态一致性
当Method通过Self Reference修改多个Attribute时,可能需要保证状态一致性。
例如:
$this->inventory -= 3;
$this->soldQuantity += 3;
形成:
inventory: 50 → 47
soldQuantity: 10 → 13
两个Value必须保持:
inventory + soldQuantity = TotalStock
如果Method只修改一个Value而没有同步另一个Value,则可能产生结构不一致。
因此:
Self Reference
↓
Multiple Attribute Updates
↓
Rule Validation
↓
State Consistency
由此说明Self Reference不仅支持访问,还参与对象内部结构一致性维护。
4.31 Self Reference与Object内部Rule
Object当前状态可能受到Rule约束。
例如:
inventory >= 0
Method:
$this->inventory -= $quantity;
执行前需要:
$this->inventory >= $quantity
因此:
$this
↓
Current Value
↓
Rule
↓
Operation
如果:
$this->inventory = 2
而:
quantity = 5
则:
2 >= 5
失败。
所以Method不能执行非法状态转移。
因此:
Self Reference所访问的不是无约束数据,而是属于当前Object结构并受到Object Rule约束的状态。
4.32 Self Reference与对象生命周期
Self Reference只能在当前Object存在并处于合法Method执行环境时成立。
因此:
Object Created
↓
Object Active
↓
Method Call
↓
Self Reference
↓
Operation
如果Object已经进入:
Deleted
状态,则不能继续进行正常实例Method运行。
因此:
Self Reference受Object生命周期约束。
形成:
Object Lifecycle
↓
Self Reference Availability
↓
Method Execution
4.33 Self Reference与实例独立性
同一个Class:
Product
产生:
A
B
C
每个Object都有自己的Self Reference。
当:
A.sell()
执行:
$this → A
当:
B.sell()
执行:
$this → B
当:
C.sell()
执行:
$this → C
所以:
Same Class
Same Method
Different Self
形成:
Different Object State
因此Self Reference是:
多个Object共享同一个Class Method,同时保持实例状态相互独立的关键机制。
4.34 Self Reference与继承
如果Method来自父Class:
Parent Class
↓
Inherited Method
↓
Child Object
当Child Object调用Inherited Method:
ChildObject.method()
其Self Reference仍然指向:
ChildObject
而不是Parent Class。
例如:
ParentClass
method()
产生:
ChildObject
调用:
ChildObject.method()
则:
$this → ChildObject
因此:
Method定义可以来自父Class,但Self Reference始终指向实际调用该Method的当前Object实例。
这是继承机制与实例运行机制之间的重要连接。
4.35 Self Reference与多态
在多态结构中:
ParentClass
method()
ChildClassA
method()
ChildClassB
method()
分别产生:
ObjectA
ObjectB
调用:
ObjectA.method()
ObjectB.method()
Method解析可能不同:
ObjectA → ChildClassA.method
ObjectB → ChildClassB.method
但:
$this
分别是:
ObjectA
ObjectB
因此:
Method Resolution
+
Self Binding
共同确定实际运行结构。
4.36 Self Reference与对象关系网络
一个Object可能连接多个Object:
CustomerA
↓
OrderA
↓
ProductA
↓
InventoryA
当:
OrderA.calculate()
执行:
$this → OrderA
Method可以从:
OrderA
通过Relation访问:
ProductA
再访问:
InventoryA
形成:
$this
↓
OrderA
↓
Relation
↓
ProductA
↓
Relation
↓
InventoryA
因此Self Reference是从当前Object出发进行结构导航的起点。
4.37 Self Reference与结构边界
虽然Method可以从当前Object通过Relation访问其他Object,但必须区分:
Self Object
与:
Related Object
例如:
$this
表示:
OrderA
而:
$this->product
可能表示:
ProductA
因此:
$this ≠ $this->product
结构上:
$this
↓
Self Object
$this->product
↓
Related Object
这一边界必须保持清晰。
4.38 Self Reference与对象内部递归
一个Method可以通过Self Reference再次调用自身:
$this->method()
形成递归结构。
例如:
Object
↓
Method
↓
$this
↓
Same Method
但是递归必须受到:
- 条件
- 深度
- State
- Rule
- Resource
等结构约束。
因此:
Self Reference
→ Recursive Method Call
→ State Transition
→ Termination Condition
如果没有终止条件,则可能形成无限运行。
这说明Self Reference不仅支持普通Method调用,也能够形成复杂的Method结构。
4.39 Self Reference与Object自身结构综合
Object内部可能存在:
Attribute
Relation
Method
Rule
State
Method通过Self Reference可以将这些结构组合起来。
例如:
$this->price
+
$this->quantity
形成:
Operation Structure
或者:
$this->inventory
+
$this->status
结合Rule形成:
State Validation Structure
因此:
Self Reference
↓
Object Components
↓
Structure Combination
↓
Operation
这使Object内部本身具备结构运算能力。
4.40 Self Reference与WSaiOS-SI对象结构
将PHP中的:
$this
抽象到WSaiOS-SI以后,可以定义:
Self Object Reference,是Method Call发生时,Method执行环境对当前Object实例建立的内部结构引用。
其作用不是复制Object,而是建立:
Method Execution Context
↓
Current Object
的确定关系。
形式化:
Self = CurrentObject(Call)
因此:
Call(O, M, P)
执行时:
Self(Call) = O
Method内部所有对自身结构的访问都可以表示为:
Self.Attribute
Self.Attribute.Value
Self.State
Self.Relation
Self.Method
Self.Rule
4.41 WSaiOS-SI中的$this抽象模型
因此,WSaiOS-SI不需要复制PHP的变量语法,而应抽象其逻辑:
Self Reference
│
├── Current Object Identity
├── Current Object Attributes
├── Current Object Values
├── Current Object State
├── Current Object Relations
├── Current Object Rules
├── Current Object Methods
├── Current Object Context
└── Current Object Lifecycle
形成:
Self(O)
=
<I, A, V, S, R, Q, M, C, L>
其中:
I= IdentityA= AttributeV= ValueS= StateR= RelationQ= RuleM= MethodC= ContextL= Lifecycle
因此:
Self不是Object之外的一个独立实体,而是Method执行环境对当前Object结构的引用方式。
4.42 Method Call中的Self Binding形式化
设:
O = Object
M = Method
P = Parameters
C = Context
Method Call:
Call = Invoke(O, M, P, C)
则:
Self(Call) = O
因此Method执行环境:
E = <Self, M, P, C, State, Rules>
其中:
Self = O
Method执行:
Result = Execute(E)
如果改变Object状态:
O.State₁
↓
Execute(E)
↓
O.State₂
所以:
Self Binding
→ Object Access
→ Operation
→ State Transition
构成完整的实例Method运行链。
4.43 Self Reference与Object状态的动态一致性
在Method执行期间:
$this
始终代表当前Object。
如果Method连续修改:
$this->price
$this->quantity
$this->total
则所有修改都属于同一个Object实例。
例如:
$this->quantity = 3
$this->price = 100
$this->total = 300
最终:
Object
├── quantity = 3
├── price = 100
└── total = 300
而不是三个不同对象的数据。
因此:
Self Reference保证Method内部多个Attribute操作保持在同一个Object结构边界内。
4.44 Self Reference与对象状态历史
由于Method通过Self Reference修改Object:
State₁
↓
$this
↓
Method Call
↓
State₂
因此可以形成:
State History
例如:
S₁
↓
$this->pay()
↓
S₂
↓
$this->ship()
↓
S₃
↓
$this->complete()
↓
S₄
于是:
Object
↓
Self Reference
↓
Method Call History
↓
State History
因此Object状态演化可以追踪到具体Method Call。
4.45 Self Reference与反馈学习
如果某次Method Call失败:
$this->pay()
结果:
failed
系统可以分析:
Self Object
+
Current State
+
Method
+
Parameters
+
Rule
+
Result
形成:
Method Call Feedback
进一步:
Feedback
↓
Object State Analysis
↓
Method Analysis
↓
Rule Analysis
↓
Structure Learning
因此Self Reference使学习系统能够知道:
究竟是哪一个Object在什么状态下执行了什么Method,以及产生了什么结果。
这对于结构智能学习非常重要。
4.46 Self Reference与知识形成
一次完整Method Call可以形成:
Object
+
Self State
+
Method
+
Parameter
+
Operation
+
Result
这一完整结构可以进入Knowledge。
例如:
ProductA
inventory = 50
调用:
sell(3)
结果:
inventory = 47
形成经验结构:
Object State
↓
Method Call
↓
Operation
↓
Result
↓
State Transition
因此:
Self Reference使Method执行过程能够与具体Object状态绑定,从而形成可记录、可比较和可学习的运行知识。
4.47 Self Reference与能力形成
如果系统发现:
Object State
+
Method Call
+
Operation
+
Result
在多个实例上都能够产生稳定结果,则可以抽象出:
Reusable Capability
例如:
inventory > quantity
↓
sell(quantity)
↓
inventory decrease
可以形成:
Inventory Reduction Capability
因此:
Self Reference
↓
Object Operation
↓
Execution Result
↓
Reusable Method Structure
↓
Capability
4.48 Self Reference与需求决策
需求可能要求:
将库存大于5的产品销售3件。
系统需要:
需求结构
↓
Object Matching
↓
Object State Matching
↓
Method Selection
↓
Method Call
↓
Self Binding
↓
Operation
例如:
ProductA.inventory = 50
ProductB.inventory = 2
只有:
ProductA
满足:
inventory > 5
因此:
ProductA.sell(3)
执行时:
$this → ProductA
于是:
$this->inventory
得到:
50
这说明Self Reference与:
需求
→ 匹配
→ Method选择
→ Object运行
之间存在直接联系。
4.49 Self Reference与自主语义理解
WSaiOS-SI必须能够自主理解类似:
“让产品A减少3件库存。”
形成:
Object = ProductA
Method = sell
Parameter = 3
Target Attribute = inventory
Operation = decrease
随后建立:
Self = ProductA
并形成:
Self.inventory
因此:
原始信息
↓
WSaiOS-SI自主语义理解
↓
Object Recognition
↓
Method Recognition
↓
Parameter Recognition
↓
Self Binding
↓
Method Call
↓
Operation
这里的:
Self
不是语言模型生成的特殊语法对象,而是WSaiOS-SI内部对象运行结构中的正式理论关系。
如果使用LLM,它最多提供外部辅助信息:
LLM Output
↓
WSaiOS-SI Semantic Interpretation
↓
Object / Method / Parameter
↓
Self Binding
因此:
Self Object Reference必须属于WSaiOS-SI自身的对象结构理论,而不是依赖LLM才能成立。
4.50 $this与WSaiOS-SI的理论对应
PHP中的:
$this
在WSaiOS-SI中可以抽象为:
Self Object Reference
其理论对应关系如下:
| PHP OOP | WSaiOS-SI理论 |
|---|---|
$this |
当前Object自身引用 |
$this->attribute |
当前Object的Attribute访问 |
$this->attribute对应的值 |
当前Object的Attribute Value |
$this->method() |
当前Object上的Method Call |
$this->state |
当前Object的State访问 |
$this->relation |
当前Object的Relation访问 |
$this->method()产生变化 |
当前Object的Operation与State Transition |
因此,WSaiOS-SI并不是照搬PHP语法,而是抽象PHP面向对象逻辑背后的结构机制。
4.51 Self Reference的核心结构
最终建立:
Method Call
↓
Current Object
↓
Self Reference
↓
┌───────────────┐
│ Attribute │
│ Value │
│ State │
│ Relation │
│ Rule │
│ Method │
│ Context │
└───────────────┘
↓
Operation
↓
Result
↓
State Transition
因此:
Self Reference是Method与Object自身结构之间的内部连接机制。
4.52 对象自身状态的统一模型
综合前两章:
Class
↓
Instantiation
↓
Object
↓
Attribute
↓
Value
↓
Object State
加入Method Call:
Object
↓
Method Call
↓
Self Reference
↓
Object State
↓
Operation
↓
New Object State
因此完整对象运行模型为:
Class
↓
Object
↓
Attribute
↓
Value
↓
State
↓
Method Call
↓
Self Reference
↓
Current Attribute / Value / State
↓
Operation
↓
New Value
↓
New State
4.53 对象自身引用的基本原则
本章建立以下原则。
第一,当前对象原则
Self Reference始终指向当前Method Call所绑定的Object。
第二,身份一致原则
Self Reference与当前Object具有相同Identity。
第三,非实例化原则
Self Reference不会创建新的Object。
第四,实例绑定原则
Self Reference在Method Call时与具体Object绑定。
第五,属性访问原则
Self Reference可以访问当前Object的Attribute。
第六,值访问原则
Self Reference可以取得当前Object的Attribute Value。
第七,状态访问原则
Self Reference可以访问当前Object的State。
第八,关系访问原则
Self Reference可以从当前Object访问其Relation。
第九,自身方法原则
Self Reference可以调用当前Object自身的其他Method。
第十,参数独立原则
Self Reference与Method Call Parameter属于不同结构角色。
第十一,状态操作原则
Self Reference支持Method对当前Object状态执行Operation。
第十二,状态转移原则
通过Self Reference产生的Operation可以使Object进入新State。
第十三,边界原则
Self Reference首先指向当前Object,不等于其他Related Object。
第十四,生命周期原则
Self Reference受Object生命周期约束。
第十五,继承原则
继承来的Method在Child Object上运行时,Self仍指向实际Child Object。
第十六,多态原则
不同Object执行同名Method时,各自Self分别绑定各自Object。
第十七,复用原则
同一个Class Method可以通过不同Self作用于多个Object。
第十八,一致性原则
同一Method Call内部对多个Self Attribute的操作必须保持Object结构一致性。
第十九,反馈原则
Self Reference使Method运行结果能够与具体Object状态绑定并进入反馈学习。
第二十,自主语义原则
Self Reference及其对应的Object、Attribute、Value、State、Relation和Method关系由WSaiOS-SI自主语义体系解释,不依赖LLM作为理论基础。
4.54 本章理论成果
本章从PHP OOP中的:
$this
抽象出WSaiOS-SI中的:
Self Object Reference(对象自身引用)
并建立其完整理论意义:
Object
↓
Method Call
↓
Self Binding
↓
Self Object Reference
↓
Object Attribute
↓
Object Value
↓
Object State
↓
Operation
↓
State Transition
因此:
$this的真正理论意义不是一个普通变量,而是Method执行环境对当前Object实例的自身引用。
进一步:
Method通过Self Reference访问当前Object自身的Attribute、Value、State、Relation、Rule和Method,从而使一个Class中定义的共同Method能够在不同Object实例上作用于不同的实例状态。
例如:
Class Product
↓
sell()
↓
┌──────────────┐
│ ProductA │
│ inventory=50 │
└──────────────┘
↓
$this → ProductA
↓
$this.inventory
↓
50 - 3
↓
47
而:
Class Product
↓
sell()
↓
┌──────────────┐
│ ProductB │
│ inventory=10 │
└──────────────┘
↓
$this → ProductB
↓
$this.inventory
↓
10 - 3
↓
7
因此:
同一个Class
↓
同一个Method
↓
不同Object
↓
不同Self Reference
↓
不同Attribute Value
↓
不同Operation Result
↓
不同Object State
最终建立:
Class定义共同Method,Object提供具体运行实例,Method Call建立调用关系,Self Reference确定当前运行对象,Attribute与Value提供具体运算数据,Operation执行实际运算,State记录对象运行后的具体状态。
由此形成完整对象方法运行链:
Class
→ Method Definition
→ Object
→ Method Call
→ Self Binding
→ Self Object Reference
→ Attribute
→ Value
→ Operation
→ Result
→ State Transition
→ Relation Change
→ Structure Change
→ Knowledge
→ Capability
→ Cognition
→ Decision
→ Execution
→ Feedback
→ Learning
→ Evolution
因此,本章最终确立:
对象方法并不是脱离对象运行的独立行为。Method在具体Object上被调用以后,必须绑定当前Object自身,并通过Self Reference访问该Object自身的结构和状态。
Self Object Reference是Object与Method之间从“调用关系”进入“对象内部运行”的关键机制,也是同一个Class Method能够作用于多个不同Object实例并分别操作其自身状态的结构基础。
同时,WSaiOS-SI将这一机制从PHP语法提升为独立的结构智能理论:
$this
↓
Self Object Reference
↓
Current Object
↓
Current Object State
↓
Object-local Operation
由此完成从:
“Method可以被Object调用”
进一步推进到:
“Method调用以后,必须知道当前Object是谁,并在这个Object自身的结构和状态上运行。”
这为下一阶段进一步研究对象属性值运算、方法参数、方法返回值以及对象状态转移建立理论基础。