四门课，一个知识库， 点进去就能玩着学 。

TOPIC 2

概念建模

鸦爪互动 · Quiz 4 题 · 5 篇笔记

σ/π 演示 · Quiz 8 题 · AT3 ⚠️ · 5 篇笔记

TOPIC 3

关系模型

互动 ×2 · Quiz 10 题 · 9 篇笔记

TOPIC 4

范式化

互动 ×2 · Quiz 10 题 · 5 篇笔记

TOPIC 5

逻辑建模

互动 ×2 · Quiz 10 题 · 7 篇笔记

TOPIC 6

建库与改库

互动 ×2 · Quiz 10 题 · 5 篇笔记

TOPIC 7

DML 与事务

CHEAT SHEET

一页速记考前 5 分钟

规则

100% 平时分：AT×10 + Test 30 + Ass 60
GitLab 每周 push（main 分支）
AT3 8/17 = Ass1 硬前置

ER 建模

四阶段：需求→概念(技术无关)→逻辑(DB类型)→物理(DBMS)
每端标 (min, max)：外侧 min、贴实体 max
|=1　o=0　<=多；站在对面读；must→min=1, may→min=0
M:N 保留；带属性才拆（桥接实体）
概念层无外键，只有关系线；禁 surrogate key
弱实体借父键（实线）；不多不少：brief 为准

W1 概念

DBMS = 数据前面的管家
data → 处理 → information；metadata = 数据的数据
四宗罪：冗余不一致/程序绑死/信息孤岛/开发慢难报表
进化史：文件→层次/网状→关系→OO→XML→NoSQL

🗄️ 完整笔记（Complete Notes）（10 题自测 + ER 画图练习）→

← 返回门户

FIT9137 · Computer Architecture & Networks

Comp Arch 知识库

Computer Architecture & Networks。W1 数制与逻辑 → W2 MARIE CPU → W3 操作系统。分数都在手算里，步进器把手感练进肌肉。

WEEK 1

数制与逻辑

步进器 ×2 · Quiz 5 题 · 4 篇笔记

WEEK 2

MARIE CPU

取指演示 · Quiz 4 题 · 4 篇笔记

动画学堂 7 关 · Quiz 10 题 · 9 篇笔记

WEEK 3

内存设计与管理

动画学堂 8 关 · Quiz 10 题 · 8 篇笔记

WEEK 4

I/O 与进程管理

动画学堂 7 关 · Quiz 10 题 · 5 篇笔记

WEEK 5

文件管理

互动 ×3 · Quiz 10 题 · 3 篇笔记

WEEK 6

计算机网络导论

🌐 完整笔记（Complete Notes）（手算自查 + 11 题自测）→

CHEAT SHEET

一页速记考前 5 分钟

数制

十→二：除 2 取余，从下往上读
二→十：位权 1,2,4,8,16,32,64,128 乘加
二↔十六：4 位一组查表；A=1010 F=1111
十六↔十：位权 1,16,256 / 除 16 取余
ASCII：'0'=48 'A'=65 'a'=97；'5'=53 ≠ 5

逻辑

XOR = 不同才 1 = A·B̄ + Ā·B
德摩根：取反时 AND↔OR 互换
吸收律 Ā+AB = Ā+B；互补律 A+Ā = 1
化简套路：德摩根→提公因式→互补律

补码

求负数/读负数：翻转 + 1
全 1 = −1；1000…0 = 最小值
溢出 = 正+正=负或负+负=正；进位丢弃正常
8-bit 范围 −128 ~ +127

MARIE

16 位指令 = 4 opcode + 12 地址 → 4096 字
Fetch：MAR←PC → MBR←M[MAR] → IR←MBR → PC+1
1 Load 2 Store 3 Add 4 Subt 7 Halt 8 Skipcond 9 Jump
Load 装的是内容；Skipcond 是跳过下一条

← 返回 FIT9131 互动页

FIT9131 · 完整笔记 · Complete Notes（冲刺包 + 10 题自测 + 补课路径）

FIT9131 W1–W2 完整笔记

Synced with the Obsidian vault. 折叠块「▸ ✅ 参考答案」先自己做再点开；手机上离线也能读。

← 返回 FIT9131 互动页

← 返回 FIT9136 互动页

FIT9136 · 完整笔记 · Complete Notes（10 题自测 + µWordle 收官）

FIT9136 W1–W2 完整笔记

Synced with the Obsidian vault. 折叠块「▸ ✅ 参考答案」先自己做再点开；手机上离线也能读。

← 返回 FIT9136 互动页

← 返回 FIT9132 互动页

FIT9132 · 完整笔记 · Complete Notes（10 题自测 + ER 画图练习）

FIT9132 W1-W2 完整笔记

Synced with the Obsidian vault. 折叠块「▸ ✅ 参考答案」先自己做再点开；手机上离线也能读。

← 返回 FIT9132 互动页

← 返回 FIT9137 互动页

FIT9137 · 完整笔记 · Complete Notes（手算自查 + 11 题自测）

FIT9137 W1-W2 完整笔记

Synced with the Obsidian vault. 折叠块「▸ ✅ 参考答案」先自己做再点开；手机上离线也能读。

← 返回 FIT9137 互动页

✏️ 返回 FIT9131 主页做本周 Quiz →

FIT9131 · 1 篇笔记连贯阅读

Week 0 · 起步

FIT9131 · 7 篇笔记连贯阅读

Week 1 · 语言与基本积木

LESSON 1.1

History & Languages编程语言金字塔（点每一层）

互动 · 语言金字塔（越往上越像人话）

4GL / 5GL第四/五代语言

High-level · Java ☕高级语言（本课）

Assembler · LDA / STA汇编语言（助记符）

Machine · 0110 1011机器语言（纯二进制）

▲ 好读好写 · 控制力弱难读难写 · 控制力强 ▼

👆 点一层试试。另外记三个词：syntax（语法规则）、paradigm（范式——Java 用 object-oriented）、bug（1947 年真有一只飞蛾卡进继电器）。

LESSON 1.2

Classes & Objects类是模具，对象是饼干

class（类）是模板，object（对象）是它的 instance（实例）。连按几次 new Cookie()，观察每块饼干什么相同、什么不同。

互动 · 饼干工厂（instantiate 实例化）

class Cookie（模具）

flavour : String　// 口味
size : int　// 尺寸(cm)
eaten : boolean　// 被吃了吗
bake() // 行为
eat() // 行为

每个对象的属性名单相同（同一个类），但属性值可以不同——这组值就是 state（状态）；属性全同的两个对象仍有不同的 identity（标识）。

冷知识（考过）"减小代码体积"不是 OOP 的优点——OOP 程序反而更大，它换来的是复用、易维护、封装安全。abstraction（抽象）= 只挑对当前应用有用的属性。

LESSON 1.3

Compile & Execute编译与执行：Java 的两段旅程

compiler 一次性翻译整个程序，interpreter 逐句翻译——Java 两个都用：先 javac 编译成 bytecode（字节码，跨平台），再由 JVM 解释执行。这就是 "Write Once, Run Anywhere"。

互动 · 编译流水线（点按钮推进）

📄Train.java

source code

源代码

➜

⚙️javac

compiler

编译器

➜

🧊Train.class

bytecode

字节码

➜

🖥️JVM

java Train

虚拟机解释

➜

✨output

machine code

运行结果

高频陷阱编译带完整文件名：javac Train.java；运行只写类名：java Train（带 .class 是经典错误）。编译成功无输出；有语法错误不生成 .class。另：public 类名必须与文件名完全一致（含大小写）——class Train ↔ Train.java。节奏：Writing → Compiling → Debugging → Executing。

LESSON 1.4

Variables & Types变量、类型、语句与表达式

int

整数（不能带小数点）

int age = 25;

double

小数

double rate = 5.75;

char

单个字符 · 单引号

char grade = 'A';

boolean

真/假 · 不加引号

boolean ok = true;

String

文本 · 双引号 · 是类（大写 S）

String name = "Daniel";

必考口诀单引号 char、双引号 String、true/false 光着写、整数别带点。还有：int / int 截断（13/5=2）；5 % 8 = 5；有一个 double 全升 double。
char 本质是数（ASCII）：'A'=65、'a'=97，参与运算按数值：'h'(104) + 20 = 124。+ 碰到 String 就变拼接且从左到右："" + 3 + 5 → "35"（(3 + 5) + "" 才是 "8"）。

互动 · 变量 = 内存盒子（按顺序点）

声明 = 贴了类型标签的空盒子；初始化 = 放进第一个值。只声明没赋值 ≠ definition（定义）——W1 原题。另记：statement（语句）以分号结尾；expression（表达式）能求出一个值；1 = x; 非法（= 只能把右边存进左边）。

互动 · 表达式求值器（precedence 优先级）

规则：括号 > * / % > + -；同级从左到右。已知 a=5, b=3, c=7, d=4, e=2：

W1 · WORKSHOP + APPLIED

First Program & Ed第一个程序、Ed 平台规矩与读报错

Lesson 是"看懂"，Workshop / Applied 是"上手"。W1 实操只要求三件事：在 Ed 里跑通第一个程序、养成 incremental coding（增量式编码）的习惯、看懂编译报错。

第一个程序的完整流程（必须亲手走一遍）

// ① 新建文件 HelloWorld.java（文件名必须 = 类名，含大小写）
// ② 终端进入文件夹：cd Week1
// ③ 编译（成功 = 无输出 + 多出 HelloWorld.class）：javac HelloWorld.java
// ④ 运行（只写类名，不带 .class）：java HelloWorld

incremental coding（增量式编码）：每写一小块就编译一次——错误必然出在刚加的几行里。Ed 不是专业 IDE，这个习惯能省大量调试时间。

互动 · 编译报错翻译器（点一条报错）

读报错三要素：文件名 + 行号 + 描述。先看行号跳过去，再对照描述。

Ed Workspace 三条规矩（关系到分）① 教学团队建的工作区不得重命名/删除（评分用它）；② 保持私有——公开可能构成 collusion（合谋作弊）；③ 文件/文件夹名不要有空格。

WEEK 1 QUIZ

Week 1 Quiz7 题 · 英文原题风格

FIT9131 · 8 篇笔记连贯阅读

Week 2 · 类与对象

LESSON 2.1

Defining Classes类的三大件：固定顺序，点图例点亮

互动 · 类的解剖图

public class WelcomeUser
{
    // 1️⃣ field：类内、方法外；一律 private；声明时不初始化
    private String username;

    // 2️⃣ 无参构造器：给默认值（与类同名、无返回类型！）
    public WelcomeUser()
    {
        username = "John Doe";
    }

    // 2️⃣ 有参构造器：用传入值（形参加 new 前缀防重名）
    public WelcomeUser(String newName)
    {
        username = newName;
    }

    // 3️⃣ accessor（get）：无形参，返回字段类型
    public String getUserName()
    {
        return username;
    }

    // 3️⃣ mutator（set）：收一个形参，返回 void
    public void setUserName(String newUser)
    {
        username = newUser;
    }
}

构造器三条铁律① 与类名完全同名（含大小写）；② 无返回类型——写了 void 就变成普通方法且不报错；③ 通常 public。字段一律 private（encapsulation 封装），本课禁止省略修饰符。

get / set 对称美get 像查余额（无形参、有返回值）；set 像存钱（有形参、返回 void）。注意：mutator 不一定叫 setXxx——insertMoney(int amount) 改了字段 balance，它就是 mutator（看是否改字段，不看名字）。method signature = 名字 + 形参表（不含返回类型）；同名不同签名 = overloading 重载；仅返回类型不同 = 编译错误。main 必背：public static void main(String[] args)。

LESSON 2.2 / 2.3

Objects at Work对象的一生：遮蔽陷阱与两种传递

实例化必背：Car objCar = new Car("Blue");——new 创建对象 + 执行签名匹配的构造器。三种变量：field（与对象共存亡）、parameter（方法执行期间）、local variable（声明行到块尾）。

互动 · 压轴陷阱：setter 遮蔽（步进器）

