疯狂的Scala缩写和用法

• 函数缩写
  addBy输入一个参数a，输出一个函数Int => Int，这个函数返回了输入参数加上a，由于输入参数只有一个的时候可以用_，并且可以不用花括号，因此缩写成a + _。
  这里使用了闭包，新返回的函数中包含了外部的输入参数a。

    def addBy(a : Int) : Int => Int = a + _
    println(addBy(1)(2))

• 匹配对象和unapply方法
  case User("zhangsan", 11) => "yes"
  调用user对象的unapply方法，任何检查输出是否为"zhangsan"和11。

class User(val name: String, val age: Int)
object User{
  def apply(name: String, age: Int): User = new User(name, age)
  def unapply(user: User): Option[(String, Int)] = {
    if (user == null)
      None
    else
      Some(user.name, user.age)
  }
}
object TestMatchUnapply {
  def main(args: Array[String]): Unit = {
    val user: User = User("zhangsan", 11)
    val result = user match {
      case User("zhangsan", 11) => "yes"
      case _ => "no"
    }
    println(result)
  }
}

• 匹配对象和正则表达式

  val myRex : Regex = "([a-zA-Z]+)name_(\\d+)_id".r

  def main(args: Array[String]): Unit = {
    val rexFunc : PartialFunction[String, String] = {
      case myRex(sourceType, _) =>
        sourceType
      case _ => "not found"
    }

    val name = rexFunc("xiaoming_name_16777231_id")
    print(name)
  }

• 样例类
  语法：case class Person (name: String, age: Int)

1 样例类仍然是类，和普通类相比，只是其自动生成了伴生对象，并且伴生对象中
自动提供了一些常用的方法，如 apply、unapply、toString、equals、hashCode 和 copy。
2 样例类是为模式匹配而优化的类，因为其默认提供了 unapply 方法，因此，样例
类可以直接使用模式匹配，而无需自己实现 unapply 方法。
3 构造器中的每一个参数都成为 val，除非它被显式地声明为 var（不建议这样做）

case class User(name: String, age: Int)
object TestMatchUnapply {
  def main(args: Array[String]): Unit = {
    val user: User = User("zhangsan", 11)
    val result = user match {
      case User("zhangsan", 11) => "yes"
      case _ => "no"
    }
    println(result)
  }
}

• 隐式函数
  为啥2能调用myMax？在编译失败的时候，隐式函数convert将Int类型转化为MyRichInt类型，MyRichInt类型中有myMax函数，调用成功。

  class MyRichInt(val self: Int) {
    def myMax(i: Int): Int = {
      if (self < i) i else self
    }
    def myMin(i: Int): Int = {
      if (self < i) self else i
    }
  }
  object TestImplicitFunction {
    // 使用 implicit 关键字声明的函数称之为隐式函数
    implicit def convert(arg: Int): MyRichInt = {
      new MyRichInt(arg)
    }
    def main(args: Array[String]): Unit = {
      // 当想调用对象功能时，如果编译错误，那么编译器会尝试在当前作用域范
      // 围内查找能调用对应功能的转换规则，这个调用过程是由编译器完成的，所以称之为隐
      // 式转换。也称之为自动转换
      println(2.myMax(6))
    }
  }