Scala：Enumeration

Scala开篇（目录）

先开看一下如何声明一个枚举对象

object EnumTest extends Enumeration{
type EnumTest = Value
val One,Two,Three = Value
}

这和我们在Java中声明有很大区别，Scala的枚举值有些特殊，它的关键是内部有一个Value类，所谓的枚举值都是通过它产生的。

如果我们不做任何约定的话，枚举值默认从0开始，依次+1

下面看一下Value类是怎么工作的。

val One,Two,Three = Value

上面代码中，分别对三个枚举元素执行Value方法，它有四个重载，它们会依次调用，源代码如下

/** Creates a fresh value, part of this enumeration. */
protected final def Value: Value = Value(nextId)

/** Creates a fresh value, part of this enumeration, identified by the
*  integer `i`.
*
*  @param i An integer that identifies this value at run-time. It must be
*           unique amongst all values of the enumeration.
*  @return  Fresh value identified by `i`.
*/
protected final def Value(i: Int): Value = Value(i, nextNameOrNull)

/** Creates a fresh value, part of this enumeration, called `name`.
*
*  @param name A human-readable name for that value.
*  @return  Fresh value called `name`.
*/
protected final def Value(name: String): Value = Value(nextId, name)

/** Creates a fresh value, part of this enumeration, called `name`
*  and identified by the integer `i`.
*
* @param i    An integer that identifies this value at run-time. It must be
*             unique amongst all values of the enumeration.
* @param name A human-readable name for that value.
* @return     Fresh value with the provided identifier `i` and name `name`.
*/
protected final def Value(i: Int, name: String): Value = new Val(i, name)

当我们编写 val One = Value 时， 调用的是Value的无参接口

protected final def Value: Value = Value(nextId)

上面的无参接口继续调用下面方法，nextId初始值是 0 ，每次构造Value对象时，自动在参数 i 的基础上加1，所以也就是我们可以为每个元素指定它的值的原因，第一个元素可以是0，也可以是其它的值，第二个元素不一定就是第一个元素+1，也可以指定任意的值

protected final def Value(i: Int): Value = Value(i, nextNameOrNull)

上面代码中我们看到 nextNameOrNull ，也就是调用了下面的接口，我们是可以为元素起名字的

protected final def Value(i: Int, name: String): Value = new Val(i, name)

我们是可以在子类中直接调用上面接口，对元素命名和指定初始值的

object EnumTest extends Enumeration{
type EnumTest = Value
val One,Two,Three = Value
val Four = Value(10,"four")
}

当我们为元素命名后，就可以通过名字来找到这个枚举元素了

println(EnumTest.withName("four").id)   // 输出：10

上面提到的四个方法，最终都会调动最后一个双参数的接口，来产生枚举值，这里就会提到另一个成员 Val

@SerialVersionUID(0 - 3501153230598116017L)
protected class Val(i: Int, name: String) extends Value with Serializable {
def this(i: Int)       = this(i, nextNameOrNull)
def this(name: String) = this(nextId, name)
def this()             = this(nextId)

assert(!vmap.isDefinedAt(i), "Duplicate id: " + i)
vmap(i) = this
vsetDefined = false
//这里对nextId在i的基础上递增
nextId = i + 1
if (nextId > topId) topId = nextId
//如果你给的值，比最后一个元素的值都大，那最后一个值是i
if (i < bottomId) bottomId = i
def id = i
/**当我们访问其中的元素时，会调用这个方法
比如：println(EnumTest.One)
*/
override def toString() =
//命过名的，就取name，没有就用nameOf产生
if (name != null) name
else try thisenum.nameOf(i)
catch { case _: NoSuchElementException => "<Invalid enum: no field for #" + i + ">" }

protected def readResolve(): AnyRef = {
val enum = thisenum.readResolve().asInstanceOf[Enumeration]
if (enum.vmap == null) this
else enum.vmap(i)
}
}

Enumeration中有一个nmap对象，它里面保存着id和name的对应关系

private val nmap: mutable.Map[Int, String] = new mutable.HashMap

如果没有为元素命名，那么将会返回这个元素的字面内容，是通过populateNameMap方法设置的

private def populateNameMap() {
/**反射，取出所有声明的字段*/
val fields = getClass.getDeclaredFields
//进行判断，名字相符并且与返回类型相符
def isValDef(m: JMethod) = fields exists (fd => fd.getName == m.getName && fd.getType == m.getReturnType)

// The list of possible Value methods: 0-args which return a conforming type
val methods = getClass.getMethods filter (m => m.getParameterTypes.isEmpty &&
classOf[Value].isAssignableFrom(m.getReturnType) &&
m.getDeclaringClass != classOf[Enumeration] &&
isValDef(m))
//循环添加到nmap中
methods foreach { m =>
val name = m.getName
// invoke method to obtain actual `Value` instance
val value = m.invoke(this).asInstanceOf[Value]
// verify that outer points to the correct Enumeration: ticket #3616.
if (value.outerEnum eq thisenum) {
val id = Int.unbox(classOf[Val] getMethod "id" invoke value)
nmap += ((id, name))
}
}
}