public class Car {
    private String color;
    public Car(String newColor) { color = newColor; }
    public void setColor(String color)
    { color = color; }   // ← 问题就在这
    // main 里：
    Car objCar = new Car("Blue");
    objCar.setColor("Yellow");
    System.out.println(objCar.getColor());

field 字段

?

color

parameter 形参

（未创建）

color

点「下一步」，跟着程序走一遍，看颜色到底变没变。

互动 · pass by value vs pass by reference

null 空引用null = 空白的收货地址纸条——纸条存在，按它敲门必崩（NullPointerException）。只能赋给对象类型。this = 我自己的字段（化解遮蔽），首选还是形参改名（newColor）。

W2 · WORKSHOP + APPLIED

Class Diagrams & Tricks类图判读、Clock 技巧与 Rolling Project

W2 实操两大件：把 class diagram（类图）翻译成代码（Workshop 的 Coffee 类全流程），以及在真代码里辨认术语（Applied 的 TicketMachine 17 连认）。下面这张类图，每一行都能点：

互动 · 类图判读器（点每一行，练辨认）

TicketMachine

− price : int

− balance : int

+ TicketMachine()

+ TicketMachine(int)

+ getBalance() : int

+ insertMoney(int) : void

类图三段式：上格类名、中格字段（− 名字 : 类型）、下格方法（+ 名字(参数类型) : 返回类型）。+ = public、− = private、# = protected。

Clock / NumberDisplay 两招（Applied 原题）① 补零显示：n / 10 取十位、n % 10 取个位；② 计数器到顶自动归零：value = (value + 1) % limit;——59 → 0，完全不用 if。

Rolling Project Part 1（必须完成）照类图写 Unit / Student / Enrolment 三个类。它每周递增——这周掉队，下周的 Part 2 直接卡死，而且与作业直接相关。已排进你周六上午的实操块。

WEEK 2 QUIZ

Week 2 Quiz7 题 · 构造器、签名与类图

FIT9131 · 8 篇笔记连贯阅读

Week 3 · 运算符、选择与输入输出

🎮 Truth Lab — logical operators（逻辑运算符实验台）

点按切换 a / b 的真假，观察每个表达式实时变化。优先级：! > && > ||。

INTERACTIVE · NEW

Selection Tracer选一个 x，看代码走哪条路

互动 · if / else if / else 走线器

if (x > 10)
{  System.out.println("big");  }
else if (x > 5)
{  System.out.println("medium");  }
else
{  System.out.println("small");  }

链式条件从上到下，只走第一个为 true 的分支——和 Python 的 if/elif/else 同一个灵魂，只是穿了花括号的衣服。

✏️ Week 3 Quiz（8 题 · Ed 真题）

FIT9131 · 8 篇笔记连贯阅读

Week 4 · 循环、数组、字符串与对象交互

🎮 Array Inspector — 数组下标实验台

数组 marks = {72, 85, 90, 64, 58}，长度 5。点一个下标，看 marks[i] 会拿到什么——合法下标是 0 … length-1。

先点上面的按钮试试。提示：其中一个会当场爆炸。

✏️ Week 4 Quiz（12 题 · Ed 真题）

FIT9131 · 6 篇笔记连贯阅读

Week 5 · 文档与类库

🎮 Random Range Lab — Math.random() 范围公式实验台

Math.random() 只会给 0 ≤ x < 1 的 double。要得到 min … max 的整数，公式是 (int)(Math.random() * (max − min + 1) + min)：乘的是"范围里有几个数"，加的是"起点"。选一个范围，抽 30 次，看 min 和 max 有没有都被抽到、有没有越界。

int n = (int)(Math.random() * 6 + 1);   // 乘 6（1…6 共 6 个数），加 1（起点）

点「抽 30 次」。好的随机数测试 = 范围内每个数都可能出现，范围外一个都不能出现。

✏️ Week 5 Quiz（9 题 · Ed 真题）

FIT9131 · 6 篇笔记连贯阅读

Week 6 · 集合与调试

🎮 ArrayList 试验台 —— add / get / remove 亲手跑一遍，看索引怎么塌下来

array{数组} 是出厂就固定 12 格的鸡蛋托盘，ArrayList 是想放几件放几件的购物袋。下面这个列表是真的：每点一次 chip 就执行一条 Java 语句，索引条会立刻重画。重点盯住 remove 之后后面元素的索引全部 −1 ——这是本周最容易踩的坑。

点上面任意一个方法。array 用 [] 和 .length（属性，没括号），ArrayList 用 .get(i) 和 .size()（方法，有括号）——写反了直接编译报错。

经典坑 · 边遍历边 remove，为什么会漏删

目标：把 [A, B, B, C, B, D] 里所有的 "B" 删干净。四种写法，只有两种能得到正确结果。先猜再点。

🎮 三类错误诊断台 —— 6 段代码，判断编译 / 运行时 / 逻辑错误

用「寄信」记这三类：编译错误＝信封格式写错，邮局根本不收（程序跑不起来，编译器指着行号骂你）；运行时错误＝寄出去了但地址不存在被退回（能启动，跑到某一行崩掉并打印异常）；逻辑错误＝信顺利送达但你内容写错了（不报错、不崩溃，结果却是错的——最难查）。下面 6 段代码，先自己判断再点按钮。

已诊断 0 / 6　·　答对 0。选一段代码，然后判断它属于哪一类错误。

✏️ Week 6 Quiz（12 题 · Ed 真题）

FIT9131 · 6 篇笔记连贯阅读

Week 7 · 身份、状态与测试

Assignment A · 计分作业 · 禁用 AIFIT9131 Assignment A《Deep Sea Discovery》周五 9/11 23:55 截止，无 extension——Ed 原文写明严禁使用生成式 AI 产出任何材料或内容；所有代码必须在 Ed 的 Assignment A workspace 里逐行敲出，从别处复制粘贴最高扣 20%；W5/W6 两次 check-in 各 5%，W8 口试占该作业 60%，解释不了的代码一分不给。本页的两个互动与 Quiz 只讲 Week 7 的通用概念（identity / equality 与测试方法），不给 Assignment A 的任何实现代码——下面「测试用例设计器」用的是一个与所有计分作业都无关的 Username 练习规格；作业里的名字校验必须完全由你自己在 workspace 内写出。

🎮 == vs equals() 对照台 —— 两个同名 Diver，内存里到底是几个对象

对象变量是两级存储：变量本身（栈上那个小盒子）里装的只是一个地址，对象真正的状态（name / score / isHuman）躺在堆上另一处。所以 == 比的是盒子里的地址（是不是同一个对象 = identity{身份}），equals() 比的才是盒子指向的那堆值（state{状态} 一不一样）。下面每点一个 chip 就执行一条 Java 语句，栈区和堆区会实时重画。按从左到右的顺序点一遍。

栈 · 引用变量（盒子里装的是地址）

堆 · 真正的对象（这里才有状态）

口诀：== 问「你俩是不是同一个人」，equals() 问「你俩长得一不一样」。先点最左边那个 chip 造出第一个对象。

equals() 有没有自己写，结果天差地别

切换下面三个版本的 Diver 类，上面对照台里 d1.equals(d2) 的结果会跟着变——切完回去再点一次那个 chip。

🎮 测试用例设计器 —— 给 Username.setUsername() 设计一套能抓到 bug 的用例

这里用一个与任何计分作业都无关的练习规格（不是 Assignment A）：某网站的 Username 类，用户名必须是 3–12 个字符、必须以字母开头、且不能包含空格。不合法的输入要被拒绝——保持原值 "guest" 不变，更不能让程序崩溃。下面先选一个实现版本，再逐条点候选测试输入，表格会累积「输入 → 期望输出 → 实际行为」。

九条候选输入，按 正常值 / 边界值 / 非法值 / 空值 四类排好了。点一条加一行；也可以先只点两条正常值，看看会发生什么。

测试输入	类别	期望结果	实际行为	判定

✏️ Week 7 Quiz（12 题 · Ed 真题）

FIT9131 · Assignment A · 10% · 截止 2026-09-11 周五 23:55（墨尔本）

Assignment A · 深海探索游戏

六条铁律① 禁 AI——不得用生成式 AI 产出任何与考核相关的内容；
② 全部代码必须在 Ed 的 Assignment A workspace 里写——大段复制粘贴外来代码最多扣 20%；
③ 口试占 60%——解释不了的代码一分不给（批改前可能先删掉你的注释再让你讲），不参加口试 = 整个作业 0 分；
④ W5/W6 有阶段 check-in 各 5%——W5 要给 tutor 看完整的 Diver + Route 类，W6 看完整 Dice 类 + 主类前三个方法，不是 W7 才开工；
⑤ 无 extension——迟交每天扣 5%（含周末），提交的代码必须能编译；
⑥ 主类必须叫 DeepSeaDiscovery.java，另须上传签名 cover sheet PDF；遵守 FIT9131 Coding Standards（Lesson 3.4）。

📅 关键时间线（勾选记录进度）

W5 applied（8/24 那周）：完整 Diver 类 + Route 类给 tutor 检查 — 5%
W6 applied（8/31 那周）：完整 Dice 类 + DeepSeaDiscovery 前三个方法 — 5%
W7 周五 9/11 23:55：Ed workspace 最终提交 + 签名 cover sheet（可多次重交，取最后一次）
W7 applied（9/10 周四）当场跟 TA 约口试时间 → W8 applied 口试（60%）
提交前在 Ed 里点一次 Run 确认能编译（编译不过 = functionality 直接 0 分）

🎤 口试官方说明（W7 Applied 幻灯片 · 60% 全靠这 10 分钟）

硬规则① 必须出席分配给你的口试，否则没资格通过本作业；
② 提交的代码必须能编译——编译不过，program functionality 部分直接 0 分；
③ 全程 Zoom 录像；
④ 禁止字典与翻译工具，现场只能用英文；
⑤ 面试中不会告诉你答得对不对；
⑥ 代码必须是你本人在 Ed workspace 内写的，用生成式 AI 产出作业代码严格禁止；
⑦ 口试时间与地点看邮件，以任课老师通知为准。

形式：约 10 分钟 · 5 个问题。考官问你代码里的某处，你要自己导航到对应的类 / 字段 / 方法，然后讲清楚三件事：它在哪里、它做什么、逻辑怎么运作；之后还会追问，确认你是真懂。可能被要求当场解释或修改代码、讨论设计与编码决策、解释 Week 1–5 的相关概念。

评分期待：自信地在项目里导航 · 用自己的话讲清代码 · 给足细节，不要只把方法名念一遍 · 证明你真的理解自己提交的代码。

❌ 念方法名 vs ✅ 讲清楚（这是拉开分差的地方）

被问「rollDice() 是做什么的？」

❌ Tim 式回答：「它掷骰子。」——等于没答，拿不到分。

✅ Tommy 式回答：「它在 Dice 类里。这个类有 minimumValue 和 maximumValue 两个字段，rollDice() 用 Math.random() 生成 0 到 1 之间的小数，乘以取值范围再取整、加上最小值，返回 1 到 4 之间的整数。我把它放在 Dice 类而不是主类，是因为骰子的取值范围是骰子自己的状态；这样以后要换成 6 面骰，只改这个类就行。」

套路：位置 → 输入 → 逻辑步骤 → 返回什么 → 为什么这样设计。五句话，每题都够用。

课上 Ravish 用 Rolling Project 的代码做了正反两版模拟面试演示（准备充分的 Tommy / 准备不足的 Tim）；你的实际问题会针对你自己的 Assignment A 代码。

你截图的 Moodle Sample 转录 6 题 · 20 分 · 含逐题参考答案与评分点

FIT9131 · Mid-semester Test · 20% · 45 分钟 · 10 题 · 20 分 · 纸笔闭卷

Midterm · 期中备考特训

官方硬信息（Ed 教学团队 #37 / #42 / #35）① 时长 45 分钟 · 共 10 题 · 总分 20 分，占学期总评 20%；
② 纸笔作答（pen and paper）、闭卷——不得带任何书面或电子材料（手机、电脑、笔记、翻译词典等一律不可）；
③ 范围：Week 1–5 全部内容（W1 类型与表达式 / W2 类与对象 / W3 运算符·选择·输入输出·编码规范 / W4 循环·数组·字符串·类图 / W5 文档·类库·Math·StringBuffer）；
④ 入场查 ID——务必带实体或电子学生证；
⑤ ⚠️ Hurdle：测试类（期中 + 期末共 45 分）必须 ≥ 20.25 分（45%），否则总分再高也可能不及格。

你的补考状态正考 9/2（周三 Week 6 workshop）已过，你因病缺考并获批 Special Consideration；SC 结果邮件把新考试日期记为 10-Sep，但教学团队口头答复：补考可能安排在下周（Week 8），具体时间地点尚未确认。⚠️ SC 信原话 "this may be your only opportunity to complete it"——改期基本不批，通知一到就锁死当天行程。持续盯 Monash 邮箱、Moodle 公告与 Ed #59。

🕐 全真模拟（45 分钟计时 · 作答框 · 交卷后逐题自评打分）

真考是纸笔闭卷，最佳练法是拿纸笔手写作答，本页负责计时、出题、对答案。官方不提供样解（Ed #38），下方参考答案由 Claude 依课程规范编写并用本机 JDK 逐段编译实测。

SIM 1 · 45 分钟

官方 Sample 全真模拟

按官方规格全新命题 · 偏重 W3 运算符选择 + W4 循环数组字符串

SIM 2 · 45 分钟

模拟卷 A（10 题 / 20 分）

覆盖面更广 · 含 W5 javadoc/Math/StringBuffer 与 W2 类与对象

SIM 3 · 45 分钟

模拟卷 B（10 题 / 20 分）

✅ 考前清单（勾选会记住）

确认补考时间与地点——看 Ed #59 回复 + Monash 邮箱（Special Consideration 结果信）
带实体或电子学生证（TA 在门口查 ID）+ 笔（纸笔考试，别只带电脑包）
Sim 1 官方 Sample 卷限时做完并自评
Sim 2 模拟卷 A 限时做完并自评
Sim 3 模拟卷 B 限时做完并自评
编码规范四大高频能默背：方法名小写开头 / 运算符两侧空格 / 花括号独占一行 / 方法体缩进一级
能手写：非默认构造器 + Scanner 键盘输入（nextLine 收 + parseInt/parseDouble 转）
能手写：数组遍历（i < length）、字符串倒序遍历（length()-1 → 0）
「抓坏人式」boolean 循环套路：循环内 return false，return true 在循环外

🎯 Hurdle 计算器（算清楚还差多少分）

规则原文（W7 Workshop 幻灯片）本单元用 threshold mark hurdles——总分够 50 不是唯一条件：
① 期中 + 期末合计（45 分池）必须 ≥ 20.25（该池 45%）；
② 周测 + 作业 A + 作业 B合计（55 分池）必须 ≥ 24.75（该池 45%）；
③ 全单元总分必须 ≥ 50；
④ ⚠️ 任一条不满足 → 记 NH 挂科，且最终成绩被压到最高 45 分（即使实际算出来更高）——对 WAM 是双重打击。

输入已知 / 预估得分（留空按 0 算，自动保存）

期中 Mid-Sem / 20
期末 Final / 25
周测 Quizzes / 10
作业 A / 10
作业 B / 35

⚡ 考前 30 分钟速记（W1–W5 全考点浓缩）

W1 · 类型与表达式：整数除法截断（11 / 4 = 2，11 / 4.0 = 2.75）；% 取余，小数除大数余数是自己（7 % 13 = 7）；整数 / 或 % 除以 0 → ArithmeticException（浮点则是 Infinity/NaN）；char 参与算术按 ASCII 值；编译错误 vs 运行时错误要分清。

W2 · 类与对象：默认构造器无参 / 非默认构造器带参；this.字段 = 参数 区分同名；accessor 有返回值无参、mutator 无返回值带参；方法重载 = 同名不同参数列表；局部变量遮蔽字段是经典坑。

W3 · 运算符与选择：优先级 ++/-- → 算术 → 关系 → 逻辑 → 赋值；! > && > ||；同级左结合（a / b % 5 从左往右）；前置先加后用 / 后置先用后加；switch 忘 break 会贯穿 fall-through；if 不写花括号只管下一句；字符串比较用 equals() 不用 ==。

W3 · 编码规范：类名大写开头、方法与变量 camelCase 小写开头；二元运算符两侧留空格；花括号独占一行；每级缩进 4 空格；避免 magic number；方法顶部写注释（Ed #45：是否要 javadoc 题目会明说）。

W4 · 循环与数组：for 次数已知 / while 次数未知 / do-while 保底一次（post-test）；死循环 = 循环体没更新条件变量；循环结束后变量停在「最后一次进门」的值；数组下标 0 到 length−1，length 无括号，越界 → ArrayIndexOutOfBoundsException；对象数组默认 null，对 null 调方法 → NullPointerException。

W4 · 字符串：length() 返回 int、charAt() 返回 char、trim()/substring()/toUpperCase() 返回 String；链式调用「下一个方法必须长在上一步的返回类型上」（s.length().trim() 编译错）；String 不可变。

W5 · 文档与类库：// 行注释、/* */ 块注释、/** */ javadoc（@param / @return）；Java API = 类库说明书，interface（会用）vs implementation（内部实现）；Math.random() 生成 1–n 随机整数写 (int)(Math.random() * n) + 1，还有 Math.abs/pow/sqrt/round/max/min；String 不可变、StringBuffer 可变（append 排队尾、insert(i, x) 占住 i 号位其余右移）。Ed #44：考试允许使用库类方法。

题型对策：追踪题先在草稿纸列变量表逐行走；规范题一行一条「Line X：原因」；意图题一句话就停；写代码题先写方法签名再填循环骨架；填空题从「循环内抓坏人、循环外下结论」反推。

🧭 试卷结构与时间分配（依官方公告 + Sample 反推）

官方：10 题 / 20 分 / 45 分钟 → 平均每题 4.5 分钟、每分 2.25 分钟。Sample 卷已见六种题型：

代码追踪（W1/W3/W4）：给代码问输出，必带 "Briefly explain your answer" —— 只写答案不解释拿不满分
编码规范找错（W3）：给带行号的类，指出 ≥4 处违规并说明理由
说出代码意图（W3/W4）：one short sentence，多写反而丢分
按类图写代码（W2+W3）：非默认构造器 / accessor / mutator + main 里 Scanner 输入造对象
写方法实现算法（W4）：字符串或数组遍历（统计、反转、查找、求最值）
补全代码填空（W3/W4）：循环 + 条件 + return 骨架

时间策略：先扫全卷把追踪题、意图题、填空题这类快分题拿下（约 15 分钟），再攻写代码题（约 20 分钟），最后 10 分钟回头补规范题细节与检查。纸笔考试不能编译——写完在心里跑一遍样例数据。

FIT9131 · 期中全真模拟 · 官方 Sample 转录 · 45 分钟

Sim 1 · 官方 Sample 模拟

FIT9131 · 期中全真模拟 · 模拟卷 A · 10 题 / 20 分 / 45 分钟

Sim 2 · 模拟卷 A

FIT9131 · 期中全真模拟 · 模拟卷 B · 10 题 / 20 分 / 45 分钟

Sim 3 · 模拟卷 B

✏️ 返回 FIT9136 主页做本周 Quiz →

FIT9136 · 2 篇笔记连贯阅读

Week 0 · 起步

FIT9136 · 7 篇笔记连贯阅读

Week 1 · 基本积木

W1 · APPLIED 重点

REPL vs .py File两种运行方式，输出规则完全不同

互动 · 同样四行代码，两种世界

REPL 交互模式（>>>）

>>> 2 + 3

5　← 裸表达式自动回显

>>> x = 5

（赋值不显示任何东西）

>>> x

5　← 裸变量名也回显

>>> print(x)

5

文件模式（python3 demo.py）

2 + 3

（什么都不显示！）

x = 5

（什么都不显示）

x

（什么都不显示！）

print(x)

5　← 唯一的输出

结论一句话：文件里想看到任何东西，必须写 print()。

W1 · PRE-CLASS

Types & Variables三种类型、赋值两步模型

int

integer 整数

17, 0, 1024

float

floating point 浮点数

3.14, 2.0

str

string 字符串（引号包住）

"hello", '17'

互动 · type() 鉴定器

每个 value（值）都有类型，type() 随时查。

互动 · 赋值两步模型（按顺序点）

assignment（赋值）：= 读作"被赋值为"。永远两步：先算完右边，再把名字贴上去。

W1 · PRE-CLASS

Operators除法三兄弟与优先级

互动 · 除法家族实验台

// 与 % 是小学除法两半：7÷3=2 余 1。单位换算万能钥匙：100 分钟 = 100//60 小时零 100%60 分钟。

互动 · 优先级求值器：16 - 2 * 5 // 3 + 1

W1 · 全课第一大坑

The input() Trap亲手掉一次坑再爬出来

互动 · 陷阱机（按顺序点）

用户敲键盘敲进来的永远是字符，所以 input() 只会给你 str。

取整三件套（考过）int(3.9999)=3（向零截断）；四舍五入 int(x+0.5)；round(50.5)=50（银行家舍入，取偶）。

✏️ Week 0–1 Quiz（6 题 · 英文）

FIT9136 · 4 篇笔记连贯阅读

Week 2 · 条件与循环

W2 · PRE-CLASS

Conditionals成绩分流器：只走第一个 True

True/False 大写不带引号；比较用 ==（两个等号）；逻辑运算是英文 and / or / not。Python 靠缩进划代码块——缩进就是语法。

互动 · 点一个分数，看链式条件怎么走

if mark >= 80:　→ "HD"

elif mark >= 70:　→ "D"

elif mark >= 60:　→ "C"

elif mark >= 50:　→ "P"

else:　→ "N"

elif mark >= 70 不用写 <= 79——能走到这行说明 >= 80 已拦走高分。顺序打乱高分会被"截胡"。

三个必考陷阱① number == 5 or 6 永远为真（非零 6 被当真）→ 两边各写完整比较式。② 短路求值：保护条件放 and 左边——num != 0 and total / num > 50。③ = 赋值、== 比较：if x = 5: 直接 SyntaxError（7 = a 同理，= 左边必须是变量名）——秘籍称之为「全课最经典错误」。

W2 · APPLIED 原题

The while Loop翻转比特：亲眼看循环跑完全程

互动 · 循环步进器（Flipping）

binary_string = "0101"
flipped = ""
index = 0
while index < len(binary_string):
    if binary_string[index] == "0":
        flipped = flipped + "1"
    else:
        flipped = flipped + "0"
    index = index + 1
print(flipped)

👇

flipped（累加器，像串珠子）""

index 是"手指"：从 0 号位开始逐格右移（Python 数位置从 0 开始）。

死循环三大来源（必考）① 条件变量从未更新；② while True: 没 break；③ 循环体内重置变量。自查一句："循环体里有哪行能让条件最终变 False？"反过来：条件一开始就是 False，循环体一次都不执行（测验考点）。

flag 模式（课程推荐）found = False → while not found: → 达成时 found = True。input() 放循环体内，别忘 int()（否则 "42"==42 永远 False = 死循环）。对照：break（跳出）= 立即散会、跳出整个循环；continue（跳过）= 跳过本轮剩余代码、回到条件判断——continue 前忘更新变量 = 死循环。

✏️ Week 2 Quiz（5 题 · 英文）

FIT9136 · 5 篇笔记连贯阅读

Week 3 · for 循环与序列

🎮 range() Explorer（range 探测器）

点一个 range 看它真正产出哪些数——半开区间：含 start，不含 stop。

👆 pick one

INTERACTIVE · NEW

for Loop Stepper和 while 步进器同款，看 for 的"自动挡"

互动 · for ch in "ROCK": print(ch)

for ch in "ROCK":
    print(ch)
print("done")

👇

已打印（output）–

对比 while：不用 index、不用 +=1、不会死循环——for 自动把每个字符依次放进 ch。这就是"自动挡"。

✏️ Week 3 Quiz（8 题 · Ed 真题）

FIT9136 · 5 篇笔记连贯阅读

Week 4 · 函数、作用域与字典

🎮 Namespace 探测器（函数作用域）

点一个情景，看函数里的名字到底住在哪个命名空间——记住查找顺序：局部 → 全局 → 内建（LEGB）。

👆 点一个情景

🎮 dict 试验台

按顺序点下面的操作，上面的字典会跟着变——注意哪些操作改字典、哪些只是读。

# 还没创建 d —— 从第一个 chip 开始

👆 从左到右按顺序点，模拟一段真实的操作历史

✏️ Week 4 Quiz（12 题 · Ed 真题）

FIT9136 · 5 篇笔记连贯阅读

Week 5 · 可变性、序列变换与递归

🎮 别名 vs 拷贝试验台（aliasing / cloning）

从左到右按顺序点，下面会显示 a / b / c 此刻各自指向哪个对象。记住本周最核心的一句话：赋值不复制对象，只复制引用——b = a 之后两个名字是同一个列表的两个标签；a[:] 才是真正造一个新列表。点任意一步会自动从头执行到那一步，点错顺序也没关系。

# 还没有任何变量 —— 从第一个 chip 开始

👆 从 a = [1, 2, 3] 开始，一步一步看引用怎么变

🎮 递归调用栈步进器（call stack · base case）

选一个例子，然后用「下一步」看函数怎样一层层压栈（push）、碰到 base case（基准情形）后又怎样一层层回溯（return）。每个方框是一个 frame（栈帧）：最上面的是正在运行的那一层，下面的都在等自己的递归调用算完。

CALL STACK 调用栈（栈顶在上）

OUTPUT 输出

👆 点「下一步」开始压栈

✏️ Week 5 Quiz（12 题 · Ed 真题）

FIT9136 · 4 篇笔记连贯阅读

Week 6 · 文件读写（File I/O）

🎮 文件读写模拟器（open / read / write / append · 文件指针）

左边是磁盘上真实的文件内容，右边是 Python 里执行的语句和它的返回值。按顺序点下面的 chip，重点看两件事：① 每读一次，文件指针（▮）就往后走一段，读过的部分不会再读第二遍；② 从 'r' 换成 'w' 的那一瞬间，文件立刻被清空——这是本周最容易「把数据写没了」的一步。点任意一步会自动从头重放到那一步，点错顺序也没关系。

阶段 A · 'r' 只读

阶段 B · 'w' 写（会清空！）

阶段 C · 'a' 追加

notes.txt · 磁盘上的真实内容

Python · 执行的语句与返回值

👆 从阶段 A 的第一个 chip 开始，一步一步看文件内容和指针怎么变

模式	文件不存在时	文件已存在时	初始指针	能读	能写
`'r'` read	FileNotFoundError	内容完整保留	0（开头）	✓	✗
`'w'` write	新建空文件	内容被全部清空	0（空文件）	✗	✓
`'a'` append	新建空文件	内容完整保留	末尾（EOF）	✗	✓（只在末尾）

🎮 with 语句 vs 手动 close 对照

左边是手动 open / close，右边是 with 语句（context manager，上下文管理器）。一切顺利时两种写法结果一样——差别全在「不顺利」的时候。切换下面四种情况看结局。

手动 open / close

with 语句（推荐写法）

✏️ Week 6 Quiz（12 题 · Ed 真题）

FIT9136 · 4 篇笔记连贯阅读

Week 7 · 模块与库（Modules and Libraries）

🎮 import 四写法对照器（同一个 math_utils.py · 命名空间里到底多了什么）

本周所有 import 题的答案都能用同一句话推出来：不同的 import 写法，往当前文件的命名空间里塞进去的名字是不一样的。下面固定用笔记 7.3 的 math_utils.py，我自己的 main_app.py 里也已经有一个叫 add 的函数（往购物车里加东西）。切换四种写法，重点盯右边那一栏：多出来的是模块对象，还是函数本身？我自己的 add 有没有被顶掉？

被借用的模块 · math_utils.py（全程不变）

# math_utils.py —— 笔记 7.3 的原例
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

main_app.py · 我自己的主程序

这一行之后 · main_app 命名空间里的名字

写法	命名空间多出的名字	绑定的是	正确调用	会顶掉同名的自己人吗
`import math_utils`	`math_utils`	模块对象	`math_utils.add(2, 3)`	不会
`import math_utils as mu`	`mu`（原名失效）	模块对象	`mu.add(2, 3)`	不会
`from math_utils import add`	`add`	函数本身	`add(2, 3)`	会（只顶 add）
`from math_utils import *`	模块里所有公开名字	函数本身（多个）	`add(2, 3)` / `multiply(4, 5)`	会（顶掉哪些看模块）

🎮 主守卫 __name__ 追踪器（同样两个文件 · 两种跑法 · 逐行走一遍）

同样是笔记 7.3／7.4 的那两个文件，一个字都没改。变的只是你在终端敲哪一条命令——而这一件事就决定了 math_utils.py 第 8 行的判断是 True 还是 False。先选跑法，再一步步点「下一步」，盯住中间那两张胸牌（每个文件的 __name__）和最下面的终端输出。

跑法

math_utils.py · 模块

main_app.py · 主程序

终端输出 · stdout

你敲的命令	math_utils 的 __name__	main_app 的 __name__	第 8 行判断	第 9–11 行
`python math_utils.py`	`"__main__"`	根本没被加载	True	执行 · 打印三行测试输出
`python main_app.py`	`"math_utils"`	`"__main__"`	False	整段跳过 · 一个字都不打印

✏️ Week 7 Quiz（12 题 · Ed 真题）

FIT9136 · Assignment 1 · 20% · 截止 2026-09-04 周五 23:55（墨尔本）

Assignment 1 · 地牢求生指南

五条铁律① 只能提交一次——蓝色 Submit 点了就锁死不能改，4 个 Set 全做完再交（左下角 Test 按钮不限次数，随便用）；
② 禁止一切 import——连 import math 都不行（教学团队在 Ed #54 的原话），跨题复用代码官方建议直接复制粘贴；
③ 禁 AI，连用 AI 翻译题目都算违规，翻译请用专门翻译软件；
④ 迟交每天扣 5%——迟 1 分钟也按 1 天算，官方明说不豁免网络问题，超 7 天记 0 分；
⑤ 别改文件名，代码只写在给定 workspace 的文件里，写在别处不给分。

📋 规则与注意事项（评分 · 学术诚信 · 提交 · 自动测试技巧 · 游戏背景）

📋 开工自查清单（每题四项各占 25%，实现只是其中一项）

每个函数写 docstring——「文档与注释」独立占每题 25%，Ed #64 有同学专门问过
给自己写测试用例——「私有测试」也占每题 25%，别只顾实现忘了这 1/4 的分
代码简洁、变量名达意——「代码质量」25%、「程序逻辑」25%
做题前看一眼 Change log——题目已修订 4 次（8/5、8/6、8/7、8/12），别照旧版写

⚔️ Set 1 · 角色数值与伤害计算（10 marks · 已放出）— 变量与表达式

A1 · 辅助理解第 2 关

Formula Stepper公式拆解步进器：把一坨公式肢解成可验算的四段

Set 1 的题面最吓人的往往不是代码，而是一坨公式：又乘又加、还带条件翻倍、最后取整。别急着一口气写成一行——先把它拆成几段中间值（intermediate value），每段单独代数、单独用计算器核对，最后再合体。这一关用一条自编的游戏伤害公式练这套手艺：伤害 = 基础×2 + 宝石×3，触发暴击（crit）整体翻倍，最后 int() 取整。

⚠️ 概念演示 · 所有数值与公式均为教学示例，不是作业答案——A1 禁止 AI 代写，这里只帮你看懂机制。

damage = int((base * 2 + gem * 3) * (2 if crit else 1))

题面原样的「一坨」。看着唬人？往下拆——四张卡，一步一段。

第 0 / 5 步

STEP 1

Base damage基础伤害

base × 2

待计算

→

STEP 2

Gem bonus宝石加成

+ gem × 3

待计算

→

STEP 3

Crit check暴击判定

× 2 if crit else × 1

待计算

→

STEP 4

int() truncate截断取整

int( · )

待计算

选一个情景 chip（不同的 base / gem / 是否暴击），然后点 ▶ 下一步——看这坨公式被拆成四段、一段一段点亮。

坑 1 · 运算优先级（operator precedence）——乘除先于加减：a + b * c 是 a + (b*c)，不是从左算到右。整体翻倍必须写 (base*2 + gem*3) * 2；漏了括号就只有最后一项被翻倍。拿不准就加括号——括号不要钱。

坑 2 · int() 是截断（truncation）不是四舍五入——int(7.9) = 7、int(0.99) = 0，小数直接扔掉；负数朝 0 砍：int(-7.9) = -7。想四舍五入要用 round()，两者混用是高频翻车点。

🗺️ Set 2 · 矩形世界（20 marks · 已放出）— 移动 · 战斗 · 逃出生天

A1 · 辅助理解第 3 关

Path Walker🧭 走格子模拟器：指令 · 边界 · 事件

Set 2 属于「按指令在网格里走」的题型：程序读一串指令，角色坐标 (x, y) 一步步变化，途中还要处理越界 (out of bounds) 和踩格触发事件 (event)。最容易翻车的三个点：① U 到底是 y+1 还是 row+1？② 撞墙那一步坐标到底动不动？③ 事件是移动前查还是移动后查？这一关用一座自编的 5×4 迷你地牢把整条流水线拆开慢放：查表得位移 → 先检查边界 → 合法才更新坐标 → 落格后结算事件。

⚠️ 概念演示 · 所有数值与公式均为教学示例，不是作业答案——A1 禁止 AI 代写，这里只帮你看懂机制。

指令带 Instructions

鎏金凸起 = 当前这条 · 变淡 = 已执行 · 红虚线框 = 那步撞了墙 · 红实线框 = 那步触发了事件

步数 0 / 10 · 当前坐标 (0, 0)

y=3y=2y=1y=0

x=0x=1x=2x=3x=4

原点 (0, 0) 在左下角——数学坐标系画法。⚠️ = 事件格（踩到扣 HP），S = 起点，每格左下角的小字是它的 (x, y)。

HP 生命值（自编示例数值）

100 / 100

指令 → 位移 (dx, dy) 查表

U 上y + 1

D 下y − 1

L 左x − 1

R 右x + 1

边界 Bounds（先检查、再移动）

合法范围：0 ≤ x ≤ 4，0 ≤ y ≤ 3（宽 5 × 高 4）。
试探出的新坐标越界 → 这一步整个作废，原地不动。

角色（鎏金圆点）站在起点 (0, 0)——左下角。点「▶ 走一步」逐条执行指令带，每一步都会在这里解释 (x, y) 怎么变。

A1 · 辅助理解第 4 关

⚔️ Battle Loop战斗回合播放器：while 双方都活着

Set 2/3 里最容易翻车的不是伤害算式，而是回合的骨架：一个 while 循环（loop）管「打到有一方倒下才停」，循环体里的先后顺序管「谁先出手、倒下之后还能不能反击」。这一关把一个回合放慢成三拍——出手 → 判定 → 反击——你会亲眼看到：判定（check）写在反击前还是反击后，结局完全不同。很多同学的「怪都死了还反手打我一下」幽灵 bug，就出在这一行的位置上。

⚠️ 概念演示 · 所有数值与公式均为教学示例，不是作业答案——A1 禁止 AI 代写，这里只帮你看懂机制。

Player · 你

勇者you_hp / you_atk

HP 40 / 40ATK 12

ROUND 回合

0

待命 standby

Monster · 怪

大史莱姆mon_hp / mon_atk

HP 35 / 35ATK 9

while you_hp > 0 and mon_hp > 0: # ① 回合开场先验票（循环条件 condition） mon_hp = mon_hp - you_atk # ② 你先出手 if mon_hp <= 0: # ③ 先判定：怪倒了吗？ break # 倒了就收工——没有反击 you_hp = you_hp - mon_atk # ④ 怪还站着，才轮到它反击

—— 战斗日志 Battle Log ——

点「▶ 下一回合」开跑。每回合拆成三拍：② 你出手 → ③ 判定 → ④ 反击。盯着上面的伪代码高亮，看程序此刻停在哪一行——循环条件 + 循环体内的顺序，就是这场战斗的裁判。

🧭 Set 3 · 地牢测绘（30 marks · 已放出）— 二维地图 · 坐标是最大的坑

A1 · 辅助理解第 1 关

Coordinate Translator坐标翻译机：地牢 (x, y) ↔ dungeon[row][col]

Set 2/3 里最大的坑：题目世界观说的是地牢坐标 (x, y)——origin（原点）在左下角，x 往右、y 往上，跟数学课的坐标系一样；可你代码里存地图用的是 Python 嵌套列表 dungeon[row][col]——第 0 行在最上面，row 越大越往下。两套方向正好相反，不做翻译，地图就会上下颠倒、英雄一走就撞墙。这一关把「翻译」拆成 4 个小步，看清 y 轴是怎么翻过来的。

⚠️ 概念演示 · 所有数值与公式均为教学示例，不是作业答案——A1 禁止 AI 代写，这里只帮你看懂机制。

未开始 · 按 ▶

冒险者的地图 · Dungeon (x, y)

y

x 往右 → · y 往上 ↑
原点 origin 在左下角

翻译公式会在这里逐步出现

① 读地图坐标

② 翻转 y 轴 flip

③ 照搬 x

④ 得到下标 index

Python 的列表 · dungeon[row][col]

row

row 往下数 ↓ · col 往右 →
[0][0] 在左上角

同一座 5×4 的地牢，左边是冒险者的叫法，右边是 Python 的叫法。点一个情景 chip，再按 ▶ 下一步，看 (x, y) 怎么一步步翻译成 dungeon[row][col]。

⏳ Set 4 · 游戏组装（尚未放出）＋ Change log 修订记录

💬 Ed 官方答疑（6 帖 · 含「禁 import」等关键裁定）

FIT9136 · In-class Test 1 · 5% · Week 5 的 applied class 第一小时 · 闭卷

Test 1 · W1–4 复习特训

考试硬信息① 60 分钟 = 4 道 quiz + 4 道编程题，在你 Allocate+ 上的 applied class 第一小时考，迟到不补时；
② 闭卷——无笔记、无计算器、无手机；带学生证（点名）、装好 SEB 的笔记本、手机或 Okta backup codes、充电器、一支笔；
③ 禁止 import（用了该题最多扣光）；不要求写注释和 docstring，只看解题正确性；
④ Test 按钮不限次数，放心多按；SEB 退出密码 EXIT；
⑤ 输出格式要和题目示例逐字符一致——多一个空格都算错。

✅ 考前准备清单（SEB 疑难速查 · 勾选会记住）

用 Applied 1 的 SEB test quiz 实测过自己的电脑（这是官方要求的预检）
Mac 报 WindowServer 错 → 装 SEB 3.7.0；Windows 误报虚拟机 → 装 3.10.0（别用 3.10.2）；缺 .NET → 见 Ed #12
接过外接屏的电脑：把笔记本屏设为主显示器（或 Mac 开镜像），否则 SEB 报多屏错误
Mac 给 SEB 开文件权限（系统设置 → Privacy & Security → Files & Folders）
Windows 最近自动更新过 → 重新测一遍 SEB
笔记本充满电 + 带充电器；手机或 backup codes 能登 Okta
搞不定 → 提前找 Monash Connect / eSolutions，或去 MGA / 图书馆借预装 SEB 的笔记本

1️⃣ Week 1 · 变量、表达式与语句

2️⃣ Week 2 · 条件与 while 循环

3️⃣ Week 3 · for 循环与序列

4️⃣ Week 4 · 函数、作用域与字典

🚨 高频陷阱总清单（20 道真题 + Sample Test 反推）

📝 官方 Sample Test 逐题拆解（先自己做，再看思路，最后翻答案）

🏋️ 分知识点刷题营（28 题 · 每题先给知识点卡 · 点选项即时判分）

🔁 再刷一遍真题

Ed 真题 quiz 都在对应周页里：Week 3 页 · 8 题／ Week 4 页 · 12 题——考前各刷一遍，错的题回来查陷阱清单。

FIT9136 · Python 练功房 ·

练功房 · 写代码，像 Ed 一样判分

用法① 每题下方是代码框，写完点 ▶ 运行并检查——在你浏览器里跑真 Python（首次点击加载运行环境约 10MB）；
② 判分和考试一样：输出逐字符比对（提示语、空格、标点都算），带 input 的题判分输出里不含你敲的数字；
③ 代码自动保存在浏览器里，关页不丢；⚠️ 写 while 记得更新条件——死循环会卡住页面，刷新即可（代码还在）；
④ 卡住超过 15 分钟：回 TEST 1 页看对应周的知识点卡，或把代码贴给 Claude 让我讲。

FIT9132 · 8 篇笔记连贯阅读

Topic 1 · 数据库导论

游戏规则

Assessment为什么这门课一天都不能拖

考核项	时间	占比
Applied Tasks AT3–AT12（各 1%）	W4 起每周	10%
Class Test 1（线下）	Week 6	15%
Assignment 1 · Database Design	9 月 16 日	30%
Class Test 2（线下）	Week 12	15%
Assignment 2 · 建库/填充/操纵	11 月 2 日	30%

三条硬规则① GitLab 每周 push（官方原话 "Weekly Git Push is Critical"，用官方 repo 的 main 分支）；② AT3 = 第一个计分节点，8 月 17 日截止，且是 Assignment 1 的硬前置；③ 迟交每 24h 扣 5%，超 7 天记 0，只有 AT3 可重交一次。

📋 追赶自查清单（现在就打勾）

VS Code 连上 Monash Oracle 服务器（校外先连 GlobalProtect VPN；Docker 本地环境可选，评分以 Monash 服务器为准）（Applied 1）
GitLab 官方 repo 克隆、能 commit + push（作者信息配置正确）
W1–W2 的空白 push 记录补上（push 历史本身就是被检查的对象）
Applied 1 / Applied 2 前置任务补做（AT3 的直接准备）
LTA Quiz（Learning and Teaching Agreement）已完成

W1 概念

Why Databases从文件柜到管家

file system（文件系统）的四宗罪（考点，要能背出来）：①数据冗余导致不一致 ②程序与数据死绑 ③信息孤岛、难安全共享 ④开发慢——想出新报表就得写新程序。 database（数据库）= 集中存放的共享数据集合；DBMS（数据库管理系统）= 站在数据前面的管家——所有读写都要经过它，由它保证一致性、安全和并发。还要分清：data（原始事实）→ 处理后才变成 information（有意义的信息）；metadata = 描述数据的数据。排序题常客——数据模型进化史：文件 → 层次/网状 → 关系（本课主角） → 面向对象 → XML/混合 → NoSQL。

✏️ Topic 1 Quiz（3 题 · 英文）

FIT9132 · 5 篇笔记连贯阅读

Topic 2 · 概念建模

W2 核心技能

Crow's Foot Notation鸦爪记号解读器：点符号看含义

先定位：数据库设计四步 = 需求 → 概念（本周：画「户型草图」，与技术完全无关） → 逻辑（依赖数据库类型）→ 物理（依赖具体 DBMS）。本单元硬规定：关系每一端必须同时标出 min（外侧）和 max（紧贴实体）。三个基本符号： | = 1（one）、o = 0（可选）、< = 多（many）。点下面每张卡：

互动 · 四种端点组合

A ──o|── B

零或一

A ──||── B

恰好一

A ──o<── B

零或多

A ──|<── B

一或多

👆 点一张卡。读法口诀：站在对面读——想知道 ORDER 端画什么，就问"一个 CUSTOMER 能有几张 ORDER？"业务规则翻译法：must → min=1（mandatory 强制参与）、may/can → min=0（optional 可选参与）。

完整例子：客户与订单

CUSTOMER ─||─────────o<─ ORDER      -- places
-- ORDER 端往回看：一张订单必须属于恰好 1 个客户 → (1,1) = ||
-- CUSTOMER 端往前看：一个客户可下 0 或多张订单 → (0,M) = o<

五个扣分点（明文规定）① 概念图禁止画外键——实体之间只靠关系线连接，把对方 id 抄进实体是逻辑层（W3+）的事，这是最经典失分点；② 概念建模禁止 surrogate key（自造 payment_id 代替复合键）；③ M:N 必须原样保留——只有当关系自己要携带属性时（如选课的成绩），才引入 bridging entity（桥接实体）拆成两条 1:M；④ 弱实体用实线（identifying，借父键），独立键用虚线；⑤ 铁律「不多不少」：brief 写的全画、没写的一个不加（自作主张加 email 和漏画一样扣分），拿不准去 Ed 问——Ed 就是你的客户。

通俗理解 · 强弱实体STUDENT 有自己的 student_id = strong entity；DEPENDENT（员工家属）光说"1 号家属"不知道是谁家的，键必须是 (emp_no, dependent_no) = weak entity。

✏️ Topic 2 Quiz（4 题 · 英文）

FIT9132 · 5 篇笔记连贯阅读

Topic 3 · 关系模型

AT3 · 计分任务Applied 3：Property Rental 概念模型——周一 8/17 23:55 截止，提交 Moodle + push GitLab（≥3 次 commit）。它是 Assignment 1 的硬前置。完整说明书在下方「本周完整笔记」的 Applied 3 篇。

🎮 Key Explorer — four kinds of keys（四种键辨析）

点每张卡。记忆链：superkey ⊇ candidate key → 选一个当 primary key；primary key 到了别人家就是 foreign key。

superkey

unique, maybe bloated

candidate key

minimal superkey

primary key

the chosen one

foreign key

the connector

👆 click a card

INTERACTIVE · NEW

σ & π VisualiserSELECT 横着切、PROJECT 竖着切

互动 · 关系代数两大刀法

custno	name	suburb	balance
SMI13	SMITH	Clayton	2000
JON44	JONES	Caulfield	800
LEE21	LEE	Clayton	10000
WAN07	WANG	Oakleigh	450

口诀：σ SELECT 挑「行」（横着切），π PROJECT 挑「列」（竖着切）。两个都不改原表——关系代数每一步都产出新关系。

✏️ Topic 3 Quiz（8 题 · Ed 真题）

FIT9132 · 9 篇笔记连贯阅读

Topic 4 · 范式化

AT4 · 计分任务Applied Task 4：Hotel 数据库「8/22–8/24 未被预订的房间」关系代数表达式——周一 8/24 23:55 截止，不允许重交。做成单页 A4 PDF at4_ra.pdf，源文件 + PDF 放 Applied/App04 push 到 GitLab，再把 PDF 提交 Moodle（两边都要有）。完整说明在下方「本周完整笔记」的 Applied 4 与 Wrap Up 篇。

🎮 范式化步进器（UNF → 1NF → 2NF → 3NF）

先选一张表单，再按顺序点四个阶段。每一步看两件事：这一步消除了什么、这一阶段必须列出哪类依赖（1NF 列部分依赖、2NF 列传递依赖、3NF 列完全依赖）。关系表写法：加粗 = 主键属性，绿色 = 外键（既加粗又绿 = 同时是主键的一部分和外键）；UNF 阶段不标任何主键。

# 选一个阶段，这里显示该阶段的关系表

👆 从 ① UNF 开始按顺序点

🎮 函数依赖判断器（完全 / 部分 / 传递）

两张关系表作背景，五条依赖轮流考你。先点一条依赖，再用下面三个按钮下判断——判断前先问自己两句：决定方是不是整个主键？（是 → 完全依赖）决定方是主键的一部分，还是根本不在主键里？（一部分 → 部分依赖；不在主键里 → 传递依赖）。

ASSIGNMENT (proj_num, emp_num, proj_name, emp_name, job_class, chg_hour, hours)   # 复合主键 (proj_num, emp_num)
ORDER      (order_no, order_date, cust_no, cust_name)                                   # 单属性主键 order_no

👆 先点一条依赖

✏️ Topic 4 Quiz（10 题 · Ed 真题）

FIT9132 · 5 篇笔记连贯阅读

Topic 5 · 逻辑建模

AT5 · 计分任务Applied Task 5：Drug Sales Salesperson Details 表单范式化——周一 8/31 23:55 截止，源文件 + PDF 放 App05 文件夹 push GitLab（≥2 次 commit），再把 at5_normalisation.pdf 交 Moodle；不可重交、禁用 AI。完整说明在下方「本周完整笔记」的 Applied 5 与 Wrap Up 篇。

🎮 ER → 关系映射器（外键放哪边、桥接表怎么建）

点一种联系／属性类型，下面给出映射后的关系模式（下划线主键用 PK: 标出）。总原则：实体 → 关系，键 → PK，联系 → PK/FK 配对。

👆 点一个类型

概念模型里的东西	逻辑模型里变成	FK 在哪
普通实体	一个关系；键 → PK；复合属性默认拆成简单属性	—
1:M	两个关系	「多」方
M:N	两个关系 + 桥接关系	桥接关系里两个 FK（通常合成 PK，须核实）
1:1	两个关系（双方 total 可合并）	强制参与的一侧（NULL 最少）
弱实体 / 多值属性	新关系，复合 PK = 父 PK + 部分键／该属性	父 PK 既是 PK 一部分又是 FK
一元 1:M	同一关系	递归 FK，必须改名（唯一允许改名的场景）
三元	三个关系 + 一个新关系	三个 PK 进来作 FK（通常合成 PK，可能还要加 date/time）

🎮 外键方向判官（4 个小场景）

读业务规则，判断外键应该落在哪张表（或者根本不该放 FK 而是建桥接表）。先想清楚再点——每个场景都有即时解释。

场景 1 · DEPARTMENT — EMPLOYEE

Each department employs many employees; each employee works in exactly one department. 每个部门雇用多名员工；每名员工只属于一个部门。

👆 选一个

场景 2 · NURSE — CARECENTER（1:1）

A nurse MAY be in charge of one care centre; every care centre MUST have exactly one nurse in charge. 护士可能负责一个中心（可选）；每个中心必须有一名负责护士（强制）。

👆 选一个

场景 3 · STUDENT — UNIT

A student enrols in many units; a unit has many students; the mark for each enrolment must be recorded. 学生选多门课，一门课有多名学生，还要记录每次选课的成绩。

👆 选一个

场景 4 · EMPLOYEE supervises EMPLOYEE

One employee supervises many employees; each employee has at most one supervisor. 一名员工管多名员工；每名员工最多一个上司。

👆 选一个

首次判对：0 / 4

✏️ Topic 5 Quiz（10 题 · 整理自 Core Reading + Wrap Up）

FIT9132 · 7 篇笔记连贯阅读

Topic 6 · 建库与改库

AT6 · 计分任务Applied Task 6：cust_orders 项目的三个文件——周一 9/7 23:55 截止，at6_logical.pdf（蓝色逻辑模型）、at6_relational.pdf（黄色关系模型）、at6_schema_output.txt（spool 输出）既交 Moodle 也 push GitLab，项目至少 3 次有意义的 commit；评分只有 1 / 0.5 / 0 三档，不可重交、禁用 AI。本周还有 Class Test 1（workshop 时段、闭卷 85 分钟）——备考包与模拟卷就在下方「本周完整笔记」里。

🎮 DDL 建表器（一步步堆出一份合规的 schema）

按 ① → ⑥ 依次点击，下面的语句会逐步累积成一份完整的 DDL 脚本。取材自 Core Reading 的 TRAINING / CUSTOMER / CUST_TRAIN 三张表——讲义推荐的写法（原文标为 Alternative BETTER method）是「CREATE TABLE 只写列 + 类型 + NOT NULL，其余约束一律用 ALTER TABLE 具名添加」。

👆 从 ① 开始点

约束	本单元命名规则	写在哪	维护什么
NOT NULL	唯一不用起名的约束	列级：CREATE TABLE 的列定义行上	该列必填
PRIMARY KEY	`表名_pk`	表级：ALTER TABLE ... ADD CONSTRAINT	实体完整性（唯一且非空）
FOREIGN KEY	`父表_子表_fk`	表级：ALTER TABLE ... ADD CONSTRAINT	参照完整性（默认 RESTRICT）
UNIQUE	`表名_uq`（第二个用 `_uq2`）	表级：ALTER TABLE ... ADD CONSTRAINT	业务规则（不重复）
CHECK	`chk_列名`（本学期也收 `列名_chk`）	表级：ALTER TABLE ... ADD CONSTRAINT	取值范围
DEFAULT	——（不是约束）	列定义里 / ALTER ... ADD 里	缺省填值 + 加列时回填已有行

🎮 ALTER TABLE 变更器（4 个真实变更场景）

表已经建好、而且里面已经有数据，客户又来提新需求。点一个场景看该写什么语句、以及哪里会翻车。

👆 点一个场景

两个都叫 CASCADE，行为却相反	`DROP TABLE … CASCADE CONSTRAINTS`	`ON DELETE CASCADE`
属于哪类语句	DDL，DROP TABLE 的子句	外键定义的一部分，配合 DELETE 生效
什么时候触发	删整张表时	删父表某一行时
删掉了什么	子表上的外键约束	子表中对应的那些行
子表数据	完整保留 ✅	被删除 ❌

名字里都有 CASCADE、行为却截然相反——这是考试高频陷阱。另外记牢 Oracle 的三种 on-delete：不写任何 ON DELETE 子句 = RESTRICT（默认、免费送，父行被引用就拒绝删除，报 ORA-02292）；ON DELETE CASCADE = 连坐删子行；ON DELETE SET NULL = 子行外键置空——前提是该外键列可空，所以外键列一旦是主键的一部分（模型上标 PF），SET NULL 直接出局。

✏️ Topic 6 Quiz（10 题 · 整理自 Core Reading + Wrap Up）

FIT9132 · 5 篇笔记连贯阅读

Topic 7 · DML 与事务

AT7 · 计分任务 · 禁用 AIApplied Task 7：at7_schema.sql + at7_schema_output.txt，周一 9/14 23:55 截止——必须在 VS Code 手写 DDL（明令禁止用 Data Modeler），不得改变模型中的属性顺序；脚本首尾加 set echo on / spool at7_schema_output.txt … spool off / set echo off；两个独立文件分别提交 Moodle（不许压缩）并 push 到 GitLab，at7_schema.sql 至少三次有意义的 commit；评分只有 1 / 0.5 / 0 三档，不允许重交。Ed 原文写明 AI & Generative AI tools MUST NOT BE USED。紧接着 Assignment 1 周三 9/16 23:55 截止。本页的两个互动与 Quiz 只讲通用的 DML / 事务概念，不涉及 AT7 的题目本身，也不给任何 AT7 答案——AT7 的 SQL 必须完全由你自己手写，Applied 7 的 A7-2 / A7-3 是它的演练，做完再对照 Ed 官方 sample solution。

🎮 DML 三连击演练台（INSERT / UPDATE / DELETE 打在同一张表上）

桌上这张 MEMBER 表来自 Workshop 7 Slide 3（P = 主键，* = NOT NULL 必填，其余列可空）。六个 chip 按顺序作用在同一个会话里，前一条的结果会留给后一条：基线是 3 行，点完 ① 之后表里变成 4 行（② 只是 ① 的另一种写法，不是第二次插入），③④⑤⑥ 全都打在这 4 行上——所以你会看到回执写 4 rows updated / 4 rows deleted。点一下看语句、看 Oracle 的回执行数、看表变成什么样。④ 和 ⑥ 是「忘了 WHERE」的灾难演示，看完请当作已经 ROLLBACK、回到 ① 之后的那 4 行，再往下点。
绿底 = 新增的行，蓝字加粗 = 被改掉的值，红色删除线 = 被删掉的行。

👆 先看基线，再依次点 ① → ⑥

忘了 WHERE = 全表遭殃。UPDATE 和 DELETE 的 WHERE 子句在语法上是可选的——省掉它，语句依然完全合法，Oracle 不会问「你确定吗」，只会平静地回一句 4 rows updated.。既然没有任何报错能救你，就只能靠三个习惯：① 先用 SELECT 把 WHERE 跑一遍，确认命中的正是你想改的那几行，再把 SELECT 换成 UPDATE / DELETE；② 盯住回执的行数，本该改 1 行却回了 4 rows，立刻停手；③ 别急着 COMMIT——只要还没提交，ROLLBACK 就能把一切原样撤回（下一个互动就演这件事）。

语句	属于	删掉什么	能带 WHERE	ROLLBACK 救得回吗
`DELETE FROM t WHERE …;`	DML	中标的那几行	✓	✓（只要还没 COMMIT）
`DELETE FROM t;`	DML	所有行，表结构保留	省略了	✓（只要还没 COMMIT）
`TRUNCATE TABLE t;`	DDL	所有行，表结构保留	✗	✗ 隐式提交，无法撤销
`DROP TABLE t PURGE;`	DDL	表结构和数据一起没	✗	✗ 隐式提交，且跳过回收站

🎮 事务时间线（两个会话，看 COMMIT 之前到底谁看得见）

左边 Session A 是你，右边 Session B 是同事——两个会话连的是同一个数据库、同一张 MEMBER 表。沿时间轴一步步点，看同一时刻两边各自 SELECT * FROM member; 会看到什么。标 未提交 的行只活在 A 自己的事务里。

Session A · 你

Session B · 同事

👆 从 T0 开始，一步一步往下点

命令	属于	做了什么	对「当前未提交的 DML」的影响
`COMMIT;`	事务控制	永久写入 + 结束事务 + 释放全部锁	全部落库，从此别人也看得见，且再也撤不回
`ROLLBACK;`	事务控制	撤销整个事务 + 释放全部锁	上一次 COMMIT 之后做的改动全部消失
`ROLLBACK TO sp1;`	事务控制（本单元没教）	回到书签处，事务继续开着	只撤销书签之后那一段，之前的还在
`CREATE` / `ALTER` / `DROP` / `TRUNCATE`	DDL	改结构，执行即生效	⚠️ 隐式提交：先把它们全部 COMMIT 掉，再执行 DDL
`SELECT`	查询	只读，不改任何数据	不影响；但读不到别的会话尚未提交的改动

一句话记牢：「别人什么时候能看到我的改动」这个问题的答案永远是——COMMIT 的那一刻，而不是执行 INSERT / UPDATE / DELETE 的那一刻。这正是 ACID 里的 I（Isolation 隔离性）：事务执行期间的数据对别人不可见；以及 D（Durability 持久性）：一旦提交，断电重启也还在。⚠️ 本互动里的 SAVEPOINT / ROLLBACK TO 是 Oracle 通用知识，Topic 7 的 Core Reading 与 Workshop 都没有讲过，而本单元明文规定「只能使用课上介绍过的语法，未讲过的不计分」——放在这里只是帮你看清事务的边界，作业和考试里不要写。

✏️ Topic 7 Quiz（10 题 · Ed 真题 + Wrap Up）

FIT9132 · 2 篇笔记连贯阅读

Topic 8 · SQL 基础

FIT9132 · 2 篇笔记连贯阅读

Topic 9 · SQL 进阶

FIT9132 · 2 篇笔记连贯阅读

Topic 10 · SQL 高级

FIT9132 · 2 篇笔记连贯阅读

Topic 11 · NoSQL 与大数据

FIT9132 · 1 篇笔记连贯阅读

Topic 12 · BI 与法律伦理

题面 1:1 复刻 · 交卷后导出 .md 丢给 Claude 批改，或对 Ed 官方样解

FIT9132 · Class Test 1 · 15% · Week 6 线下 workshop · 闭卷 85 分钟

Class Test 1 · 备考特训

考试硬信息① 2026-09-04（周五）7:45 PM，在你 allocated 的 workshop 线下进行，85 分钟、闭卷；
② 只能用 Safe Exam Browser 作答（macOS 3.7 / 3.10.0 均可）；SEB 里不能右键——复制粘贴 RA 符号用 ⌘C/⌘V，范式化题给主键加下划线用 ⌘U；
③ 范围：Relational Algebra + Normalisation + Conceptual Modelling；官方指定复习 Workshop 2/3/4 + Applied 3/4/5，不是课本；
④ Sample 密码 ct1sample，可反复做；官方样解在 Ed（先完成 sample + 勾选确认才解锁）；
⑤ 考前必须用 sample 验证过 SEB——考试当天软件出问题可能直接 0/15。

🕐 全真模拟（85 分钟计时 · 大题输入框 · 交卷导出答案文件）

SIM 1 · 40 分

官方 Sample 全真模拟

全新题目同构卷 · 单车 RA + 象棋范式化 + 仓储单选

SIM 2 · 40 分

模拟卷 A 全真模拟

模拟页内选择题不即时判分（还原考场）；答案自动暂存本机，交卷或倒计时归零后锁定并导出。下方的互动 Quiz 仍是"即点即判"的练习模式，两不冲突。

✅ 考前准备清单（勾选会记住）

SEB 已安装并用 sample 完整跑通一遍（官方要求的预检）
在 SEB 里验证过：RA 符号能 ⌘C/⌘V 粘贴
在 SEB 里验证过：⌘U 能给主键加下划线
Ed 的 Sample Class Test 1 确认页已勾选提交 → 样解已解锁
8/28 晚：对完 sample 官方答案 + Applied 5 官方答案，错题记录在案
AT3 反馈四弱点已修：属性前缀 / 复合键最小性 / 关系路径验证 / 假设不写废话
模拟卷 A 三部分全部做完并对分

🧭 试卷结构与时间分配（依据官方 Sample 反推）

Sample 共 17 题 / 3 页 / 40 分，正式卷"内容不同、题型结构可能有变"，但三大块比例可参考：

Q1 关系代数（10 分）：给 4 个关系，写 2 条查询（4 分 + 6 分），必须体现效率意识，符号可从题面复制
Q2 范式化（15 分）：给一张业务表单 → 写 UNF → 1NF → 2NF → 3NF；1NF 起主键加下划线；1NF 要列全部候选键；依赖用依赖图（a_id → a_name）标注：1NF 标部分依赖、2NF 标传递依赖、3NF 标完全依赖；不得新增属性
Q3–17 单选（15 × 1 分）：一个概念建模场景（强/弱实体、键充分性、identifying、基数 min/max、属性归属）

85 分钟建议分配：Q1 约 18 分钟 → Q2 约 35 分钟（分值最大、步骤最多）→ 选择题约 20 分钟 → 剩余检查。先把会做的拿满，别在一小题上卡死。

📋 官方 Sample 题面存档（做完再来对 Ed 官方样解）

Q1 RA（10 分）——度假租房系统，同一房产同一时间只能租给一位客人：

GUEST (guest_id, guest_name, guest_address, guest_mobile)
BOOKING (guest_id, prop_id, booking_startdate, booking_enddate, booking_totalguest)
PROPERTY (prop_id, prop_streetaddress, prop_city, prop_state, prop_capacity,
          prop_pricepernight, prop_cleaningfee, host_id)
HOST (host_id, host_name, host_mobile, host_email)

(a) 列出客人 'Jack Kaniva' 订过的所有房产的 street address / city / state（该名字唯一）[4 分]
(b) 列出 2022-03-01 至 2022-05-31（含，按 booking start date）之间被 'Ian McCain' 接待过的客人的 name / address / mobile（该名字唯一）[6 分]

Q2 范式化（15 分）——少儿篮网球联赛赛程表单：每轮（ROUND n + 日期）有 4 场比赛，行含 start time / court no / team 1 / team 2（各带 Grade A/B）/ umpire name / umpire acc level。要求：team_id、umpire_id 必须加进 UNF；轮号全局唯一；同一队每轮只打一场。UNF → 3NF，1NF 起划主键、列全部候选键、画依赖图，不得新增属性。

Q3–17 单选（15 分）——GreenLeaf 公寓管理场景：Building（building_code 唯一）/ Unit（unit_number 仅楼内唯一，存在依赖 Building，级联删除）/ Tenant（tenant_id 独立识别；一 Unit 可多 Tenant 合租，每 Tenant 只租一 Unit）。考点：三个实体的强弱判定及理由、键充分性 ×3、级联删除、Building–Unit 与 Unit–Tenant 的关系类型、基数与最小基数、Unit 完整键、属性归属匹配。

✍️ 模拟卷 A · Q1 关系代数（10 分）

共享单车系统，每辆车归一家运营商投放：

RIDER (rider_id, rider_name, rider_address, rider_mobile)
RENTAL (rider_id, bike_id, rental_startdate, rental_enddate, rental_km)
BIKE (bike_id, bike_model, bike_city, bike_state, provider_id)
PROVIDER (provider_id, provider_name, provider_mobile, provider_email)

符号：π σ ⋈ ∩ ∪ −　（答案必须体现查询效率：join 前先瘦身、不携带多余属性）

(a) 列出骑手 'Amy Rojas' 租过的所有单车的 model / city / state（该名字唯一）[4 分]

(b) 列出 2026-04-01 至 2026-06-30（含，按 rental start date）期间租过 'CycleHub P/L' 投放车辆的骑手的 name / address / mobile（该运营商名唯一）[6 分]

📖 参考答案（先自己写完再展开）

(a)
AMY_ID    = π rider_id (σ rider_name = 'Amy Rojas' (RIDER))
AMY_BIKES = π bike_id (AMY_ID ⋈ (π rider_id, bike_id (RENTAL)))
R = π bike_model, bike_city, bike_state
      (AMY_BIKES ⋈ (π bike_id, bike_model, bike_city, bike_state (BIKE)))

(b)
CH_ID      = π provider_id (σ provider_name = 'CycleHub P/L' (PROVIDER))
CH_BIKES   = π bike_id (CH_ID ⋈ (π bike_id, provider_id (BIKE)))
CH_RENTERS = π rider_id (CH_BIKES ⋈ (π rider_id, bike_id
               (σ rental_startdate >= 01-Apr-2026 and
                  rental_startdate <= 30-Jun-2026 (RENTAL))))
R = π rider_name, rider_address, rider_mobile (CH_RENTERS ⋈ RIDER)

自查点：每一步 join 前是否只留了连接键 + 最终要的列；σ 是否推到了最里层；最后一行是否恰好输出题目要的三列。

✍️ 模拟卷 A · Q2 范式化（15 分）

社区象棋联赛赛程表单：每轮标注 ROUND 轮号 + 日期，下方表格每行一场对局：start time / board no / player 1（带 Rating Class A/B）/ player 2（同）/ arbiter name / arbiter level。同一棋台一轮内在不同时间承办多场。

注意事项（对照 sample 的出题口吻）：Player 由 player_id 识别、Arbiter 由 arbiter_id 识别，这两个属性必须加进你的 UNF；每位棋手有姓名和等级组（A/B）；轮号全局唯一；同一棋手每轮只下一场。写出 UNF → 1NF → 2NF → 3NF；1NF 起给主键加下划线；1NF 阶段列出全部候选键；用依赖图标注部分/传递依赖；不得新增属性。

📖 参考答案（先自己写完再展开）

UNF:
CHESS_ROUND (round_no, round_date,
   (start_time, board_no, player1_id, player1_name, player1_class,
    player2_id, player2_name, player2_class,
    arbiter_id, arbiter_name, arbiter_level))

1NF:（拆重复组）
ROUND (round_no, round_date)                       PK: round_no
MATCH (round_no, board_no, start_time,
       player1_id, player1_name, player1_class,
       player2_id, player2_name, player2_class,
       arbiter_id, arbiter_name, arbiter_level)
MATCH 的候选键（必须全部列出）:
  (round_no, board_no, start_time)   — 一台一时一场
  (round_no, player1_id)             — 每人每轮只下一场
  (round_no, player2_id)
选 PK: round_no + board_no + start_time（加下划线）
部分依赖: player1_id → player1_name, player1_class
          player2_id → player2_name, player2_class
          （依赖候选键 (round_no, playerX_id) 的一部分）

2NF:（去部分依赖）
PLAYER (player_id, player_name, player_class)      PK: player_id
MATCH  (round_no, board_no, start_time,
        player1_id, player2_id,
        arbiter_id, arbiter_name, arbiter_level)
传递依赖: arbiter_id → arbiter_name, arbiter_level（非键 → 非键）

3NF:（去传递依赖）
ROUND   (round_no, round_date)
PLAYER  (player_id, player_name, player_class)
ARBITER (arbiter_id, arbiter_name, arbiter_level)
MATCH   (round_no, board_no, start_time,
         player1_id, player2_id, arbiter_id)
完全依赖: round_no → round_date;  player_id → player_name, player_class;
          arbiter_id → arbiter_name, arbiter_level;
          (round_no, board_no, start_time) → player1_id, player2_id, arbiter_id

自查点：player1/player2 是两个角色共用 PLAYER 一张表（两个 FK）；round_date 在 1NF 拆重复组时就随 round_no 分离；两处 rating class 都只依赖各自 player_id——这正是部分依赖的教科书形态。

🎯 模拟卷 A · Q3–17 概念建模单选（15 分）

场景（对照 sample 的 GreenLeaf）：StoreSafe 自助仓储公司管理多个仓储中心。每个 FACILITY 有全公司唯一的 facility_code，另记录 facility_name、street_address、num_floors、year_opened；新开业的中心可能尚未设置任何储物间。每个中心内的 UNIT（储物间）由 unit_number 识别，但 unit_number 只在本中心内唯一（A、B 两中心都可以有 Unit 101）；每间记录 floor_level、floor_area_sqm、monthly_fee；储物间记录不能脱离其中心存在，中心删除时其储物间记录一并删除。一个储物间可同时租给一位或多位 CUSTOMER（合租），也可能空置；每位客户恰好租一间。客户由 customer_id 独立识别，另有 full_name、phone、email。

Topic 2 概念建模 → Topic 3 关系模型 → Topic 4 范式化 → ← 返回 FIT9132 主页

FIT9132 · Class Test 1 全真模拟 · 官方 Sample · 40 分

Sim 1 · 官方 Sample 模拟

FIT9132 · Class Test 1 全真模拟 · 模拟卷 A · 40 分

Sim 2 · 模拟卷 A 模拟

FIT9137 · 4 篇笔记连贯阅读

Week 1 · 数制与逻辑

W1 · 手算技能 ①

Decimal → Binary除 2 取余：165 一步步变成二进制

互动 · 除 2 取余步进器

165 ÷ 2	= 82	余 1	← 最低位
82 ÷ 2	= 41	余 0
41 ÷ 2	= 20	余 1
20 ÷ 2	= 10	余 0
10 ÷ 2	= 5	余 0
5 ÷ 2	= 2	余 1
2 ÷ 2	= 1	余 0
1 ÷ 2	= 0	余 1	← 最高位

口诀：除 2 取余，从下往上读。转完必验算：位权乘加回去。

反方向 & 十六进制二→十：位权 1,2,4,8,16,32,64,128 乘加（11000101₂ = 128+64+4+1 = 197）。二↔十六：4 位一组查表，零计算（11101010 → 1110|1010 → EA₁₆）。十六→十：位权 1,16,256 乘加（1AF₁₆ = 256+10×16+15 = 431）；十→十六：除 16 取余（151₁₀ → 余 7、余 9 → 97₁₆）。

ASCII 陷阱字符 '5' ≠ 数字 5！数字 5 = 00000101；字符 '5' 存的是 ASCII 码 53。三个锚点：'0'=48、'A'=65、'a'=97（小写 = 大写 + 32）；7-bit ASCII 共 2⁷ = 128 个字符。

W1 · 手算技能 ②

Two's Complement补码"翻转 + 1"：−37 的 8-bit 表示

互动 · 翻转 + 1 步进器

目标：把 −37 写成 8-bit 补码。第一步先写出 +37 的二进制。

四个高频坑① 翻转忘 +1（那是反码，全错）；② 全 1 位串 = −1（不是最小值；1000…0 才是 −2ⁿ⁻¹）；③ 进位 ≠ 溢出：超位宽进位丢弃是正常操作，溢出 = 同号相加得异号；④ n-bit 范围：−2ⁿ⁻¹ ~ 2ⁿ⁻¹−1（8-bit：−128~+127）。

W1 · 手算技能 ③

Boolean Logic布尔逻辑：四个门 + 化简三板斧

四门真值表（背 XOR：不同才 1）

A	B	AND（都真才真）	OR（有真就真）	XOR（不同才真）
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

NOT 是一元运算：NOT 0 = 1、NOT 1 = 0。XOR 可以拼出来：A⊕B = A·B̄ + Ā·B（2 个 NOT + 2 个 AND + 1 个 OR）——W1 Applied 原题。

化简三板斧（W1 Applied 大题）① De Morgan（德摩根律）：取反时 AND↔OR 互换——¬(A+B) = Ā·B̄、¬(A·B) = Ā+B̄；② 吸收律：Ā + AB = Ā + B；③ 互补律：A + Ā = 1、A·Ā = 0。化简套路：德摩根 → 提公因式 → 互补律收尾。

✏️ Week 1 Quiz（5 题 · 英文）

FIT9137 · 4 篇笔记连贯阅读

Week 2 · MARIE CPU

W2 · MARIE

MARIE教学 CPU：五大寄存器与取指循环

MARIE：16 位指令 = 4 位 opcode + 12 位地址 → 2⁴ 条指令、2¹² = 4096 个内存字。地址宽度决定"有多少房间"，数据宽度决定"每间装多宽的货"。

互动 · Fetch–Decode–Execute（点亮四步取指）

MAR ← PC        // ① 把"下一条指令的地址"放上地址总线
MBR ← M[MAR]    // ② 按地址取出指令内容
IR  ← MBR       // ③ 指令装入指令寄存器
PC  ← PC + 1    // ④ PC 立刻指向下一条（执行时 PC 已在前方！）

之后 Decode 读 IR 的高 4 位（opcode），Execute 因指令而异。五大寄存器：PC(下条地址,12位) IR(当前指令,16) MAR(访存地址,12) MBR(访存数据,16) AC(累加器,16)。

核心指令表（背这 9 条）

opcode	指令	做什么
1	Load X	AC ← 地址 X 里的内容（不是数值 X！）
2	Store X	把 AC 写回地址 X
3 / 4	Add / Subt X	AC ± M[X]（ALU 只算 AC 和 MBR）
5 / 6	Input / Output	与外界交换 AC
7	Halt	停机——忘写会跑飞（把后面内存当指令执行）
8	Skipcond	条件成立就跳过下一条（000 是 AC<0 / 400 是 =0 / 800 是 >0）——不是 goto！
9	Jump X	PC ← X（无条件跳转）

MARIE 没有乘除——用循环累加实现。细节见 Obsidian《FIT9137 W2 零基础一本通》。

✏️ Week 2 Quiz（4 题 · 英文）

FIT9137 · 动画学堂 7 关 · 9 篇笔记

Week 3 · 内存设计与管理

W3 · 动画学堂第 1 关

Memory Address & Decoder内存地址与解码器：快递柜与门卫

想象一整排快递柜：每个格子放一件东西，柜门上有编号——这就是 memory（内存）和 address（地址）。取件时你报一个 binary（二进制）编号，门卫 decoder（解码器）就恰好打开一扇门，其余全部锁死。n 根 address lines（地址线）能编出 2ⁿ 个柜号：4 根 → 16 个，MARIE 的 12 位地址 → 4096 个。

4 根地址线：每根是一个 0/1 的 bit（位）开关，点它翻转

16 个快递柜：左上是 0 号，右下是 15 号

👋 点左边的 bit 开关，看门卫开哪扇门。

W3 · 动画学堂第 2 关

Building RAM from Chips用内存芯片拼 RAM

一颗内存芯片就像一栋公寓楼：楼里有 2048 个房间，每个房间住 8 个 bit——正好 1 Byte（字节）。想要更大的内存？把 64 栋楼拼成一个小区，再请一位「门卫」负责指路。这一关先解剖一栋楼，再拼出 1 Mbit 的小区，最后学会在小区里找到任意一个房间。

芯片解剖图 · 2K Byte Chip（一栋楼）

CS 片选

R/W̄ 读写

decoder 解码器

2048 × 8 bit

11 根地址线选房间 · 8 根数据线一次搬 1 Byte

拼装图 · 64 颗 = 1 Mbit（一个小区）

10011010101100011

■ 高 6 位 → 选芯片（楼栋）■ 低 11 位 → 片内选字节（房间）

…

W3 · 动画学堂第 3 关

Memory Hierarchy存储层级：一场跑腿赛

把 CPU 想成正在写作业的你：便签攥在手里、铅笔盒摆在桌上、书架立在房间、图书馆远在城里。Memory Hierarchy（存储层级）说的就是这件事：数据放得越近拿得越快，可近处的位置又小又贵——所以电脑把存储摆成了一座金字塔。

🏃

🧠

CPU

写作业的你

🤲

寄存器

Register <1ns

✏️

缓存

Cache 几ns

📚

内存

RAM ~100ns

🏛️

硬盘

Disk 0.1–10ms

⏱ 跑腿计时（把寄存器当 1 秒，感受人类时间）

寄存器人类≈1 秒 <1 ns

缓存人类≈几秒几 ns

内存人类≈2 分钟 ~100 ns

硬盘 SSD≈1天多 · HDD≈4个月 0.1–10 ms

条长仅是示意——真实差距从 ns 到 ms，相差上万到千万倍。

存储金字塔：顶＝快·贵·小 ↓ 底＝慢·便宜·大

寄存器

缓存

内存

硬盘

🧠 CPU（你）正要做题：数据放在哪儿，差别巨大。点上面的按钮，让 🏃 替你跑一趟取数据——从「拿便签」开始，四趟都跑完有彩蛋。

W3 · 动画学堂第 4 关

Virtual Memory虚拟内存 · 人人都以为自己独占一栋楼

Zoom 和 Word 住进同一栋大楼 RAM，可两家的门牌都写着「从 0 号开始」。秘密在于物业管家 MMU（Memory Management Unit，内存管理单元）：每次进门它都偷偷把「自家门牌」换算成「真实房号」；谁敢摸别人家的门，立刻拉响警报。

第 0/5 步

📹 Zoom → 已搬进 10000ʜ

虚拟地址 0000ʜ … A300ʜ

整块程序 · 自以为从 0000ʜ 起

📝 Word → 已搬进 40000ʜ

虚拟地址 0000ʜ … B100ʜ

整块程序 · 自以为从 0000ʜ 起

MMU

内存管理单元

待命中…

物理 = base + offset

物理内存 RAM
00000ʜ–FFFFFʜ = 1MB

📹 Zoom

📝 Word

00000 10000 1A300 40000 4B100 FFFFF

斜纹 = 空闲

规则：物理地址 = 基址 base + 偏移 offset。左边两位住户马上要搬进右边的大楼 RAM（物理内存 00000ʜ–FFFFFʜ，20 位地址，共 1MB）。点 ▶ 下一步 开门。

W3 · 动画学堂第 5 关

Memory Partitioning内存分区 · 一栋旅馆的三种开法

把内存想成一栋旅馆：System A 全是标准间，System B 备好了大小房型，动态分区干脆来一位客人现隔一间。Partitioning（分区）研究的就是：怎么切内存，浪费最少？

步骤 0/3

斜纹 = 空着（可分配）

红斜纹 = 内部碎片（白白浪费）

金块 = 进程（住客）

墨块 = OS（操作系统）

内部碎片 0 MB

System A 已就绪：按 ▶ 迎接第一位客人。

W3 · 动画学堂第 6 关

Paging vs Segmentation分页与分段：等份切，还是按意义切？

内存是家只租 4KB 标准间的旅馆。paging（分页）把程序切成一样大的「页」，哪里有空房塞哪里；segmentation（分段）按「代码 / 数据 / 栈」的意义切成大小不一的块——听着优雅，碎片却会找上门。

进程 A 的行李 · 15KB（整块，还没切）

P0 · 4KB

P1 · 4KB

P2 · 4KB

P3 · 3KB▲ 浪费 1KB

进程 A · 15KB

代码 6KB

数据 5KB

栈 4KB

进程 A · 15KB

Physical Memory（物理内存）· 11 帧 × 4KB

F0

A.P0

F1

A.P1

F2

B.P0

F3

A.P2

F4

B.P1

F5

F6

F7

B.P2

F8

B.P3

F9

A.P3

F10

进程 A（15KB → 4 页）进程 B（13KB，已入住）空闲帧

A 的 Page Table（页表）

虚拟页		物理帧
P0	→	—
P1	→	—
P2	→	—
P3	→	—

内存旅馆的房间叫 frame（帧），每间固定 4KB。A 同学拖着 15KB 行李来了，B 同学（13KB）早已入住。怎么切、怎么住、怎么找？点 🔪 切页 开始。

W3 · 动画学堂第 7 关

Page Replacement LabFIFO vs LRU 页面置换实验台

内存帧有限，12 个页面请求依次到来：3 2 1 0 3 2 4 3 2 1 0 4。选算法和帧数，一步步看谁被踢出去。跑完 FIFO 的 3 帧和 4 帧各一遍——帧变多，缺页反而变多，这就是 Bélády's anomaly（Bélády 异常）。

互动 · 逐步跑一遍置换算法

点「▶ 下一步」开始。规则：请求的页不在帧里 = 缺页（fault）；帧满了就按所选算法踢人——FIFO 踢最早进门的，LRU 踢最久没被用过的（命中会刷新新鲜度）。

✏️ Week 3 Quiz（10 题 · 英文）

FIT9137 · 动画学堂 8 关 · 8 篇笔记

Week 4 · I/O 与进程管理

W4 · 动画学堂第 1 关

I/O Devices & Interfaces眼耳口手：I/O 世界与接口权衡

上周我们一直待在「大脑」里面看内存；这周走出来——电脑本体其实又聋又哑，全靠 I/O（Input/Output，输入/输出）设备当它的眼、耳、口、手。这一关先认设备，再看它们靠什么「关节」——Interface（接口）——接到大脑上。

① 翻牌猜类别：眼耳（进）还是口手（出）？

眼和耳把世界送进大脑＝ Input（输入）；口和手替大脑对世界做事＝ Output（输出）。点卡片翻面，看你猜得对不对。

已翻开 0 / 10

Input（输入）＝眼耳 Output（输出）＝口手两者皆是＝两栖（卡背颜色为示意色）

这 10 张只是代表队——Input 家族还有 Touchscreen（触屏）、Accelerometer（加速度计）、LIDAR（激光雷达）；Output 家族还有音响、机器人；存储两栖队除了硬盘、SSD 还有 SD 卡；网络两栖队除了 WiFi 还有 4G / 5G / 以太网 / 蓝牙。

🕰️ 冷知识：I/O 的祖先

Punched tape（打孔纸带）纸带上打孔＝1、不打＝0，最早的输入就是一条纸。● ○ ● ● ○ ● ○ ●

→

Teleprinter（电传打字机）键盘＋打印机合体：敲进去是输入，打出来是输出。

→

今天 · 标准化接口统一插头 USB / PCIe / HDMI，谁家设备都能接上大脑。

② Four tradeoffs（四大权衡）：没有接口四项全能

Convenience（便利）· Speed（速度）· Cost（成本）· Compatibility（兼容）——鱼与熊掌不可兼得，所以接口标准才这么多。点一个场景看看侧重：

条越长＝该场景越看重这一项；其中 Cost（成本）条越长＝越要求接口便宜。

先玩 ①：点卡片翻面，猜它是眼耳还是口手；再玩 ②：切换三个场景，看四条属性此消彼长。

W4 · 动画学堂第 2 关

Memory-mapped vs Port-mapped I/O信箱挂在哪：内存映射与端口映射

键盘、打印机这些设备，身上都自带一个小「信箱」——register（寄存器）：键盘的信箱里躺着当前按键，打印机的信箱等着要打的字。CPU 想跟设备说话，就去信箱取信、投信。整件事只剩一个问题：信箱挂在哪？挂进自家内存楼道（memory-mapped，内存映射），还是在门口单开一排专用信箱（port-mapped，端口映射）？

CPU

AC = —

设备寄存器不在我这儿，
在设备身上！

总线 Bus

0000ʜ FFFFʜ

内存楼道（地址空间）

A000:42

A100:00

Port（端口）空间

⌨️A000ʜ

🖨️A100ʜ

⌨️ 键盘 Keyboard

寄存器 K

存着当前按键

🖨️ 打印机 Printer

寄存器 —

（还没打印东西）

A000

现在是内存映射模式：⌨️ 和 🖨️ 的信箱直接挂在内存楼道的 A000ʜ / A100ʜ 上。点上面的指令按钮看数据怎么走，再切到「端口映射」看信箱搬家。

640KB 往事——早期 PC 的地址空间是 2²⁰ = 1MB，可其中只有 640KB 分给程序，剩下的门牌划给了 I/O 和显示——内存映射是要吃掉真门牌的。如今 64 位机地址空间 2⁶⁴ 大到挥霍不完，所以主流机器全用内存映射；门牌金贵的小型嵌入式 microcontroller（微控制器）里，端口映射仍在服役。

MARIE 是混血儿——W2 认识的 MARIE 两样都占：Input / Output 指令是端口式（instruction-based I/O，读写 IN/OUT 寄存器）；而 F00ʜ–FFFʜ 的显示器是内存映射——往这些地址 Store，就是往屏幕上画点。一台小机器，两种方案同框。

W4 · 动画学堂第 3 关

MARIE Pixel PainterMARIE 像素画板

还记得 W2 那台迷你电脑 MARIE 吗？它的小屏幕其实是内存里划出来的一段「魔法快递柜」：地址 F00ʜ–FFFʜ 共 256 格，一格管一个像素。往格子里 Store（存）一个数，像素立刻变色——不需要任何「画图指令」，这招叫 memory-mapped I/O（内存映射输入输出）。

行优先：第 r 行第 c 列 → 地址 = F00 + 16×r + c（悬停或点击任意格可看算式）

当前指令MARIE Assembly

黑
0000

白
FFFF

红
F800

绿
07E0

蓝
001F

黄
FFE0

调色板与画板均为「示意色」：纸面主题下用近似色调示意，真机写入的是 RGB565（红5·绿6·蓝5 的 16 位色编码）色值——就是色块下方那串十六进制数。未上色的浅格 = 还没写过（真机默认 0000 黑）。

先在右边选个颜色（默认红），再点左边画板任意一格——代码框会立刻亮出这一笔的「真身」：一段三行的 MARIE 程序。也可以点 ▶ 跑竖线程序，看程序自动画一条四红四蓝的竖线。

W4 · 动画学堂第 4 关

Polling vs Interrupt vs DMA三种送货方式：轮询 · 中断 · 直达

CPU 是手脚麻利的大厨，打印机是慢吞吞的服务员——I/O device（I/O 设备）比 CPU 慢得多。现在要把 8 道菜（字符 A–H）一道道递出去：是守在窗口死等？是让服务员按铃叫人？还是雇个跑腿小哥全权代劳？三种送法，大厨的命运天差地别。

CPU · 大厨

空闲 · 等待指令

ready?…ready?…

正事进度0%

Memory（内存）· 8 道菜

ABCDEFGH

Data Bus（数据总线）DMA 占用中

A

中断线 IRQ（Interrupt Request，中断请求）

⚡

DMA 控制器 · 跑腿小哥

待命

命令：搬 8 个字符 → 打印机

打印机 · 慢服务员

就绪 · 等菜

已打出：

（空）

模式	CPU 空闲率（示意）	中断次数	特点 · 适用场景
① Polling 轮询	？	？	跑一遍揭晓
② Interrupt 中断	？	？	跑一遍揭晓
③ DMA	？	？	跑一遍揭晓

① Polling（轮询），又叫 Programmed I/O（程序控制 I/O）：大厨亲自守在传菜口，写个死循环，一遍遍读打印机的 status register（状态寄存器）问「ready 了吗？」。优点：最简单，轮询频率全由程序员定——网络可以问 1 万次/秒，键盘问 10 次/秒就够。缺点：CPU 全程空转（费电），整个程序被 I/O 绑架。按 ▶ 送第 1 道菜。

W4 · 动画学堂第 5 关

Interrupts Under the Microscope中断的显微镜：取指循环 · 上下文切换 · 内核态

上周虚拟内存那关里，缺页时你已经见过「interrupt（中断）」露了一面；这回我们拿显微镜对准它。CPU 是一台不知疲倦的旋转木马：取指令、译码、执行（还记得 W2 的 MARIE 吗？），转个不停——但每转一圈之前，它都会先在门口看一眼：有人按门铃吗？

User mode（用户态）应用在跑 · 受限指令 · 禁 I/O PC = 100

取指转盘 · fetch–decode–execute

🚪中断检查⚡

→

Fetch取指

→

Decode译码

→

Execute执行📞

↻ 执行完回到🚪门口再转一圈——检查中断永远是每圈的第一站

寄存器架 · registers

用户寄存器（程序的现场）

AC17

PC100

IR——

Shadow registers（影子寄存器）

AC0

PCF000

IR——

Interrupt handler（中断处理程序 · OS 的代码）

💤 handler 空闲中——这段 OS 代码只有切入内核态才会被叫醒。

🎡 转盘匀速转。每一圈的第一站是🚪门口：CPU 先问一句「有设备请求中断吗？」——没有，就照常取指。现在是 User mode（用户态）：程序只能用受限指令，连 I/O 指令都被禁用。点上面的 ⚡ 或 📞，送它进一趟 Kernel mode（内核态）。

📜 小历史：从 15 条门铃线，到 APIC

