Question

我试图根据定义它们的范围来构造类的实例，而不使用显式参数。

这是从Python到Kotlin的端口的一部分，但主要的想法是：

var d = MyClass()

use_scope(contextAForScope) {
    var a = MyClass()
    use_scope(contextBForScope) {
        var b=MyClass()
    }
}

在此示例中， d 构造函数将使用默认上下文， a 构造函数将使用 contextAForScope < / strong>和b构造函数将使用 contextBForScope （use_scope只是一个占位符）。像隐含的上下文？

当然，我可以使构造函数参数显式化，但这可能会在单个作用域中多次使用，我宁愿不定义其他变量。

Answer 1

class MyClass(val context: Int)

fun MyClass() = MyClass(0)

interface MyClassScope {
    fun MyClass(): MyClass
}

object ContextAForScope : MyClassScope {
    override fun MyClass() = MyClass(1)
}

object ContextBForScope : MyClassScope {
    override fun MyClass() = MyClass(2)
}

inline fun useScope(scope: MyClassScope, block: MyClassScope.() -> Unit) {
    scope.block()
}

fun main(args: Array<String>) {
    val d = MyClass()

    useScope(ContextAForScope) {
        val a = MyClass()
        useScope(ContextBForScope) {
            val b = MyClass()
        }
    }
}

使用工厂功能创建课程。如果将该函数命名为类，则它看起来像构造函数。

定义具有相同工厂函数的接口和作用域的两个对象。

定义一个占用范围和初始化程序块的函数。

现在您可以使用useScope - 函数，并在块中调用正确的工厂函数。

Answer 2

with正是您所寻找的：

class MyClass()

var d = MyClass()

fun main(args: Array<String>){
  var c = "c: Could be any class"
  var d = "d: Could be any class"

  with(c) {
    // c is "this"
    var a = MyClass()
    print(c) // prints "c: Could be any class"

    with(d) {
        // d is "this"
        var b = MyClass()
    }
    // b is undefined in this scope
  }
  // a is undefined in this scope
}

with将lambda作为参数，lambda中的所有内容仅在该范围内定义。

如何隐式为Kotlin中的构造函数传递上下文

2 个答案: