接口定义的语法#

接口的定义使用interface关键字, 接口定义依次为: 可缺省的修饰符、interface关键字、接口名、可选的类型参数、是否指定父接口、可选的泛型约束、接口体的定义

以下示例是一些接口定义:

1
interface I1 {}
2
public interface I2<T> {}
3
public interface I3<U> {}
4
public interface I4<V> <: I2<V> & I3<Int32> {}

接口定义的语法如下:

1
interfaceDefinition
2
    : interfaceModifierList? 'interface' identifier
3
    typeParameters?
4
    ('<:' superInterfaces)?
5
    genericConstraints?
6
    interfaceBody
7
    ;

接口只可以定义在top level

接口体的{}不允许省略

1
interface I {}    // {} 不允许被省略

接口的定义语法, 除了关键词是interface之外, 基本与 类的定义语法保持一致

接口的修饰符#

在此小节中, 我们将介绍定义接口可以使用的修饰符

接口中的函数#

接口中的成员属性#

interface中也可以定义成员属性, 定义成员属性的语法参见[属性]

接口的默认实现#

interface中的抽象函数和抽象属性都可以拥有默认实现

interface被其它interface或类型继承或实现的时候, 如果该interface的默认实现没有被重新实现, 则这些默认实现会被拷贝子类型中

• 实例成员函数的默认实现中可以使用this, this的类型是当前interface

• 默认实现和非抽象的成员函数一样, 可以访问当前作用域中所有可访问的元素

• 默认实现是一种语法糖, 可以给实现类型提供默认行为, 子接口可以沿用父接口的默认实现

• 默认实现不属于继承语义, 因此不能使用override/redef, 也不能使用super

• 继承接口的子类型为类时, 默认实现保留open语义, 可以被类的子类重写

1
interface I {
2
    func f() {            // f: () -> I
3
        let a = this      // a: I
4
        return this
5
    }
6
}

上述内容中存在一句描述: 默认实现不属于继承语义, 因此不能使用override/redef, 也不能使用super

但经过测试, 在interface的继承链中, override和redef都是可以使用的, 但super无法被使用

所以, 此描述存在混淆 或 存在描述错误, 可能是在强调 不存在继承或实现关系的interface的默认实现不能使用override/redef, 但这是一定的, 好像并不需要特别强调

或者是在说, 接口的继承关系不是传统的继承语义, 因为super无法被使用

子接口中的默认实现#

子接口如果继承了 父接口中 没有默认实现的函数或属性, 则在子接口中 允许仅写此函数或属性的声明(当然也允许定义默认实现), 并且函数声明或定义前的override或redef修饰符是可选的

示例如下:

1
interface I1 {
2
    func f1(): Unit
3
    static func f2(): Unit
4
}
5
interface I2 <: I1 {
6
    func f1(): Unit                   // ok
7
    static func f2(): Unit            // ok
8
}
9
interface I3 <: I1 {
10
    override func f1(): Unit          // ok
11
    redef static func f2(): Unit      // ok
12
}
13
interface I4 <: I1 {
14
    func f1(): Unit {}                // ok
15
    static func f2(): Unit {}         // ok
16
}
17
interface I5 <: I1 {
18
    override func f1(): Unit {}       // ok
19
    redef static func f2(): Unit {}   // ok
20
}

子接口中的成员函数是可以使用override或redef修饰的

子接口如果继承了 父接口中 有默认实现的函数或属性, 则在子接口中 不允许 仅写此函数或属性的声明而 没有实现, 如果子接口中给出新的默认实现, 那么定义前的override或redef修饰符是可选的

示例如下:

1
interface I1 {
2
    func f1(): Unit {}
3
    static func f2(): Unit {}
4
}
5
interface I2 <: I1 {
6
    func f1(): Unit                   // Error, 'f1' 必须有一个新的实现
7
    static func f2(): Unit            // Error, 'f2' 必须有一个新的实现
8
}
9
interface I3 <: I1 {
10
    override func f1(): Unit {}       // ok
11
    redef static func f2(): Unit {}   // ok
12
}
13
interface I4 <: I1 {
14
    func f1(): Unit {}                // ok
15
    static func f2(): Unit {}         // ok
16
}

父接口的成员函数或属性, 如果存在默认实现, 则子接口中不允许只声明不实现, 要不就不声明, 要不就要重新实现

如果子接口继承的多个父接口中拥有相同签名成员的默认实现, 子接口必须提供自己版本的新默认实现, 否则会编译报错

1
interface I1 {
2
    func f() {}
3
}
4
interface I2 {
5
    func f() {}
6
}
7
interface I3 <: I1 & I2 {}        // error, I3 必须实现 f: () -> Unit

子接口如果是多继承, 且不同父接口中存在同签名成员函数且 都有默认实现 或 都无默认实现

