# Objects And Classes

文档类型：语法主线
是否可直接用于生成代码：仅部分
是否含已验证可执行示例：是
是否含已验证反例：是
遇到不确定时跳转到：[10_units_and_scope.md](10_units_and_scope.md)（优先）、[23_object_runtime_and_introspection.md](23_object_runtime_and_introspection.md)、[12_pitfalls.md](12_pitfalls.md)

手册位置：第 9 篇，共 32 篇。上一篇：[08_control_flow.md](08_control_flow.md)。下一篇：[10_units_and_scope.md](10_units_and_scope.md)。

这一篇收拢面向对象语法，只保留语言层规则。

## 这一篇解决什么问题

回答“`type Name = class`、字段、`static`、方法、`property`、析构、类类型、继承和对象创建在 TSL 里怎样写”。

本页后半段有少量依赖 `unit` 的双文件示例；如果你还没建立 `unit` / `uses` 的多文件心智模型，先看 [10_units_and_scope.md](10_units_and_scope.md)。

## 必须记住的规则

- 类定义统一按 `type Name = class ... end;` 写。
- 顶层类声明当前已验证可以放在松散语句之后（单向允许）。
- 顶层类声明当前也已验证可以放在顶层 `function / procedure` 之后。
- 类声明当前没有通过写在函数体内部。
- 在松散语句脚本里，可以先写松散语句再进入顶层类声明；但一旦进入顶层 `type Name = class ... end;` 声明，后面不能再回到松散语句模式。
- 类里可以直接写字段和方法。
- `static` 字段已验证可用；可以通过类类型访问，也可以通过实例访问。
- `const` 成员已验证可用；实例常量可通过实例读取，`static const` 可通过类类型读取，也已验证可用于成员函数默认参数。
- 方法体里可以用 `self` 指向当前实例。
- `overload` 方法已验证可用；同名不同参数个数的方法可以共存。
- 基础 `property` 形态已验证：`property Name read fieldOrMethod write fieldOrMethod`。
- `property Name: Type ...` 这种类型注解写法已验证可用。
- 参数化 `property` 已验证；当前这篇只写已经单独跑通的基础模式。
- 参数化 `property` 的 accessor 方法当前已验证两种常见模式：读方法接同参数个数，写方法接“参数个数 + 赋值值”。
- 索引型 `property` 已验证；调用时用圆括号 `obj.Prop(index)`。
- 固定 `index` property 已验证；它可以把某个固定索引直接映射成普通属性读写。
- `class(Name)` 和 `FindClass("Name")` 都可以拿到类类型。
- `FindClass("ClassName", obj)` 已验证可把对象转成指定父类视图。
- `class function` 已验证可用；本页里的“类方法”就是指 `class function`，前者是中文描述，后者是代码写法。
- 当前解释器下更稳妥的类方法调用方式是先拿到类类型，再在类类型上调用。
- 基础继承写法是 `type Child = class(Parent)`。
- 多重继承写法 `type Child = class(Base1, Base2)` 已验证可用。
- 基础覆盖写法是：父类方法声明为 `virtual`，子类对应方法声明为 `override`。
- 基础祖先类调用已验证：可以用 `Inherited;`、`Inherited MethodName(...)` 或 `class(BaseClass, ObjectName).MethodName()`。
- 已验证的对象创建写法至少有三种：`CreateObject("ClassName")`、`CreateObject(ClassType)` 和 `new ClassName()`。
- 如果没有特殊需求，默认优先用 `new ClassName()`；只有需要字符串路径、类类型变量或跨 `unit` 路径时，再改用 `CreateObject(...)`。
- 如果类里定义了 `function create(...)`，`new`、`CreateObject("ClassName", ...)` 和 `CreateObject(ClassType, ...)` 都已验证可以透传构造参数，也都已验证支持默认参数和命名参数。
- 当前已验证的析构写法是无参 `function destroy();`；把对象引用设为 `nil` 时会触发它。
- 工厂式 `self(0)` / `self(1)` 已验证可用；当前解释器没有通过 `self()` 这种无参工厂式写法。
- 已做双文件运行验证：如果类定义在 `unit` 的嵌套路径里，可以用 `CreateObject("Unit1.Class1.Class2")` 这种字符串路径创建对象。
- 已做双文件运行验证：可以写 `type MyNewClass = class(Unit1.Class1.Class2)` 直接继承单元里的嵌套类路径。
- 当前环境里 `{$IFDEF ParentClassInUnit}` 为真，可用于探测“继承和构造单元中的类”能力是否可用。
- `private` / `protected` / `public` 已验证可用；类开头未写可见性时，成员默认按 `public` 处理。
- 同一个可见性段里后续没有切换关键字的成员，会沿用前一个可见性。
- 外部访问 `private` / `protected` 字段或方法，会在执行时报对象成员访问错误。
- 子类可以通过 `self` 访问父类 `protected` 成员；不能通过 `self` 访问父类 `private` 成员。
- `create` 写成 `private` 或 `protected` 时，对象仍能创建，但 `new` 和 `CreateObject(...)` 不会执行该构造逻辑；构造函数应保持 `public`。
- 更复杂的多重继承边界和更复杂的对象模型还没有在这篇里完整展开。

