主构造函数#

主构造函数的语法定义如下:

1
classPrimaryInit
2
    : classNonStaticMemberModifier?  className '(' classPrimaryInitParamLists? ')'
3
     '{'
4
          superCallExression?
5
          ( expression
6
           | variableDeclaration
7
           | functionDefinition)*
8
     '}'
9
    ;
10

11
className
12
    : identifier
13
    ;
14

15
classPrimaryInitParamLists
16
    : unnamedParameterList (',' namedParameterList)? (',' classNamedInitParamList)?
17
    | unnamedParameterList (',' classUnnamedInitParamList)?
18
        (',' classNamedInitParamList)?
19
    | classUnnamedInitParamList (',' classNamedInitParamList)?
20
    | namedParameterList (',' classNamedInitParamList)?
21
    | classNamedInitParamList
22
    ;
23

24
classUnnamedInitParamList
25
    : classUnnamedInitParam (',' classUnnamedInitParam)*
26
    ;
27

28
classNamedInitParamList
29
    : classNamedInitParam (',' classNamedInitParam)*
30
    ;
31

32
classUnnamedInitParam
33
    : classNonStaticMemberModifier? ('let'|'var') identifier ':' type
34
    ;
35

36
classNamedInitParam
37
    : classNonStaticMemberModifier? ('let'|'var') identifier'!' ':' type ('=' expression)?
38
    ;
39

40
classNonStaticMemberModifier
41
    : 'public'
42
    | 'protected'
43
    | 'internal'
44
    | 'private'
45
    ;

主构造函数的定义包括以下几个部分:

1. 修饰符: 可选

   主构造函数可以使用public、protected、private其中之一修饰, 都不使用是包内可见; 详见 访问修饰符

2. 主构造函数名: 与类型名一致

   主构造函数名前不允许使用func关键字

3. 形参列表: 主构造函数与init构造函数不同的是, 前者有两种形参: 普通形参和成员变量形参

   普通形参的语法和语义与函数定义中的形参一致

   引入成员变量形参是为了减少代码冗余

   成员变量形参的定义, 同时包含形参和成员变量的定义, 除此之外还表示了通过形参给成员变量赋值的语义

   省略的定义和表达式会由编译器自动生成

   • 成员变量形参的语法和成员变量定义语法一致, 此外, 和普通形参一样支持使用!来标注是否为命名形参

   • 成员变量形参的修饰符有:public,protected,private

   • 成员变量形参只允许实例成员变量, 即不允许使用static修饰

   • 成员变量形参不能与主构造函数外的成员变量同名

   • 成员变量形参可以没有初始值

     这是因为主构造函数会由编译器生成一个对应的构造函数, 将在构造函数体内完成将形参给成员变量的赋值

   • 成员变量形参也可以有初始值, 初始值仅用于构造函数的参数默认值

     成员变量形参的初值表达式中可以引用该成员变量定义之前已经定义的其他形参或成员变量(不包括定义在主构造函数外的实例成员变量), 但不能修改这些形参和成员变量的值

     需要注意的是, 成员变量形参的初始值只在主构造函数中有效, 不会在成员变量定义中包含初始值

   • 成员变量形参后不允许出现普通形参, 并且要遵循函数定义时的参数顺序, 命名形参后不允许出现非命名形参

仓颉类中的主构造函数, 函数名与类名相同, 与 C++中的构造函数有些类似

主构造函数, 可以声明成员变量形参, 声明的形参 实际会被编译器自动生成为 成员变量

成员变量形参的定义方式与成员变量的定义方式一致, 即 需要let或var进行修饰

成员变量形参, 可以声明为命名形参, 可以用 同在主构造函数参数列表中且已经声明完毕的参数 进行赋值, 但不能使用在主构造函数外的成员变量进行赋值

与struct类型的主构造函数应该是大致相同的

4. 主构造函数体: 如果显式调用父类构造函数, 函数体内第一个表达式必须是调用父类构造函数的表达式

   同时, 主构造函数中不允许使用this调用本类中其它构造函数

   父类构造函数调用之后, 主构造函数体内允许写表达式、局部变量声明、局部函数定义, 其中声明、定义和表达式需要满足init构造函数中对this和super使用的规则

   具体规则详见[init 构造函数]

主构造函数定义的例子如下:

