Kotlin 在物化之后，我们还需要类（或KClass）吗？

通过将

具体化

，我可以替换以下函数

private fun <T>createFragmentX(fragmentClass: Class<T>, fragmentArgs: Bundle?): Fragment {
    try {
        val fragment = fragmentClass.newInstance() as Fragment
        fragment.arguments = fragmentArgs
        return fragment
    } catch (exception: Exception) {
        throw RuntimeException(exception.message)
    }
}

private fun createFragmentX（fragmentClass:Class，fragmentArgs:Bundle？）：Fragment{
试一试{
val fragment=fragmentClass.newInstance（）作为片段
fragment.arguments=fragmentArgs
返回片段
}捕获（异常：异常）{
抛出运行时异常（exception.message）
}
}

用这个

private inline fun <reified T>createFragmentZ(fragmentArgs: Bundle?): Fragment {
    try {
        val fragment = T::class.java.newInstance() as Fragment
        fragment.arguments = fragmentArgs
        return fragment
    } catch (exception: Exception) {
        throw RuntimeException(exception.message)
    }
}

private-inline-fun-createFragmentZ（fragmentArgs:Bundle？）：Fragment{
试一试{
val fragment=T:：class.java.newInstance（）作为片段
fragment.arguments=fragmentArgs
返回片段
}捕获（异常：异常）{
抛出运行时异常（exception.message）
}
}

在我看来，随着

具体化

，不再需要使用

类

或

KClass

。我说得对吗

除了想做纯粹的反射工作外，

Class

或

KClass

是否还有其他不能通过

具体化的
实现的用途？
简短回答：
在您的示例中，除了美学之外，它没有任何区别

长答覆：
如果将
T
作为
reified
传入，则可以像这样从
reified
类型参数
T
中检索
KClass

val kClass = T::class

随时都可以。然后，使用
KClass
作为参数，就有了所有的选项，所以这里没有区别


但在某些情况下，您需要使用
KClass
作为参数。这里有两个：

1）无内联

当您不希望函数是
内联的
，因为使用
具体化的
类型仅适用于内联函数时

2）默认值

另一种情况是默认值：

fun f(kClass: KClass<*> = Int::class) { /*...*/ }

funf（kClass:kClass=Int:：class）{/*…*/}

使用具体化的类型参数无法实现完全相同的效果

结论：

在所有其他情况下，使用泛型类型参数，因为它使调用站点更加简洁，如图所示（这可能是个人偏好）：

inline fun printType（）{
println（T:：class.simpleName）
}
趣味打印类型（kClass:kClass）{
println（kClass.simpleName）
}

呼叫站点

printType<Int>() // better
printType(Int::class)

printType（）//更好
打印类型（Int:：class）
简短回答：
在您的示例中，除了美学之外，它没有任何区别

长答覆：
如果将
T
作为
reified
传入，则可以像这样从
reified
类型参数
T
中检索
KClass

val kClass = T::class

随时都可以。然后，使用
KClass
作为参数，就有了所有的选项，所以这里没有区别


但在某些情况下，您需要使用
KClass
作为参数。这里有两个：

1）无内联

当您不希望函数是
内联的
，因为使用
具体化的
类型仅适用于内联函数时

2）默认值

另一种情况是默认值：

fun f(kClass: KClass<*> = Int::class) { /*...*/ }

funf（kClass:kClass=Int:：class）{/*…*/}

使用具体化的类型参数无法实现完全相同的效果

结论：

在所有其他情况下，使用泛型类型参数，因为它使调用站点更加简洁，如图所示（这可能是个人偏好）：

inline fun printType（）{
println（T:：class.simpleName）
}
趣味打印类型（kClass:kClass）{
println（kClass.simpleName）
}

呼叫站点

printType<Int>() // better
printType(Int::class)

printType（）//更好
打印类型（Int:：class）
您不需要在此处将其作为参数传递，但您的代码仍然使用
Class
：这就是
t:：Class.java
的含义。是的，在很多情况下，您需要
Class
，而您的就是其中之一。
您不需要在这里将其作为参数传递，但您的代码仍然使用
Class
：这就是
t:：Class.java
的含义。因此，是的，在很多情况下，您需要
类，而您的类就是其中之一。
为什么不
私有内联乐趣
？为什么不
私有内联乐趣
？3）当它是类参数时（尽管您可以使用
具体化的
创建帮助函数）。3）当它是类参数时（尽管您可以使用
具体化的
创建助手函数）。