## 已验证语法

最短类骨架：

如果你现在只是要“先写出一个类”，先从这个骨架起手；后面的例子再逐步进入字段、工厂函数和声明位置边界。

代码块身份：已验证可执行示例

```tsl
type Person = class
end;
```

字段、方法和 `CreateObject`：

代码块身份：已验证可执行示例

```tsl
type Person = class
    name;
    function SetName(new_name);
    begin
        name := new_name;
    end;
end;

function MakePerson();
begin
    return CreateObject("Person");
end;
```

类声明位置：

代码块身份：已验证可执行示例

```tsl
obj := CreateObject("MyClass");
obj.value := 5;
WriteLn(obj.value);

type MyClass = class
    value;
end;
```

已验证运行结果：

- 输出 `5`
- 说明在当前解释器里，顶层类声明可以放在松散语句之后
- 同时也说明 `CreateObject("MyClass")` 可以解析到后面才出现的类声明

顶层函数后面也可以继续声明类：

代码块身份：已验证可执行示例

```tsl
function MakeObj();
begin
    return 1;
end;

type MyClass = class
    value;
end;
```

已验证结果：

- 上述 `.tsf` 例子可以编译通过

类声明位置的反例：

代码块身份：反例 / 不可照写

```text
// 函数体内部声明类
function Demo();
begin
    type InnerClass = class
        value;
    end;
    return 1;
end;

// 松散语句在 type 之后继续出现
a := 1;
type MyClass = class
    value;
end;
WriteLn(a);
```

已验证结果：

- 函数体内部声明类会报 `invalid statement`
- 在松散语句脚本里，`type MyClass = class ... end;` 之后继续写 `WriteLn(a);` 也会报 `invalid statement`

`static` 字段：

代码块身份：已验证可执行示例

```tsl
program test;
type THuman = class
    static
    mCount;
    function create();
    begin
        mCount := (mCount ?: 0) + 1;
    end;
end;
begin
    class(THuman).mCount := 100;
    WriteLn(class(THuman).mCount);
    h := new THuman();
    WriteLn(class(THuman).mCount);
    WriteLn(h.mCount);
end.
```

已验证运行结果：

- `class(THuman).mCount := 100` 可以直接写静态字段
- `class(THuman).mCount` 先输出 `100`
- 创建对象后，`class(THuman).mCount` 输出 `101`
- 通过实例读取 `h.mCount` 也输出 `101`

同一字段也接受内联声明：

代码块身份：已验证可执行示例

