Scala学习笔记(七) Sealed Class 和 Enumeration

2022-05-10 250

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： Scala学习笔记(七) Sealed Class 和 Enumeration

1. Sealed Class

1.1 sealed class

先上一段代码，看看sealed是怎么使用的

scala> sealed abstract class Drawing
defined class Drawing
scala> case class Point(x: Int, y: Int) extends Drawing
defined class Point
scala> case class Circle(p: Point, r: Int) extends Drawing
defined class Circle
scala> case class Cylinder(c: Circle, h: Int) extends Drawing
defined class Cylinder
scala> def what(d: Drawing) = d match {
     |   case Point(_,_) => "点"
     |   case Circle(_,_) => "圆"
     | }
<console>:16: warning: match may not be exhaustive.
It would fail on the following input: Cylinder(_, _)
       def what(d: Drawing) = d match {
                              ^
what: (d: Drawing)String

在这里what()方法报错了，主要是因为还缺少了对Cylinder的匹配，只要改成如下的代码就可以正常运行了。

scala> def what(d: Drawing) = d match {
     |   case Point(_,_) => "点"
     |   case Circle(_,_) => "圆"
     |   case Cylinder(_,_) => "柱"
     | }
what: (d: Drawing)String

在使用模式匹配的时候，使用 sealed 修饰某个 class 的目的是让 Scala 知道所有 case 的情况，否则会编译报错。

当然，也有例外的时候，使用 @unchecked 告诉编译器可以不用检查也能编译通过。

scala> def what(d: Drawing) = (d: @unchecked) match {
     |   case Point(_,_) => "点"
     |   case Circle(_,_) => "圆"
     | }
what: (d: Drawing)String

还有一点很重要，当使用 sealed 来修饰某个 class 时，继承该类的其他子类需要跟父类在同一文件中。

1.2 sealed trait

同样，先上一段代码

scala> sealed trait Color
defined trait Color
scala> final case object Red extends Color
defined object Red
scala> final case object Green extends Color
defined object Green
scala> final case object Blue extends Color
defined object Blue
scala> val colors = List(Red,Green,Blue)
colors: List[Product with Serializable with Color] = List(Red, Green, Blue)

可以看到“Product with Serializable with Color”这一句。

case class 会自动继承两个trait：Product 和 Serializable。

Product Trait 让 case class 被扩展为具有Algebraic Data Type，或者说具有产品类型。

Serializable Trait 让 case class 可以被视为一个纯粹的数据，能够被序列化。

如果你想避免看到这个实现的细节，可以提前声明Color已经扩展了 Product 和 Serializable 这些 trait。

scala> sealed trait Color extends Product with Serializable
defined trait Color
scala> final case object Red extends Color
defined object Red
scala> final case object Green extends Color
defined object Green
scala> final case object Blue extends Color
defined object Blue
scala> val colors = List(Red, Green, Blue)
colors: List[Color] = List(Red, Green, Blue)

sealed 修饰的 trait 也只能在当前文件里面被继承。

1.3 sealed abstract 和 abstract class 的区别

sealed class的所有子类，无论是否是抽象类，都必须跟 sealed class 在同一个文件中。

而abstract class并没有这样的规定。

2. Enumeration

Scala 中并没有枚举类型，但是在标准库中有scala.Enumeration。可以扩展Enumeration类，调用Value方法来初始化枚举中的可能值。

/**
  * Created by tony on 2017/4/12.
  */
object Source extends Enumeration {
  type Source = Value
  //枚举的定义
  val Net, Memory, Disk = Value
}
import Source._
object Data extends App {
  def loadData(source: Source){
    source match {
      case Net => println ("source type is " + source)
      case Memory => println ("source type is " + source)
      case Disk => println ("source type is " + source)
      case _ => println ("unknown type")
    }
  }
  val net = Source(0) // Calls Enumeration.apply
  println(loadData(net)) // source type is Net
  // 遍历Source枚举
  for (s <- Source.values)
    println(s.id + ":" + s)
}

打印的结果:

source type is Net
()
0:Net
1:Memory
2:Disk

在定义枚举值的时候也可以自定义id和名称，Source2重新定义了几个枚举。

/**
  * Created by tony on 2017/4/12.
  */
object Source2 extends Enumeration {
  type Source = Value
  //枚举的定义
  val Net, Memory, Disk = Value
  val Other = Value(10,"other source")
}
object Data2 extends App {
  // 遍历Source枚举
  for (s <- Source2.values)
    println(s.id + ":" + s)
}