【华为鸿蒙开发技术】仓颉语言中的扩展机制【扩展概述、直接扩展、接口扩展、访问规则】

举报
柠檬味拥抱 发表于 2024/08/12 22:26:55 2024/08/12
【摘要】 1. 引言在仓颉语言中，扩展（Extension）是一种重要的机制，它允许开发者在不修改原有类型定义的情况下，为类型添加额外的功能。这种机制可以提升代码的可维护性和扩展性，使得类型的功能能够在需要时进行增强，而不需要对原有代码进行修改。本文将详细介绍仓颉语言中的扩展机制，包括其基本概念、语法结构、使用规则及扩展的访问和遮盖规则。 2. 扩展的基本概念扩展是指为已有的类型（类、结构体等）添加...

1. 引言

在仓颉语言中，扩展（Extension）是一种重要的机制，它允许开发者在不修改原有类型定义的情况下，为类型添加额外的功能。这种机制可以提升代码的可维护性和扩展性，使得类型的功能能够在需要时进行增强，而不需要对原有代码进行修改。本文将详细介绍仓颉语言中的扩展机制，包括其基本概念、语法结构、使用规则及扩展的访问和遮盖规则。

2. 扩展的基本概念

扩展是指为已有的类型（类、结构体等）添加新的功能，具体包括：

  • 添加成员函数：为类型增加新的方法。
  • 添加操作符重载函数：为类型提供自定义的操作符行为。
  • 添加成员属性：为类型增加新的属性。
  • 实现接口：使类型符合新的接口要求。

需要注意的是，扩展不能改变原有类型的封装性，因此不能增加成员变量，也不能访问原类型的私有成员。此外，扩展中的函数和属性必须拥有实现，不能使用 open、override、redef 修饰，并且扩展不能遮盖原有类型的成员或其他扩展的成员。

3. 扩展的语法结构

扩展的语法结构如下：

extend Type {
    // 添加成员函数
    public func newMethod() {
        // 方法实现
    }
    
    // 添加成员属性
    public var newProperty: Type {
        // 属性实现
    }
}

4. 直接扩展

直接扩展是指为现有类型添加新功能，而不涉及新的接口实现。下面是一个简单的示例，展示了如何为 String 类型添加一个 printSize 方法：

extend String {
    public func printSize() {
        println("The size is ${this.size}")
    }
}

在这个示例中，printSize 方法被添加到 String 类型中。这样，我们就可以在当前包内对 String 的实例使用这个新方法：

main() {
    let a = "123"
    a.printSize() // Output: The size is 3
}

5. 泛型类型的扩展

扩展也支持泛型类型，具体有两种方式：

  1. 针对特定泛型实例化类型进行扩展：

    class Foo<T> where T <: ToString {}

extend Foo<Int64> {
    // 扩展实现
}

    这种方式只对完全实例化的泛型类型有效。

  2. 针对泛型类型进行泛型扩展：

    class MyList<T> {
    public let data: Array<T> = Array<T>()
}

extend<T> MyList<T> {
    // 扩展实现
}

    这种方式可以对未实例化或未完全实例化的泛型类型进行扩展。

6. 接口扩展

接口扩展允许类型实现额外的接口，增强类型的抽象能力。例如，下面的代码为 Array 类型实现了 PrintSizeable 接口：

interface PrintSizeable {
    func printSize(): Unit
}

extend<T> Array<T> <: PrintSizeable {
    public func printSize() {
        println("The size is ${this.size}")
    }
}

这样，Array 类型就实现了 PrintSizeable 接口，能够使用 printSize 方法：

main() {
    let a: PrintSizeable = Array<Int64>()
    a.printSize() // Output: The size is 0
}

7. 扩展的访问和遮盖规则

扩展中的成员可以使用 this 来访问当前实例的属性和方法，但不能使用 super。扩展不能访问被扩展类型的 private 成员，也不能遮盖被扩展类型的任何成员或其他扩展的成员。例如：

class A {
    private var v1 = 0
    protected var v2 = 0
}

extend A {
    func f() {
        print(v2) // OK
        print(v1) // Error
    }
}

在同一个包内对同一类型可以多次扩展，但扩展中的函数和属性必须遵循访问规则。例如：

extend Foo {
    private func f() {}
    func g() {}
}

