在Scala 2.10中，我们可以这样做

import scala.reflect.runtime.universe

val runtimeMirror = universe.runtimeMirror(getClass.getClassLoader)

val module = runtimeMirror.staticModule("package.ObjectName")

val obj = runtimeMirror.reflectModule(module)

println(obj.instance)

Scala仍然缺少反射API。您可以通过加载伴随对象类来获取伴随对象的示例：

import scala.reflect._
def companion[T](implicit man: Manifest[T]) : T = 
  man.erasure.getField("MODULE$").get(man.erasure).asInstanceOf[T]

scala> companion[List$].make(3, "s")
res0: List[Any] = List(s, s, s)

要获取非类型化的伴随对象，您可以直接使用该类：

import scala.reflect.Manifest
def companionObj[T](implicit man: Manifest[T]) = { 
  val c = Class.forName(man.erasure.getName + "$")
  c.getField("MODULE$").get(c)
}

scala> companionObj[List[Int]].asInstanceOf[List$].make(3, "s")
res0: List[Any] = List(s, s, s)

这取决于ScalaMap到Java类的方式。

调整Thomas Jung上面的答案：你最好说成伙伴[List.type]，因为a)这应该是一种稳定的引用它的方式，而不是依赖于名字破坏方案，b)你得到的是未擦除的类型。

def singleton[T](implicit man: reflect.Manifest[T]) = {
  val name = man.erasure.getName()
  assert(name endsWith "$", "Not an object: " + name)
  val clazz = java.lang.Class.forName(name)

  clazz.getField("MODULE$").get(clazz).asInstanceOf[T]
}  

scala> singleton[List.type].make(3, "a")                       
res0: List[java.lang.String] = List(a, a, a)

请注意，例如，方法companion是如何在Scala 2.8集合上定义的--它在那里是这样的，因此类的示例可以获得伴随对象，否则这是不可能的。

Scala 2：

val runtimeMirror = universe.runtimeMirror(this.getClass.getClassLoader)

          val objectClass = Class.forName("org.test.MyObject$")
          val moduleSymbol = runtimeMirror.staticModule(objectClass.getName)
          val moduleMirror = runtimeMirror.reflectModule(moduleSymbol)
          val instance = moduleMirror.instance

或者只使用Java API从静态字段中获取值：

val instance = objectClass.getField("MODULE$").get(null)

注意对象名称中的$。