Class 通过给定的泛型类型Scala获取类的伴生对象

我试图做的是创建一个函数，它将接受一个泛型类，并在其中使用一个静态方法（对不起Java语言，我指的是它的伴生对象的方法）

trait Worker{def doSth:Unit}
阶级基础
对象库扩展了Worker
//这实际上是行不通的，只是为了表明我正在努力实现的目标
def callSthStatic[T伴生对象可能会给您一个提示：

trait Companion[T] {
  type C
  def apply() : C
}

object Companion {
  implicit def companion[T](implicit comp : Companion[T]) = comp()
}

object TestCompanion {
  trait Foo

  object Foo {
    def bar = "wibble"

    // Per-companion boilerplate for access via implicit resolution
    implicit def companion = new Companion[Foo] {
      type C = Foo.type
      def apply() = Foo
    }
  }

  import Companion._

  val fc = companion[Foo]  // Type is Foo.type
  val s = fc.bar           // bar is accessible
}

如果使用Scala 2.9.x，则应使用
-Ydependent-method-types
标志编译该类。
您可以使用反射来获取伴生类及其实例，但这依赖于Scala内部，这些内部可能会在较远的时间内发生变化（？）当您得到一个AnyRef时，就没有类型安全性。但是没有必要向类和对象添加任何隐式

def companionOf[T : Manifest] : Option[AnyRef] = try{
  val classOfT = implicitly[Manifest[T]].erasure
  val companionClassName = classOfT.getName + "$"
  val companionClass = Class.forName(companionClassName)
  val moduleField = companionClass.getField("MODULE$")
  Some(moduleField.get(null))
} catch {
  case e => None
}

case class A(i : Int)

companionOf[A].collect{case a : A.type  => a(1)}
// res1: Option[A] = Some(A(1))

当我忘记如何做这件事时，我一直在点击这一页，而答案并不是百分之百让我满意。下面是我如何进行反思：

val thisClassCompanion = m.reflect(this).symbol.companion.asModule
val structural = m.reflectModule(thisClassCompanion)
                  .instance.asInstanceOf[{def doSth: Unit}]

您可能需要验证该类是否确实有一个companion对象或companion.asModule将抛出一个反射异常，该异常不是一个模块

更新：为清晰起见，添加了另一个示例：

    object CompanionUtil {

  import scala.reflect.runtime.{currentMirror => cm}

  def companionOf[T, CT](implicit tag: TypeTag[T]): CT = {
    Try[CT] {
      val companionModule = tag.tpe.typeSymbol.companion.asModule
      cm.reflectModule(companionModule).instance.asInstanceOf[CT]
    }
  }.getOrElse(throw new RuntimeException(s"Could not get companion object for type ${tag.tpe}"))

}

根据by的答案，下面是一个方法，用于获取指定类对象的伴生对象的类型引用：

  /**
    * Returns the companion object type reference for the specified class
    *
    * @param clazz The class whose companion is required
    * @tparam CT Type of the companion object
    * @return The type of the relevant companion object
    */
  def companionOf[CT](clazz: Class[_]): CT = {
    import scala.reflect.runtime.{currentMirror => cm}
    Try[CT] {
      val companionModule = cm.classSymbol(clazz).companion.asModule
      cm.reflectModule(companionModule).instance.asInstanceOf[CT]
    }.getOrElse(throw new RuntimeException(s"Could not get companion object for $clazz"))
  }

我添加了实际的Gist内容-Gist可能会消失，并且链接本身就可以作为注释。我在“implicit def COMPANY[T]（implicit comp:COMPANY[T]）=comp.apply（）”行中得到“错误：非法依赖方法类型implicit def COMPANY[T]（implicit comp:COMPANY[T]）=comp（）对于scala 2.9.1，我做错了吗？：-）我会在括号中加上，如果类型
Foo
是可见的，那么它的伴生对象也是可见的，所以尽管这看起来很漂亮，但我认为它在实践中并没有用。这是一个很好的技巧。我必须阅读一些关于依赖方法类型的内容，但这似乎是可行的！感谢一种将此信息传递给w没有“每个同伴样板”的工作部分？谢谢，反射将解决问题…直到scala版本更新，因为伴星对象的名称不保证以这种方式保留。嗯，这是真的。但我认为命名不会很快改变，因为这种约定至少在scala 2.x早期就已经存在。m是什么？你能给出一个完整的例子吗？我正在寻找我可以这样使用：
abstract class which[T]={val companion=companionOf[T]}
m是当前镜像，我只需重命名导入scala.reflect.runtime即可得到它。{currentmirr=>m}注意，
CT
是
T.type
的伴生对象的类型，例如
companionOf[Foo，Foo.type]
其中
Foo
是具有伴生对象的类的名称。根据答案，下面是一个获取指定类对象伴生对象的类型引用的方法：
def companionOf[CT]（clazz:class[]）：CT={import scala.reflect.runtime.{currentmirr=>cm}Try[CT]{val companionModule=cm.classSymbol（clazz）.companion.asModule cm.reflectmodel（companionModule）.instance.asInstanceOf[CT]}.getOrElse（抛出新的运行时异常（s“无法获取$clazz的伴随对象”）}
  /**
    * Returns the companion object type reference for the specified class
    *
    * @param clazz The class whose companion is required
    * @tparam CT Type of the companion object
    * @return The type of the relevant companion object
    */
  def companionOf[CT](clazz: Class[_]): CT = {
    import scala.reflect.runtime.{currentMirror => cm}
    Try[CT] {
      val companionModule = cm.classSymbol(clazz).companion.asModule
      cm.reflectModule(companionModule).instance.asInstanceOf[CT]
    }.getOrElse(throw new RuntimeException(s"Could not get companion object for $clazz"))
  }