```tsl
program test;
type THuman = class
    static mCount;
    function create();
    begin
        mCount := (mCount ?: 0) + 1;
    end;
end;
begin
    class(THuman).mCount := 100;
    h := new THuman();
    WriteLn(class(THuman).mCount);
end.
```

已验证运行结果：

- `static mCount;` 这种内联写法也可以通过
- 上述例子中的 `class(THuman).mCount` 输出 `101`

`const` 成员：

代码块身份：已验证可执行示例

```tsl
program test;
type C = class
public
    const mA = 1;
    static const mB = mA + 10;
    function TestConst();
    begin
        return mA + mB;
    end;
    function TestConstInParam(b = mB);
    begin
        return b;
    end;
end;
begin
    o := new C();
    WriteLn(o.TestConst());
    WriteLn(o.TestConstInParam());
    WriteLn(o.mA);
    WriteLn(class(C).mB);
end.
```

已验证运行结果：

- 依次输出 `12`、`11`、`1`、`11`
- 说明类里可以定义实例常量和 `static const`
- 说明实例常量可通过实例读取，`static const` 可通过 `class(C)` 读取
- 说明成员常量当前也可用于成员函数默认参数

`self` 指向当前实例：

代码块身份：已验证可执行示例

```tsl
program test;
type Counter = class
    value;
    function create(v);
    begin
        self.value := v;
    end;
    function Inc();
    begin
        self.value := self.value + 1;
        return self.value;
    end;
end;
begin
    c := new Counter(10);
    WriteLn(c.Inc());
end.
```

已验证运行结果：

- `c.Inc()` 输出 `11`

可见性 `private` / `protected` / `public`：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    value;
private
    secret;
    backup;
public
    function create();
    begin
        self.secret := 2;
        self.backup := 3;
    end;
    function ReadSecret();
    begin
        return self.secret + self.backup;
    end;
end;
begin
    a := new A();
    a.value := 9;
    WriteLn(a.value);
    WriteLn(a.ReadSecret());
end.
```

已验证运行结果：

- 类开头没有显式可见性时，`value` 默认按 `public` 处理，因此 `a.value := 9` 可以直接写。
- `backup` 跟在 `private` 段后面，没有重新切换关键字，因此仍按 `private` 处理。
- 上述例子依次输出 `9`、`5`。

`protected` 可供子类通过 `self` 访问：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
protected
    value;
    function Hidden();
    begin
        return 88;
    end;
end;
type B = class(A)
public
    function SetValue(v);
    begin
        self.value := v;
    end;
    function GetValue();
    begin
        return self.value;
    end;
    function TryCall();
    begin
        return self.Hidden();
    end;
end;
begin
    b := new B();
    b.SetValue(66);
    WriteLn(b.GetValue());
    WriteLn(b.TryCall());
end.
```

已验证运行结果：

- 子类里可以通过 `self.value` 访问父类 `protected` 字段。
- 子类里也可以通过 `self.Hidden()` 调用父类 `protected` 方法。
- 上述例子依次输出 `66`、`88`。

`private` 的失败场景，因为是已验证反例，这里用 `text` 展示：

代码块身份：反例 / 不可照写

```text
// 外部访问 private 字段
program test;
type A = class
private
    secret;
public
    function create();
    begin
        self.secret := 7;
    end;
end;
begin
    a := new A();
    WriteLn(a.secret);
end.

// 子类访问父类 private 字段
program test;
type A = class
private
    secret;
public
    function ReadSecret();
    begin
        return self.secret;
    end;
end;
type B = class(A)
public
    function SetSecret(v);
    begin
        self.secret := v;
    end;
end;
begin
    b := new B();
    b.SetSecret(77);
    WriteLn(b.ReadSecret());
end.
```

已验证运行结果：

- 外部访问 `a.secret` 会在执行时报对象成员访问错误。
- 子类里通过 `self.secret` 访问父类 `private` 字段也会在执行时报错。
- 同样的规则也已单独用 `private` / `protected` 方法访问做过复核：外部不能调 `private` / `protected` 方法，子类只能调 `protected` 方法，不能调 `private` 方法。

