属性的语法#

属性的语法规则为:

1
propertyDefinition
2
    : propertyModifier* 'prop' identifier ':' type propertyBody?
3
    ;
4

5
propertyBody
6
    : '{' propertyMemberDeclaration+ '}'
7
    ;
8

9
propertyMemberDeclaration
10
    : 'get' '(' ')' block end*
11
    | 'set' '(' identifier ')' block end*
12
    ;
13

14
propertyModifier
15
    : 'public'
16
    | 'private'
17
    | 'protected'
18
    | 'internal'
19
    | 'static'
20
    | 'open'
21
    | 'override'
22
    | 'redef'
23
    | 'mut'
24
    ;

一个属性基本的定义长这样:

1
class PropTest {
2
    mut prop prop1: Int64 {
3
        get() {}
4
        set() {}
5
    }
6
}

还可以使用public、open、static等其他修饰符修饰

没有mut修饰符声明的属性需要定义getter实现

用mut修饰符声明的属性需要单独的getter和setter实现

特别是, 对于数值类型、Bool、Unit、Nothing、Rune、String、Range、Function、Enum和Tuple类型, 在它们的扩展或定义体中不能定义mut修饰的属性, 也不能实现有mut属性的接口

如下面的示例所示, a是没有mut声明的属性, b是使用mut声明的属性

1
class Foo {
2
    prop a: Int64 {
3
        get() {
4
            0
5
        }
6
    }
7
    mut prop b: Int64 {
8
        get() {
9
            0
10
        }
11
        set(v) {}
12
    }
13
}

没有mut声明的属性没有setter, 而且与用let声明的字段一样, 它们不能被赋值

1
class A {
2
    prop i: Int64 {
3
        get() {
4
            0
5
        }
6
    }
7
}
8
main() {
9
    var x = A()
10
    x.i = 1           // error
11
}

特别是, 当使用let声明struct的实例时, 不能为struct中的属性赋值, 就像用let声明的字段一样

1
struct A {
2
    var i1 = 0
3
    mut prop i2: Int64 {
4
        get() {
5
            i1
6
        }
7
        set(value) {
8
            i1 = value
9
        }
10
    }
11
}
12
main() {
13
    let x = A()
14
    x.i1 = 2          // error
15
    x.i2 = 2          // error
16
}

属性与字段不同, 属性不可以赋初始值, 必须要声明类型

属性不是字段, 即 不是变量, 它不能存储值, 不能给初始值, 所以必须要声明类型

虽然不能存储值, 但是要声明类型, 是为了getter返回目标类型数据, 以及setter的传参类型, 即 决定了访问属性时获取的数据类型, 以及赋值时参与计算的数据类型

属性是否用mut修饰, 决定此属性是否需要实现setter以及此属性是否允许被赋值

let实例化的strcut, 即使属性为mut, 也禁止修改属性

基础类型在扩展时, 不能定义mut属性, 也不能实现拥有mut属性的接口, 因为基础类型都是值类型

属性的定义#

属性可以在interface, class, struct, enum, extend中定义

1
class A {
2
    prop i: Int64 {
3
        get() {
4
            0
5
        }
6
    }
7
}
8

9
struct B {
10
    prop i: Int64 {
11
        get() {
12
            0
13
        }
14
    }
15
}
16

17
enum C {
18
    prop i: Int64 {
19
        get() {
20
            0
21
        }
22
    }
23
}
24

25
extend A {
26
    prop s: String {
27
        get() {
28
            ""
29
        }
30
    }
31
}

可以在interface和abstract class中声明抽象属性, 它的定义体可以省略

在实现类型中实现抽象属性时, 它必须保持相同的名称、相同的类型和相同的mut修饰符

1
interface I {
2
    prop a: Int64
3
}
4

5
class A <: I {
6
    public prop a: Int64 {
7
        get() {
8
            0
9
        }
10
    }
11
}

如同interface中的抽象函数可以拥有默认实现, interface中的抽象属性也同样可以拥有默认实现

拥有默认实现的抽象属性, 实现类型可以不提供自己的实现(必须符合默认实现的使用规则)

1
interface I {
2
    prop a: Int64 {   // ok
3
        get() {
4
            0
5
        }
6
    }
7
}
8
class A <: I {}       // ok

接口和抽象类中可以声明抽象属性, 但在子类或子接口中实现时, 必须要与原抽象属性声明保持完全一致

属性分为实例成员属性和静态成员属性

其中, 实例成员属性只能由实例访问, 在getter或setter的实现中可以访问this、实例成员和其它静态成员

而静态成员属性只能访问静态成员

1
class A {
2
    var x = 0
3
    mut prop X: Int64 {
4
        get() {
5
            x + y
6
        }
7
        set(v) {
8
            x = v + y
9
        }
10
    }
11
    static var y = 0
12
    static mut prop Y: Int64 {
13
        get() {
14
            y
15
        }
16
        set(v) {
17
            y = v
18
        }
19
    }
20
}

属性不支持重载, 也不支持遮盖, 不能和其它同级别成员重名

1
open class A {
2
    var i = 0
3
    prop i: Int64 {       // error
4
        get() {
5
            0
6
        }
7
    }
8
}
9
class B <: A {
10
    prop i: Int64 {       // error
11
        get() {
12
            0
13
        }
14
    }
15
}

静态属性的getter和setter中 只能访问静态成员

普通属性的getter和setter中 也可以访问静态成员, 同时可以访问this

属性的名字不能与其他成员存在任何冲突, 也不支持重载, 也不支持遮盖, 但是支持覆盖

