接口定义#

一个简单的接口定义如下:

1
interface I { // 'open' 修饰符是可选的
2
    func f(): Unit
3
}

接口使用关键字interface声明, 其后是接口的标识符I和接口的成员

接口成员可被open修饰符修饰, 并且 open修饰符是可选的

当接口I声明了一个成员函数f之后, 要为一个类型实现 I 时, 就必须在该类型中实现一个对应的f函数

因为interface默认具有open语义, 所以interface定义时的 open修饰符是可选的

如下面的代码所示, 定义了一个class Foo, 使用Foo <: I的形式声明了Foo实现I接口

在Foo中必须包含I声明的所有成员的实现, 即需要定义一个相同类型的f, 否则会由于没有实现接口而编译报错

1
class Foo <: I {
2
    public func f(): Unit {
3
        println("Foo")
4
    }
5
}
6

7
main() {
8
    let a = Foo()
9
    let b: I = a
10
    b.f() // "Foo"
11
}

当某个类型实现了某个接口之后, 该类型就会成为该接口的子类型

对于上面的例子, Foo是I的子类型, 因此任何一个Foo类型的实例, 都可以当作I类型的实例使用

在main中将一个Foo类型的变量a, 赋值给一个I类型的变量b

然后再调用b中的函数f, 就会打印出Foo实现的f版本

程序的输出结果为:

1
Foo

接口使用interface作为定义关键字

语法为:

1
interface IIdent {
2
    public func functiong(): Unit {}
3
}

接口默认拥有open语义, 成员函数和成员属性也默认拥有open语义

其他类型要实现接口, 语法为, class Sample <: IIdent {}, 同时 需要包含目标接口的所有成员的实现

实现了接口的类型, 就是此接口的子类型, 所以可以赋值给 接口类型变量使用

interface也可以使用sealed修饰符表示 只能在interface定义所在的包内 继承、实现或扩展该interface

sealed已经蕴含了public/open的语义, 因此定义sealed interface时若提供public/open修饰符, 编译器将会告警

继承sealed接口的子接口或实现sealed接口的抽象类, 仍可 被sealed修饰 或 不使用sealed修饰

若sealed接口的子接口被public修饰, 且不被sealed修饰, 则其子接口可在包外被继承、实现或扩展

继承、实现sealed接口的类型 可以不被public修饰

1
package A
2
public interface I1 {}
3
sealed interface I2 {}                // OK
4
public sealed interface I3 {}         // Warning, 冗余修饰符, 'sealed' 含有 'public' 语义
5
sealed open interface I4 {}           // Warning, 冗余修饰符, 'sealed' 含有 'open' 语义
6

7
class C1 <: I1 {}
8
public open class C2 <: I1 {}
9
sealed abstract class C3 <: I2 {}
10
extend Int64 <: I2 {}

1
package B
2
import A.*
3

4
class S1 <: I1 {}                     // OK
5
class S2 <: I2 {}                     // Error, I2 在 package A 中被 'sealed' 修饰 , 不能在这里实现

接口也可以被sealed修饰, 同样表示只能在本包中被继承、实现、扩展

通过接口的这种约束能力, 可以对一系列的类型约定共同的功能, 达到对功能进行抽象的目的

例如下面的代码, 可以定义一个Flyable接口, 并且让其他具有Flyable属性的类实现它

1
interface Flyable {
2
    func fly(): Unit
3
}
4

5
class Bird <: Flyable {
6
    public func fly(): Unit {
7
        println("Bird flying")
8
    }
9
}
10

11
class Bat <: Flyable {
12
    public func fly(): Unit {
13
        println("Bat flying")
14
    }
15
}
16

17
class Airplane <: Flyable {
18
    public func fly(): Unit {
19
        println("Airplane flying")
20
    }
21
}
22

23
func fly(item: Flyable): Unit {
24
    item.fly()
25
}
26

27
main() {
28
    let bird = Bird()
29
    let bat = Bat()
30
    let airplane = Airplane()
31
    fly(bird)
32
    fly(bat)
33
    fly(airplane)
34
}

编译并执行上面的代码, 会看到如下输出:

1
Bird flying
2
Bat flying
3
Airplane flying

接口, 一般就是将一系列实体共同的功能 约定、抽象出来, 定义为一个接口, 然后供其他类型定义时使用

文档中, 举了个例子 将可飞定义为一个接口, 可以给bird``bat``airplane定义使用

接口的成员可以是实例的或者静态的, 以上的例子已经展示过实例成员函数的作用, 接下来来看看静态成员函数的作用

静态成员函数和实例成员函数类似, 都要求实现类型提供实现

例如下面的例子, 定义了一个NamedType接口, 这个接口含有一个静态成员函数typename用来获得每个类型的字符串名称

这样其他类型在实现NamedType接口时就必须实现typename函数, 之后就可以安全地在NamedType的子类型上获得类型的名称

1
interface NamedType {
2
    static func typename(): String
3
}
4

5
class A <: NamedType {
6
    public static func typename(): String {
7
        "A"
8
    }
9
}
10

11
class B <: NamedType {
12
    public static func typename(): String {
13
        "B"
14
    }
15
}
16