	当年 · IBM PC	现代 · APIC（高级可编程中断控制器）
门铃线（IRQ）	只有 15 条，装新设备要手动挑号，挑重了就冲突、只能共享	直接集成进 CPU，IRQ 数量管够
定时器	——	内置高精度定时器：可以每 1ms 敲一次门
它意味着	插块声卡都要玄学调 IRQ	OS 靠这声「每毫秒的门铃」按时抢回 CPU——下一关的主角

W4 · 动画学堂第 6 关

The Art of Abstraction操作系统——抽象的艺术

把电脑想象成一座四层大厦：你住顶楼，硬件在地下室轰鸣，中间隔着一位全能物业——Operating System（操作系统）。住户从不下地下室，只按服务铃，脏活累活物业全包。这一关看它怎么用 Abstraction（抽象）把复杂世界整个藏起来。

👤 用户层User（用户）

你：点点鼠标、敲敲键盘、喝口咖啡——完全不知道下面三层的兵荒马乱。

📱 应用层Applications（应用程序）

🐍 Python 程序

💭 我独占 CPU！

🌐 浏览器

💭 我的内存从 0 连到无穷！

🎮 游戏

💭 键盘磁盘只伺候我一个！

🏛️ OS 内核层Kernel（内核）· 三大核心职能

进程管理Process

内存管理Memory

I/O 管理I/O

⚙️ 硬件层Hardware（硬件）

CPU

RAM

💽 磁盘

⌨️ 键盘

📶 网卡

🖨️ 打印机

🧬 UNIX 家谱一句话：Linux 是 UNIX 的自由重实现；macOS 基于 BSD UNIX；Windows 没有直接血缘，却处处是它的影子。

远古时代的 OS 只是一摞常用子程序库：整台机器一次只跑一个程序，程序直接全权摸硬件——整栋楼就一个房客，锅炉房他自己管。后来 UNIX 开创了现代 OS：多进程并发、进程间内存保护（一个窗口里的游戏读不到你在另一个窗口敲的密码）、用户间文件保护。点上面的场景，看这位物业管家怎么干活。

W4 · 动画学堂第 7 关

Process States & Time Slice进程状态机与时间片

饭馆只有一位大厨（单核 CPU——一次只能执行一条指令），却同时接了两桌客人。他不会分身，只是这桌炒 30 秒、那桌炒 30 秒地飞快轮换，两桌客人都觉得「大厨一直在为我服务」——这套魔术叫 timesharing（分时）。而每个进程任一时刻只会处于三种状态之一：Ready（就绪）、Running（运行）、Blocked（阻塞）。

t = 0 / 10

Ready就绪
排队等 CPU

Running运行
正占着 CPU

Blocked阻塞
等 I/O

被调度选中

时间片到 · 被抢占

发起 I/O

I/O 完成

✗ Blocked 不能直接回 Running——必须先回 Ready 重新排队

🖥️ CPU（单核 · 一次只跑一个）当前在跑：—（空转）

🎵 Media Player（媒体播放器）MP

Ready（就绪）

在就绪队列排队，随时能上

🌐 Web Browser（网页浏览器）WB

Ready（就绪）

在就绪队列排队，随时能上

时刻	🎵 MP	🌐 WB	发生了什么
t1	Running	Ready	调度器选中 MP
t2	Running	Ready	MP 继续跑
t3	Running	Ready	MP 发起 I/O
t4	Blocked	Running	MP 阻塞，切到 WB
t5	Blocked	Running	WB 继续跑
t6	Ready	Running	I/O 完成，MP 回就绪
t7	Ready	Running	WB 继续跑
t8	Running	Ready	时间片到，切回 MP
t9	Running	Ready	MP 继续跑
t10	Ready	Running	又切到 WB

📖 名词对照：工作坊里说的 Waiting（等待） ＝讲义里的 Blocked（阻塞），同一个状态两种叫法。状态图配色：金实心＝Running，金描边＝Ready，红描边＝Blocked。

按 ▶ 开始播放 10 个时刻。

⚙️ 幕后花絮：每次「切换」的那一瞬，正是上一关的内核态 + 上下文切换在干活——timer 定时器电路定期发中断，CPU 转入内核态，OS 调度器保存旧进程的寄存器快照、装入新进程的。时间片切得越短，大家越公平、越像「同时」在跑；但切换本身也要花时间——切太勤，CPU 光忙着换人，正事反而干得少。这就是调度永远在权衡的 overhead（开销）。

W4 · 动画学堂第 8 关

Round-Robin Scheduler轮转调度台 · 考试真题模拟器

食堂只有一口锅，五位同学轮流用，每人一次最多 50ms——到点就换人，没做完的去队尾重新排。这就是 Round-Robin（轮转调度）：一次能用多久叫 quantum（时间量子），排队的地方叫 Ready Queue（就绪队列）。下面是 Workshop Activity B 的考试同款数据，一片一片放给你看。

片 0 / 9

现在 t = 0ms：P1 刚到达，就绪队列里只有它一个。规则三条：先到先跑、到点让座（满 50ms 就换人；提前跑完立即换，不空等）、队尾排队（片内新到的先入队，片末被抢占的排它后面）。点 ▶ 下一步，看第 1 个时间片。

✏️ Week 4 Quiz（10 题 · 英文）

FIT9137 · 动画学堂 7 关 · 5 篇笔记

Week 5 · 文件管理

W5 · 动画学堂第 1 关

File System Layers文件系统分层塔

硬盘只是一间大仓库，真正管事的是 File System（文件系统）——它像图书馆的三层管理员：前台管「能不能借」，向导管「书在哪」，搬运工只管「上架搬箱」。这一关，跟着一颗光点，走完「读一个文件」的全程。

①「读一个文件」光点之旅

$read("essay.txt", 块 2)← 数据到手 ✓

Logical File System逻辑文件系统 · 前台

管元数据：所有权 · 权限 · 时间戳 · 目录结构

权限 ✓ 放行

File Organization Module文件组织模块 · 向导

逻辑块号 → 物理块号 · 管空闲空间 · 按需分配

块 2 → 块 4711

Basic File System基本文件系统 · 搬运工

管裸数据块 · 按物理块号存取

取块 #4711

硬件 HDD · SSD · M.2 · NVMe01001101… ✓

你敲下 read("essay.txt", 块 2)——上周（W4）说过，这其实是一次 system call（系统调用）。这张「借书条」现在要从塔顶一路传到塔底。点 ▶ 下一步，跟着光点走。

②「这块盘该用什么格式」翻牌小测

U 盘：Windows、Mac、Linux 都要能插

点我翻面

exFAT

三家系统通吃，而且没有单文件 4GB 上限——U 盘首选

十几年前的老车载 MP3

点我翻面

FAT32

兼容之王，再老的设备都认识它；代价：单文件 ≤ 4GB

纯 Windows 的内置硬盘

点我翻面

NTFS

Windows 亲儿子：权限、日志、大文件全都支持

Mac 的 Time Machine 备份盘

点我翻面

APFS

macOS 现代文件系统；更老的盘用 HFS+

树莓派的 SD 卡（跑 Linux）

点我翻面

F2FS / ext4

F2FS 专为闪存设计；ext4 是 Linux 万金油

点一张卡翻面看答案。已翻开 0 / 5。

③常见文件系统速查

文件系统	阵营	一句话记住
FAT32 · exFAT · NTFS	Windows	FAT32 最老最兼容（单文件 ≤ 4GB）；exFAT 跨平台；NTFS 现代主力
ext2/3/4 · XFS · ZFS · BtrFS	Linux	ext4 是万金油；ZFS / BtrFS 自带快照与校验
HFS+ · APFS	macOS	APFS 是现款，HFS+ 是老款
ISO 9660	CD	光盘专用格式
UDF	DVD · 蓝光	DVD / 蓝光通用格式
F2FS	闪存	Flash-Friendly：为 SD 卡 / 手机闪存而生

W5 · 动画学堂第 2 关

Partitions & Volumes分区与卷：把硬盘隔成单元房

一块硬盘就像一栋刚盖好的楼。直接住毛坯楼太乱——先隔成一间间独立的单元房，这就是 Partition（分区）；等会儿你还会看到「两间房打通当一间用」的 Volume（卷），以及格式化好的房间怎么 mount（挂载）进目录树。

① 一刀一刀，把整块磁盘切成四个分区

Disk 整块硬盘 · 512 GB（毛坯，还没隔间）

Bootraw

Rootext4 · 100 GB

Swapraw · 16 GB

Dataext4 · 396 GB

这是一栋刚盖好的毛坯楼——一整块 512 GB 的硬盘。直接住进去太乱，我们把它隔成一间间单元房。点 ▶ 下一步，开始切第一刀。

② Partition vs Volume：卷可以跨盘

Disk 1 · sda

sda1系统 · 312 GB

sda2空闲 · 200 GB

Disk 2 · sdb

sdb1备用 · 312 GB

sdb2空闲 · 200 GB

Volume（卷）· 400 GB · 跨两块盘

新问题来了：Disk 1 只剩 200 GB，Disk 2 也只剩 200 GB，可你的电影库要 400 GB——哪一块盘都装不下。怎么办？点上面的按钮试试。

③ 亲眼看看：Linux 用 lsblk 列出刚才那块盘

$ lsblk

NAME SIZE TYPE MOUNTPOINT sda 512G disk ├─sda1 4M part ├─sda2 100G part / ├─sda3 16G part [SWAP] └─sda4 396G part /home

和①的动画一一对上了：sda1 是 Boot、sda2 是 Root、sda3 是 Swap、sda4 是 Data。MOUNTPOINT（挂载点）就是每个分区被「挂」到哪个目录：Root 挂在 /，Data 挂在 /home——挂上了，你才能像逛文件夹一样使用它。注意 sda1 那格是空的：raw 分区没有文件系统，根本不需要挂载；Swap 也不挂进目录树，只标一个 [SWAP]。

⚠️ Windows 的 Disk Management、macOS 的 Disk Utility、Linux 的 lsblk/fdisk 都能做这些事——它们也都挂着同一句警告：分区手滑 = 数据永久丢失，动手之前先备份。

W5 · 动画学堂第 3 关

Everything Is a File一切皆文件：七种标签与 inode 身份证

Unix 眼里没有「照片」「程序」「硬盘」之分——万物都是仓库里的包裹：一串 bytes（字节），区别只在标签。这一关先翻七张标签牌，再解剖一个目录，最后查一张包裹的身份证 inode（索引节点）。

第 0 / 7 步

①七张标签牌 — ls -l 每行的第一个字符（点牌翻面）

②解剖一个目录 — 它也只是个文件

docs/ 这个「文件」的真实内容：

inode 号	文件名
234	.（我自己）
100	..（上一级）
1234	essay.txt
5678	photo.png

表里只有「号 ↔ 名」两栏——没装任何文件本体。

③包裹的身份证 — inode（索引节点），stat 可查

$ ls -l essay.txt

-rw-r--r-- 1 dan staff 4096 essay.txt

$ stat essay.txt

Inode: 1234

$ mv essay.txt thesis.txt

$ stat thesis.txt

Inode: 1234 ← 号没变！

改个名，看 inode 号变不变

欢迎来到仓库。Unix 眼里万物都是文件——一个文件就是一串 bytes（字节），像仓库里的一个个包裹，区别只在标签。按 ▶ 一步步看，也可以随手点任何卡牌玩。

W5 · 动画学堂第 4 关

File Permissions: rwx & chmod权限拨盘与 chmod 实验台

把文件想成一间小屋，门口挂着一块 3×3 的开关板：三行是三种人 —— user（拥有者）、group（同组）、others（其他人）；三列是三种动作 —— read（读，记 4 分）、write（写，记 2 分）、execute（执行，记 1 分）。命令 chmod（change mode，改权限）就是去拨这块板子的那只手 —— 和上周 W4 学的 open、read 一样，它最终也是一次系统调用。

① 权限拨盘 · 点格子开关

r读 · 4

w写 · 2

x执行 · 1

u拥有者

g同组

o其他人

口诀：一组三个开关的分数相加，就是这一组的一位数字。

权限串 string

类型- urwx grw- or--

八进制 octal

等价命令 chmod

② 照命令拨 · 出题模式

③ chmod 符号法 · 小终端

数字	样子	常见用途
644	rw-r--r--	普通文件的默认权限
755	rwxr-xr-x	可执行程序 / 目录
700	rwx------	私密目录（如 ~/.ssh）
664	rw-rw-r--	组内协作文件
764	rwxrw-r--	本周 Activity A 目标

先自由拨几下 9 个开关：权限串、八进制、命令三块会实时联动。然后点 ② 的题卡接受挑战——拨对了拨盘会亮金圈；再到 ③ 看符号法逐条演示。

W5 · 动画学堂第 5 关

Who Can Touch This File?谁能动这个文件？——访问判定与 setuid 变身术

文件像一间上锁的房间，门口贴着三行门规：主人怎么进、家人怎么进、陌生人怎么进。门卫查证件只认 effective uid/gid（有效身份）这一对，从上往下、最多命中一次。最后还有一个会「变身」的彩蛋：setuid（设置用户身份位）。

判定流水线（只看 effective，从上往下，命中即停）

euid == david ?① 是属主吗？→ 用 User 段

↓ 否

egid == fit9137 ?② 在属组里吗？→ 用 Group 段

↓ 否

其余所有人③ 兜底 → 用 Others 段

🦸 root = Superuser（超级用户）：无视全部权限位，直接放行

📄 groupwork.txt

-rw-rw-r--= 664

■ User 属主段■ Group 属组段■ Others 其他人

属主 owner：david · 属组 group：fit9137

📖 读 read

✍️ 写 write

$ echo "hi" >> groupwork.txt
bash: groupwork.txt: Permission denied

👩susan
effective uid = susan

susan$ _

⚙️ /usr/bin/passwd

-rwsr-xr-x

属主 root · 属组 root · 一个「会变身」的程序

🗂 /etc/passwd

-rw-r--r--

属主 root · 全系统账户名单，普通人只读

W5 · 动画学堂第 6 关

Hard Link vs Symbolic Link硬链接与符号链接：户口名与便签纸

一个文件可以有几个名字？Unix 把「名字」和「文件本体」分成两回事：Hard Link（硬链接）像同一个人再办一个正式户口名，Symbolic Link（符号链接 / 软链接）只是一张写着地址的便签纸。看完这一关你就知道，rm 删掉的到底是什么。

第 1 / 6 步

目录条目 · 名字

inode 表 · 本体档案

数据块 · 内容

file名字①

hard_link名字②

inode 1234

链接数 1

权限 rw-r--r-- · 大小 12 B

data blocks

Hello, Unix!

soft_link

一张便签，内容只有路径：
→ hard_link

dangling ⚠️ 悬空

♻ 空间已标记，可复用

# 终端 · 跟着每一步看命令

$ ln file hard_link # 硬链接：再登记一个正式名字

$ rm file # 只删名字

$ ln -s hard_link soft_link # 软链接：写一张地址便签

$ rm hard_link # 最后一个名字没了…

对比	Hard Link（硬链接）	Symbolic Link（软链接）
命令	`ln file hard_link`	`ln -s file soft_link`
指向什么	直接指 inode——又一个正式名字	一个独立小文件，内容是「目标路径」
跨分区（文件系统）	不行	可以
链接到目录	不行	可以
目标删除后	还剩一个名字就活着；最后一个被删才真正消亡	便签还在，地址落空 → dangling（悬空）

初始状态：目录里登记着一个名字 file——这行登记叫 directory entry（目录条目），它指向 inode 1234。inode（index node，索引节点）是 Unix 文件系统里描述文件「本体」的数据结构：权限、大小、数据块位置都记在它身上，再由它指向硬盘上的数据块。名字 file 本身就是这个 inode 的第 1 个硬链接：每个文件天生至少有一个硬链接。

W5 · 动画学堂第 7 关

Terminal QuestLinux 命令闯关终端

点图标是「用手指点菜」，敲命令是直接跟后厨喊单——话说对了，上菜飞快。这个黑框叫 Terminal（终端）：你打一句、电脑回一句；替你传话的翻译官叫 Shell（壳程序），它把你的命令变成上周 W4 讲过的系统调用。下面 8 关，每关一条命令，把本周 Applied 实操一次练熟。

①pwd✅ ②ls -l✅ ③mkdir -p✅ ④cd✅ ⑤cd ../..✅ ⑥cp✅ ⑦rm -r✅ ⑧ls -ld✅

daniel@vm — bash

Welcome to Ubuntu 24.04 LTS (daniel@vm)

# 提示：man 命令名 = 随时查说明书

daniel@vm:~$pwd

命令已替你填好，放心点

📂 文件树 · 🚩 = 你在这里

🏠 /home/daniel🚩

📄 notes.txt

📁 photos

📁 monash🚩

📁 data🚩

📄 hostname

📁 temp🚩

🗄 参观区：系统的配置抽屉（只读）

📁 /etc

📄 host.conf

📄 hostname

📄 hosts

🎯 第 1 关：你刚登录一台 Linux 虚拟机，两眼一抹黑。先问电脑一句：我现在在哪个文件夹？命令已经替你填在提示符后面了，点终端里的 ▶ 执行 就行。

✏️ Week 5 Quiz（10 题 · 英文）

FIT9137 · 3 篇笔记连贯阅读

Week 6 · 计算机网络导论

🎮 消息封装流水线 —— 一条消息从应用层套到物理层，再反着拆回来

讲义 Slide 7 用的是邮政类比：你写好的一张信纸，先塞进信封、再套进印着完整门牌的邮包、最后装进本地快递箱，才被卡车拉走。TCP/IP 协议栈干的是同一件事——每下一层就在数据前面贴一个自己的 header（首部），同一坨东西也跟着换一个名字（PDU）。下面这条流水线用的是本周 pcap 第 6 帧的真实数值。点 ▶ 下一层 一层层套下去，再按 🔁 切到接收端反着拆一遍。

套信封 · 逐层包装 / 逐层拆包装

TCP/IP 层	PDU 名称	本帧加的首部	这一层靠什么找人	邮政类比
Application 应用层	Message 消息	无（HTTP 是纯文本，没有定长首部）	domain name 域名	你手写的那张信纸
Transport 传输层	Segment 段	TCP 首部 32 字节	port number 端口号	信封：写「寄件分机 → 收件窗口」
Network 网络层	Packet / Datagram 分组·数据报	IPv4 首部 20 字节	IP address 地址	邮包：印着完整街道门牌
Data Link 数据链路层	Frame 帧	Ethernet 首部 14 字节	MAC address 地址	本地快递箱：只写「下一站」
Physical 物理层	Bits 比特	无（直接变信号）	无地址	卡车开走，只剩一路颠簸

🎮 Wireshark 帧解剖台 —— 432 字节是怎么分掉的

讲义 Slide 13 的真实抓包：第 6 帧一共 432 字节，拆开是 Ethernet 14 + IPv4 20 + TCP 32 + HTTP 载荷 366。为了送出 366 字节的实际内容，网络额外付出了 66 字节的首部开销（overhead），约 15.3%。点下面任意一层，看它占多大、里面到底装了什么。

字节占比条 · 一格代表线缆上的一段字节

层 / 协议	字节数	占整帧	头里装的关键字段	本帧的真实值
Data Link · Ethernet II	14	3.2%	目的 MAC 6 B + 源 MAC 6 B + Type 2 B	Src 68:a8:6d:0c:d1:68 → Dst 78:a0:51:1e:d9:4e，Type 0x0800
Network · IPv4	20	4.6%	源 IP / 目的 IP / TTL / Protocol	192.168.1.15 → 130.194.64.145，TTL 64，Protocol 6
Transport · TCP	32	7.4%	源端口 / 目的端口 / Seq / Ack / Flags / 选项	56021 → 80，Flags PSH+ACK，含 12 B Timestamps 选项
Application · HTTP	366	84.7%	无定长首部，整段就是请求报文	GET /~guidot/ HTTP/1.1，Host: www.csse.monash.edu
合计 = 整帧	432	100%	首部合计 66 B（开销约 15.3%）	432 字节 = 3456 比特

🎮 网络命令速查台 —— 六条命令，各查哪一层的地址

工作坊活动 A 要在 VM 终端里敲的就是这几条。它们的分工正好对应本周的分层：nslookup 把应用层的域名翻成网络层的 IP，ifconfig 一次看到本机两层的地址，ping / traceroute 测的是网络层的连通性与路径，netstat 摊开传输层的连接，arp 则是 IP 与 MAC 之间的翻译表。下面的输出为示意示例（自行编写，非真实抓取），字段格式与真机一致，用来练读法。

输出里的行 / 字段	中文解读

✏️ Week 6 Quiz（10 题）