属性的实现#

属性的getter和setter分别对应两个不同的函数

• getter函数类型是()->T, T是该属性的类型, 当使用该属性作为表达式时会执行getter函数

• setter函数类型是(T)->Unit, T是该属性的类型, 形参名需要显式指定, 当对该属性赋值时会执行setter函数

属性的实现同函数的实现规则一样, 其中可以包含声明和表达式, 可以省略return, 其返回值必须符合返回类型

1
class Foo {
2
    mut prop a: Int64 {
3
        get() {           // () -> Int64
4
            "123"         // error
5
        }
6
        set(v) {          // (Int64) -> Unit
7
            123
8
        }
9
    }
10
}

无论在属性内部还是外部, 访问属性的行为都是一致的, 因此属性递归访问时与函数一样可能会造成死循环

1
class Foo {
2
    prop i: Int64 {
3
        get() {
4
            i             // dead loop
5
        }
6
    }
7
}

需要注意的是, struct的setter是mut函数, 因此也可以在setter内部修改其它字段的值, 并且this会受到mut函数的限制

属性声明的类型, 决定了setter和getter函数的类型

禁止在getter函数内访问属性本身, 禁止在setter函数内给属性本身赋值, 会出现无限递归

属性的修饰符#

属性跟函数一样可以使用修饰符修饰, 但只允许对整个属性修饰, 不能对getter或setter独立修饰

1
class Foo {
2
    public mut prop a: Int64 {        // ok
3
        get() {
4
            0
5
        }
6
        set(v) {}
7
    }
8
    mut prop b: Int64 {
9
        public get() {                // error
10
            0
11
        }
12
        public set(v) {}              // error
13
    }
14
}

属性可以使用访问控制修饰符有private, protected, public

1
class Foo {
2
    private prop a: Int64 {           // ok
3
        get() { 0 }
4
    }
5
    protected prop b: Int64 {         // ok
6
        get() { 0 }
7
    }
8
    public static prop c: Int64 {     // ok
9
        get() { 0 }
10
    }
11
}

实例属性像实例函数一样, 可以使用open和override修饰

使用open修饰的属性, 子类型可以使用override覆盖父类型的实现(override是可选的)

1
open class A {
2
    public open mut prop i: Int64 {
3
        get() { 0 }
4
        set(v) {}
5
    }
6
}
7
class B <: A {
8
    override mut prop i: Int64 {
9
        get() { 1 }
10
        set(v) {}
11
    }
12
}

静态属性像静态函数一样, 可以使用redef修饰(redef是可选的), 子类型可以重新实现父类型的静态属性

1
open class A {
2
    static mut prop i: Int64 {
3
        get() { 0 }
4
        set(v) {}
5
    }
6
}
7
class B <: A {
8
    redef static mut prop i: Int64 {
9
        get() { 1 }
10
        set(v) {}
11
    }
12
}

子类型override/redef使用let声明的实例属性必须要重新实现getter

子类型override/redef父类型中使用mut修饰符声明的的属性时, 允许只重新实现getter或setter, 但不能均不重新实现

1
open class A {
2
    public open mut prop i1: Int64 {
3
        get() { 0 }
4
        set(v) {}
5
    }
6
    static mut prop i2: Int64 {
7
        get() { 0 }
8
        set(v) {}
9
    }
10
}
11

12
// case 1
13
class B <: A {
14
    public override mut prop i1: Int64 {
15
        get() { 1 }                       // ok
16
    }
17
    redef static mut prop i2: Int64 {
18
        get() { 1 }                       // ok
19
    }
20
}
21

22
// case 2
23
class B <: A {
24
    public override mut prop i1: Int64 {
25
        set(v) {}                         // ok
26
    }
27
    redef static mut prop i2: Int64 {
28
        set(v) {}                         // ok
29
    }
30
}
31

32
// case 3
33
class B <: A {
34
    override mut prop i1: Int64 {}        // error
35
    redef static mut prop i2: Int64 {}    // error
36
}

子类型的属性override/redef必须与父类保持相同的mut修饰符, 并且还必须保持相同的类型

1
class P {}
2
class S {}
3

4
open class A {
5
    open prop i1: P {
6
        get() { P() }
7
    }
8
    static prop i2: P {
9
        get() { P() }
10
    }
11
}
12

13
// case 1
14
class B <: A {
15
    override mut prop i1: P {         // error
16
        set(v) {}
17
    }
18
    redef static mut prop i2: P {     // error
19
        set(v) {}
20
    }
21
}
22
// case 2
23
class B <: A {
24
    override prop i1: S {             // error
25
        get() { S() }
26
    }
27
    redef static prop i2: S {         // error
28
        get() { S() }
29
    }
30
}

我不理解这一句话: 子类型override/redef使用let声明的实例属性必须要重新实现getter

1. 属性并不能被let和var修饰

2. 经测试, 就算父类型属性基于let成员变量, 如果不显式覆盖, 也可以直接不重新实现属性

3. 假设要显式覆盖属性, 就必须要重新实现getter, 那跟let或var也没有任何关系

所以我不是很理解, 这一句话是什么意思?

子类override父类的属性时, 可以使用super调用父类的实例属性

1
open class A {
2
    open prop v: Int64 {
3
        get() { 1 }
4
    }
5
}
6
class B <: A {
7
    override prop v: Int64 {
8
        get() { super.v + 1 }
9
    }
10
}

其实不仅是通过super访问父类的实例属性, 还能访问其他成员