柯里化(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())
}
}