正向建模：具体 → 抽象 → 模型
正向建模回答「模型从哪里来」。第一次遇到一类问题时，我们不是直接拿到模型，而是先看到很多具体事物，观察、比较、提取共同结构，最后抽象成模型。这是所有知识的产生方式——循环、函数、分层、系统，都是从具体例子里长出来的。
一、模型不是凭空发明的
教材常直接给出定义：「循环 = 对某个状态反复执行某种操作」。但第一次学习时，我们看到的不是定义，而是具体的东西：
1
2
3
4
| 例子 1：打印 1、2、3、4、5
例子 2：遍历数组中的每个元素
例子 3：不断读取用户输入，直到输入 q
例子 4：游戏主循环（更新 → 碰撞检测 → 渲染 → 更新 → ...）
|
这些例子看起来完全不同。但观察久了会发现共同结构：
1
2
3
4
5
6
7
8
9
| 具体程序
↓
重复行为
↓
循环结构
↓
for / while / loop
↓
「循环」模型
|
模型是从具体例子里抽象出来的，不是先有定义再有例子。
二、正向建模的四个步骤
1
2
3
4
5
6
7
8
| 具体事物
↓ ① 观察：看到了什么
多个例子
↓ ② 比较：有什么相同
共同结构
↓ ③ 抽象：把共同点提炼出来
模型
↓ ④ 命名：给它一个名字，可以复用了
|
以「循环」为例：
1
2
3
4
| ① 观察：打印 1~5、遍历数组、读输入直到 q、游戏主循环
② 比较：都有「重复执行某个过程」
③ 抽象：重复执行 = 循环结构
④ 命名：for / while / loop
|
以「函数」为例：
1
2
3
4
| ① 观察：多处需要同样的加法、同样的读取、同样的格式化
② 比较：都是「一段逻辑被多处调用」
③ 抽象：跳过去执行再跳回来
④ 命名：函数 / CALL / RET
|
三、从指令到系统就是正向建模的完整实例
主线「从指令到系统」的每一步，都是正向建模：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| 顺序执行 + 判断跳转
↓ 观察：程序需要根据情况选择不同处理
↓ 抽象
if-else 模型
多个重复步骤
↓ 观察：反复做同一件事
↓ 抽象
循环模型
多段可复用逻辑
↓ 观察：多处需要同一段逻辑
↓ 抽象
函数模型
main 膨胀
↓ 观察：职责混在一起
↓ 抽象
分层模型 / 模块模型 / 系统模型
|
主线的每一步都是「具体 → 抽象 → 模型」——概念不是某天被发明的，是从具体程序的「扛不住」里长出来的。
四、正向建模的产物：知识体系
多次正向建模后，模型之间形成结构：
1
2
3
4
5
6
7
8
9
10
| 模型 M1（函数）
├── 应用 A
├── 应用 B
└── 边界：M1 解释不了什么
↓
模型 M2（文件）
├── 应用 C
└── 边界
↓
模型 M3（分层）……
|
这就是知识体系——模型为什么递进、依赖、扩展，背后有原因：
1
2
3
4
| M2 为什么在 M1 基础上产生？
哪些问题 M1 能解释？
哪些解释不了？
为什么必须扩大模型？
|
知识体系 = 模型演化的结构。 正向建模产生了模型，也产生了模型之间的关系。
五、正向建模的陷阱
1
2
3
4
5
6
7
8
9
10
| ❌ 只观察不抽象：看到一堆例子，提取不出共同结构
→ 每个例子单独记忆，无法复用
❌ 过早抽象：例子还不够就急着下定义
→ 模型太粗糙，解释不了新例子
❌ 把例子当模型：记住「打印 1~5」的代码，没提炼出「循环」
→ 换个场景就不会了
✅ 足够多的例子 + 找到共同结构 + 抽象 + 命名
|
六、和其他内容的关系
1
2
3
4
5
6
7
8
9
10
11
12
| 正向建模 ←→ 从指令到系统
主线是正向建模在软件组织的完整实例
正向建模 ←→ 拆解与组织
正向建模的第一步是拆解：把具体事物拆开看结构
抽象 = 从拆开的零件里提取共同结构
正向建模 ←→ 领域对象分析
领域对象分析 = 从业务现实里正向抽象出对象模型
正向建模 ←→ 认知与语言主题（09，01 认知语言智能）
语言理解的前半段（语言 → 概念 → 结构）是正向建模
|
收束
1
2
3
4
5
6
7
8
9
10
| 模型不是凭空发明的，是从具体例子里长出来的
四步：观察 → 比较 → 抽象 → 命名
从指令到系统 = 正向建模的完整实例
每一步都是「具体 → 抽象 → 模型」
多次正向建模 → 模型之间形成知识体系
陷阱：只观察不抽象 / 过早抽象 / 把例子当模型
|
正向建模是知识的产生方式。 先看具体，再找共同结构，最后形成可复用的模型。
