类和包的可见性-优快云博客

Kotlin 是 JetBrains 开发的一门现代编程语言，因其简洁性、安全性和强大功能而广受欢迎。本主题将深入探讨 Kotlin 中一个重要的概念：类、包和模块的可见性（visibility）。可见性决定了代码中的哪些组件可以从其他部分访问。理解可见性将帮助你编写更安全、更模块化的代码。

定义类的可见性

在 Kotlin 中，类的可见性由**可见性修饰符（visibility modifiers）**决定，这些修饰符指定了哪些代码可以访问该类。Kotlin 提供了四种可见性修饰符：

public：类可以被任意代码访问（默认可见性）。
internal：类只能在同一个模块中访问。
protected：类只能在其自身及其子类中访问。
private：类只能在声明它的文件内部访问。

示例：

public class PublicClass
internal class InternalClass
protected class ProtectedClass // 编译错误，顶层类不能使用 protected
private class PrivateClass

说明：在 Kotlin 中，顶层类不能使用 protected 修饰符，因为 protected 只适用于类成员（字段、函数）而不是顶层声明。

protected是一种可见性修饰符（visibility modifier），它的作用是在类内部以及该类的子类中使成员（例如属性、方法）可访问

继承与可见性

在 Kotlin 中，如果一个类继承了另一个类，它可以访问父类的 protected 和 internal 成员。但无法访问父类的 private 成员。

open class Parent {
    protected val protectedValue = 42
    private val privateValue = 21
}

class Child : Parent() {
    fun printValues() {
        println(protectedValue) // 合法访问
        println(privateValue)   // 编译错误，无法访问 private 成员
    }
}

说明：protectedValue 可以被子类访问，而 privateValue 只能在 Parent 类中访问。

定义包的可见性

在 Kotlin 中，包用于组织相关的类、对象和函数。包中的可见性同样由可见性修饰符控制。

// 文件：mypackage/MyClass.kt
package mypackage

public class MyClass
internal class MyInternalClass

public 类对所有包可见，而 internal 类只能在同一模块内的其他文件中访问。

导入与包的使用

若要在其他包中使用类，必须导入它们。如果类是 public 或在同一模块中定义的 internal 类，则可以导入或使用全限定名访问。

import mypackage.MyClass

fun main() {
    val myClass = MyClass() // 使用已导入的类
    val myInternalClass = mypackage.MyInternalClass() // 使用 internal 类（同模块内可以）
}

注意：internal 类不能跨模块访问。

模块与 internal 可见性

模块（module） 是一起编译的一组源代码文件。在 Kotlin 中，一个模块可以是：

一个 IntelliJ IDEA 项目，
一个 Gradle 或 Maven 项目，
或者其他编译单元。

internal 修饰符用于表示某个代码元素只能在一个模块内部访问。当你希望限制某些代码的访问范围，使其不被模块外部访问时，这非常有用。

// 文件：mymodule/MyInternalClass.kt
package mymodule

internal class MyInternalClass {
    val value = 42
}

// 同模块下的另一个文件
import mymodule.MyInternalClass

fun main() {
    val instance = MyInternalClass() // 合法，因为在同一模块中
    println(instance.value)
}