`create` 建议保持 `public`：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
public
    value;
private
    function create(v);
    begin
        self.value := v;
    end;
end;
begin
    a := new A(111);
    WriteLn(a.value);
end.
```

已验证运行结果：

- `a := new A(111)` 可以创建对象。
- 上述例子里的 `a.value` 输出 `<NIL>`，说明 `private create` 没有执行。
- 同样的结果已单独用 `protected create`、`CreateObject("A", ...)` 和 `CreateObject(class(A), ...)` 复核；当前解释器里构造函数应保持 `public`。

基础 `property`：

代码块身份：已验证可执行示例

```tsl
program test;
type MyBox = class
    _value;
    function SetValue(v);
    begin
        if v > 0 then
            _value := v;
    end;
    property Value read _value write SetValue;
end;
begin
    b := new MyBox();
    b.Value := 7;
    WriteLn(b.Value);
    b.Value := -1;
    WriteLn(b.Value);
end.
```

已验证运行结果：

- `b.Value := 7` 后，`b.Value` 输出 `7`
- `b.Value := -1` 后，`b.Value` 仍输出 `7`

带类型注解的 `property`：

代码块身份：已验证可执行示例

```tsl
program test;
type MyBox = class
    _value;
    function SetValue(v);
    begin
        _value := v;
    end;
    property Value: score_value read _value write SetValue;
end;
begin
    b := new MyBox();
    b.Value := 9;
    WriteLn(b.Value);
end.
```

已验证运行结果：

- `property Value: score_value ...` 这种类型注解写法可以通过
- 上述例子中的 `b.Value` 输出 `9`

索引型 `property`：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    arr;
    function create();
    begin
        arr := array();
    end;
    function rIndex(i);
    begin
        return arr[i];
    end;
    function wIndex(i, value);
    begin
        arr[i] := value;
    end;
    property idx read rIndex write wIndex;
end;
begin
    aa := new A();
    aa.idx(0) := "abc";
    WriteLn(aa.idx(0));
end.
```

已验证运行结果：

- `aa.idx(0) := "abc"` 可以写入索引 property
- `aa.idx(0)` 输出 `abc`

固定 `index` property：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    arr;
    function create();
    begin
        arr := array();
    end;
    function rIndex(i);
    begin
        return arr[i];
    end;
    function wIndex(i, value);
    begin
        arr[i] := value;
    end;
    property idx read rIndex write wIndex;
    property idx0 index 0 read rIndex write wIndex;
end;
begin
    aa := new A();
    aa.idx0 := "abc";
    WriteLn(aa.idx0);
    WriteLn(aa.idx(0));
end.
```

已验证运行结果：

- `aa.idx0 := "abc"` 可以写入固定整数索引 property
- `aa.idx0` 输出 `abc`
- `aa.idx(0)` 也输出 `abc`

固定字符串索引：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    arr;
    function create();
    begin
        arr := array();
    end;
    function rIndex(i);
    begin
        return arr[i];
    end;
    function wIndex(i, value);
    begin
        arr[i] := value;
    end;
    property idx read rIndex write wIndex;
    property school index "High school" read rIndex write wIndex;
end;
begin
    aa := new A();
    aa.school := "math";
    WriteLn(aa.school);
    WriteLn(aa.idx("High school"));
end.
```

已验证运行结果：

- `property school index "High school"` 这种固定字符串索引写法可以通过
- `aa.school` 输出 `math`
- `aa.idx("High school")` 也输出 `math`

参数化 `property`：

代码块身份：已验证可执行示例

