Kotlin顶级类用protected修饰符报错，如何实现包内可见？

Ah, I see the issue here! Let's break this down step by step.

First, the error you're getting makes perfect sense: in Kotlin, the protected modifier can't be used on top-level classes (classes declared directly in a file, not nested inside another class). protected is only meant for class members (properties, functions) or nested classes, where it restricts access to the class itself and its subclasses.

Now, to achieve your goal of making NetworkManagerImpl visible only within its current package, let's look at the options Kotlin provides:

Option 1: Use internal (Closest Built-In Alternative) #

Kotlin doesn't have a direct equivalent to Java's package-private access, but internal is the most common solution. It makes the class visible to all code within the same module (a Gradle module, IntelliJ module, or Maven artifact). If your package is contained within a single module, this will likely meet your needs:

internal class NetworkManagerImpl : NetworkManager { }

Option 2: Strict Package-Level Visibility (Workaround) #

If you strictly need visibility limited to the exact package (even other packages in the same module can't access it), Kotlin doesn't have a native modifier for this. But you can use a workaround with a private class and a package-level factory function:

// Declare the class as private (only visible within this file)
private class NetworkManagerImpl : NetworkManager { }

// Expose a package-level function to create instances (visible only to the package)
internal fun createNetworkManager(): NetworkManager {
    return NetworkManagerImpl()
}

This way, code outside the package can only interact with the NetworkManager interface, not the concrete NetworkManagerImpl class. Code within the same package can use the factory function to get instances. If you need direct access to the class itself, you'd have to keep all related classes in the same file (using private for the class, which limits visibility to that specific file).

Key Takeaways #

• Don't use protected for top-level classes: It's not allowed in Kotlin and will throw the error you saw.
• internal is the go-to choice for most cases where you want to restrict visibility beyond public access.
• Use the private class + factory function workaround if you need strict package-level hiding of the concrete implementation.

内容的提问来源于stack exchange，提问作者Tarun Deep Attri