1
class Test {
2
    static let counter: Int64 = 3
3
    let name: String = "afdoaidfad"
4
    private Test(
5
        name: String,                     // 常规参数
6
        annotation!: String = "nnn",      // 常规参数
7
        var width!: Int64 = 1,            // 携带初始值的成员变量参数
8
        private var length!: Int64,       // 成员变量参数
9
        private var height!: Int64 = 3    // 携带初始值的成员变量参数
10
    ) {
11
    }
12
}

主构造函数定义时, 成员变量形参后不允许出现普通形参的例子如下:

1
class Test {
2
    static let counter: Int64 = 3
3
    let name: String = "afdoaidfad"
4
    private Test(
5
        name: String,                     // 常规参数
6
        annotation!: String = "nnn",      // 常规参数
7
        var width!: Int64 = 1,            // 携带初始值的成员变量参数
8
        length!: Int64                    // Error: 常规参数不能在成员变量参数之后
9
    ) {
10
    }
11
}

类的静态成员变量, 可以在定义时直接赋值进行初始化

主构造函数中不能通过this调用本类的其他构造函数

主构造函数是init构造函数的语法糖, 编译器会自动生成与主构造函数对应的构造函数和成员变量的定义

自动生成的构造函数形式如下:

• 其修饰符与主构造函数修饰符一致

• 其形参从左到右的顺序与主构造函数形参列表中声明的形参一致

• 构造函数体内形式依次如下:

  • 依次是对成员变量的赋值, 语法形式为this.x = x, 其中x为成员变量名

  • 主构造函数体中的代码

1
open class A<X> {
2
    A(protected var x: Int64, protected var y: X) {
3
        this.x = x
4
        this.y = y
5
    }
6
}
7

8
class B<X> <: A<X> {
9
     B(      // 主构造函数, 函数名与类名相同
10
        x: Int64,                     // 常规参数
11
        y: X,                         // 常规参数
12
        v!: Int64 = 1,                // 常规参数
13
        private var z!: Int64 = v     // 成员变量参数
14
        ) {
15
          super(x, y)
16
     }
17

18
     /* 编译器自动生成的 与主构造函数 对应的init构造函数.
19

20
     private var z: Int64             // 自动在构造函数前 生成成员变量定义
21
     init( x: Int64,
22
        y: X,
23
        v!: Int64 = 1,
24
        z!: Int64 = v) {              // 自动生成命名参数定义
25
          super(x, y)
26
          this.z = z                  // 自动生成 成员变量的赋值表达式
27
     }
28
     */
29
}

一个类 最多可以定义一个主构造函数, 除了主构造函数之外, 可以照常定义其他构造函数, 但要求其他构造函数必须和主构造函数所对应的构造函数构成重载

事实上, 主构造函数只是init构造函数的语法糖, 在编译时 会由编译器自动生成对应的init构造函数

且, 在主构造函数中声明的成员变量形参, 会在生成init构造函数之前, 由编译器自动生成好 成员变量的定义

实际上, 仓颉中类的构造函数, 语法上支持主构造函数, 但本质上并不存在与类名同名的主构造函数, 在编译时 都会被转换为init构造函数, 所以要注意init构造函数之间禁止重定义

init构造函数#

构造函数使用init关键字指定, 不能带有func关键字, 不能为构造函数显式定义返回类型, 且必须有函数体

构造函数的返回类型为Unit类型

构造函数的语法如下:

1
Init
2
    : nonSMemberModifier?  'init' '(' InitParamLists? ')'
3
     '{'
4
          (superCallExression | initCallExpression)?
5
          ( expression
6
           | variableDeclaration
7
           | functionDefinition)*
8
     '}'
9
    ;
10

11
InitParamLists
12
  : unnamedParameterList (',' namedParameterList)?
13
  | namedParameterList
14
  ;

可以在init前添加访问修饰符来限制该构造函数的可访问范围: 详见 访问修饰符

当构造一个类的对象时, 实际上会调用此类的构造函数, 如果没有参数类型匹配且可访问的构造函数, 则会编译报错

在一个类中, 用户可以为这个类提供多个init构造函数, 这些构造函数必须符合函数重载的要求

关于函数重载的详细描述, 请参见 函数重载

1
class C {
2
    init() {}
3
    init(name: String, age: Int32) {}
4
}

