| name | cangjie-interface |
| description | 仓颉语言接口。当需要了解仓颉语言的接口定义、接口实现(单个/多个)、接口继承、默认实现(实例/静态)、sealed接口、泛型成员、Any类型、属性(prop)在接口中的使用、菱形继承解决方案等特性时，应使用此 Skill。 |
仓颉语言接口 Skill
1. 接口定义
1.1 基本语法
interface I { ... } — 定义抽象类型，不包含数据，定义类型的行为- 成员可包含：成员函数、操作符重载函数、成员属性（prop）
- 成员隐式
public（不允许额外访问修饰符）。实现者须使用 public
interface 隐式 open（open 修饰符可选）
1.2 接口定义与实现示例
interface Flyable {
func fly(): Unit
}
class Bird <: Flyable {
public func fly(): Unit {
println("Bird flying")
}
}
class Airplane <: Flyable {
public func fly(): Unit {
println("Airplane flying")
}
}
// 接口作为参数类型，实现多态
func fly(item: Flyable): Unit {
item.fly()
}
main() {
fly(Bird()) // 输出：Bird flying
fly(Airplane()) // 输出：Airplane flying
}
1.3 sealed interface
sealed interface — 仅同包内可继承/实现/扩展sealed 隐含 public/open 语义- 继承
sealed 接口的子接口仍可被 sealed 修饰或不使用 sealed
- 若继承
sealed 接口的子接口被 public 修饰且不被 sealed 修饰，则该子接口可在包外被继承/实现/扩展
package A
sealed interface Shape {
func area(): Float64
}
class Circle <: Shape {
var radius: Float64
public init(r: Float64) { radius = r }
public func area(): Float64 { 3.14159 * radius * radius }
}
// 包外不能实现 Shape（sealed），但可通过非 sealed 的 public 子接口间接实现
2. 接口实现
2.1 基本实现
class Foo <: I { ... } — 须实现 I 的所有成员。Foo 成为 I 的子类型- 多接口：
class C <: I1 & I2 { ... }（无顺序要求）
interface Addable {
func add(other: Int64): Int64
}
interface Subtractable {
func sub(other: Int64): Int64
}
class MyInt <: Addable & Subtractable {
var value = 0
public func add(other: Int64): Int64 { value + other }
public func sub(other: Int64): Int64 { value - other }
}
2.2 可实现接口的类型
- 除 Tuple、VArray 和函数类型外的所有类型
2.3 三种实现途径
- 在类型定义处声明实现
- 通过扩展实现接口（详见
cangjie-extension Skill）
- 语言内置实现
2.4 实现规则
- 函数：名称、参数列表、返回类型须相同。例外：若接口返回类型为
class，实现者可返回其子类
mut 函数：接口中声明的 mut 函数，class 实现时忽略 mut 修饰（class 实例成员函数始终可修改实例状态），struct 实现时须匹配 mut 修饰符- 属性：
mut 修饰符须匹配；类型须相同
- 实现时函数或属性定义前的
override/redef 修饰符可选（无论接口中是否有默认实现）
2.5 返回子类型示例
open class Base {}
class Sub <: Base {}
interface I {
func f(): Base
}
class C <: I {
public func f(): Sub { // 允许返回 Base 的子类型
Sub()
}
}
2.6 mut 函数实现示例
interface Resettable {
mut func reset(): Unit
}
struct Counter <: Resettable {
var count: Int64 = 0
public mut func reset(): Unit { // struct 须匹配 mut
count = 0
}
}
class Logger <: Resettable {
var entries = 0
public func reset(): Unit { // class 忽略 mut
entries = 0
}
}
3. 接口继承
3.1 基本规则
- 接口可继承一个或多个接口（不能继承类）：
interface I3 <: I1 & I2 { ... }
- 可添加新成员。实现
I3 须实现 I1、I2、I3 的所有成员
interface Addable {
func add(other: Int64): Int64
}
interface Subtractable {
func sub(other: Int64): Int64
}
// Calculable 继承了 Addable 和 Subtractable，并添加新成员
interface Calculable <: Addable & Subtractable {
func mul(other: Int64): Int64
func div(other: Int64): Int64
}
class MyInt <: Calculable {
var value = 0
public func add(other: Int64): Int64 { value + other }
public func sub(other: Int64): Int64 { value - other }
public func mul(other: Int64): Int64 { value * other }
public func div(other: Int64): Int64 { value / other }
}
main() {
let myInt = MyInt()
// MyInt 同时是 Calculable、Addable、Subtractable 的子类型
let add: Addable = myInt
let calc: Calculable = myInt
}
3.2 子接口覆盖父接口成员
- 父接口成员有默认实现 → 子接口不允许仅写声明，须给出新的默认实现
- 父接口成员无默认实现 → 子接口允许仅写声明，也允许定义默认实现
override（实例函数）/ redef（静态函数）修饰符可选
interface I1 {
func f(a: Int64): Int64 { a } // 有默认实现
func f1(a: Int64): Unit // 无默认实现
}
interface I2 <: I1 {
func f(a: Int64): Int64 { a + 1 } // 须提供新的默认实现
func f1(a: Int64): Unit {} // 可以仅声明，也可提供默认实现
}
4. 默认实现
4.1 实例成员默认实现
- 接口成员可有默认实现
- 实现类型可继承默认实现，也可提供自己的实现
interface SayHi {
func say(): String { "hi" }
}
class A <: SayHi {} // 继承默认实现
class B <: SayHi {
public func say(): String { "hi, B" } // 覆盖默认实现
}
4.2 静态成员默认实现
- 有默认实现的静态成员可通过接口名和实现者名访问
- 无默认实现的静态成员不能通过接口名直接访问
- 通常在泛型约束中使用静态成员：
func f<T>() where T <: I { T.staticFunc() }
interface NamedType {
static func typename(): String {
"interface NamedType"
}
}
class A <: NamedType {}
main() {
println(NamedType.typename()) // 输出：interface NamedType
println(A.typename()) // 输出：interface NamedType
}
4.3 在泛型约束中使用静态成员
interface NamedType {
static func typename(): String
}
class A <: NamedType {
public static func typename(): String { "A" }
}
class B <: NamedType {
public static func typename(): String { "B" }
}
func printTypeName<T>() where T <: NamedType {
println("the type is ${T.typename()}")
}
main() {
printTypeName<A>() // 输出：the type is A
printTypeName<B>() // 输出：the type is B
}
4.4 菱形继承解决
- 若多个继承接口提供同一成员的冲突默认实现，实现者须提供自己的实现
interface SayHi {
func say(): String { "hi" }
}
interface SayHello {
func say(): String { "hello" }
}
// 两个接口都有 say 的默认实现，产生冲突
class Foo <: SayHi & SayHello {
public func say(): String { "Foo" } // 须自行实现，否则编译错误
}
5. 泛型成员
- 接口可定义具有
open 语义的泛型实例/静态函数
- 实现时泛型参数名称可不同
import std.collection.ArrayList
interface M {
func foo<T>(a: T): T
static func toString<T>(b: ArrayList<T>): String where T <: ToString
}
class C <: M {
public func foo<S>(a: S): S { a } // 泛型参数名可不同
public static func toString<T>(b: ArrayList<T>) where T <: ToString {
var res = ""
for (s in b) {
res += s.toString()
}
res
}
}
6. Any 类型
- 内置接口：
interface Any {}
- 所有接口默认继承
Any；所有非接口类型默认实现 Any
- 每个类型都是
Any 的子类型
main() {
var any: Any = 1
any = 2.0
any = "hello, world!"
}
7. 属性（prop）在接口中的使用
7.1 抽象属性
- 在接口中可声明抽象属性（无实现）
- 实现类型须提供实现
interface HasName {
prop name: String
mut prop id: Int64
}
class User <: HasName {
var _id: Int64 = 0
public prop name: String {
get() { "User" }
}
public mut prop id: Int64 {
get() { _id }
set(v) { _id = v }
}
}
7.2 默认实现属性
- 接口中的属性也可提供默认实现
- 实现类型可继承或覆盖
7.3 实现规则
- 若接口属性有
mut，实现类型也须有 mut，类型须相同
8. 接口成员访问修饰符
- 接口成员默认
public，不可声明额外的访问修饰符
- 实现类型中对应成员须使用
public
interface I {
func f(): Unit
}
open class C <: I {
protected func f() {} // ❌ Error: 须为 public
}
