Java 是否可以为kotlin中的多个伴生对象创建一个全局通用函数

我在Kotlin开发了一个应用程序，它有许多

活动

。大多数导航都是基本的，开始新的活动，而不是传递任何内容。对于一些活动组，我可能会传递标志，这在整个项目中也是重复的（例如，设置

intent.flags=intent.FLAG\u ACTIVITY\u CLEAR\u TASK或intent.FLAG\u ACTIVITY\u NEW\u TASK

）。所以，如果我能找到一种方法，只要一个实现，事情就会变得更好

为了使事情变得更简单、更整洁，我为

活动

创建了包含以下功能的伴生对象：

class MyActivity: AppCompatActivity() {
   companion object {
        fun startActivity(context: Context) {
            context.startActivity(
                Intent(context, MyActivity::class.java)
            )
        }
    }
...

其他类可以简单地调用

MyActivity.startActivity（context）

该函数非常基本，不同活动中实现的唯一区别显然是

MyActivity:：class.java

-部分。因此，我想知道是否可以只声明一次这个函数，并在不同活动的多个伴生对象中使用它

现在，我明白我可以这样做：

object MyObject {
    inline fun <reified T: AppCompatActivity>startActivity(context: Context) {
        context.startActivity(
            Intent(context, T::class.java)
        )
    }
}

class MyActivity() : AppCompatActivity() {
    companion object {
        fun start(context: Context) = MyObject.startActivity<MyActivity>(context)
    }
}

我定义了一个具有泛型类型函数的对象，并将其设置为：

object MyObject {
    inline fun <reified T: AppCompatActivity>startActivity(context: Context) {
        context.startActivity(
            Intent(context, T::class.java)
        )
    }
}

class MyActivity() : AppCompatActivity() {
    companion object {
        fun start(context: Context) = MyObject.startActivity<MyActivity>(context)
    }
}

对象MyObject{
内联趣味startActivity（上下文：上下文）{
情境性(
意图（上下文，T:：class.java）
)
}
}
类MyActivity（）：AppCompatActivity（）{
伴星{
有趣的开始（上下文：上下文）=MyObject.startActivity（上下文）
}
}

但这看起来还是有点不太对劲。我要找的是继承之类的东西，或者是一个接口的实现版本，可以简单地添加到我的同伴对象中。比如：

companion object : MyObject<MyActivity>
// Assuming I can somehow put the generic parameter into the object declaration instead of the function or do something similar

伴生对象：MyObject
//假设我可以以某种方式将泛型参数放入对象声明中，而不是函数或执行类似操作

或

伴生对象{
导入MyObject.startActivity
}

---

第一个选项特别有用，因为它会自动为

MyActivity

设置多个

MyObject

函数。这样做可能吗？

您甚至不需要同伴，只需要一个扩展函数

inline fun <reified T: AppCompatActivity> Activity.startActivity() {
    startActivity(Intent(this, T::class.java))
}

inline fun Activity.startActivity（）{
startActivity（Intent（this，T:：class.java））
}

如果需要其他配置，可以传递lambda

inline fun <reified T: AppCompatActivity> Activity.startActivity(intentConfiguration: Intent.() -> Unit) {
    startActivity(Intent(this, T::class.java).apply(intentConfiguration))
}

inline fun Activity.startActivity（intentConfiguration:Intent.（->Unit）{
startActivity（Intent（this，T:：class.java）.apply（intentConfiguration））
}

您甚至不需要伴侣，只需要一个扩展功能

inline fun <reified T: AppCompatActivity> Activity.startActivity() {
    startActivity(Intent(this, T::class.java))
}

inline fun Activity.startActivity（）{
startActivity（Intent（this，T:：class.java））
}

如果需要其他配置，可以传递lambda

inline fun <reified T: AppCompatActivity> Activity.startActivity(intentConfiguration: Intent.() -> Unit) {
    startActivity(Intent(this, T::class.java).apply(intentConfiguration))
}

inline fun Activity.startActivity（intentConfiguration:Intent.（->Unit）{
startActivity（Intent（this，T:：class.java）.apply（intentConfiguration））
}

伴生对象可以从其他类继承。只需在某个地方进行基本实现：

abstract class ActivityCompanion<T: Activity>(val activityClass : Class<T>) {
    fun startActivity(context: Context) {
        context.startActivity(Intent(context, activityClass))
    }
    /** rest of functions that reference activityClass **/
}

抽象类ActivityCompanion（val activityClass:class）{
趣味性（上下文：上下文）{
context.startActivity（意图（context，activityClass））
}
/**引用activityClass的其余函数**/
}

并在你的同伴身上继承它：

class MyActivity() : AppCompatActivity() {
    companion object : ActivityCompanion<MyActivity>(MyActivity::class.java)
}

class MyActivity（）：AppCompatActivity（）{
伴随对象：ActivityCompanion（MyActivity:：class.java）
}

---

这有点冗长，但泛型就是这样工作的。

伴生对象可以从其他类继承。只需在某个地方进行基本实现：

abstract class ActivityCompanion<T: Activity>(val activityClass : Class<T>) {
    fun startActivity(context: Context) {
        context.startActivity(Intent(context, activityClass))
    }
    /** rest of functions that reference activityClass **/
}

抽象类ActivityCompanion（val activityClass:class）{
趣味性（上下文：上下文）{
context.startActivity（意图（context，activityClass））
}
/**引用activityClass的其余函数**/
}

并在你的同伴身上继承它：

class MyActivity() : AppCompatActivity() {
    companion object : ActivityCompanion<MyActivity>(MyActivity::class.java)
}

class MyActivity（）：AppCompatActivity（）{
伴随对象：ActivityCompanion（MyActivity:：class.java）
}

---

这有点冗长，但泛型就是这样工作的。

只想指出，更简洁的语法是在

上下文上使用具体化的扩展函数来实现这一点。你也不必担心伴星

inline fun <reified T: Activity> Context.startActivity() = 
    startActivity(Intent(this, T::class.java))

//Usage:
someViewOrActivity.startActivity<MyActivity>()

inline fun Context.startActivity（）=
startActivity（Intent（this，T:：class.java））
//用法：
someViewOrActivity.startActivity（）

它在语义上也更有意义。上下文开始一项活动。活动不会自行启动。
只想指出，更简洁的语法是在
上下文上使用具体化的扩展函数。你也不必担心伴星

inline fun <reified T: Activity> Context.startActivity() = 
    startActivity(Intent(this, T::class.java))

//Usage:
someViewOrActivity.startActivity<MyActivity>()

inline fun Context.startActivity（）=
startActivity（Intent（this，T:：class.java））
//用法：
someViewOrActivity.startActivity（）

它在语义上也更有意义。上下文开始一项活动。活动本身不会启动。
您不需要类的实例来调用扩展函数吗？我刚刚注意到，我曾经实现过一个类似于此的函数，只是将类作为KClass类型的普通参数传递，并将扩展赋予上下文而不是活动，以便视图能够在不强制转换的情况下调用它。但是lambda是一个很好的补充。回答得好！！现在剩下的唯一问题是哪一个性能更好。同伴或扩展。难道你不需要一个类的实例来调用它的扩展函数吗？我刚刚注意到，我甚至实现了一个类似于此的函数，只是将类作为KClass类型的普通参数传递，并将扩展赋予上下文而不是活动，以使视图能够在不强制转换的情况下调用它。但是lambda是一个很好的补充。回答得好！！现在剩下的唯一问题是哪一个更好