修饰符#

可以在 prop 前面声明需要的修饰符

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

和成员函数一样，成员属性也支持 open、override、redef 修饰，所以也可以在子类型中覆盖/重定义父类型属性的实现

子类型覆盖父类型的属性时，如果父类型属性带有 mut 修饰符，则子类型属性也需要带有 mut 修饰符，同时也必须保持一样的类型

如下代码所示，A 中定义了 x 和 y 两个属性，B 中可以分别对 x 和 y 进行 override/redef：

1
open class A {
2
    private var valueX = 0
3
    private static var valueY = 0
4

5
    public open prop x: Int64 {
6
        get() { valueX }
7
    }
8

9
    public static mut prop y: Int64 {
10
        get() { valueY }
11
        set(v) {
12
            valueY = v
13
        }
14
    }
15
}
16
class B <: A {
17
    private var valueX2 = 0
18
    private static var valueY2 = 0
19

20
    public override prop x: Int64 {
21
        get() { valueX2 }
22
    }
23

24
    public redef static mut prop y: Int64 {
25
        get() { valueY2 }
26
        set(v) {
27
            valueY2 = v
28
        }
29
    }
30
}

属性也可以通过可访问性修饰符修饰, 具体可访问性限制不再赘述, 与其他成员的可访问性限制保持一致

属性除了实例成员属性之外, 还可以定义静态成员属性

既然有静态成员属性, 那么就有实例成员和静态成员之间的访问问题

1. 静态成员属性

   只能访问其他静态成员变量, 不能访问实例成员变量

   只能访问其他静态成员属性, 不能访问实例成员属性

   只能访问其他静态成员函数, 不能访问实例成员函数

2. 实例成员属性

   可以通过类型名访问其他静态成员变量, 也可以访问其他实例成员变量

   可以通过类型名访问其他静态成员属性, 也可以访问其他实例成员属性

   可以通过类型名访问其他静态成员函数, 也可以访问其他实例成员函数

其实总结起来, 仓颉各类型:

静态成员函数或成员属性, 只能访问其他静态成员, 不能访问实例成员

而实例成员函数和成员属性, 可以访问其他实例成员, 也可以通过类型名访问静态成员

另外, 属性也可以用open修饰, 表示可以覆盖或重定义, override和redef同样也是可选的

覆盖或重定义时, 属性是否被mut修饰, 属性类型 都要与父类型保持一致

抽象属性#

类似抽象函数，在 interface和抽象类中也可以声明抽象属性，这些抽象属性没有实现

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

5
abstract class C {
6
    public prop a: Int64
7
}

当实现类型实现 interface或者非抽象子类继承抽象类时，必须要实现这些抽象属性

与覆盖的规则一样，实现类型或子类在实现这些属性时，如果父类型属性带有mut修饰符，则子类型属性也需要带有mut修饰符，同时也必须保持一样的类型

1
interface I {
2
    prop a: Int64
3
    mut prop b: Int64
4
}
5
class C <: I {
6
    private var value = 0
7

8
    public prop a: Int64 {
9
        get() { value }
10
    }
11

12
    public mut prop b: Int64 {
13
        get() { value }
14
        set(v) {
15
            value = v
16
        }
17
    }
18
}

通过抽象属性，可以让接口和抽象类对一些数据操作能以更加易用的方式进行约定，相比函数的方式要更加直观

如下代码所示，如果要对一个 size 值的获取和设置进行约定，使用属性的方式(I1)相比使用函数的方式(I2)代码更少，也更加符合对数据操作的意图

1
interface I1 {
2
    mut prop size: Int64
3
}
4

5
interface I2 {
6
    func getSize(): Int64
7
    func setSize(value: Int64): Unit
8
}
9

10
class C <: I1 & I2 {
11
    private var mySize = 0
12

13
    public mut prop size: Int64 {
14
        get() {
15
            mySize
16
        }
17
        set(value) {
18
            mySize = value
19
        }
20
    }
21

22
    public func getSize() {
23
        mySize
24
    }
25

26
    public func setSize(value: Int64) {
27
        mySize = value
28
    }
29
}
30

31
main() {
32
    let a: I1 = C()
33
    a.size = 5
34
    println(a.size)
35

36
    let b: I2 = C()
37
    b.setSize(5)
38
    println(b.getSize())
39
}

1
5
2
5

抽象属性, 就是没有具体实现, 只有声明的属性

可以在interface和抽象类中定义, 实现或继承的类型必须要实现

同样的, 也需要与父类型中的属性声明保持一致, 即 类型一致, mut修饰一致