子接口就会出现冲突, 子接口实现一个自己的同签名成员函数 可以解决冲突

但, 如果不同父类接口中 存在同函数名、同参数列表 但返回值类型毫无关系的成员函数, 那么冲突无法解决

实现接口时的覆盖与重载#

一个类型实现一个或多个接口时规则如下:

• 抽象类以外的类型实现接口时, 必须实现所有的函数、属性

• 抽象类实现接口时, 允许不实现接口中的函数和属性

• 实现函数的函数名、参数列表必须与接口中对应函数的相同

• 实现函数的返回类型 应该与 接口中对应函数的返回类型相同 或者 为其子类型

• 如果接口中的函数为泛型函数, 则要求实现函数的类型变元约束 比 接口中对应函数更宽松或相同

• 实现属性的mut修饰符必须与接口中相应的属性相同

• 实现属性的类型, 必须与接口中对应的属性相同

• 如果多个接口中 只有同一函数或属性的 一个默认实现, 则实现类型可以 不实现该函数或属性, 使用默认实现

• 如果多个接口中 包含同一函数或属性的 多个默认实现, 则实现类型 必须要实现该函数或属性, 无法使用默认实现

• 如果实现类型已经存在 (从父类继承或本类定义) 接口中同一函数或属性的实现, 则不会再使用任何接口中的默认实现

• 类型在实现接口时, 函数或属性定义前的override修饰符(或redef修饰符)是可选的, 无论接口中的函数或属性是否存在默认实现

仓颉中, 抽象类可以只实现接口的部分函数或属性, 非抽象类 需要实现接口的所有的函数或属性

抽象类以外的类型实现接口时:

必须对接口中的抽象函数和抽象属性进行实现, 如下示例中的f1, f3

允许不使用接口中的函数默认实现, 如下示例中的f2

抽象类允许不实现接口中的实例成员函数, 如下示例中抽象类C1并没有实现接口I中的f1

1
interface I {
2
    func f1(): Unit
3
    func f2(): Unit {
4
        return
5
    }
6
    static func f3(): Int64
7
}
8
class C <: I {
9
    public func f1(): Unit {}
10
    public func f2(): Unit {
11
        return
12
    }
13
    public static func f3(): Int64 {
14
        return 0
15
    }
16
}
17

18
abstract class C1 <: I {
19
    public static func f3(): Int64 {
20
        return 1
21
    }
22
}

示例: 接口I中的函数f和g为泛型函数, class E和F满足实现函数的类型变元约束 比 被实现函数的更宽松或相同的要求, 编译成功;class D不满足要求, 则编译报错

1
// C <: B <: A
2
interface I {
3
    static func f<T>(a: T): Unit where  T <: B
4
    static func g<T>(): Unit where T <: B
5
}
6

7
class D <: I  {
8
    public static func f<T>(a: T) where T <: C {}         // Error, 约束过于严格
9
    public static func g<T>() where T <: C {}             // Error, 约束过于严格
10
}
11

12
class E <: I  {
13
    public static func f<T>(a: T) where T <: A {}         // OK, 约束更宽松
14
    public static func g<T>() where T <: A {}             // OK, 约束更宽松
15
}
16

17
class F <: I  {
18
    public static func f<T>(a: T) where T <: B {}         // OK, 相同的约束
19
    public static func g<T>() where T <: B {}             // OK, 相同的约束
20
}

更多例子:

1
// case 1
2
interface I1 {
3
    func f(): Unit
4
}
5
interface I2 {
6
    func f(): Unit
7
}
8
class A <: I1 & I2 {
9
    public func f(): Unit {}                  // ok
10
}
11

12
// case 2
13
interface I1 {
14
    func f(): Unit
15
}
16
interface I2 {
17
    func f(): Unit {}
18
}
19
open class A {
20
    public open func f(): Unit {}             // ok
21
}
22
class B <: A & I1 & I2 {
23
    public override func f(): Unit {}         // ok
24
}
25

26
// case 3
27
interface I1 {
28
    func f(): Unit
29
}
30
interface I2 {
31
    func f(): Unit {}
32
}
33
class A <: I1 & I2 {}                         // ok, f from I2
34

35
// case 4
36
interface I1 {
37
    func f(): Unit {}
38
}
39
interface I2 {
40
    func f(): Unit {}
41
}
42
class A <: I1 & I2 {}                         // error
43
class B <: I1 & I2 {                          // ok,
44
    public func f(): Unit {}
45
}
46

47
// case 5
48
interface I1 {
49
    func f(a: Int): Unit {}
50
}
51
interface I2  {
52
    func f(a: Int): Unit {}
53
}
54

55
open class A  {
56
    public open func f(a: Int): Unit {}
57
}
58
open class B <: A & I1 & I2 {                 // ok, f from A
59
}

对于泛型interface的成员函数, 在子类或子接口中实现时, 类型变元约束不能变得更严格