创建类的实例时调用的构造函数, 将根据以下顺序执行类中的表达式:

• 先初始化主构造函数之外定义的有缺省值的变量

• 如果构造函数体内未显式调用父类构造函数或本类其它构造函数, 则调用父类的无参构造函数super(), 如果父类没有无参构造函数, 则报错

• 执行构造函数体内的代码

仓颉中, 类的init构造函数除了命名不同外, 才与 C++中类的构造函数比较相似

但 无论是主构造函数还是init构造函数, 返回值类型均为Unit类型

如果一个类既没有定义主构造函数, 也没有定义init构造函数, 则会尝试生成一个(public修饰的)无参构造函数

如果父类没有无参构造函数或者存在本类的实例成员变量没有初始值, 则编译报错

与 C++一样, 仓颉中的类, 如果没有显示定义任何构造函数, 编译器会尝试生成一个无参构造函数, 但如果父类没有无参构造函数 会编译错误

构造函数、this和super的使用规则:

• 禁止使用实例成员变量this.variableName及其语法糖variableName和super.variableName作为构造函数参数的默认值

• init构造函数可以调用父类构造函数或本类其它构造函数, 但两者之间只能调用一个

  如果调用, 必须在构造函数体内的第一个表达式处, 在此之前不能有任何表达式或声明

• 若构造函数没有显式调用其他构造函数, 也没有显式调用父类构造函数, 编译器会 在该构造函数体的开始处 插入直接父类的无参构造函数的调用

  如果此时父类没有无参构造函数, 则会编译报错

• 构造函数体内调用完父类构造函数或本类其它构造函数之后, 允许使用super.x访问父类的实例成员变量x

• 若构造函数没有显式调用其他构造函数, 则需要确保return之前本类声明的所有实例成员变量均完成初始化, 否则编译报错

• 可以被继承的类的构造函数中, 禁止调用实例成员函数 或 实例成员属性

• 可以被继承的类的构造函数中, 禁止this逃逸

• 构造函数在所有实例成员变量完成初始化之前, 禁止使用隐式传参或捕获了this的函数或lambda, 禁止使用super.f访问父类的实例成员方法f, 禁止使用单独的this表达式, 但允许使用this.x或其语法糖x来访问已经完成初始化的成员变量x

• 在构造函数体外, 不允许通过this调用该类的构造函数

• 禁止构造函数之间循环依赖, 否则将编译报错

1
var b: Int64 = 1
2
class A {
3
    var a: Int64 = 1
4
    var b: ()->Int64 =  { 3 }     // OK
5

6
    /* 在所有实例成员变量都初始化之前, 不能使用捕获了 this 的 lambda 表达式 */
7
    var c: ()->Int64 =  { a }     // Error
8

9
    /* 在所有实例成员变量初始化完成前, 不能使用捕获了 this 的函数 */
10
    var d: ()->Int64 = f          // Error
11

12
    var e: Int64 = a + 1          // OK
13

14
    func f(): Int64 {
15
        return a
16
    }
17
}
18

19
class B {
20
    var a: Int64 = 1
21
    var b: ()->Int64
22

23
    init() {
24
        b =  { 3 }
25
    }
26

27
    init(p: Int64) {
28
        this()
29
        b = { this.a }        // OK
30
        b = f                 // OK
31
    }
32

33
    func f(): Int64 {
34
        return a
35
    }
36
}
37

38
var globalVar: C = C()
39
func f(c: C) {
40
    globalVar = c
41
}
42
open class C {
43
    init() {
44
        globalVar = this      // Error, this 无法从 open 类的构造函数中逃逸
45
        f(this)               // Error, this 无法从 open 类的构造函数中逃逸
46
        m()                   // Error: 在 open 类的构造函数中禁止调用实例函数
47
    }
48

49
    func m() {}
50
}

仓颉的类, 构造函数最核心的一点就是, 需要在构造函数内完成所有成员变量的初始化, 且只能在构造函数内完成

如果 成员变量还未被初始化, 则无法将this或super作为参数传递或闭包捕获

且, 仓颉的构造函数, 编译器最终只认init构造函数, 主构造函数会被自动转换为对应的init构造函数

this逃逸, 是指 将this作为参数传递或闭包捕获

而在类的所有成员变量未完成初始化前, 总是禁止this逃逸

