Scala柯里化、样例类和模式匹配

柯里化（Currying）

方法可以定义多个参数列表，当使用较少的参数列表调用多参数列表的方法时，会产生一个新的参数，该函数接收剩余的参数列表作为其参数。这被称为柯里化

//单参数列表
def modN(n: Int,x: Int) = ((x % n) == 0)
//多参数列表
def modN(n: Int)(x: Int) = ((x % n) == 0)
//新函数接收剩余的参数列表作为其参数
def f1(x: Int) = modN(10)(x) 
def f2(n: Int) = modN(n)(10) 
def f3 = modN(10)(_)  

示例

object test {
  def main(args: Array[String]): Unit = {
    def fun1(a:Int,b:Int,c:Int,d:Int):Int={
      a+b+c+d
    }
    def fun2(a:Int,b:Int,c:Int)(d:Int):Int={
      a+b+c+d
    }
    def fun3(a:Int,b:Int)(c:Int,d:Int):Int={
      a+b+c+d
    }
    def fun4(a:Int)(b:Int,c:Int,d:Int):Int={
      a+b+c+d
    }
    def fun5(a:Int)(b:Int)(c:Int)(d:Int):Int={
      a+b+c+d
    }
    println(fun1(1,2,3,4))
    println(fun2(1,2,3)(4))
    println(fun3(1,2)(3,4))
    println(fun4(1)(2,3,4))
    println(fun5(1)(2)(3)(4))
  }
}

样例类（case class）

样例化常用于描述不可变的值对象（Value Object）

case class Student(name:String,age:Int)      //定义样例类
val stu=Student("Jason",19)      //创建样例类的实例，无需new关键字
println(stu.name)       //访问对象属性                                       

• 样例类构造参数默认声明为"val"，自动实现类构造参数的getter

• 样例类构造参数声明为"var"时，自动实现类构造参数的setter和getter

• 样例类自动创建伴生对象

• 样例类自动实现的其他方法

 toString()、equals()、copy()、hashCode()
 伴生对象中的apply()、unapply()
 //unapply()接受一个对象，从对象中提取出相应的值，主要用于模式匹配中

模式匹配

match表达式模式匹配

类似于Java switch语句

• 能处理类型所有类型
• 不需要break
• 能够生成值

val firstArg=if(args.length>0) args(0) else ""
firstArg match{
    case "salt" => println("pepper")
    case "chips" => println("salsa")
    case "eggs" => println("bacon")
    case _ => println("huh?")	//以上未列出的值，使用“_”表示
}

基本模式匹配

object test {
  def main(args: Array[String]): Unit = {
    def testMatch(a:Int):String=a match {
      case 1=>"one"
      case 2=>"two"
      case _=>"many"
    }
    println(testMatch(1))
    println(testMatch(2))
    println(testMatch(3))
  }
}

object test {
  def main(args: Array[String]): Unit = {
    def studentScore(score:String):Unit=score match {
      case "A"=>println("超级棒")
      case "B"=>println("很不错")
      case "C"=>println("还行")
      case _=>println("需要加油")
    }
    studentScore("A")
    studentScore("B")
    studentScore("c")
    studentScore("D")
  }
}

模式守卫（在模式后面加上if条件）

object test {
  def main(args: Array[String]): Unit = {
    def studentScore(name:String,score:String):Unit=score match {
      case "A"=>println("超级棒")
      case "B"=>println("很不错")
      case "C"=>println("还行")
      case _ if name=="老王"=>println("你是最棒的")
      case _=>println("加油")
    }
    studentScore("老王","D")
  }
}

import java.io.FileNotFoundException

object test {
  def main(args: Array[String]): Unit = {
    def exception(e:Exception):Unit=e match {
      case e1:IllegalArgumentException=>println("IllegalArgumentException")
      case e2:FileNotFoundException=>println("FileNotFoundException")
      case e3:IndexOutOfBoundsException=>println("IndexOutOfBoundsException")
      case _:Exception=>println("Exception")
    }
    exception(new IllegalArgumentException)
    exception(new FileNotFoundException)
    exception(new IndexOutOfBoundsException)
    exception(new Exception)
  }
}

对Array和List的元素进行模式匹配

object test {
  def main(args: Array[String]): Unit = {
    def array(arr:Array[String]):Unit=arr match {
      case Array("kb09")=>println("hello,kb09")
      case Array(boy1,boy2,boy3)=>println(s"hello $boy1 & $boy2 & $boy3")
      case Array("kb09",_*)=>println("hi,kb09!")
      case _=>println("who are you")
    }
    array(Array("kb09"))
    array(Array("kb09","kb08","kb07"))
    array(Array("kb09","kb08","kb07","kb06"))
    array(Array("kb08","kb09"))
  }
}

Option与模式匹配

object test {
  def main(args: Array[String]): Unit = {
    val grades=Map("Leo"->"A","Jack"->"B","Jen"->"C")
    def getGrade(name:String):Unit ={
      val grade=grades.get(name)
      grade match {
        case Some(grade)=>println("your grade is "+grade)
        case None=>println("sorry,your grade information is not in the system")
      }
    }
    getGrade("Leo")
    getGrade("Jack")
    getGrade("Jen")
    getGrade("Zhang")
  }
}

样例类模式匹配

object test {
  def main(args: Array[String]): Unit = {
    case class Teacher(name:String,age:Int)
    def testMatch(teacher: Teacher):Unit=teacher match {
      case Teacher("老王", 18) => println("hello，老王")
      case Teacher("老张", 28) => println("hello，老张")
      case Teacher(name, age)=>println(s"hello，$name")
    }
    testMatch(Teacher("老王",18))
    testMatch(Teacher("老张",28))
    testMatch(Teacher("老林",38))
  }
}

object test {
  def main(args: Array[String]): Unit = {
    class Person
    case class Teacher(name:String,subject:String) extends Person
    case class Student(name:String,classroom:Int) extends Person
    case class Worker(name:String,work:String) extends Person
    case class Stranger() extends Person
    def a(p:Person):Unit=p match {
      case Teacher(name,subject)=>println(s"hello,$name,welcome to school,you teach $subject")
      case Student(name,classroom)=>println(s"hello,$name,welcome to school,your classroom is $classroom")
      case Worker(name,work)=>println(s"hello,$name,you should leave school 2 hours later")
      case _=>println(s"stranger,you can not into shcool")
    }
    a(Teacher("老张","大数据"))
    a(Student("小明",9))
    a(Worker("老王","cleaner"))
    a(Stranger())
  }
}