Scala Generic，通过变量指定Generic

我有一个类，它接受一个泛型：

class MyClass[T <: RecordType] (myRecordType: T) {
  def doAction() : Unit =
  {
    myRecordType.someMethod();
  }
}

理想情况下，我们不需要为每种记录类型添加新行，而是希望有一个有效记录类型的枚举，只需循环即可。这样，添加新的记录类型就和添加到预定义列表一样简单。但我无法弄清楚如何拥有类类型的数组或枚举，然后将它们传递给MyClass的实例化。例如，这个简单的测试：

val testClass = classOf(RecordType10);
new MyClass[testClass](new testClass()).doAction();

。。。它不编译

所以基本的问题是：有没有一种方法可以拥有一个类集合，然后遍历该集合并实例化另一个传递泛型类型值的类。大概是这样的：

val myClasses = Array(classOf(Record10), classOf(Record20), classOf(Record30));
for (theClass <- myClasses)
{
   new MyClass[theClass](new theClass()).doAction();
}

val myClasses=Array（classOf（Record10）、classOf（Record20）、classOf（Record30））；
对于（类Edit）：通过Alexander的解决方案简化以获得类名

这是可行的，但我不知道有什么方法可以自动构建该列表（可能是通过反射）

trait A{def say=println（“你好”）}
类B扩展了{override def say=println（“Hello B”）}
类C扩展了{override def say=println（“Hello C”）}
val ls:List[Class[\up>可能更简单：

trait MyType{def myMethod:Unit}
class ActionInvoker[T <: MyType](parameter: T){
  def invoke:Unit = parameter.myMethod
}
class Inst1 extends MyType{def myMethod = println("Inst1 here")}
class Inst2 extends MyType{def myMethod = println("Inst2 here")}
val l:List[Class[_ <: MyType]] = List(classOf[Inst1], classOf[Inst2])
for(c <- l){
  new ActionInvoker(c.newInstance).invoke
}

trait MyType{def myMethod:Unit}
类ActionInvoker[T为简单起见，使用OP的示例：

object Main {
  trait RecordType {
    def someMethod()
  }

  class MyClass[T <: RecordType](myRecordType: T) {
    def doAction(): Unit = myRecordType.someMethod()
  }

  class RecordType10() extends RecordType {
    override def someMethod(): Unit = println("some method 10")
  }

  class RecordType20() extends RecordType {
    override def someMethod(): Unit = println("some method 20")
  }

  def main(args: Array[String]): Unit = {
    new MyClass[RecordType10](new RecordType10()).doAction()
    new MyClass[RecordType20](new RecordType20()).doAction()

    val myClasses = List(classOf[RecordType10], classOf[RecordType20])
    for(theClass <- myClasses) {
      val instance = theClass.newInstance()
      val m = new MyClass(instance)
      m.doAction()
    }
  }
}

objectmain{
性状记录类型{
def someMethod（）
}
类MyClass[T它可能与之相关？如果您在列表声明中提供了特定类型，那么您也不需要使用
asInstanceof[a]
强制转换，感谢您使用原始示例…清晰而精彩！
trait MyType{def myMethod:Unit}
class ActionInvoker[T <: MyType](parameter: T){
  def invoke:Unit = parameter.myMethod
}
class Inst1 extends MyType{def myMethod = println("Inst1 here")}
class Inst2 extends MyType{def myMethod = println("Inst2 here")}
val l:List[Class[_ <: MyType]] = List(classOf[Inst1], classOf[Inst2])
for(c <- l){
  new ActionInvoker(c.newInstance).invoke
}

object Main {
  trait RecordType {
    def someMethod()
  }

  class MyClass[T <: RecordType](myRecordType: T) {
    def doAction(): Unit = myRecordType.someMethod()
  }

  class RecordType10() extends RecordType {
    override def someMethod(): Unit = println("some method 10")
  }

  class RecordType20() extends RecordType {
    override def someMethod(): Unit = println("some method 20")
  }

  def main(args: Array[String]): Unit = {
    new MyClass[RecordType10](new RecordType10()).doAction()
    new MyClass[RecordType20](new RecordType20()).doAction()

    val myClasses = List(classOf[RecordType10], classOf[RecordType20])
    for(theClass <- myClasses) {
      val instance = theClass.newInstance()
      val m = new MyClass(instance)
      m.doAction()
    }
  }
}