```tsl
program test;
type MyDate = class
    _year;
    _month;
    _day;
    function getDateV();
    begin
        return _year * 10000 + _month * 100 + _day;
    end;
    function setDateV(y, m, d);
    begin
        _year := y;
        _month := m;
        _day := d;
    end;
    property DateV(y, m) read getDateV write setDateV;
end;
begin
    d := new MyDate();
    d.DateV(2025, 8) := 10;
    WriteLn(d.DateV());
end.
```

已验证运行结果：

- `d.DateV(2025, 8) := 10` 可以给参数化 property 赋值
- `d.DateV()` 输出 `20250810`

参数化 `property` 的 accessor 方法参数：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    arr;
    function create();
    begin
        arr := array();
    end;
    function getItem(i);
    begin
        return arr[i];
    end;
    function setItem(i, value);
    begin
        arr[i] := value;
    end;
    property Item(i): slot_type read getItem write setItem;
end;
begin
    aa := new A();
    aa.Item(2) := "x";
    WriteLn(aa.Item(2));
end.
```

已验证运行结果：

- `read getItem` 这种“读方法接同参数个数”的写法可以通过
- `write setItem` 这种“写方法接参数个数 + 赋值值”的写法可以通过
- 上述例子中的 `aa.Item(2)` 输出 `x`

`new` 关键字：

代码块身份：已验证可执行示例

```tsl
type Person = class
end;

function MakePerson();
begin
    return new Person();
end;
```

通过类类型创建对象：

代码块身份：已验证可执行示例

```tsl
program test;
type Person = class
    value;
end;
begin
    cls := FindClass("Person");
    obj := CreateObject(cls);
    obj.value := 42;
    WriteLn(obj.value);
end.
```

已验证运行结果：

- `CreateObject(cls)` 可以通过类类型创建对象
- 上述例子中的 `obj.value` 输出 `42`

也可以用 `class(Name)` 取得类类型：

代码块身份：已验证可执行示例

```tsl
program test;
type Person = class
    value;
    function create(v);
    begin
        value := v;
    end;
end;
begin
    cls := class(Person);
    obj := CreateObject(cls, 44);
    WriteLn(obj.value);
end.
```

已验证运行结果：

- `class(Person)` 可以拿到 `Person` 的类类型
- `CreateObject(cls, 44)` 输出 `44`

构造参数、默认值和命名参数：

代码块身份：已验证可执行示例

```tsl
program test;
type Person = class
    a;
    b;
    c;
    function create(a, b = 20, c = 30);
    begin
        self.a := a;
        self.b := b;
        self.c := c;
    end;
end;
begin
    a := CreateObject("Person", 11);
    WriteLn(a.a);
    WriteLn(a.b);
    WriteLn(a.c);
    b := new Person(22, c:99);
    WriteLn(b.a);
    WriteLn(b.b);
    WriteLn(b.c);
end.
```

已验证运行结果：

- `CreateObject("Person", 11)` 依次输出 `11`、`20`、`30`
- `new Person(22, c:99)` 依次输出 `22`、`20`、`99`
- 说明构造函数默认参数和命名参数不只适用于普通函数调用，也适用于对象创建

类类型也同样支持默认参数和命名参数：

代码块身份：已验证可执行示例

```tsl
program test;
type Person = class
    a;
    b;
    c;
    function create(a, b = 20, c = 30);
    begin
        self.a := a;
        self.b := b;
        self.c := c;
    end;
end;
begin
    cls := FindClass("Person");
    obj := CreateObject(cls, 33, c:77);
    WriteLn(obj.a);
    WriteLn(obj.b);
    WriteLn(obj.c);
end.
```

已验证运行结果：

- `CreateObject(cls, 33, c:77)` 依次输出 `33`、`20`、`77`
- 因此类类型入口下的 `CreateObject(cls, ...)` 也遵循同样的构造参数规则

`class function`：

代码块身份：已验证可执行示例

```tsl
program test;
type MathBox = class
    class function Add(x, y);
    begin
        return x + y;
    end;
