Scala入门到放弃——模式匹配和样例类（十二）

十六、模式匹配和样例类

模式匹配是Scala中非常有特色，非常强大的一种功能。模式匹配，其实类似于Java中的swich case语法，即对一个值进行条件判断，然后针对不同的条件，进行不同的处理。

但是Scala的模式匹配的功能比Java的swich case语法的功能要强大地多，Java的swich case语法只能对值进行匹配。但是Scala的模式匹配除了可以对值进行匹配之外，还可以对类型进行匹配、对Array和List的元素情况进行匹配、对case class进行匹配、甚至对有值或没值（Option）进行匹配。

Scala Switch语句

val city = readLine("city：")
city match {
  case "bj" => println("北京")
  case "sh" => println("上海")
  case _ => println("其它城市")  // 等价于default
}

守卫

守卫可以是任何Boolean条件，注意模式总是从上向下进行匹配

val age = readLine("age:").toInt
age match {
  case _ if age > 60 => println("老年")
  case _ if age > 40 => println("中年")
  case _ if age > 20 => println("青年")
  case _ => println("未成年")
}

模式中的变量

如果case关键字后面跟着一个变量名，那么匹配的表达式会被赋值给那个变量

val age = readLine("age:").toInt
age match {
  case c1 if c1 > 60 => println("老年人：" + c1) // 模式匹配 匹配的表达式赋值给变量
  case c2 if c2 > 40 => println("中年:"+c2)
  case c3 if c3 > 20 => println("青年:"+c3)
  case _c4=> println("未成年："+_c4)
}

类型匹配

对表达式的类型进行匹配，Scala推荐使用这样的方式进行类型匹配，而不是使用isInstanceOf操作符

obj match {
  case x: Int => x // 匹配类型Int
  case y: String => y
  case z: Double => z
  case _ => println("其它类型")
}

// 对象类型匹配
val p = new Person
// val p = new Student
// val p = new Dog
p match {
  case p: Person => println(p)
  case s: Student => println(s)
  case _ => println("others types")
}

注意：类型匹配不能适用于泛型

集合元素匹配

对Array进行模式匹配，分别可以匹配带有指定元素的数组、带有指定个数元素的数组、以某元素打头的数组
对List进行模式匹配，与Array类似，但是需要使用List特有的::操作符

// 匹配Array元素数量
val arr = Array(1,2,3,4)
arr match {
  case Array(e1) => println("匹配1个元素")
  case Array(e1,e2) => println("匹配2个元素")
  case Array(e1,e2,e3) => println("匹配3个元素")
  case Array(_*) => println("匹配任意多个元素")
}

// 匹配Array的内容
val arr2 = Array("a", "b", "c", "d")
arr2 match {
  case Array("a") => println("匹配a")
  case Array("a", "b") => println("匹配a、b")
  case Array("a", "b", "c") => println("匹配a、b、c")
  case Array("a", _*) => println("匹配a开头")
  case Array(_) => println("匹配任意多个元素")
}

// 元组的模式匹配可以匹配内容、内容数量、内容+类型
val t3: Any = (1, "zs", false, 10.0)
t3 match {
  // case (n1, n2, n3) => println(n1, n2, n3)   // 匹配元组内容数量
  // case t: Tuple3[Int, String, Boolean] => println(t)  // 匹配元组类型
  // case t2: (Int, String, Boolean, Double) => println(t2)  //  匹配元组类型
  // case (1, _x: String, _y: Boolean, _z: Double) => println(_x +"\t"+_y+"\t"+_z) //  匹配元组值和类型
}

Case Class(样例类)

• Scala中提供了一种特殊的类，用case class进行声明，中文也可以称作样例类。case class其实有点类似于Java中的JavaBean的概念。即只定义field，并且由Scala编译时自动提供getter方法，但是没有method。
• case class的主构造函数接收的参数通常不需要使用var或val修饰，Scala自动就会使用val修饰（但是如果你自己使用var修饰，那么还是会按照var来）
• Scala自动为case class定义了伴生对象，也就是object，并且定义了apply()和unapply()方法，该方法接收主构造函数中相同的参数，并返回case class对象
• case class常用于模式匹配

object CaseClasses {
  def main(args: Array[String]): Unit = {
    // sayHello(Student2("zs", 18, "A123")) //学生：zs 年龄：18 学号：A123
    // sayHello(Teacher2("zs", 18, "A123")) //老师：zs 年龄：18 学号：A123
    // sayHello(NoBody2("zs")) //其它人：zs
  }

  def sayHello(p: Person): Unit = {
    p match {
      case Student2(name, age, stuNo) => println(s"学生：$name 年龄：$age 学号：$stuNo")
      case Teacher2(name, age, stuNo) => println(s"老师：$name 年龄：$age 学号：$stuNo")
      case NoBody2(name) => println(s"其它人：$name")
      case _o=> println(s"信息不合法：$_o")
    }
  }
}

abstract class Person

case class Student2(name: String, age: Int, stuNo: String) extends Person

case class Teacher2(name: String, age: Int, teaNo: String) extends Person

case class NoBody2(name: String) extends Person

密封类（sealed）

密封类的所有子类都必须在与该密封类相同的文件中定义，主要作用：

• 防止滥用继承：sealed关键字可以修饰类和特质（特质）**。密封类提供了一种约束：**不能在类定义的文件之外定义任何新的子类。如：scala的List的实现使用了sealed关键字
• 语法校验

sealed trait A // 子类需要在系统的源文件中

class B extends A