extend Foo {
    func h() {
        g() // OK
        f() // Error
    }
}

8. 扩展的导入和导出

扩展可以被导入和导出，但需要遵循特定规则。对于直接扩展，只有当扩展与被扩展类型在同一个包，并且使用 public 或 protected 修饰时，扩展的功能才会被导出。接口扩展的导出规则也类似：

// package a
public class Foo {}
extend Foo {
    public func f() {}
}

// package b
import a.*
extend Foo {
    public func g() {}
}

// package c
import a.*
import b.*

main() {
    let a = Foo()
    a.f() // OK
    a.g() // Error
}

扩展的导入与导出

在仓颉语言中，扩展不仅可以增加类型的功能，还可以被导入和导出。导入和导出扩展需要遵循一些特定的规则，以确保代码的组织性和可访问性。以下是关于扩展的导入和导出机制的详细说明：

1. 直接扩展的导出

直接扩展（即不涉及接口的扩展）只有在满足以下条件时才会被导出：

  • 扩展与被扩展的类型位于同一个包。
  • 被扩展的类型以及扩展中添加的成员都使用了 public 或 protected 修饰符。

在满足上述条件的情况下，扩展中添加的功能将会随同被扩展的类型一起被导出。否则，扩展将仅在当前包内可用。

示例

假设我们在包 a 中定义了一个 Foo 类，并对其进行了扩展：

// package a
public class Foo {}

extend Foo {
    public func f() {}
}

在包 b 中，我们试图对 Foo 进行进一步的扩展：

// package b
import a.*

extend Foo {
    public func g() {}
}

在包 c 中，我们导入了包 a 和包 b：

// package c
import a.*
import b.*

main() {
    let a = Foo()
    a.f() // OK
    a.g() // Error
}

在这个例子中，虽然 Foo 的功能在包 b 中得到了扩展，但包 b 中的扩展 g 在包 c 中是不可用的，因为 g 的扩展不符合导出的条件。

2. 接口扩展的导出

接口扩展的导出规则分为两种情况：

  • 当接口扩展和被扩展的类型在同一个包中：只有当被扩展的类型使用 public 修饰时，扩展的功能才会被导出。

  • 当接口扩展与接口在同一个包中：只有当接口使用 public 修饰时，扩展的功能才会被导出。

示例

在包 a 中，我们定义了一个 Foo 类和一个 I 接口，并对 Foo 进行了接口扩展：

// package a

public class Foo {}

public interface I {
    func g(): Unit
}

extend Foo <: I {
    public func g(): Unit {}
}

在包 b 中，我们只需要导入 Foo 和 I：

// package b
import a.Foo

public interface I {
    func g(): Unit
}

extend Foo <: I {
    public func g() {
        this.f() // OK
    }
}

在包 c 中，我们同时导入了包 a 和包 b：

// package c
import a.Foo
import b.I

func test() {
    let a = Foo()
    a.f() // OK
    a.g() // OK
}

在这个例子中，由于 Foo 和 I 都在导入范围内，Foo 的扩展功能 g 可以在包 c 中使用。

扩展的访问和遮盖

扩展的访问规则和遮盖规则都遵循特定的机制，以保证扩展的功能不会干扰原有类型的行为。

  1. 访问规则：
    • 扩展中的实例成员可以访问 this，并且与原类型的 this 功能一致。
    • 扩展中的成员不能使用 super。
    • 扩展不能访问被扩展类型的 private 成员。
    • 扩展不能遮盖被扩展类型的成员。
    • 扩展也不能遮盖其他扩展中定义的成员。

示例

class A {
    private var v1 = 0
    protected var v2 = 0
}

extend A {
    func f() {
        print(v2) // OK
        print(v1) // Error
    }
}

在上述例子中，扩展 A 的 f 方法可以访问 protected 成员 v2，但不能访问 private 成员 v1。

  1. 遮盖规则：
    • 扩展不能遮盖被扩展类型的任何成员。
    • 扩展不能遮盖其他扩展中定义的成员。

示例

class A {
    func f() {}
}

extend A {
    func f() {} // Error
}

在这个例子中，扩展 A 的 f 方法不能遮盖原类型 A 的 f 方法。

扩展的泛型类型

