第4章　类—对象结构关系

4.1 提出背景

前两章分别建立了基础类理论和对象实例理论。

基础类回答的是：

世界中有哪些相对稳定的对象类别？

对象实例回答的是：

这些类别在现实世界中具体表现为什么？

但是，仅仅知道“类”和“对象”仍然不足以形成完整的机器世界结构。机器还必须理解：

类与对象是什么关系？
对象与属性是什么关系？
对象与状态是什么关系？
不同层次的类之间如何形成结构？
类的结构如何对应现实世界中的结构？

因此，本章建立“类—对象结构关系”理论。

本章的核心不是简单讨论程序设计中的类和对象，而是研究：

抽象的类结构如何映射到现实世界中的对象结构，以及对象如何通过属性、状态和关系形成现实世界的具体结构。

最终建立：

世界
↓
类结构
↓
对象实例
↓
对象属性
↓
对象状态
↓
现实关系
↓
现实场景

这一结构使机器能够把抽象知识与现实对象连接起来。

---

4.2 类 → 对象

**类（Class）**是对一组具有共同结构对象的抽象定义。

**对象（Object）**是某一个类在现实世界中的具体实例。

因此，类与对象之间首先建立的是：

类 → 对象

例如：

苹果类
↓
苹果01
苹果02
苹果03

这里：

苹果类 = 抽象类别结构
苹果01 = 具体对象
苹果02 = 具体对象
苹果03 = 具体对象

类并不是现实世界中的某一个苹果，而是机器对“苹果这一类对象”的结构性定义。

对象则是现实世界中具体存在的个体。

因此可以表示：

Object ∈ Class

其中：

• Object 表示对象；
• Class 表示对象所属的类；
• ∈ 表示对象属于某个类。

例如：

苹果01 ∈ 苹果类
苹果02 ∈ 苹果类
苹果03 ∈ 苹果类

多个对象可以属于同一个类：

          苹果类
       ↙    ↓    ↘
    苹果01 苹果02 苹果03

这构成机器世界中最基本的分类结构。

---

4.3 类是结构，对象是实例

类和对象最大的区别，在于二者所处的抽象层次不同。

类主要描述：

对象应该具有什么结构

对象主要描述：

这个具体对象实际上具有什么内容

例如：

鸡蛋类
├── 颜色
├── 重量
├── 尺寸
├── 形状
└── 状态

实例化以后：

鸡蛋01
├── 颜色：白色
├── 重量：52g
├── 尺寸：中等
├── 形状：椭圆
└── 状态：完整、生

因此：

类 → 规定结构
对象 → 填充结构

可以进一步表示：

ClassStructure → ObjectInstance

其中：

• ClassStructure 表示类结构；
• ObjectInstance 表示对象实例。

这意味着，类不是对象数据的简单复制，而是对象结构的来源。

---

4.4 对象 → 属性

对象建立以后，需要进一步描述对象自身的特征。

因此形成：

对象 → 属性

**属性（Attribute）**是描述对象特征、性质或参数的数据结构。

例如：

苹果01
├── 颜色：红色
├── 重量：180g
├── 直径：8cm
└── 成熟度：成熟

其中：

苹果01 → 颜色 → 红色
苹果01 → 重量 → 180g
苹果01 → 直径 → 8cm

对象是属性的承载者。

因此：

类
↓
定义属性结构
↓
对象
↓
保存属性值

例如：

苹果类
├── 颜色
├── 重量
└── 尺寸

实例化：

苹果01
├── 颜色：红
├── 重量：180g
└── 尺寸：8cm

苹果类中的“重量”是结构定义，而苹果01中的“180g”是具体实例值。

所以：

类定义属性，实例保存属性值。

这一区分对于机器知识结构非常重要。

---

4.5 对象 → 状态

对象不仅具有属性，还具有当前状态。

因此形成第二个基本结构：

对象 → 状态

**状态（State）**是对象在特定时间条件下所处的动态条件。

例如：

鸡蛋01
├── 颜色：白色
├── 重量：52g
└── 状态：完整

经过动作：

鸡蛋01
↓
打破
↓
状态改变

变成：

鸡蛋01
├── 颜色：白色
├── 重量：52g
└── 状态：破损

这里需要注意：

状态发生变化，并不意味着对象所属的基础类发生变化。

仍然是：