17
main() {
18
    println("the type is ${ A.typename() }")
19
    println("the type is ${ B.typename() }")
20
}

程序输出结果为:

1
the type is A
2
the type is B

接口中的静态成员函数(或属性)可以没有默认实现

当其没有默认实现时, 将无法通过接口类型名对其进行访问

例如下面的代码, 直接访问NamedType的typename函数会发生编译报错, 因为NamedType不具有typename函数的实现

1
interface NamedType {
2
    static func typename(): String
3
}
4
main() {
5
    NamedType.typename() // Error
6
}

接口中的静态成员函数(或属性)也可以拥有默认实现, 当另一个类型继承拥有默认静态函数(或属性)实现的接口时, 该类型可以不再实现这个静态成员函数(或属性), 该函数(或属性)可以通过接口名和该类型名直接访问

如下用例, NamedType的成员函数typename拥有默认实现, 且在A中都可以不用再重新实现它, 同时, 也可以通过接口名和该类型名对其进行直接访问

1
interface NamedType {
2
    static func typename(): String {
3
        "interface NamedType"
4
    }
5
}
6

7
class A <: NamedType {}
8

9
main() {
10
    println(NamedType.typename())
11
    println(A.typename())
12
    0
13
}

程序输出结果为:

1
interface NamedType
2
interface NamedType

仓颉接口, 除了实例成员函数, 还可以拥有静态成员函数

静态成员函数 可以拥有默认实现, 也可以没有默认实现

如果没有默认实现, 那么 要实现此接口的其他类型, 就必须要实现此静态成员函数

如果接口的静态成员变量已经有了默认实现, 那么 要实现此接口的其他类型, 不用必须实现此静态成员函数

其实不止静态成员函数, 实例成员函数也可以拥有默认实现J 并不一定必须是抽象的、没有函数体的

接口中有默认实现的静态成员函数, 与类的静态成员函数一样, 可以直接通过接口名(类名)调用此静态成员函数

通常会通过泛型约束, 在泛型函数中使用这类静态成员

例如下面的printTypeName函数, 当约束泛型变元T是NamedType的子类型时, 需要保证T的实例化类型中所有的静态成员函数(或属性)都必须拥有实现, 以保证可以使用T.typename的方式访问泛型变元的实现, 达到了对静态成员抽象的目的(详见 泛型 )

1
interface NamedType {
2
    static func typename(): String
3
}
4

5
interface I <: NamedType {
6
    static func typename(): String {
7
        f()
8
    }
9
    static func f(): String
10
}
11

12
class A <: NamedType {
13
    public static func typename(): String {
14
        "A"
15
    }
16
}
17

18
class B <: NamedType {
19
    public static func typename(): String {
20
        "B"
21
    }
22
}
23

24
func printTypeName<T>() where T <: NamedType {
25
    println("the type is ${ T.typename() }")
26
}
27

28
main() {
29
    printTypeName<A>()        // Ok
30
    printTypeName<B>()        // Ok
31
    printTypeName<I>()        // Error, 'I' 必须实现所有静态函数  否则, 会调用未实现的 'f', 出现问题
32
}

文档中提道, 接口的静态成员函数, 通常通过泛型约束在泛型函数中使用

接口中可以定义 泛型实例成员函数 或 泛型静态成员函数, 与非泛型函数一样具有open语义

1
import std.collection.*
2

3
interface M {
4
    func foo<T>(a: T): T
5
    static func toString<T>(b: ArrayList<T>): String where T <: ToString
6
}
7
class C <: M {
8
    public func foo<S>(a: S): S { // implements M::foo, names of generic parameters do not matter
9
        a
10
    }
11
    public static func toString<T>(b: ArrayList<T>) where T <: ToString {
12
        var res = ""
13
        for (s in b) {
14
            res += s.toString()
15
        }
16
        res
17
    }
18
}

需要注意的是, 接口的成员默认就被public修饰, 不可以声明额外的访问控制修饰符, 同时也要求 实现类型必须使用public实现

1
interface I {
2
    func f(): Unit
3
}
4

5
open class C <: I {
6
    protected func f() {} // Compiler Error, f needs to be public semantics
7
}

仓颉接口中, 还可以定义泛型成员, 特性当然与普通成员一样

但要注意:

接口的成员默认是public的, 且 只能是public, 不能显式使用其他可访问性修饰符修饰, 且 要求实现时 也必须public修饰

接口继承与接口实现#

当想为一个类型实现多个接口, 可以在声明处使用&分隔多个接口, 实现的接口之间没有顺序要求

例如下面的例子, 可以让MyInt同时实现Addable和Subtractable两个接口

1
interface Addable {
2
    func add(other: Int64): Int64
3
}
4

5
interface Subtractable {
6
    func sub(other: Int64): Int64
7
}
8

9
class MyInt <: Addable & Subtractable {
10
    var value = 0
11
    public func add(other: Int64): Int64 {
12
        value + other
13
    }
14
    public func sub(other: Int64): Int64 {
15
        value - other
16
    }
17
}