end;
begin
    cls1 := class(MathBox);
    WriteLn(cls1.Add(3, 4));
    cls2 := FindClass("MathBox");
    WriteLn(cls2.Add(5, 6));
end.
```

已验证运行结果：

- `class(MathBox).Add(...)` 可以调用类方法
- `FindClass("MathBox").Add(...)` 可以调用类方法
- 上述例子依次输出 `7`、`11`

`overload` 方法：

代码块身份：已验证可执行示例

```tsl
program test;
type TestClass = class
    function fun(p1, p2); overload;
    begin
        return p1 + p2;
    end;
    function fun(p1); overload;
    begin
        return p1 + 10;
    end;
end;
begin
    t := new TestClass();
    WriteLn(t.fun(1, 2));
    WriteLn(t.fun(5));
end.
```

已验证运行结果：

- 依次输出 `3`、`15`
- 说明同名不同参数个数的方法当前可以共存

基础继承：

代码块身份：已验证可执行示例

```tsl
program test;
type Animal = class
    function Speak();
    begin
        return 1;
    end;
end;
type Dog = class(Animal)
end;
begin
    d := new Dog();
    WriteLn(d.Speak());
end.
```

已验证运行结果：

- `type Dog = class(Animal)` 可以继承父类实例方法
- 上述例子中的 `d.Speak()` 输出 `1`

多重继承：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    function Fa();
    begin
        return 1;
    end;
end;
type B = class
    function Fb();
    begin
        return 2;
    end;
end;
type C = class(A, B)
end;
begin
    obj := new C();
    WriteLn(obj.Fa());
    WriteLn(obj.Fb());
end.
```

已验证运行结果：

- `type C = class(A, B)` 可以同时继承 `A` 和 `B` 的方法
- 上述例子依次输出 `1`、`2`

多重继承下的同名方法优先级：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    function Speak();
    begin
        return 1;
    end;
end;
type B = class
    function Speak();
    begin
        return 2;
    end;
end;
type C = class(A, B)
end;
begin
    obj := new C();
    WriteLn(obj.Speak());
end.
```

已验证运行结果：

- 当多个父类存在同名方法时，当前例子优先命中第一个父类 `A`
- 上述例子中的 `obj.Speak()` 输出 `1`

基础 `virtual` / `override`：

代码块身份：已验证可执行示例

```tsl
program test;
type Animal = class
    function Speak(); virtual;
    begin
        return 1;
    end;
end;
type Dog = class(Animal)
    function Speak(); override;
    begin
        return 2;
    end;
end;
begin
    d := new Dog();
    WriteLn(d.Speak());
end.
```

已验证运行结果：

- 父类 `virtual` + 子类 `override` 组合可以通过
- 上述例子中的 `d.Speak()` 输出 `2`

`class(BaseClass, ObjectName).MethodName()`：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    function Speak(); virtual;
    begin
        return 1;
    end;
end;
type B = class(A)
    function Speak(); override;
    begin
        return 2;
    end;
end;
begin
    obj := new B();
    WriteLn(obj.Speak());
    WriteLn(class(A, obj).Speak());
end.
```

已验证运行结果：

- `obj.Speak()` 输出 `2`
- `class(A, obj).Speak()` 会定向调用祖先类方法，因此输出 `1`

`FindClass("ClassName", obj)` 强制转型：

代码块身份：已验证可执行示例

```tsl
program test;
type ClassA = class
    function Fuc(); virtual;
    begin
        return 1;
    end;
end;
type ClassB = class(ClassA)
    function Fuc(); override;
    begin
        return 2;
    end;
end;
begin
    objb := new ClassB();
    obj := FindClass("ClassA", objb);
    WriteLn(obj.Fuc());
    WriteLn(obj is class(ClassA));
    WriteLn(obj is class(ClassB));
end.
```

已验证运行结果：