鸡蛋01 ∈ 鸡蛋类

只是：

状态(t) → 状态(t+1)

因此：

对象身份
↓
保持连续

对象状态
↓
可以动态变化

这进一步确定了：

基础类 → 相对稳定
对象 → 持续存在
属性 → 可以变化
状态 → 动态变化

---

4.6 类与对象的实例关系

类与对象之间最基本、最直接的关系是：

实例关系（Instance Relationship）。

实例关系表示：

某一个具体对象是某个类的实例。

例如：

苹果类
↓ 实例化
苹果01

可以表示：

苹果01 → instanceOf → 苹果类

其中：

• 苹果01是对象；
• 苹果类是基础类；
• instanceOf 表示“是……的实例”。

多个对象可以同时属于同一个类：

苹果类
├── instanceOf ← 苹果01
├── instanceOf ← 苹果02
└── instanceOf ← 苹果03

实例关系的方向从概念上可以理解为：

对象 → 所属类

或者：

类 → 对象实例集合

二者表达的是同一个结构的两个观察方向。

---

4.7 类与对象的继承关系

这里必须对“继承”和“实例”进行严格区分。

**继承（Inheritance）**发生在类与类之间。

**实例（Instantiation）**发生在类与对象之间。

因此：

类 → 类

可以形成继承关系：

动物类
↓
鸟类
↓
鹰类

而：

类 → 对象

形成实例关系：

鸟类
↓
鸟01

所以：

继承关系：
父类 → 子类

实例关系：
类 → 对象

两种关系不能混淆。

例如：

动物类
↓ 继承
鸟类
↓ 继承
鹰类
↓ 实例化
鹰01

这里存在三个不同层次：

动物类 → 鸟类 → 鹰类

属于类之间的继承结构；

鹰类 → 鹰01

属于类与对象之间的实例结构。

因此可以形成：

父类
↓
子类
↓
对象实例

---

4.8 继承结构的意义

继承使机器能够把不同类别组织成层级结构。

例如：

动物类
├── 人类
├── 鸟类
├── 鱼类
└── 哺乳动物类

进一步：

鸟类
├── 鸽子类
├── 鸡类
└── 鹰类

这种结构使机器能够获得从一般到特殊的结构关系。

例如：

动物类
↓
鸟类
↓
鸡类
↓
鸡01

机器可以理解：

鸡01
属于鸡类
鸡类
属于鸟类
鸟类
属于动物类

因此形成：

鸡01 → 鸡类 → 鸟类 → 动物类

这是从对象向上追溯类别结构的一条认知路径。

反方向则是：

动物类 → 鸟类 → 鸡类 → 鸡01

这是从抽象类别向具体对象展开的一条结构路径。

---

4.9 继承与对象属性

继承关系还能够形成属性结构的继承。

例如：

动物类
├── 生命状态
├── 位置
└── 移动能力

鸟类
├── 羽毛
├── 翅膀
└── 飞行能力

鸡类
├── 鸡冠
└── 蛋生产能力

鸡类可以获得来自上层类别的部分结构，同时增加自身结构。

因此：

动物类
↓
鸟类
↓
鸡类

可以形成结构继承：

动物类结构
+
鸟类扩展结构
+
鸡类扩展结构

最终：

鸡类
↓
鸡01

鸡01获得的是已经组织完成的类结构在具体对象上的实例化结果。

因此：

继承负责类结构的纵向组织，实例关系负责类结构向具体对象的横向展开。

---

4.10 类结构与对象结构

类结构可以看作对象结构的抽象模板。

例如：

类结构：

鸡蛋类
├── 属性
│   ├── 颜色
│   ├── 重量
│   └── 尺寸
├── 状态
│   ├── 完整
│   ├── 破损
│   ├── 生
│   └── 熟
└── 方法
    ├── 加热
    └── 处理

对象结构：

鸡蛋01
├── 属性
│   ├── 颜色：白色
│   ├── 重量：52g
│   └── 尺寸：中等
├── 状态
│   ├── 完整
│   └── 生
└── 当前关系
    └── 位于：桌面01

类结构与对象结构存在对应关系：

类属性 → 对象属性值
类状态定义 → 对象当前状态
类方法 → 对象可执行处理
类关系定义 → 对象实际关系

这形成：

类结构 → 实例化 → 对象结构

---