其他类型可以一次性实现多个接口, 需要实现的多个接口 在声明接口实现时 使用&连接起来

而且, 如果是class, 类的继承和接口的实现是可以同时存在的, 但类的继承必须要声明为<:之后的首个类型, 之后可以使用&连接要实现的接口, 且只能是接口(仓颉class只允许单继承):

1
open class ClassBase {}
2

3
interface I1 {}
4

5
interface I2 {}
6

7
class ClassSuper <: ClassBase & I1 & I2 {}
8
// 类的继承 与 接口实现 共存

继承必须要声明为<:之后的首个类型, 之后使用&连接实现的接口(顺序无关)

接口可以继承一个或多个接口, 但不能继承类

与此同时, 接口继承的时候可以添加新的接口成员

例如下面的例子, Calculable接口继承了Addable和Subtractable两个接口, 并且增加了乘除两种运算符重载

1
interface Addable {
2
    func add(other: Int64): Int64
3
}
4

5
interface Subtractable {
6
    func sub(other: Int64): Int64
7
}
8

9
interface Calculable <: Addable & Subtractable {
10
    func mul(other: Int64): Int64
11
    func div(other: Int64): Int64
12
}

这样实现类型实现Calculable接口时就必须同时实现加减乘除四种运算符重载, 不能缺少任何一个成员

1
class MyInt <: Calculable {
2
    var value = 0
3
    public func add(other: Int64): Int64 {
4
        value + other
5
    }
6
    public func sub(other: Int64): Int64 {
7
        value - other
8
    }
9
    public func mul(other: Int64): Int64 {
10
        value * other
11
    }
12
    public func div(other: Int64): Int64 {
13
        value / other
14
    }
15
}

MyInt实现Calculable的同时, 也同时实现了Calculable继承的所有接口, 因此MyInt也实现了Addable和Subtractable, 即同时是它们的子类型

1
main() {
2
    let myInt = MyInt()
3
    let add: Addable = myInt
4
    let sub: Subtractable = myInt
5
    let calc: Calculable = myInt
6
}

对于interface的继承, 子接口 如果继承了 父接口中有默认实现的 函数或属性, 则在子接口中 不允许仅写此函数或属性的声明(即没有默认实现), 而是必须要给出新的默认实现, 并且函数定义前的override修饰符(或redef修饰符)是可选的

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

1
interface I1 {
2
   func f(a: Int64) {
3
        a
4
   }
5
   static func g(a: Int64) {
6
        a
7
   }
8
   func f1(a: Int64): Unit
9
   static func g1(a: Int64): Unit
10
}
11

12
interface I2 <: I1 {
13
    /* 'override' 是可选的 */ func f(a: Int64) {
14
       a + 1
15
    }
16
    override func f(a: Int32) {}                          // Error, 重写函数 'f', 但 在其父类型中没有 可以重写的函数
17
    static /* 'redef' 是可选的 */ func g(a: Int64) {
18
       a + 1
19
    }
20
    /* 'override' 是可选的 */ func f1(a: Int64): Unit {}
21
    static /* 'redef' 是可选的 */ func g1(a: Int64): Unit {}
22
}

如果其他类型要实现接口, 那么在<:之后声明接口就行了

而, 如果 定义接口时, 在<:之后声明其他接口, 此时就叫做接口的继承

接口的继承:

1. 如果父接口的成员函数、属性没有默认实现

   子接口对继承的成员函数、属性, 也可以不默认实现, 可以只声明

2. 如果父接口的成员函数、属性有默认实现

   子接口对继承的成员函数、属性:

   1. 要不就干脆不做任何显式声明, 此时 会直接继承父接口的默认实现

   2. 但不能只做声明而不提供默认实现, 即 如果子接口要显式声明, 就必须提供默认实现

3. 子接口是可以定义自己的成员函数、属性的

4. 接口的继承是可以多继承的, 而仓颉类 只允许单继承

5. 子接口在覆盖、重定义父类的成员函数时, 也可以省略override和redef修饰符

接口允许多继承, 因为接口成员实际都是抽象语义, 且接口不允许成员变量存在, 不会造成语义冗余和冲突

Any类型#

Any类型是一个内置的接口, 它的定义如下:

1
interface Any {}

仓颉中所有接口都默认继承它, 所有非接口类型都默认实现它, 因此所有类型都可以作为Any类型的子类型使用

如下面的代码, 可以将一系列不同类型的变量赋值给Any类型的变量

1
main() {
2
    var any: Any = 1
3
    any = 2.0
4
    any = "hello, world!"
5
}

在阅读 类 的文档时, 提到: 仓颉拥有一个Object类 不拥有任何成员, 它是所有class的父类, 没有显式指定继承的类 默认继承Object

此时, 接口也存在一个Any接口, 同样不拥有任何成员, 但他比class Object使用更广

interface Any, 所有接口都继承它, 所有类型都实现它, 包括任意的class

所以, calss不仅一定拥有一个父类叫Object, 而且一定是实现了接口Any

即, 也可以说仓颉中所有类型都是interface Any的子类型

所以 所有值都可以赋值给Any类型变量, 包括Unit类型字面量()