如何限制Kotlin接口仅在指定模块内实现？

针对你提出的禁止模块C实现接口A、B的需求，以下是几种可行的实现方案：

方案1：完全禁止外部模块实现（编译期拦截） #

利用Kotlin的internal权限特性，给接口添加外部模块无法访问的方法，迫使外部无法完成接口实现：

模块A代码 #

interface A {
    // 公开业务方法
    fun doSomething()

    // internal标记方法，仅当前模块可见
    internal fun internalImplementationMarker()
}

final class ImplA : A {
    override fun doSomething() {
        // 业务逻辑实现
    }

    override fun internalImplementationMarker() {
        // 空实现即可，仅用于标记
    }
}

模块B代码 #

interface B : A {
    // 公开业务方法
    fun doAnotherThing()

    // 同样添加internal标记方法
    internal fun internalBMaker()
}

final class ImplB : B {
    override fun doSomething() {
        // 业务逻辑实现
    }

    override fun doAnotherThing() {
        // 业务逻辑实现
    }

    override fun internalImplementationMarker() {
        // 实现A的internal方法
    }

    override fun internalBMaker() {
        // 空实现
    }
}

原理：接口的所有成员必须被实现，而internal方法仅在所属模块内可见。模块C尝试实现A/B时，无法看到这些internal方法，自然无法完成接口实现，编译直接报错。

方案2：要求外部实现必须添加@OptIn注解（编译期提醒） #

如果不想完全禁止，而是要求外部模块显式声明“允许实现”，可以自定义@RequiresOptIn注解：

步骤1：定义注解（模块A中） #

@RequiresOptIn(level = RequiresOptIn.Level.ERROR)
annotation class AllowImplementation

步骤2：标记接口 #

模块A中：

@AllowImplementation
interface A {
    fun doSomething()
}

final class ImplA : A {
    override fun doSomething() { /* 实现 */ }
}

模块B中：

@AllowImplementation
interface B : A {
    fun doAnotherThing()
}

final class ImplB : B {
    override fun doSomething() { /* 实现 */ }
    override fun doAnotherThing() { /* 实现 */ }
}

步骤3：模块A/B内部开启OptIn #

在模块A和B的build.gradle.kts中添加配置，让内部实现无需显式加注解：

kotlin {
    sourceSets {
        all {
            languageSettings.optIn("com.yourpackage.AllowImplementation")
        }
    }
}

效果：模块C实现A/B时，必须添加@OptIn(AllowImplementation::class)注解，否则编译报错（Level.ERROR级别），达到“显式授权才能实现”的目的。

方案3：运行时拦截 #

如果编译期限制无法满足需求，可以在接口的初始化逻辑中检查实现类所属模块：

模块A代码 #

interface A {
    init {
        val moduleName = this::class.java.module.name
        // 仅允许模块A和B实现
        if (moduleName !in setOf("moduleA", "moduleB")) {
            throw IllegalStateException("禁止在模块[$moduleName]中实现接口A")
        }
    }

    fun doSomething()
}

final class ImplA : A {
    override fun doSomething() { /* 实现 */ }
}

模块B代码 #

interface B : A {
    init {
        val moduleName = this::class.java.module.name
        if (moduleName !in setOf("moduleA", "moduleB")) {
            throw IllegalStateException("禁止在模块[$moduleName]中实现接口B")
        }
    }

    fun doAnotherThing()
}

final class ImplB : B {
    override fun doSomething() { /* 实现 */ }
    override fun doAnotherThing() { /* 实现 */ }
}

效果：模块C实现A/B后，实例化时会抛出运行时异常，阻止非法实例的创建。

关于你之前尝试的错误说明 #

你将抽象类A的构造方法设为private，这会导致只有A类内部可以调用该构造方法，模块B的抽象类B自然无法访问A的构造，因此编译报错。如果要使用抽象类的方式，应该将构造方法设为internal，但internal仅在当前模块可见，跨模块的B依然无法继承，因此这种方式不适合你的多模块场景。

内容的提问来源于stack exchange，提问作者kosmo16