为了在内联方法中使用它们而混淆对优先私有但实际上 public class 成员的访问的方法

Question

有哪些方法可以混淆或限制对 class 的 public 成员的访问？

这样做的动机是我希望能够inline一个方法，但是它需要访问class中的其他成员，这要求他们是[=14] =]，但我更希望这些成员不是 public，但由于它们必须是 public，我正在寻找混淆或限制对它们的访问的方法。

这是我希望 preferablyPrivateLock 私有化的例子：

class SomeClass
{
    val preferablyPrivateLock = ReentrantLock()

    inline fun <R> fancyInlineFunction(function:()->R):R
    {
        preferablyPrivateLock.lock()
        try
        {
            return function()
        }
        finally
        {
            preferablyPrivateLock.unlock()
        }
    }
}

P.S。我知道这似乎是糟糕的 OO 设计；希望这个问题不会让我失去任何声誉...

Answer 1

这是一种在 extensions 的帮助下混淆对 preferablyPrivateLock 的访问的方法：

class SomeClass
{
    private val preferablyPrivateLock = ReentrantLock()
    val Unit.obfuscatedLock:ReentrantLock
        get() = preferablyPrivateLock

    inline fun <R> fancyInlineFunction(function:()->R):R
    {
        with(this) {Unit.obfuscatedLock}.lock()
        try
        {
            return function()
        }
        finally
        {
            with(this) {Unit.obfuscatedLock}.unlock()
        }
    }
}

Answer 2

同样可以在没有 Unit 的情况下完成，方法是将方法作为其自身的扩展 class，在本例中为 SomeClass。这简化了用法：

class SomeClass
{
    private val preferablyPrivateLock = ReentrantLock()
    val SomeClass.hiddenLock: ReentrantLock
        get() = preferablyPrivateLock

    inline fun <R> fancyInlineFunction(function:()->R):R
    {
        with(this) { hiddenLock }.lock()
        try
        {
            return function()
        }
        finally
        {
            with(this) { hiddenLock }.unlock()
        }
    }
}

class OtherClass {
    fun foo() {
        val x = SomeClass().hiddenLock // ERROR: Unresolved reference hiddenLock
    }
}

@Kirill 在 Kotlin Slack 中提到了这个解决方案。这是与此类似的技术：

为了在内联方法中使用它们而混淆对优先私有但实际上 public class 成员的访问的方法

Ways to obfuscate access to prefereably private, but actually public class members for the sake of using them in inline methods

visibility

inline

kotlin