但, 如果存在open class, 即使所有成员变量已经完成了初始化, 也禁止this逃逸

应该是防止出现 子类成员未完全初始化, 但却通过父类this进行多态调用的情况

成员变量的声明#

声明在类、接口中的变量称为成员变量

成员变量可以用关键字let声明为不可变的, 也可以用关键字var声明为可变的

主构造函数之外的实例成员变量声明时可以有初始值, 也可以没有初始值:

如果有初始值, 初始值表达式可以使用此变量声明之前的成员变量

由于这些成员变量的初始化的执行顺序是在调用父类构造函数之前, 初始值表达式中禁止使用带super的限定名访问父类的成员变量

以下是变量的代码示例:

1
open class A {
2
    var m1: Int32 = 1
3
}
4

5
class C <: A {
6
    var a: Int32 = 10
7
    let b: Int32 = super.m1  // Error
8
}

仓颉中, 类的成员变量 如果在声明时就直接赋予初始值, 初始值表达式中禁止使用super访问父类的成员变量, 即使 所访问的父类成员变量也在声明时就赋予了初始值

变量的修饰符#

类中的变量可以被访问修饰符修饰, 详细内容请参考包和模块管理章节[访问修饰符]

另外, 如果类中的一个变量用static修饰, 则它属于类的静态变量

static可以与其他访问修饰符同时使用

静态变量会被子类继承, 子类和父类的静态变量是同一个

1
class C {
2
    static var a = 1
3
}
4

5
var r1 = C.a          // ok

类的静态变量, 在整个继承关系中, 都是同一个静态变量

类成员函数的声明和定义#

在类中允许定义函数, 同时允许在抽象类中声明函数

定义和声明的区别在于该函数 是否有函数体

类成员的函数分为实例成员函数、静态成员函数

类成员函数定义或声明的语法如下:

1
functionDefinition
2
    : modifiers 'func' identifier typeParameters? functionParameters (':' returnType)? genericConstraints? (('=' expression) | block)?
3
     ;

成员函数定义的语法与普通函数定义的语法保持一致

唯一不同的是, 成员函数可以省略函数体的实现, 以达到只声明成员函数的目的

实例成员函数#

实例成员函数的第一个隐式参数是this, 每当调用实例成员函数时, 都意味着需要先传入一个完整的对象, 因此 在对象未创建完成时 就调用实例成员函数的行为 是被禁止的, 但是该函数的类型将不包括该隐式参数

类对象创建完成的判断依据是已经调用了类的构造函数

实例成员函数可以分为抽象成员函数和非抽象成员函数

• 抽象成员函数

  抽象成员函数只能在抽象类或接口中声明, 没有函数体

  1
  abstract class A {
  2
      public func foo(): Unit       // 抽象成员函数
  3
  }
  

• 非抽象成员函数

  非抽象成员函数允许在任何类中定义, 必须有函数体

  1
  class Test {
  2
      func foo(): Unit {            // 非抽象成员函数
  3
          return
  4
      }
  5
  }
  

抽象实例成员函数默认具有open的语义

在抽象类中定义抽象实例成员函数时,open修饰符是可选的, 但必须显式指定它的可见性修饰符为public或protected

仓颉中, 只要类的构造函数执行完毕, 就标志着类对象创建完成

且, 仓颉中的类成员函数 与 C++类的成员函数类似, 也存在一个 位于第一个参数的隐式的this参数, 调用时会被自动传入

仓颉中, 没有函数体实现的成员函数是抽象成员函数, 抽象成员函数只能存在于 抽象类中, 即 类需要用abstract修饰

抽象成员函数必须显式使用public或protected修饰

静态成员函数#

静态成员函数用static关键字修饰, 它不属于某个实例, 而是属于它所在的类型, 同时静态函数必须有函数体

• 静态成员函数中不能使用实例成员变量, 不能调用实例成员函数, 不能调用super或this关键字

• 静态成员函数中可以引用其他静态成员函数或静态成员变量

• 静态成员函数可以用private、protected、public、internal修饰, 详见[访问修饰符]

• 静态成员函数在被其它子类继承时, 这个静态成员函数不会被拷贝到子类中

• 抽象类和非抽象类中的静态成员函数都必须拥有实现

例如:

