java - JVM 语言的包

Question

在 Java 中，类被放置在一个带有诸如 package com.acme.foo 声明的包中 和 通过将源文件放入诸如 com 的子目录中/acme/foo.

我正在开发一种 JVM 语言，其风格比 Java 更不要重复，因此我将使用这些机制中的一种或另一种，但不会同时使用两者，并且我想知道该使用哪个。

Scala 和 Clojure 等其他 JVM 语言如何处理它？它们需要两种机制还是只需要一种机制，如果需要，是哪一种？

Answer 1

正如问题 Travis Brown 的评论中提到的那样是正确的，scalac 不会对源文件的路径或名称施加任何此类约束或限制，如果您愿意，您甚至可以在一个文件中指定多个包。

但是，scalac 生成的字节码将字节码类文件放入相应类加载器所需的必要目录结构中。

这里有一些展示灵 active 的例子(我不一定提倡这些风格，只是展示灵 active )。

// in packages1.scala file in local directory
package my {
  package states {
    sealed trait State
    case class CheckingOut(shoppingCartId: Long) extends State
    case class ConfirmedOrder(orderId: Long) extends State
    case class ItemShipped(orderId: Long, itemId: Long, quantity: Int) extends State
  }
}

还有这个...

// in packages2.scala file
package com.foo.bar

sealed trait Scale
case object WebScale extends Scale
case object LolScale extends Scale
case object RoflScale extends Scale
case object WatScale extends Scale

这种风格也是可能的:

// in packages3.scala file
package foo {
  package awesomeness {
    class Main extends App {
      println("Bananas are awesome")
    }
  }
}

package foo {
  package lameness {
    class Main extends App {
      println("Congress is pretty lame, honestly")
    }
  }
}

还有这个...

package foo
package bar

// now we are in package foo.bar for remainder of file unless another package statement is made

这是生成的源代码和编译后的字节码树:

$ tree
.
├── com
│   └── foo
│       └── bar
│           ├── LolScale$.class
│           ├── LolScale.class
│           ├── RoflScale$.class
│           ├── RoflScale.class
│           ├── Scale.class
│           ├── WatScale$.class
│           ├── WatScale.class
│           ├── WebScale$.class
│           └── WebScale.class
├── foo
│   ├── awesomeness
│   │   ├── Main$delayedInit$body.class
│   │   └── Main.class
│   └── lameness
│       ├── Main$delayedInit$body.class
│       └── Main.class
├── my
│   └── states
│       ├── CheckingOut$.class
│       ├── CheckingOut.class
│       └── State.class
├── packages1.scala
├── packages2.scala
└── packages3.scala

8 directories, 19 files

我不确定 Clojure 是否支持这种灵 active ，但 Clojure 约定是使用 Java 约定来构建源代码及其常用的构建工具 lein(请参阅 leiningen tutorial here )。

但是，需要注意的一件事是，Scala 和 Clojure 中似乎都偏离了 Java 世界中经常使用的 $DOMAIN.$APPLICATION 格式(例如 com.oracle.jdbc...、org.hibernate.session...等)。在 Scala 中，您将看到包名称的 $DOMAIN 部分被完全删除(例如 scalaz...、akka.{actor,io, ...}，等)。

还值得注意的是从 Scala 中的包导入的方式:

• 导入foo.bar包中的所有公共(public)“东西”:import foo.bar._
• 仅导入一个类/特征/等(就像 Java 一样):import foo.bar.Baz
• 从包中导入一个类/特征/等，并在当前范围内重命名:import foo.bar.{Baz => FooBarBaz}
• 从包中导入部分内容:import foo.bar.{Baz, Boo, Bla}

另外值得注意的是 Scala 中的包私有(private)作用域:

package foo.bar

class Baz{
  private[bar] def boo[A](a: A)
  private[foo] def bla[A](a: A)
}

上面的 boo 是 foo.bar 包(和子包)私有(private)的，而 bla 是 foo 私有(private)的> 及其所有子包。

有关更多详细信息，请阅读 Scala 语言规范和相关链接:

• Section 9.2 "Packagings", 9.3 "Package Objects", 9.4 "Package References"
• A Tour of Scala: Packages