包对象

什么是包对象，而不是概念，而是它们的用法？

我试图使示例工作，而我上班的唯一形式如下：

package object investigations {
    val PackageObjectVal = "A package object val"
}

package investigations {

    object PackageObjectTest {
        def main(args: Array[String]) {
            println("Referencing a package object val: " + PackageObjectVal)
        }
    }
}

我到目前为止所做的观察是：

package object _root_ { ... }

被禁止（这是合理的），

package object x.y { ... }

也不允许。

似乎必须在直接父包中声明一个包对象，并且，如果如上所述编写，则需要用大括号分隔的包声明形式。

它们是常用的吗？如果是这样，怎么办？

通常，您会将包对象放在package.scala与之对应的包中称为的单独文件中。您也可以使用嵌套的包语法，但这很不常见。

包对象的主要用例是，当您使用包定义的API时，需要在包内以及包外的各个地方进行定义。这是一个例子：

// file: foo/bar/package.scala

package foo

package object bar {

  // package wide constants:
  def BarVersionString = "1.0"

  // or type aliases
  type StringMap[+T] = Map[String,T]

  // can be used to emulate a package wide import
  // especially useful when wrapping a Java API
  type DateTime = org.joda.time.DateTime

  type JList[T] = java.util.List[T]

  // Define implicits needed to effectively use your API:
  implicit def a2b(a: A): B = // ...

}

现在，该包对象中的定义在整个包中可用foo.bar。此外，当该包之外的人导入时，定义也将导入foo.bar._。

这样，您可以避免要求API客户端发出其他导入才能有效使用您的库-例如，在scala-swing中，您需要编写

import swing._
import Swing._

具有onEDT从Tuple2到的所有相似和隐式转换Dimension。

尽管Moritz的答案很明确，但要注意的另一件事是，包对象是对象。除其他外，这意味着您可以使用混合继承从特征中构建它们。莫里茨的例子可以写成

package object bar extends Versioning 
                          with JodaAliases 
                          with JavaAliases {

  // package wide constants:
  override val version = "1.0"

  // or type aliases
  type StringMap[+T] = Map[String,T]

  // Define implicits needed to effectively use your API:
  implicit def a2b(a: A): B = // ...

}

这里Versioning是一个抽象特征，它表示包对象必须具有“版本”方法，而JodaAliases和JavaAliases是包含方便的类型别名的具体特征。所有这些特征都可以被许多不同的包对象重用。

您可以做得比直接去做还要糟糕。:)

https://lampsvn.epfl.ch/trac/scala/browser/scala/trunk/src/library/scala/package.scala

https://lampsvn.epfl.ch/trac/scala/browser/scala/trunk/src/library/scala/collection/immutable/package.scala

包对象的主要用例是，当您使用包定义的API时，需要在包内以及包外的各个地方进行定义。

并非如此，斯卡拉3，按计划将发布中期到2020年，基于斑点狗，因为在这里：

顶级定义

各种定义都可以写在顶层。
包对象不再需要，将被淘汰。

package p 

type Labelled[T] = (String, T) 
val a: Labelled[Int] = ("count", 1) 
def b = a._2 
def hello(name: String) = println(i"hello, $name)