- `FindClass("ClassA", objb)` 会把 `objb` 转成 `ClassA` 视图
- 上述例子中的 `obj.Fuc()` 输出 `1`
- 转型后的 `obj is class(ClassA)` 输出 `1`
- 转型后的 `obj is class(ClassB)` 输出 `0`

`Inherited;`：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    function Speak(); virtual;
    begin
        WriteLn(1);
    end;
end;
type B = class(A)
    function Speak(); override;
    begin
        Inherited;
        WriteLn(2);
    end;
end;
begin
    obj := new B();
    obj.Speak();
end.
```

已验证运行结果：

- `Inherited;` 会先执行父类同名同参数方法
- 上述例子依次输出 `1`、`2`

`Inherited MethodName(...)`：

代码块身份：已验证可执行示例

```tsl
program test;
type A = class
    function BaseValue(x);
    begin
        WriteLn(x + 1);
    end;
end;
type B = class(A)
    function Run();
    begin
        Inherited BaseValue(5);
        WriteLn(9);
    end;
end;
begin
    obj := new B();
    obj.Run();
end.
```

已验证运行结果：

- `Inherited BaseValue(5)` 可以显式调用父类指定方法
- 上述例子依次输出 `6`、`9`

析构函数 `destroy`：

代码块身份：已验证可执行示例

```tsl
program test;
type THuman = class
    static mCount;
    function create();
    begin
        mCount := (mCount ?: 0) + 1;
    end;
    function destroy();
    begin
        mCount--;
        WriteLn(mCount);
    end;
    class function GetCount();
    begin
        return mCount;
    end;
end;
begin
    h := new THuman();
    WriteLn(class(THuman).GetCount());
    h := nil;
    WriteLn(class(THuman).GetCount());
end.
```

已验证运行结果：

- 创建对象后，`class(THuman).GetCount()` 输出 `1`
- `h := nil` 时会触发 `destroy()`，中途输出 `0`
- 释放后再次读取 `class(THuman).GetCount()` 也输出 `0`

`self(0)` / `self(1)`：

代码块身份：已验证可执行示例

```tsl
program test;
type BaseBox = class
    function MakeOwner();
    begin
        return self(1);
    end;
    function MakeBase();
    begin
        return self(0);
    end;
end;
type ChildBox = class(BaseBox)
end;
begin
    c := new ChildBox();
    a := c.MakeOwner();
    b := c.MakeBase();
    WriteLn(a is class(ChildBox));
    WriteLn(b is class(ChildBox));
end.
```

已验证运行结果：

- `self(1)` 返回的对象在这个例子里是 `ChildBox`，因此输出 `1`
- `self(0)` 返回的对象在这个例子里不是 `ChildBox`，因此输出 `0`

`unit` 中的嵌套类路径创建，因为依赖多文件环境，这里用 `text` 展示：

代码块身份：配置片段 / 概念骨架
代码块说明：已在多文件环境下验证；这里只用来展示结构和结果，不是可直接复制的单文件最小示例。

```text
// Unit1.tsf
unit Unit1;
interface
type Class1 = class
    type Class2 = class
        value;
    end;
end;
implementation
end.

// main.tsl
program test;
begin
    obj := CreateObject("Unit1.Class1.Class2");
    obj.value := 42;
    WriteLn(obj.value);
end.
```

已验证运行结果：

- `CreateObject("Unit1.Class1.Class2")` 可以创建对象
- 上述例子中的 `obj.value` 输出 `42`

继承单元中的嵌套类路径，因为依赖多文件环境，这里也用 `text` 展示：

代码块身份：配置片段 / 概念骨架
代码块说明：已在多文件环境下验证；这里只用来展示结构和结果，不是可直接复制的单文件最小示例。

```text
// Unit1.tsf
unit Unit1;
interface
type Class1 = class
    type Class2 = class
        value;
    end;
end;
implementation
end.

// main.tsl
program test;
type MyNewClass = class(Unit1.Class1.Class2)
end;
begin
    obj := CreateObject("MyNewClass");
    obj.value := 42;
    WriteLn(obj.value);
