多类型对象表达式中的Lambda

我得到了一个类

Foo

，它执行一些

工作（）

我还（但由其他人）提供了一个方法
useJob（）
，它使用接口类型为
Bar
的对象，该对象具有一个方法
doJob（）

结果是
Foo.work（）
完成了
useJob（）
所期望的任务。但是，为了让
useJob（）
调用
work（）
，我需要这样写：

useJob(object : Foo(), Bar { fun doJob(x: T) { work(x) } })

有没有办法用lambda来代替这个blob

编辑：@jrtapsell评论让我意识到Foo实际上是开放的
 这是一个问题，
useJob
希望直接使用接口而不是函数类型。这样，您只能执行以下操作：

val bar = object : Bar {
    override fun doJob(x: String) = Foo().work(x)
}

useJob(bar)

这是一个问题，
useJob
希望直接使用接口而不是函数类型。这样，您只能执行以下操作：

val bar = object : Bar {
    override fun doJob(x: String) = Foo().work(x)
}

useJob(bar)

实现这一点的最简单方法是使用工厂方法，创建Bar实例并接受函数调用：

fun job(func: (Param) -> Unit) : Bar = object: Bar { 
   override fun doJob(x: Param) = func(x)
}

然后你可以用

useJob( job { Foo().work(it) } )

实现这一点的最简单方法是使用工厂方法，创建Bar实例并接受函数调用：

fun job(func: (Param) -> Unit) : Bar = object: Bar { 
   override fun doJob(x: Param) = func(x)
}

然后你可以用

useJob( job { Foo().work(it) } )

如果
Bar
是用Java定义的，那么您可以编写

useJob { Foo().work(x) }

或

为了避免每次在case
useJob
多次调用其参数时构造
Foo（）

但是


如果不将
Bar
移动到Java，我会使用joecks的解决方案，或者定义
useJob
的重载（可能作为扩展方法）。哪个更好取决于您有多少方法，比如
useJob
，以及每个方法有多少用法。
如果
Bar
是用Java定义的，您可以编写

useJob { Foo().work(x) }

或

为了避免每次在case
useJob
多次调用其参数时构造
Foo（）

但是


如果不将
Bar
移动到Java，我会使用joecks的解决方案，或者定义
useJob
的重载（可能作为扩展方法）。哪一种更好取决于您有多少种方法，如
useJob
，以及每种方法有多少种用途。
您可以这样做：

// Mock class
class Param

// Provided code
open class Foo<T> {
    fun work(x: T) {
        // Effects taking place here
    }
}

fun useJob(bar: Bar) {}

interface Bar {
    fun doJob(x: Param)
}

// New code
object FooBar: Foo<Param>(), Bar {
    override fun doJob(x: Param) = work(x)
    fun use() = useJob(this)
}

fun x() {
    FooBar.use()
}

//模拟类
类参数
//提供的代码
公开课Foo{
有趣的工作（x:T）{
//这里发生的影响
}
}
有趣的工作（酒吧：酒吧）{}
接口条{
有趣的doJob（x:Param）
}
//新代码
对象FooBar:Foo（），Bar{
覆盖作业（x:Param）=工作（x）
fun use（）=useJob（此）
}
funx（）{
FooBar.use（）
}

FooBar对象需要更多的代码，但它会清理调用站点。
您可以这样做：

// Mock class
class Param

// Provided code
open class Foo<T> {
    fun work(x: T) {
        // Effects taking place here
    }
}

fun useJob(bar: Bar) {}

interface Bar {
    fun doJob(x: Param)
}

// New code
object FooBar: Foo<Param>(), Bar {
    override fun doJob(x: Param) = work(x)
    fun use() = useJob(this)
}

fun x() {
    FooBar.use()
}

//模拟类
类参数
//提供的代码
公开课Foo{
有趣的工作（x:T）{
//这里发生的影响
}
}
有趣的工作（酒吧：酒吧）{}
接口条{
有趣的doJob（x:Param）
}
//新代码
对象FooBar:Foo（），Bar{
覆盖作业（x:Param）=工作（x）
fun use（）=useJob（此）
}
funx（）{
FooBar.use（）
}

FooBar对象需要多一点代码，但它会清理调用站点。
foo可以打开吗？@jrtapsell是的，它可以吗？您需要
Bar
界面，还是只需要
fun useJob（Bar:（T）->Unit）
？foo可以打开吗？@jrtapsell是的，它可以吗？您需要
Bar
界面，或者你可以只做
有趣的工作（bar：（T）->单位）
？很好的代码。实际上，
Param
是
Bar
中的一个输入错误，
T
是一个定义类型，而不是泛型参数。代码不错。实际上，
Param
是
Bar
中的一个输入错误，
T
是一个定义类型，而不是泛型参数。