2

在 Java 中，类被放置在具有类似声明的包中package com.acme.foo ，并将源文件放在类似com/acme/foo.

我正在研究一种 JVM 语言，其目的是在风格上比 Java 更不重复，所以我将使用这些机制中的一种或其他，但不会同时使用两者，我想知道使用哪一种。

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

4

3 回答 3

11

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

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

下面是一些展示灵活性的例子（我不一定提倡这些风格，只是展示灵活性）。

// 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 是否支持这种灵活性，但 Clojure 约定是使用 Java 的结构化源代码约定及其常用的构建工具lein（请参阅此处的 leiningen 教程）。

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

另外值得注意的是您可以从 Scala 中的包中导入的方式：

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

另外值得注意的是 Scala 中的包私有作用域：

package foo.bar

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

以上boo是foo.bar包（和子包）私有的，并且bla是私有的foo及其所有子包。

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

于 2013-09-30T22:48:46.683 回答
1

Clojure 有点像 Java，但没有真正的类，所以有点不同。

如果有命名空间 project.foo，那么 Clojure 编译器将期望在项目目录中的源根目录下名为 foo.clj 的文件中找到它。

例如，假设 src 是保存源文件的目录。然后 project.foo 命名空间将与顶部src/project/foo.clj的声明类似。(ns project.foo)

我认为这真的很难摆脱，因为在运行时，当 Clojure 去加载文件时（大多数 Clojure 被捆绑为源），Clojure 运行时会将文件作为资源加载，这需要它在正确的放置在目录层次结构中（无论是基于 jar 还是基于文件）。

就个人而言，我也不介意包名 == 目录位置约定。它使工具可以在编译或运行时轻松查找文件，如果我只是使用 emacs，我也可以轻松找到它们。与目录中的一堆文件相比，它也感觉更有条理，尽管这可能更多是因为我一直在使用它之后习惯了。

于 2013-09-30T23:44:33.973 回答
0

我对 Clojure 没有任何经验，但我确实对 Scala 有一些经验，而且 scala 也使用子目录作为它们的包，但其中一个漂亮的特性是能够重命名类，类似于 C++ typedef 关键字功能。一个有趣的想法是，如果您创建了一个类似于 C++ 的链接器并允许 typedef 功能但仍将其保留在 JVM 中。

于 2013-09-30T22:14:15.973 回答