end.
```

已验证运行结果：

- `type MyNewClass = class(Unit1.Class1.Class2)` 可以通过并继承该路径类
- 上述例子中的 `obj.value` 输出 `42`

能力探测：

代码块身份：已验证可执行示例

```tsl
program test;
begin
{$IFDEF ParentClassInUnit}
    WriteLn(1);
{$ELSE}
    WriteLn(0);
{$ENDIF}
end.
```

已验证运行结果：

- 当前环境里 `{$IFDEF ParentClassInUnit}` 输出 `1`

## 最小可编译示例

如果你只是想先起一个最短类骨架，直接复用本页开头的“最短类骨架”。

代码块身份：已验证可执行示例

```tsl
type Person = class
end;
```

## 常见误写

- 以下误写中，有代码块的条目都已经单独验证；没有单独代码块展开的文字条目，属于已知语义陷阱或错误泛化，不要把它们当成可写事实。
- 把类写成裸 `class Person`。
- 还没建立类定义就直接写 `CreateObject("Person")` 或 `new Person()`。
- 把 `MathBox.Add(...)` 这种裸类名调用直接当成当前解释器已验证的类方法调用写法。
- 把 `THuman.mCount` 这种裸类名静态字段访问直接当成当前解释器已验证事实。
- 把 `self()` 当成当前解释器已验证的工厂式写法。
- 把 `private` / `protected create` 当成当前解释器一定会自动执行的构造函数。
- 在子类里把父类 `private` 成员当成 `protected` 成员来访问。
- 把带命名空间的 `new a.b.c` 直接当成当前解释器已支持事实。
- 把 `class(Unit1.Class1.Class2)` 这种表达式写法直接当成当前解释器已验证事实。
- 以为类声明既然能放在松散语句后面，就还能在 `type` 后面继续回到松散语句模式。

代码块身份：反例 / 不可照写

```text
obj := new Unit1.Class1.Class2();
```

上面这种写法在当前已记录验证里没有通过；当前只把 `CreateObject("Unit1.Class1.Class2")` 这种路径创建写成已验证事实。

代码块身份：反例 / 不可照写

```text
cls := class(Unit1.Class1.Class2);
```

上面这种表达式写法在当前解释器里没有通过；当前只把继承声明里的 `class(Unit1.Class1.Class2)` 和字符串路径创建写成已验证事实。

代码块身份：反例 / 不可照写

```text
MathBox.Add(1, 2);
```

上面这种裸类名调用在当前解释器里没有通过；当前已验证可用的是先拿到类类型，再用 `class(MathBox).Add(...)` 或 `FindClass("MathBox").Add(...)` 调用。

代码块身份：反例 / 不可照写

```text
THuman.mCount := 7;
```

上面这种裸类名静态字段访问在当前解释器里没有通过；当前已验证可用的是 `class(THuman).mCount`。

代码块身份：反例 / 不可照写

```text
self();
```

上面这种无参工厂式 `self()` 在当前解释器里没有通过；当前只把 `self` 实例引用，以及 `self(0)` / `self(1)` 写成已验证事实。

代码块身份：反例 / 不可照写

```text
a := 1;
type MyClass = class
    value;
end;
WriteLn(a);
```

上面这种写法在当前解释器里没有通过，会报 `invalid statement`。当前只把“松散语句后面可以接顶层类声明”写成已验证事实，不把它泛化成“`type` 之后还能继续写松散语句”。

## 跳转指引

- 回看 unit 与作用域：见 [10_units_and_scope.md](10_units_and_scope.md)
- 最后统一扫坑：见 [12_pitfalls.md](12_pitfalls.md)
- 继续看对象运行时和更深对象能力：见 [23_object_runtime_and_introspection.md](23_object_runtime_and_introspection.md) 和 [32_object_overloads_and_iteration.md](32_object_overloads_and_iteration.md)