一个很大的区别是枚举支持从某个名称String实例化它们。例如:

object Currency extends Enumeration {
   val GBP = Value("GBP")
   val EUR = Value("EUR") //etc.
} 

然后你可以这样做:

val ccy = Currency.withName("EUR")

这在希望持久化枚举(例如，到数据库)或从驻留在文件中的数据创建枚举时非常有用。然而，我发现在Scala中枚举通常有点笨拙，给人一种笨拙的附加组件的感觉，所以我现在倾向于使用case对象。case对象比enum更灵活:

sealed trait Currency { def name: String }
case object EUR extends Currency { val name = "EUR" } //etc.

case class UnknownCurrency(name: String) extends Currency

所以现在我的优势是……

trade.ccy match {
  case EUR                   =>
  case UnknownCurrency(code) =>
}

正如@ chaotic3equilibrium所指出的(为了便于阅读，做了一些更正):

关于“UnknownCurrency(code)”模式，除了“破坏”currency类型的封闭集性质外，还有其他方法可以处理找不到货币代码字符串的问题。类型为Currency的UnknownCurrency现在可以潜入API的其他部分。 建议将这种情况推到枚举之外，并让客户端处理Option[Currency]类型，这将清楚地表明确实存在匹配问题，并“鼓励”API的用户自己进行排序。

为了跟进这里的其他答案，case对象相对于Enumerations的主要缺点是:

不能遍历“枚举”的所有实例。这当然是事实，但我发现在实践中很少需要这样做。 不容易从持久化值实例化。这也是正确的，但是，除了在大量枚举的情况下(例如，所有货币)，这并不会带来巨大的开销。

在过去几次我需要这两个选择的时候，我一直在反复考虑。直到最近，我的偏好一直是密封的trait/case对象选项。

1) Scala枚举声明

object OutboundMarketMakerEntryPointType extends Enumeration {
  type OutboundMarketMakerEntryPointType = Value

  val Alpha, Beta = Value
}

2)封印属性+个案对象

sealed trait OutboundMarketMakerEntryPointType

case object AlphaEntryPoint extends OutboundMarketMakerEntryPointType

case object BetaEntryPoint extends OutboundMarketMakerEntryPointType

虽然这两种方法都不能满足java枚举提供的所有功能，但以下是优点和缺点:

Scala枚举

优点: -使用选项实例化或直接假设准确的函数(从持久存储加载时更容易) -支持迭代所有可能的值

缺点: 不支持非穷举搜索的编译警告(使模式匹配不理想)

Case对象/密封特征

优点: 使用密封特征，我们可以预实例化一些值，而其他值可以在创建时注入 完全支持模式匹配(应用/取消应用定义的方法)

缺点: -从持久存储实例化-你经常需要在这里使用模式匹配或者定义你自己的所有可能的“enum值”列表

最终让我改变观点的是以下片段:

object DbInstrumentQueries {
  def instrumentExtractor(tableAlias: String = "s")(rs: ResultSet): Instrument = {
    val symbol = rs.getString(tableAlias + ".name")
    val quoteCurrency = rs.getString(tableAlias + ".quote_currency")
    val fixRepresentation = rs.getString(tableAlias + ".fix_representation")
    val pointsValue = rs.getInt(tableAlias + ".points_value")
    val instrumentType = InstrumentType.fromString(rs.getString(tableAlias +".instrument_type"))
    val productType = ProductType.fromString(rs.getString(tableAlias + ".product_type"))

    Instrument(symbol, fixRepresentation, quoteCurrency, pointsValue, instrumentType, productType)
  }
}

object InstrumentType {
  def fromString(instrumentType: String): InstrumentType = Seq(CurrencyPair, Metal, CFD)
  .find(_.toString == instrumentType).get
}

object ProductType {

  def fromString(productType: String): ProductType = Seq(Commodity, Currency, Index)
  .find(_.toString == productType).get
}

.get调用是可怕的-使用枚举代替我可以简单地调用withName方法对枚举如下:

object DbInstrumentQueries {
  def instrumentExtractor(tableAlias: String = "s")(rs: ResultSet): Instrument = {
    val symbol = rs.getString(tableAlias + ".name")
    val quoteCurrency = rs.getString(tableAlias + ".quote_currency")
    val fixRepresentation = rs.getString(tableAlias + ".fix_representation")
    val pointsValue = rs.getInt(tableAlias + ".points_value")
    val instrumentType = InstrumentType.withNameString(rs.getString(tableAlias + ".instrument_type"))
    val productType = ProductType.withName(rs.getString(tableAlias + ".product_type"))

    Instrument(symbol, fixRepresentation, quoteCurrency, pointsValue, instrumentType, productType)
  }
}

所以我认为我的首选是使用枚举当值打算从存储库访问和case对象/密封特征。

与枚举相比，使用case类的优点是:

当使用密封大小写类时，Scala编译器可以判断匹配是否完全指定，例如，当所有可能的匹配都支持在匹配声明中。对于枚举，Scala编译器无法判断。 Case类自然比支持名称和ID的基于值的枚举支持更多的字段。

使用枚举而不是case类的优点是:

枚举通常需要编写更少的代码。 对于Scala新手来说，枚举比较容易理解，因为它们在其他语言中很普遍

所以一般来说，如果你只需要一个简单的常量列表的名称，使用枚举。否则，如果你需要一些更复杂的东西，或者想要编译器告诉你是否指定了所有匹配的额外安全，用例类。

如果你想要维护与其他JVM语言(如Java)的互操作性，那么最好的选择是编写Java枚举。这些功能在Scala和Java代码中都可以透明地工作，这在Scala中是做不到的。枚举或case对象。如果可以避免的话，让我们不要为GitHub上的每个新爱好项目都创建一个新的枚举库!

我在这里有一个简单的库，允许你使用密封的trait /类作为枚举值，而不必维护自己的值列表。它依赖于一个简单的宏，不依赖于有bug的knownDirectSubclasses。

https://github.com/lloydmeta/enumeratum

2017年3月更新:正如Anthony Accioly所评论的，scala。枚举/枚举PR已关闭。

Dotty (Scala的下一代编译器)将占据主导地位，尽管Dotty发行于1970年，Martin Odersky的PR发行于1958年。

注意:现在(2016年8月，6年多之后)有一个移除scala的提案。编号:PR 5352

scala抨击。枚举，添加@enum注释 的语法

@enum
 class Toggle {
  ON
  OFF
 }

是一个可能的实现示例，目的是也支持符合某些限制(没有嵌套，递归或变化的构造函数参数)的adt，例如:

@enum
sealed trait Toggle
case object ON  extends Toggle
case object OFF extends Toggle

Deprecates the unmitigated disaster that is scala.Enumeration. Advantages of @enum over scala.Enumeration: Actually works Java interop No erasure issues No confusing mini-DSL to learn when defining enumerations Disadvantages: None. This addresses the issue of not being able to have one codebase that supports Scala-JVM, Scala.js and Scala-Native (Java source code not supported on Scala.js/Scala-Native, Scala source code not able to define enums that are accepted by existing APIs on Scala-JVM).