4.11 类结构与现实结构的对应

机器认识现实世界，不能停留在抽象类别层面。

机器必须建立：

机器类结构 ↔ 现实对象结构

例如现实世界中存在：

现实世界
↓
一只鸡
↓
鸡蛋
↓
锅
↓
炉具

机器可以建立：

鸡类
鸡蛋类
锅类
炉具类

然后将现实对象映射进去：

鸡01 → 鸡类
鸡蛋01 → 鸡蛋类
锅01 → 锅类
炉具01 → 炉具类

进一步建立现实关系：

鸡01
↓ 产生
鸡蛋01

鸡蛋01
↓ 放入
锅01

锅01
↓ 位于
炉具01

于是机器内部形成：

类结构
↓
对象结构
↓
对象关系
↓
现实场景

这就是类结构与现实结构之间的对应。

---

4.12 结构对应不是简单复制

类结构与现实结构之间的对应，不是把现实世界简单复制到机器数据库中。

机器需要完成的是：

现实对象
↓
识别结构
↓
确定类别
↓
建立对象实例
↓
提取属性
↓
确定状态
↓
建立关系
↓
形成场景结构

例如机器感知到一个物体：

颜色：白
形状：椭圆
尺寸：中等
位置：桌面

机器首先获得的是感知结构，而不是直接获得“鸡蛋01”。

经过类结构匹配：

感知结构
↓
属性匹配
↓
形状匹配
↓
类别匹配
↓
鸡蛋类

然后建立对象：

鸡蛋类
↓
鸡蛋01

再继续建立：

鸡蛋01
├── 属性
├── 状态
├── 位置
└── 对象关系

因此：

类结构是机器对现实对象进行结构化认知的基础，而对象实例是类结构与现实个体之间的连接点。

---

4.13 类结构、对象结构与现实结构的三层对应

可以把整个结构分成三个层次。

第一层：类结构

鸡蛋类
├── 属性结构
├── 状态结构
├── 方法结构
└── 关系结构

第二层：对象结构

鸡蛋01
├── 属性值
├── 当前状态
├── 当前关系
└── 当前参数

第三层：现实结构

现实中的鸡蛋
├── 实际位置
├── 实际温度
├── 实际重量
├── 实际状态
└── 与其他物体的实际关系

三者之间形成：

类结构
↓
对象结构
↓
现实结构

同时也可以从现实向机器反向建立：

现实结构
↓
感知
↓
对象结构
↓
类匹配
↓
类结构

因此，机器世界结构不是单向生成，而是存在双向映射：

类结构
↓
对象结构
↓
现实结构

现实结构
↓
对象识别
↓
对象结构
↓
类结构匹配

---

4.14 类—对象结构关系的统一模型

经过前面的分析，可以建立完整结构：

世界
↓
基础类
↓
类结构
↓
对象实例
↓
对象属性
↓
对象状态
↓
对象关系
↓
现实场景

其中：

基础类 → 稳定分类
继承 → 类结构组织
实例 → 类到对象的映射
属性 → 对象特征
状态 → 对象动态条件
关系 → 对象之间连接
场景 → 对象结构整体

进一步形成：

类
↓
继承
↓
子类
↓
实例化
↓
对象
↓
属性 / 状态 / 关系
↓
场景

这是机器世界结构的基本骨架。

---

4.15 类关系与对象关系的层次区分

还需要进一步明确：

类关系不等于对象关系。

例如：

人类
↓ 使用
手机类

这是类层面的结构关系。

现实中：

张三
↓ 使用
手机01

则是对象层面的现实关系。

二者对应为：

类层：
人类 → 使用 → 手机类

对象层：
张三 → 使用 → 手机01

类关系提供可能的结构范围，对象关系提供现实中的具体实例。

因此：

类关系
↓
定义可能结构
↓
对象关系
↓
表现现实结构

但对象关系并不一定机械地复制类关系，它还必须受到当前场景、对象状态和现实条件的约束。

这为后续的关系理论和认知匹配理论留下了基础。

---

4.16 类结构与现实结构的动态对应

现实世界不是静态的，因此类结构与现实结构之间的对应也不是一次完成以后永久不变。

例如：

锅01
↓
空锅

经过动作：

加入鸡蛋

形成：

锅01
↓
包含鸡蛋01

继续：

加入西红柿01