1
class C<T> {
2
    static let a: Int32 = 0
3
    static func foo(b: T): Int32 {
4
        return a
5
    }
6
}
7

8
main(): Int64 {
9
    print("${C<Int32>.foo(3)}")
10
    print("${C<Bool>.foo(true)}")
11

12
    return 0
13
}

这段程序对于C<Int32>与C<Bool>分别有他们各自的静态成员变量a与静态函数foo

类中的静态函数可以声明新的类型变元, 这些类型变元也可以存在约束

在调用时只需对类给出合法的类型, 然后对静态函数给出合法的类型就可以了:

1
class C<T> {
2
    static func foo<U>(a: U, b: T): U { a }
3
}
4

5
var a: Bool = C<Int32>.foo<Bool>(true, 1)
6
var b: String = C<Bool>.foo<String>("hello", false)
7

8
func f<V>(a: V): V { C<Int32>.foo<V>(a, 0) }

仓颉中, 类的静态成员函数, 不能只声明

静态成员函数内, 无法调用普通成员函数, 因为静态成员函数不属于任何实例, 而是属于类, 更没有对应的this或super

静态成员函数被继承时, 整个继承链中的静态成员函数都是同一个, 不会在子类中拷贝一份, 如果是泛型父类, 则 指定变元父类的继承链中共享

类成员函数的修饰符#

类成员函数可以被所有访问修饰符修饰, 详见访问修饰符

其他可修饰的非访问修饰符如下:

• open: 一个成员函数想要被覆盖, 需要用open修饰符修饰, 它与static修饰符有冲突

  当带open修饰的实例成员被class继承时, 该open的修饰符也会被继承

  如果class中存在被open修饰的成员, 而当前class没有被open修饰或不包含open语义, 那么这些open修饰的成员仍然没有open效果, 编译器对这种情况会报warning提示(对于继承下来的open成员或者override的成员不需要报warning)

  一个被 open 修饰的函数, 必须被public或protected修饰

  1
  // case 1
  2
  open class C1 {                   // 在这种情况下, 需要在 class C1 之前添加 open 修饰符
  3
      public open func f() {}
  4
  }
  5
  class C2 <: C1 {
  6
      public override func f() {}
  7
  }
  8
  
  9
  // case 2
  10
  open class A {
  11
      public open func f() {}
  12
  }
  13
  open class B <: A {}
  14
  class C <: B {
  15
      public override func f() {}   // ok
  16
  }
  17
  
  18
  // case 3
  19
  interface I {
  20
      func f() {}
  21
  }
  22
  open class Base <: I {}           // 函数 f 继承了 open 修饰符
  23
  class Sub <: Base {
  24
      public override func f() {}   // ok
  25
  }
  

• override: 当一个函数覆盖另一个可以被覆盖的函数时, 允许可选地使用override进行修饰(override不具备open的语义, 如果用override修饰的函数还需要允许能被覆盖, 需要重新用open修饰), 示例如上

  函数覆盖的规则请参见[覆盖]章节

• static: 用static修饰的函数为静态成员函数, 必须有函数体

  静态成员函数不能用open修饰

  静态成员函数内不可以访问所在类的实例成员; 实例成员函数内能访问所在类的静态成员

  1
  class C {
  2
      static func f() {}   // 不能被重写, 且必须存在函数体
  3
  }
  

• redef: 当一个静态函数重定义继承自父类型的静态函数时, 允许可选地使用redef进行修饰

  1
  open class C1 {
  2
      static func f1() {}
  3
      static func f2() {}
  4
  }
  5
  class C2 <: C1 {
  6
      redef static func f1() {}
  7
      redef static func f2() {}
  8
  }
  

仓颉的成员函数修饰符有这几个:open``override``static``redef

override和static不用过多理解,override只是用来表示此函数是被重写的(不具有open语义),static表示此函数是一个静态函数

open修饰成员函数, 表示此函数可以被子类重写, 但 要求此类(拥有open成员函数的父类)是open的, 毕竟只有具有open语义的类才能被继承

open成员函数, 必须要有public或protected的修饰

仓颉中, 类的成员函数 存在redef修饰符, 此修饰符的作用是 让子类重写 继承于父类的static成员函数

子类通过redef修饰符重写继承于父类的static成员函数之后, 子类就拥有了自己的同名static成员函数