对于泛型类型的扩展，除了基本的扩展功能外，还可以使用额外的泛型约束。两个扩展的可见性规则如下：

  • 如果两个扩展的约束相同，则两个扩展相互可见，即可以直接使用对方的函数或属性。
  • 如果两个扩展的约束不同，且一个约束包含另一个约束，则约束更宽松的扩展对约束更严格的扩展可见，反之不可见。
  • 如果两个扩展的约束不相关，则两个扩展之间互不影响。

示例

open class A {}
class B <: A {}
class E<X> {}

interface I1 {
    func f1(): Unit
}
interface I2 {
    func f2(): Unit
}

extend<X> E<X> <: I1 where X <: B {  // extension 1
    public func f1(): Unit {
        f2() // OK
    }
}

extend<X> E<X> <: I2 where X <: A   { // extension 2
    public func f2(): Unit {
        f1() // Error
    }
}

在这个例子中，扩展 E<X> 的 f1 方法可以调用 f2 方法，因为 f2 方法属于约束更宽松的扩展 1。而在扩展 2 中调用 f1 方法则会出错，因为 f1 方法在扩展 2 的约束下不可见。

扩展的导入导出规则

扩展本身不能使用 public 修饰，但扩展的导入和导出遵循特定的规则：

  • 导入：扩展会随着类型的导入而隐式导入。只需导入被扩展的类型和接口，即可使用其对应的扩展功能。
  • 导出：扩展的导出规则取决于其定义的位置和所用的修饰符。对于直接扩展，需确保扩展和被扩展的类型在同一包中，并且添加的成员使用 public 或 protected 修饰符。对于接口扩展，需确保接口使用 public 修饰符，并在同一包内定义。

示例

// package a
public class Foo {}
extend Foo {
    public func f() {}
}

// package b
import a.Foo

public interface I {
    func g(): Unit
}
extend Foo <: I {
    public func g() {
        this.f() // OK
    }
}

// package c
import a.Foo
import b.I

func test() {
    let a = Foo()
    a.f() // OK
    a.g() // OK
}

在这个例子中，Foo 的扩展功能在包 c 中可以正常使用，因为所有相关的包和接口都已经被正确导入。

通过以上内容，我们可以看到扩展在仓颉语言中的强大功能和灵活性。扩展不仅允许我们在不修改原有类型的情况下增加新功能，还可以通过复杂的泛型和接口机制，满足不同的需求和约束条件。

总结

仓颉语言中的扩展机制提供了一种强大且灵活的方式来增强现有类型的功能，而无需修改原有代码。以下是扩展机制的核心要点总结：

  1. 扩展的基本概念：

    • 扩展允许为已有类型（类、结构体等）添加新的成员函数、属性或实现接口。
    • 扩展不能修改原有类型的私有成员，也不能增加成员变量。

  2. 扩展的语法结构：

    • 使用 extend Type { ... } 语法为指定类型添加新功能。
    • 扩展中添加的成员必须具备实现，且不能使用 open、override、redef 修饰。

  3. 直接扩展与泛型扩展：

    • 直接扩展适用于现有类型，不涉及新的接口。
    • 泛型扩展可以对特定实例化的泛型类型或泛型类型本身进行扩展。

  4. 接口扩展：

    • 允许类型实现新的接口，增强类型的抽象能力。
    • 接口扩展的导出规则与直接扩展类似，但需要接口使用 public 修饰。

  5. 访问和遮盖规则：

    • 扩展中的成员可以访问 this，但不能使用 super。
    • 扩展不能访问被扩展类型的 private 成员，也不能遮盖原类型或其他扩展的成员。

  6. 扩展的导入和导出：

    • 扩展的功能会随着类型的导入而隐式导入。
    • 扩展的导出规则取决于其定义的位置和修饰符，直接扩展需要在同一包内且成员为 public 或 protected，接口扩展需要接口为 public。

  7. 泛型扩展的复杂性：

    • 对泛型类型的扩展允许使用泛型约束，以满足特定的需求。
    • 扩展的可见性规则依据泛型约束的关系进行定义，确保扩展的功能在不同上下文中的适用性。

通过这些机制，仓颉语言的扩展功能提供了极大的灵活性，支持代码的模块化和重用，同时保持了良好的封装性和结构性。这使得开发者能够在不破坏现有代码的情况下，轻松地增加新功能和改进现有功能。

image.png

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
开发者 鸿蒙
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入