形成：

锅01
├── 鸡蛋01
└── 西红柿01

此时基础类没有发生变化：

锅类
鸡蛋类
西红柿类

变化的是对象之间的现实结构：

锅01
↓ 包含
鸡蛋01

锅01
↓ 包含
西红柿01

进一步，随着烹饪行为发生：

对象状态变化
↓
关系变化
↓
场景变化
↓
认知变化

因此：

基础类可以保持稳定，而对象结构和现实场景可以持续动态变化。

---

4.17 对机器认知的意义

类—对象结构关系为机器认知提供了一个基本结构框架。

机器面对现实世界时，不应该只进行：

感知 → 分类 → 输出

而应该逐步建立：

感知
↓
对象发现
↓
类匹配
↓
对象实例
↓
属性
↓
状态
↓
关系
↓
场景
↓
认知

这样机器得到的不是孤立标签，而是一个具有结构的对象。

例如机器看到一个鸡蛋，不应该只得到：

鸡蛋 = 1

而应该形成：

鸡蛋01
├── 类：鸡蛋类
├── 属性：白色、52g、椭圆
├── 状态：完整、生
├── 位置：桌面01
└── 关系：靠近机械臂01

这时机器才真正获得了一个可以进入后续认知计算的对象结构。

---

4.18 工程映射

从理论结构映射到工程系统，可以建立：

ClassDefinition
↓
ClassInheritance
↓
ObjectInstance
↓
ObjectAttribute
↓
ObjectState
↓
ObjectRelation
↓
Scene

对应的数据结构可以表示为：

ClassDefinition
{
    id
    name
    parent_id
    attributes
    states
    methods
}

对象：

ObjectInstance
{
    id
    class_id
    attributes
    states
    relations
}

实例关系：

ObjectInstance.class_id
        ↓
ClassDefinition.id

继承关系：

ClassDefinition.parent_id
        ↓
ParentClass.id

因此，工程系统中可以明确区分：

class.parent_id

表示：

类 → 父类

而：

object.class_id

表示：

对象 → 所属类

这两个字段虽然都建立结构连接，但表达的不是同一种关系。

---

4.19 类—对象结构的运行模型

机器运行过程中，可以形成：

现实世界
↓
感知数据
↓
对象候选
↓
对象实例建立
↓
类结构匹配
↓
属性绑定
↓
状态建立
↓
关系建立
↓
场景形成
↓
认知

如果对象发生变化：

动作
↓
对象变化
↓
属性更新
↓
状态更新
↓
关系更新
↓
场景更新
↓
重新认知

整个过程形成：

类结构
↓
对象实例
↓
现实场景
↓
动态变化
↓
对象更新
↓
再认知

由此，类与对象不再是静态的程序设计概念，而成为机器世界模型中的两个基础层次。

---

4.20 本章总结

本章建立了类与对象之间的基本结构关系。

首先，类是抽象结构，对象是具体实例：

类 → 对象

其次，对象承载具体属性和当前状态：

对象 → 属性
对象 → 状态

再次，继承关系与实例关系必须严格区分：

类 → 类

表示继承结构；

类 → 对象

表示实例结构。

进一步，类结构能够向对象结构映射，对象结构又能够对应现实世界中的具体结构：

类结构
↓
对象结构
↓
现实结构

同时，机器也可以从现实世界反向建立结构：

现实结构
↓
感知
↓
对象结构
↓
类匹配
↓
类结构

因此，本章最终建立如下统一模型：

世界
↓
基础类
↓
类结构
↓
继承结构
↓
对象实例
↓
对象属性
↓
对象状态
↓
对象关系
↓
现实场景
↓
动态变化
↓
再认知

本章最核心的理论结论是：

类是现实世界对象结构的抽象定义，对象是类结构在现实个体上的实例化表现，属性和状态描述对象的具体内容，继承负责类结构之间的组织，实例关系负责类结构与具体对象之间的连接，而类结构与对象结构共同构成机器对现实世界进行结构化表示的基础。

由此，机器世界不再只是由孤立的“类”和“对象”组成，而是形成了一个具有层次性的结构体系：

类 → 子类 → 对象 → 属性 → 状态 → 关系 → 场景。

下一步需要进一步研究的是：这些对象之间究竟如何建立关系，以及对象关系如何从静态连接发展为动态场景结构。