Generics 如何在Kotlin中将类型传递给泛型方法？

我有一个如下的通用方法

private fun <T> getSomething(): T {
    return "something" as T
}

在运行时，我不知道什么是泛型类型

t

。我从

types

获取类型，应该使用generic

getSomething

方法传递它

用例 我想调用包含多个表的数据库。示例模型如下所示

class User{

}

class Student{

}

由于所有调用查询基本相同，所以我希望使用通用方法调用数据库并获取数据

private fun <T> getData(model: String): List<T>?{
    return when(model){
        "user" -> getUsers()
        "student" -> getStudents()
        else -> null
    }
}

---

我怎样才能做到这一点。

这里有一个完整的例子：

import kotlin.reflect.KClass

data class User(val name: String)
data class Student(val name: String)

fun getUsers(): List<User> = listOf(User("JB"))
fun getStudents(): List<Student> = listOf(Student("Claire"))

fun <T: Any> getData(clazz: KClass<T>): List<T>? {
    return when(clazz) {
        User::class -> getUsers() as List<T>
        Student::class -> getStudents()  as List<T>
        else -> null
    }
}

fun main(args: Array<String>) {
    val types = listOf(User::class, Student::class)
    types.forEach { type ->
        val data = getData(type)
        println(data)
    }
}

import kotlin.reflect.KClass
数据类用户（val名称：字符串）
数据类学生（val名称：字符串）
fun getUsers（）：List=listOf（用户（“JB”））
fun getStudents（）：List=listOf（学生（“克莱尔”））
有趣的getData（clazz:KClass）：列表？{
返回时间（clazz）{
User:：class->getUsers（）作为列表
学生：：类->获取学生（）作为列表
else->null
}
}
趣味主线（args:Array）{
val types=listOf（用户：：类，学生：：类）
types.forEach{type->
val data=getData（类型）
println（数据）
}
}

我会坚持使用以下具体类型

import kotlin.reflect.KClass

interface IBaseData
interface IDataTable<out T> where T : IBaseData
{
    fun getData(): List<T>
}

class User : IBaseData
class Student : IBaseData

class UserTable : IDataTable<User>
{
    override fun getData(): List<User>
    {
        return listOf(User())
    }
}

class StudentTable : IDataTable<Student>
{
    override fun getData(): List<Student>
    {
        return listOf(Student())
    }
}

inline fun <reified T: IBaseData> getDataTable() : IDataTable<T>?
{
    return when(T::class)
    {
        User::class -> UserTable() as IDataTable<T>
        Student::class -> StudentTable() as IDataTable<T>
        else -> null
    }
}

fun main()
{
    var user = getDataTable<User>()?.getData()
    var student = getDataTable<Student>()?.getData()
}

import kotlin.reflect.KClass
接口IBAA
接口IDatable，其中T:a
{
fun getData（）：列表
}
类用户：IBAA
班级学生：IBAA
类UserTable:IDataTable
{
覆盖getData（）：列表
{
返回（用户（）的列表）
}
}
班级学生表：IDataTable
{
覆盖getData（）：列表
{
返回（学生（）的列表）
}
}
inline fun getDataTable（）：IDataTable？
{
返回时间（T:：class）
{
User:：class->UserTable（）作为IDataTable
Student:：class->StudentTable（）作为IDatable
else->null
}
}
主要内容（）
{
var user=getDataTable（）？.getData（）
var student=getDataTable（）？.getData（）
}

---

但是，这仍然是一项开销，为什么不直接使用

getUser（）

或

getStudents（）

从上面的示例中可以看出，您不是在传递类型，而是在返回类型。你到底想要什么？为什么要用“变量类名”来称呼它？你想用它做什么？由于泛型只能用于静态类型检查，并且根据定义，变量不是静态的，所以对于变量泛型类型，您无法做任何事情。（一个例外是内联函数上的

具体化的
泛型类型，但您没有使用它）@ErwinBolwidt它不必是“变量类名”。我稍微编辑了一下这个例子。因此，我有类列表，我必须将类型从那里传递到
getSomething
方法。如果可以使用
具体化
我该如何使用它？您想用它做什么？您想对需要此功能的
东西做什么？请在您的代码中说明这一点。@ErwinBolwidt我包含了一个示例，我希望该示例能够解释在您将val数据作为列表时我要做的事情，并且必须猜测它必须转换为什么类型以供进一步使用。那有什么意义？这是你应该问医生的问题，不是我。但在这样一个循环中，你只需要做同样的事情，不管类型是什么。如果您知道类型，并使用getData（Student:：class），您将得到一个列表，而不是列表。我在Idea中检查了它-在您的示例中，val数据是ListNo，它是List？。那又怎么样？就像我说的，这里你想做同样的事情，不管类型是什么，但你不知道实际的类型。如果您这样做，并使用
val data=getData（Student:：class）
，您会得到一个列表？>使用val data=getData（Student:：class），您会得到一个列表吗？是的，你是对的，但是如果你知道类型并明确地设置它，它与直接调用“getStudents”有何不同？我这里有一个类似的问题。你能帮忙吗。
import kotlin.reflect.KClass

data class User(val name: String)
data class Student(val name: String)

fun getUsers(): List<User> = listOf(User("JB"))
fun getStudents(): List<Student> = listOf(Student("Claire"))

fun <T: Any> getData(clazz: KClass<T>): List<T>? {
    return when(clazz) {
        User::class -> getUsers() as List<T>
        Student::class -> getStudents()  as List<T>
        else -> null
    }
}

fun main(args: Array<String>) {
    val types = listOf(User::class, Student::class)
    types.forEach { type ->
        val data = getData(type)
        println(data)
    }
}

import kotlin.reflect.KClass

interface IBaseData
interface IDataTable<out T> where T : IBaseData
{
    fun getData(): List<T>
}

class User : IBaseData
class Student : IBaseData

class UserTable : IDataTable<User>
{
    override fun getData(): List<User>
    {
        return listOf(User())
    }
}

class StudentTable : IDataTable<Student>
{
    override fun getData(): List<Student>
    {
        return listOf(Student())
    }
}

inline fun <reified T: IBaseData> getDataTable() : IDataTable<T>?
{
    return when(T::class)
    {
        User::class -> UserTable() as IDataTable<T>
        Student::class -> StudentTable() as IDataTable<T>
        else -> null
    }
}

fun main()
{
    var user = getDataTable<User>()?.getData()
    var student = getDataTable<Student>()?.getData()
}