第三章 Class与Object关系
3.1 Class与Object关系的基本定义
在WSaiOS结构智能(WSaiOS-SI)理论中,Class与Object构成对象结构理论中的基本定义—实例关系。
前一章已经确定:
Class 是对一类对象共同结构、属性、方法、关系和规则的定义。
同时确定:
Object 是 Class 经过实例化形成的具体对象实例。
因此,Class与Object之间最基本、最核心的关系为:
Class
↓
实例化
↓
Object
形式化表示:
Object = Instantiate(Class)
这意味着Object不是脱离Class独立产生的结构概念,而是在Class定义基础上形成的具体实例。
因此:
Class是定义层,Object是实例层。
Class解决的是:
一类对象共同应该具有什么结构?
Object解决的是:
某一个具体对象实际具有什么结构、属性值、状态和运行关系?
二者共同构成:
抽象定义
↓
Class
↓
Instantiation
↓
具体实例
↓
Object
这一关系是WSaiOS-SI对象结构理论的基础。
3.2 Class → 实例化 → Object
Class与Object之间不是简单的包含关系,而是通过**实例化(Instantiation)**建立联系。
其基本过程为:
Class
│
│ Class Definition
↓
Instantiation
│
│ Identity + Attribute + Value + State
↓
Object
实例化的本质,是将Class中的共同结构定义转换为一个具体Object的结构实例。
例如:
Class Product
定义:
Attribute:
name
price
inventory
Method:
calculatePrice()
updateInventory()
Rule:
inventory = 0
→
status = out_of_stock
通过实例化:
ProductA = Instantiate(Product)
形成:
Object ProductA
进一步:
ProductB = Instantiate(Product)
ProductC = Instantiate(Product)
形成:
Product Class
│
├── ProductA
├── ProductB
└── ProductC
因此:
一个Class可以通过多次实例化形成多个Object。
3.3 一个Class可以产生多个Object
这是Class与Object关系中最重要的性质之一。
一个Class不是只能产生一个Object。
例如:
Class Product
可以产生:
ProductA
ProductB
ProductC
ProductD
...
形式化表示:
C → {O₁, O₂, O₃, ..., Oₙ}
其中:
C表示一个Class;O₁...Oₙ表示由该Class实例化形成的多个Object。
因此:
Class Product
│
├── Object ProductA
├── Object ProductB
├── Object ProductC
├── Object ProductD
└── Object ProductN
这些Object具有共同的Class来源,但每一个Object都是独立的具体实例。
所以:
Class(ProductA)
=
Class(ProductB)
=
Class(ProductC)
=
Product
但:
ProductA ≠ ProductB
ProductB ≠ ProductC
ProductA ≠ ProductC
这种关系体现了:
共同定义与具体实例之间的统一性和差异性。
3.4 一个Class形成多个Object的理论意义
一个Class可以形成多个Object,意味着Class不是具体数据,而是一种可以反复用于创建对象的结构定义机制。
例如:
Class Customer
可以形成:
CustomerA
CustomerB
CustomerC
每一个Customer Object都具有Customer Class所规定的共同结构:
name
email
address
status
但每一个Object可以具有不同的具体值。
例如:
CustomerA
name = Alice
status = active
CustomerB
name = Bob
status = inactive
CustomerC
name = Carol
status = active
因此:
共同结构
↓
Class
↓
多个实例
↓
不同具体状态
这使系统能够同时表达:
一类对象的共同规律
以及:
每一个具体对象的个体差异。
这也是Class理论与Object理论能够进入结构智能运算体系的重要原因。
3.5 Class定义共同结构,Object保存具体实例
Class与Object之间最核心的区别可以归纳为:
Class
├── Common Structure
├── Common Attributes
├── Common Methods
├── Common Relations
└── Common Rules
而Object则是:
Object
├── Identity
├── Attribute Values
├── Current State
├── Runtime Relations
├── Method Execution Context
└── Lifecycle State
因此:
Class描述共同性,Object体现具体性。
例如:
Class Product
price
inventory
status
这是共同定义。
而:
ProductA
price = 100
inventory = 50
status = available
是具体实例。
另一个:
ProductB
price = 200
inventory = 10
status = available
同样来自Product Class,但其具体状态不同。
所以:
Class
↓
共同结构
↓
Instantiation
↓
Object A
Object B
Object C
↓
各自独立的Value和State
3.6 不同Object可以拥有不同属性值
一个Class产生多个Object以后,这些Object并不要求拥有完全相同的属性值。
这是Class与Object关系中的核心机制。
例如:
Class Product
规定:
price
inventory
status
实例化:
ProductA
ProductB
则:
ProductA
price = 100
inventory = 50
status = available
而:
ProductB
price = 200
inventory = 10
status = available
因此:
Attribute(ProductA)
=
Attribute(ProductB)
但是:
Value(ProductA)
≠
Value(ProductB)
更准确地说:
ProductA.price = 100
ProductB.price = 200
因此:
ProductA.price ≠ ProductB.price
同样:
ProductA.inventory ≠ ProductB.inventory
这说明:
Class定义Attribute的存在和结构,Object保存Attribute在具体实例中的Value。
3.7 Attribute与Value的Class—Object映射
Class与Object之间可以建立明确的属性映射关系。
例如:
Class Product
Attribute:
price
inventory
status
实例化以后:
ProductA
price → 100
inventory → 50
status → available
可以表示为:
Class Attribute
↓
Object Attribute Instance
↓
Concrete Value
因此:
Class.price
表示Class中的属性定义。
而:
ProductA.price = 100
表示具体Object的属性值。
严格来说:
Attribute ≠ Value
并且:
Class Attribute ≠ Object Value
正确关系为:
Class
↓
Attribute Definition
↓
Object
↓
Attribute Instance
↓
Value
3.8 Object之间可以共享Class结构,但不共享身份
多个Object可以来自同一个Class,但不能因此被视为同一个Object。
例如:
Class Product
形成:
ProductA
ProductB
ProductC
它们共享:
共同Class
共同Attribute定义
共同Method定义
共同Rule定义
共同结构特征
但是各自具有:
不同Identity
不同Value
不同State
不同Runtime Relation
不同Lifecycle
因此:
Class(ProductA)
=
Class(ProductB)
但:
Identity(ProductA)
≠
Identity(ProductB)
这一区分保证了对象系统既能够表达类别共同性,又能够表达个体独立性。
3.9 Object之间可以具有不同State
不仅Object的属性值可以不同,Object的当前状态也可以不同。
例如:
Class Product
规定:
status
但实例化以后:
ProductA.status = available
而:
ProductB.status = out_of_stock
所以:
State(ProductA)
≠
State(ProductB)
即使:
Class(ProductA)
=
Class(ProductB)
也不能认为两个Object处于相同状态。
因此:
Class定义允许存在的状态结构和状态转换规则,Object保存自身当前实际状态。
可以表示为:
Class
↓
State Definition
↓
Object
↓
Current State
3.10 Object的状态可以独立变化
多个Object来自同一个Class以后,每一个Object可以独立运行。
例如:
ProductA.inventory = 50
ProductB.inventory = 10
调用:
ProductA.updateInventory(5)
得到:
ProductA.inventory = 45
但:
ProductB.inventory = 10
仍然保持不变。
因此:
Operation(ProductA)
不会自动等于:
Operation(ProductB)
这说明:
Object实例之间具有独立运行状态。
形式化表示:
O₁' = Operation(O₁)
并不意味着:
O₂' = Operation(O₂)
除非Class Rule、Relation、共享结构或其他机制明确规定二者存在联动关系。
3.11 Object之间可以具有不同Relation
多个Object不仅属性值和状态可以不同,它们之间的具体Relation也可以不同。
例如Class层面:
Customer
↓ places
Order
表示:
Customer类对象可以与Order类对象形成places关系。
具体运行时可能是:
CustomerA
↓ places
Order001
而:
CustomerB
↓ places
Order002
同时可能存在:
CustomerA
↓ places
Order003
因此:
Class Relation
规定的是可能形成的关系结构,而:
Object Relation
描述的是具体Object之间实际形成的关系。
所以:
Class Relation
↓
Relation Definition
↓
Object Relation
3.12 Class与Object的Method关系
Class可以定义共同Method,而多个Object可以分别调用同一个Method。
例如:
Class Product
Method:
calculatePrice()
实例化:
ProductA
ProductB
分别调用:
ProductA.calculatePrice()
ProductB.calculatePrice()
虽然调用的是同一个Class Method定义,但实际计算可以使用不同Object的Value。
例如:
ProductA
price = 100
quantity = 2
执行:
calculatePrice()
得到:
200
而:
ProductB
price = 200
quantity = 3
执行:
calculatePrice()
得到:
600
因此:
Same Method Definition
↓
Different Object State
↓
Different Operation Input
↓
Different Result
这说明:
Class Method提供共同运算定义,Object提供具体运算对象和具体运行数据。
3.13 Class与Object的Rule关系
Class可以定义一类Object共同遵循的Rule。
例如:
Class Product
Rule:
inventory = 0
→
status = out_of_stock
对于不同Object:
ProductA.inventory = 0
则:
ProductA.status = out_of_stock
而:
ProductB.inventory = 20
则该Rule当前不会触发相同状态转换。
因此:
Same Class Rule
↓
Different Object State
↓
Different Rule Result
这说明:
Rule的定义可以共享,但Rule的运行结果属于具体Object。
3.14 Object的实例独立性
Class与Object关系必须满足实例独立性。
所谓实例独立性,是指:
一个Class形成多个Object以后,每个Object拥有独立的Identity、Attribute Value、State、Runtime Relation和Lifecycle。
例如:
ProductA
price = 100
和:
ProductB
price = 200
修改:
ProductA.price = 120
不应自动导致:
ProductB.price = 220
除非系统存在明确的共享Relation、共享结构或统一Operation。
因此:
ObjectA
│
│ independent state
↓
ObjectB
默认不意味着二者共享实例状态。
3.15 Class共享定义与Object独立状态
Class与Object之间形成一种特殊的“共享—独立”结构。
Class层共享
多个Object共享:
Class
├── Structure Definition
├── Attribute Definition
├── Method Definition
├── Relation Definition
└── Rule Definition
Object层独立
每个Object拥有:
Object
├── Identity
├── Attribute Values
├── Current State
├── Runtime Relations
└── Lifecycle State
因此:
Class
│
┌────────┼────────┐
↓ ↓ ↓
ObjectA ObjectB ObjectC
│ │ │
Values Values Values
State State State
Relations Relations Relations
这就是Class与Object关系的核心结构。
3.16 Class不是Object集合
虽然一个Class可以产生多个Object,但Class本身不能简单定义为Object的集合。
原因在于:
Class
首先是一种定义结构。
而:
Object Collection
是一组已经存在的具体实例。
例如:
Class Product
即使当前没有任何Product Object:
Product Objects = ∅
Product Class仍然可以存在。
因此:
Class ≠ Object Collection
正确关系是:
Class
↓
defines possible Object structure
↓
Instantiation
↓
Object Collection
所以Class具有独立于当前实例数量的定义意义。
3.17 一个Class可以没有Object
Class可以先存在,Object以后再创建。
例如:
Class Vehicle
刚创建时:
Vehicle Objects = 0
仍然存在:
Vehicle Class
之后:
VehicleA = Instantiate(Vehicle)
得到一个Object。
再:
VehicleB = Instantiate(Vehicle)
VehicleC = Instantiate(Vehicle)
形成:
Vehicle
├── VehicleA
├── VehicleB
└── VehicleC
因此:
Class的存在不以当前是否存在Object为必要条件。
这进一步说明Class是定义层,而Object是实例层。
3.18 Object可以被删除而Class继续存在
如果删除一个Object,不意味着对应Class必须被删除。
例如:
Class Product
拥有:
ProductA
ProductB
ProductC
如果:
Delete(ProductA)
则可以形成:
Class Product
├── ProductB
└── ProductC
Product Class仍然存在。
因此:
Delete(Object)
≠
Delete(Class)
二者具有不同生命周期。
同样:
Delete(Class)
也不能简单理解为:
Delete(All Original Information)
Class、Object、Structure和原始资料必须保持生命周期边界。
3.19 Object数量与Class数量不是一一对应
一个Class可以产生:
0 → n
个Object。
因此:
|Objects(Class)| = n
其中:
n ≥ 0
例如:
Class Product
可以有:
n = 0
n = 1
n = 100
n = 1,000,000
而Class仍然只有一个定义。
因此:
1 Class
↓
Multiple Objects
是基本结构关系。
反过来:
1 Object
在同一时刻具有一个主要Class归属,但它可以参与多个更高层Structure。
因此:
Object
↓
Class Identity
↓
Multiple Structures
这使Class、Object与Structure形成三个不同层次。
3.20 Object可以参与多个Structure
一个Object虽然来源于一个Class,但不意味着它只能参与一个Structure。
例如:
ProductA
可以同时参与:
Product Structure
Order Structure
Inventory Structure
Warehouse Structure
Sales Structure
因此:
ProductA
/ | \
↓ ↓ ↓
Order Inventory Sales
Structure Structure Structure
其原因在于:
Object是具体实例,而Structure是根据不同目标、Context、Relation和Organization形成的结构整体。
同一个Object在不同Structure中可以承担不同结构角色。
例如:
ProductA + Order001
中:
ProductA = OrderItem
而:
ProductA + WarehouseA
中:
ProductA = InventoryItem
所以:
Object + Context + Relation
↓
Structural Role
3.21 Class与Object的结构继承
Class可以通过继承形成新的Class。
例如:
Product
↓
ElectronicProduct
其中:
ElectronicProduct
=
Product
+
Additional Structure
然后:
ElectronicProduct
↓
Instantiate
↓
LaptopA
形成:
Product
↓
ElectronicProduct
↓
LaptopA
因此继承链可以表示为:
Parent Class
↓
Child Class
↓
Object
Object获得的是最终Class定义中的结构特征。
例如:
Product
├── name
├── price
└── inventory
ElectronicProduct
├── Product inherited structure
└── voltage
LaptopA
├── name
├── price
├── inventory
└── voltage
因此:
Class继承发生在定义层,Object实例化发生在实例层。
3.22 Class与Object的生命周期关系
Class和Object各自具有生命周期,但二者并不完全相同。
Class生命周期可以表示为:
Class Creation
↓
Definition
↓
Update
↓
Active
↓
Deprecation
↓
Deletion / Replacement
Object生命周期可以表示为:
Object Creation
↓
Initialization
↓
Active
↓
Update
↓
Inactive
↓
Deletion / Archive
二者关系为:
Class Lifecycle
│
│ defines
↓
Object Lifecycle
但是Class的生命周期变化不应简单等同于Object生命周期变化。
例如:
Class Product v1
更新为:
Class Product v2
可能要求已有Object:
ProductA
ProductB
ProductC
进行:
- 结构迁移
- 属性补充
- Value转换
- State转换
- 重新实例化
- 重新分类
- 保持原有Identity
因此:
Class演化与Object演化相关,但不是同一过程。
3.23 Class更新与Object更新
Class可以发生结构更新:
C₀
↓
ΔStructure
↓
C₁
例如:
Class Product
原来:
name
price
inventory
后来增加:
supplier
则:
Class Product'
=
Class Product
+
supplier
这时已有Object可能需要:
ProductA
↓
Structure Migration
↓
supplier = SupplierA
但这不是自动等价于:
所有Object = 新Object
系统需要依据Class生命周期规则、对象迁移规则和结构兼容性决定。
因此:
Class Update
可能引发:
Object Structure Update
但:
Class Update ≠ Object Update
二者之间需要通过明确的结构转换机制连接。
3.24 Object反向支持Class抽象
Class不仅可以自上而下产生Object,也可以通过对Object进行结构分析而形成。
例如系统获得:
ObjectA
ObjectB
ObjectC
系统通过WSaiOS-SI自主语义理解和结构分析识别:
共同Element
共同Attribute
共同Method
共同Relation
共同Rule
共同Lifecycle
形成:
Common Structure
再抽象为:
Class
其过程为:
多个Object
↓
Object Structure Analysis
↓
Common Element Identification
↓
Common Attribute Identification
↓
Common Method Identification
↓
Common Relation Identification
↓
Common Rule Identification
↓
Common Structure
↓
Class Definition
因此:
Class → Object
和:
Object → Class
共同形成一个闭环。
这也是结构智能区别于简单对象存储的重要地方。
3.25 Class与Object的自主语义形成
Class与Object关系必须建立在WSaiOS-SI自主语义理解之上。
其完整过程为:
原始信息
↓
WSaiOS-SI自主语义理解
↓
识别对象概念
↓
识别共同结构
↓
形成Class
↓
Object实例识别
↓
Attribute识别
↓
Value识别
↓
Relation识别
↓
Object Structure
例如系统从不同信息中识别:
Product A
Product B
Product C
首先不是简单根据文字相似度认为它们属于同一类。
而是通过自主语义理解识别:
它们是否具有共同对象语义?
是否具有共同Attribute?
是否具有共同Relation?
是否具有共同Method?
是否具有共同Rule?
是否具有共同Structure?
满足相应结构条件以后,才可以形成:
Product Class
然后:
Product A → ProductA Object
Product B → ProductB Object
Product C → ProductC Object
因此:
Class与Object关系不是字符串分类关系,而是结构语义关系。
3.26 Object实例化不是简单复制
必须进一步明确:
实例化不是把Class的全部内容机械复制到Object。
实例化实际上包括:
Class Definition
↓
Structure Interpretation
↓
Identity Assignment
↓
Attribute Instance Creation
↓
Value Initialization
↓
State Initialization
↓
Relation Initialization
↓
Lifecycle Initialization
↓
Object
Class中的:
Attribute Definition
变成Object中的:
Attribute Instance
Class中的:
Rule Definition
成为Object运行时的:
Rule Constraint
Class中的:
Method Definition
成为Object可以调用的:
Method
Class中的:
Relation Definition
成为Object可以形成的:
Runtime Relation
因此:
实例化是一种结构转换过程,而不是文本复制过程。
3.27 Class与Object的统一结构模型
综合本章,可以建立如下模型:
Class
│
Common Definition
│
┌────────────────┼────────────────┐
↓ ↓ ↓
Attributes Methods Relations
↓ ↓ ↓
Definitions Definitions Definitions
│ │ │
└────────────────┼────────────────┘
↓
Instantiation
│
┌─────────────┼─────────────┐
↓ ↓ ↓
ObjectA ObjectB ObjectC
│ │ │
┌────┼────┐ ┌────┼────┐ ┌────┼────┐
↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
Value State R Value State R Value State R
这里:
R = Runtime Relation
因此:
Class提供共同结构,Instantiation负责结构实例化,Object保存具体实例状态。
3.28 Class与Object的形式化关系
设:
C = Class
O = Object
则:
Oᵢ = Instantiate(C, Iᵢ, Vᵢ, Tᵢ, Rᵢ)
其中:
Oᵢ:第i个ObjectC:共同ClassIᵢ:Object IdentityVᵢ:Object Attribute ValuesTᵢ:Object StateRᵢ:Object Runtime Relations
对于多个Object:
O₁ = Instantiate(C, I₁, V₁, T₁, R₁)
O₂ = Instantiate(C, I₂, V₂, T₂, R₂)
O₃ = Instantiate(C, I₃, V₃, T₃, R₃)
则:
Class(O₁)
=
Class(O₂)
=
Class(O₃)
=
C
但:
I₁ ≠ I₂ ≠ I₃
并且:
V₁
可能 ≠
V₂
可能 ≠
V₃
以及:
T₁
可能 ≠
T₂
可能 ≠
T₃
同时:
R₁
可能 ≠
R₂
可能 ≠
R₃
因此,同一个Class可以形成多个具有不同实例状态的Object。
3.29 Class与Object关系中的结构不变量
虽然不同Object可以具有不同Value和State,但Class实例化必须保持一定的结构约束。
例如:
Class Product
规定:
price
inventory
status
则Object:
ProductA
必须能够解释这些结构属性。
因此:
Class Structure
↓
Object Structure
需要满足:
- Attribute结构兼容
- Method结构兼容
- Relation定义兼容
- Rule定义兼容
- Lifecycle定义兼容
- 类型和约束兼容
但:
Attribute Value
State
Runtime Relation
可以因Object而不同。
因此:
Class约束Object的结构形式,Object保存具体实例内容。
3.30 Class与Object关系中的变化传播
Class发生变化时,变化可能向Object层传播。
例如:
Class Product
增加:
supplier
则:
Class Product'
形成新的结构定义。
已有Object可能需要:
ProductA
ProductB
ProductC
分别执行结构更新。
其传播过程为:
Class Change
↓
Structure Difference Analysis
↓
Object Compatibility Analysis
↓
Object Migration / Update
↓
New Object Structure
但这种传播不是无条件的。
系统需要判断:
是否兼容?
是否需要补充Value?
是否需要转换Value?
是否需要修改State?
是否需要重新建立Relation?
是否需要重新执行Rule?
因此Class变化进入Object层必须经过结构运算和结构验证。
3.31 Object变化向更高结构传播
反过来,Object变化也可能影响更高层结构。
例如:
ProductA.inventory
从:
10
变为:
0
导致:
ProductA.status = out_of_stock
进一步可能导致:
Order001
无法完成:
Order Fulfillment
最终影响:
Sales Structure
因此:
Object Value Change
↓
Object State Change
↓
Object Relation Change
↓
Structure Change
↓
Knowledge Change
↓
Capability / Decision Change
这说明Object是结构智能中一个重要的动态传播节点。
3.32 Class与Object关系在结构学习中的作用
WSaiOS-SI的学习不是单纯学习Object名称或Object属性。
系统需要学习:
Object
↓
Object Structure
↓
Common Structure
↓
Class
同时也需要学习:
Class
↓
Instantiation
↓
Object
↓
Object State
↓
Operation Result
因此形成:
Class Abstraction
↕
Object Instantiation
学习过程可以同时发生:
Top-Down Learning:
Class → Object → Operation → Result
以及:
Bottom-Up Learning:
Object → Common Structure → Class
最终:
Class ↔ Object
形成动态结构学习关系。
3.33 Class与Object关系在知识形成中的作用
多个Object可以提供具体事实。
例如:
ProductA
price = 100
inventory = 50
ProductB
price = 200
inventory = 10
ProductC
price = 150
inventory = 30
系统可以从这些Object中发现:
共同结构
共同Attribute
共同Rule
共同Relation
形成:
Product Class
同时,多个Object的实际状态又可以形成知识:
Product Knowledge
因此:
Class
+
Object Instances
+
Relations
+
Rules
+
Operations
+
Validation
↓
Knowledge Structure
Class提供抽象结构,Object提供具体实例。
二者共同参与知识形成。
3.34 Class与Object关系在结构匹配中的作用
当系统面对需求时,可以先匹配Class,再进一步匹配具体Object。
例如需求:
查找库存不足的产品。
系统可以先识别:
需求
↓
Product Class
然后:
Product Objects
再根据:
inventory < threshold
进行Object级匹配。
过程:
需求
↓
需求结构
↓
Class Matching
↓
Product Class
↓
Object Matching
↓
ProductA
ProductB
...
↓
State / Value Evaluation
↓
Result
因此:
Class匹配解决“找哪一类结构”,Object匹配解决“找哪一个具体实例”。
这是结构匹配理论的重要分层。
3.35 Class匹配与Object匹配的区别
两者必须严格区分。
Class Matching
比较:
共同结构
Attribute Definition
Method Definition
Relation Definition
Rule Definition
解决:
哪一类对象符合需求结构?
Object Matching
比较:
Identity
Attribute Value
Current State
Runtime Relation
Context
Lifecycle
解决:
哪一个具体对象符合当前条件?
因此:
需求
↓
Class Matching
↓
Candidate Class
↓
Object Matching
↓
Candidate Objects
这一机制使结构智能能够从“类别层”逐步进入“实例层”。
3.36 Class与Object关系中的结构运算
Class与Object关系还可以进入结构运算。
例如:
Class Product
定义:
calculatePrice()
Object:
ProductA
price = 100
quantity = 2
运行:
ProductA.calculatePrice()
形成:
100 × 2 = 200
于是:
Class Method Definition
↓
Object Method Invocation
↓
Operation
↓
Result
因此:
Class定义可运算结构,Object提供具体运算实例。
3.37 Class与Object的结构演化
Class和Object都可以演化。
Class演化:
Class₀
↓
Structure Change
↓
Class₁
Object演化:
Object₀
↓
Value / State / Relation Change
↓
Object₁
二者共同形成:
Class Evolution
↓
Object Structure Evolution
↓
Object State Evolution
↓
Knowledge Evolution
↓
Capability Evolution
因此:
Class演化决定对象定义可以如何演化,Object演化体现具体实例如何随运行环境变化。
3.38 Class与Object关系的完整生命周期
Class与Object之间可以形成完整生命周期链:
Class Creation
↓
Class Definition
↓
Object Instantiation
↓
Object Creation
↓
Object Operation
↓
Object State Change
↓
Object Relation Change
↓
Structure Change
↓
Object Update
↓
Object Deletion
↓
Class Evolution
↓
New Object Instantiation
因此Class与Object并不是静态的定义关系,而是一个持续运行的结构生命周期关系。
3.39 Class与Object关系的核心数学模型
可以将Class与多个Object表示为:
C → {O₁, O₂, ..., Oₙ}
其中:
Oᵢ = Instantiate(C, Iᵢ, Aᵢ, Vᵢ, Tᵢ, Rᵢ)
对于任意两个Object:
Oᵢ ≠ Oⱼ
但:
Class(Oᵢ) = Class(Oⱼ) = C
它们可以满足:
Aᵢ = Aⱼ
即拥有共同Attribute定义,
但:
Vᵢ ≠ Vⱼ
即具体Value可以不同。
同时:
Tᵢ ≠ Tⱼ
表示State可以不同。
并且:
Rᵢ ≠ Rⱼ
表示Runtime Relation可以不同。
因此可以得到:
Common Definition
↓
Different Instances
↓
Different Values
↓
Different States
↓
Different Runtime Relations
这就是Class—Object关系的形式化基础。
3.40 Class与Object关系的总体结构
综合本章,可以形成:
Class
│
Definition
│
↓
Instantiation
│
┌────────────────┼────────────────┐
↓ ↓ ↓
ObjectA ObjectB ObjectC
│ │ │
Identity A Identity B Identity C
│ │ │
Values A Values B Values C
│ │ │
State A State B State C
│ │ │
Relations A Relations B Relations C
│ │ │
└────────────────┼────────────────┘
↓
Object Structures
↓
Structure Composition
↓
Knowledge
↓
Capability
↓
Cognition
↓
Decision
这一模型清楚表达:
一个Class可以产生多个Object;
多个Object共享Class定义;
每个Object具有独立Identity;
不同Object可以拥有不同Attribute Value;
不同Object可以拥有不同State;
不同Object可以拥有不同Runtime Relation;
不同Object可以独立调用Method并产生不同Operation Result;
多个Object又可以进一步参与更高层Structure。
3.41 Class与Object的理论原则
第一,定义—实例原则
Class是定义,Object是实例。
Class → Object
第二,多实例原则
一个Class可以经过多次实例化形成多个Object。
C → {O₁, O₂, O₃, ..., Oₙ}
第三,共同结构原则
同一个Class产生的Object具有共同的结构定义。
第四,实例独立原则
不同Object具有独立Identity、Value、State和Runtime Relation。
第五,属性值差异原则
不同Object可以拥有不同的属性值。
Attribute(O₁) = Attribute(O₂)
Value(O₁) ≠ Value(O₂)
第六,状态差异原则
不同Object可以处于不同状态。
State(O₁) ≠ State(O₂)
第七,方法实例运行原则
Class定义Method,Object调用Method并执行具体Operation。
第八,关系实例化原则
Class定义可能的Relation,Object形成具体Runtime Relation。
第九,结构参与原则
Object可以参与一个或多个Structure。
第十,结构演化原则
Class变化可以影响Object结构,Object变化也可以影响更高层Structure。
第十一,抽象—实例双向原则
Class可以实例化Object,多个Object也可以通过共同结构分析抽象形成Class。
Class → Object
Object → Common Structure → Class
第十二,自主语义原则
Class与Object的识别、定义、实例化和关系解释由WSaiOS-SI自主语义理解层完成,不依赖LLM作为理论基础。
3.42 本章结论
Class与Object构成WSaiOS-SI对象结构理论中最基本的定义—实例关系。
其核心关系为:
Class → 实例化 → Object
一个Class可以经过多次实例化产生多个Object:
Class
├── ObjectA
├── ObjectB
├── ObjectC
└── ObjectN
这些Object共享Class所定义的:
- 共同Structure
- Attribute Definition
- Method Definition
- Relation Definition
- Rule Definition
- Lifecycle Definition
但是每个Object拥有自己的:
- Identity
- Attribute Value
- State
- Runtime Relation
- Lifecycle State
- Operation Context
因此:
Class(ObjectA)
=
Class(ObjectB)
=
Class(ObjectC)
但:
Identity(A) ≠ Identity(B) ≠ Identity(C)
同时:
Value(A) 可以 ≠ Value(B)
State(A) 可以 ≠ State(B)
Relation(A) 可以 ≠ Relation(B)
由此建立:
Class定义共同性,Object体现个体性。
Class定义结构,Object实例化结构。
Class定义Attribute,Object拥有Value。
Class定义Method,Object执行Operation。
Class定义Relation,Object形成Runtime Relation。
Class定义Rule,Object在具体状态和Context中运行Rule。
进一步形成:
Class
↓
Instantiation
↓
Object
↓
Attribute / Value
↓
Method / Operation
↓
State
↓
Relation
↓
Object Structure
↓
Composite Structure
↓
Knowledge
↓
Capability
↓
Cognition
↓
Decision
因此,Class与Object关系并不是传统意义上的简单“类—实例”关系,而是WSaiOS-SI中从抽象结构定义向具体可运行结构实例转换的核心机制。
它使结构智能能够同时处理:
共同结构
+
具体实例
+
个体属性值
+
个体状态
+
个体关系
+
实例运算
并进一步将这些Object重新纳入更高层的结构匹配、结构运算、结构组合、结构综合、知识形成、能力形成和决策过程。
最终确立:
Class提供一类对象的共同结构定义;实例化将该定义转换为具体Object;一个Class可以产生多个Object,而每个Object拥有独立的Identity、属性值、状态和运行关系。多个Object在共享Class结构的同时保持实例独立性,并可以进一步通过Relation参与不同Structure,从而成为WSaiOS-SI结构智能运行、知识形成和能力形成的具体结构载体。