目录

模式匹配练习成绩匹配case 后接if条件完成二次筛选case 后接_x变量接收输入值异常类型匹配Array匹配List匹配元组匹配case class与模式匹配Option与模式匹配/Some()/None调用代码 隐式参数隐式包隐式参数在隐式包内隐式函数在隐式包内隐式类在隐式包内 功能增加

模式匹配练习

模式匹配不关心泛型，即Map[String,Int]和Map[Int,String]对于模式匹配是一样的，只要是个Map就会匹配上。

成绩匹配

def match1(score:String):String=score match{ case "A"=>"excellent" case "B"=>"good" case "C"=>"soso" case _=>"you need work harder" }

case 后接if条件完成二次筛选

def match2(score: String, age: Int): Unit = score match { case "A" => println("excellent") case "B" => println("good") case "C" => println("soso") case _ if age > 18 => println(age + "岁的小伙子加油呀") case _ => println("work harder") }

case 后接_x变量接收输入值

可以在输入语句调用，其实可以直接调用score,name都是可以的 def match3(score: String, name: String): Unit = score match { case "A" => println("excellent") case "B" => println("good") case "C" => println("soso") case _ if name.equals("haha")=> println("加油呀" + name) case _x => println(name + ",you need work harder,your score only" + _x) case x => println("x表示通配符跟_一样，其实也就是无论输入什么都会匹配上" + x) }

异常类型匹配

def match4(e:Exception):Unit = e match { case i:IndexOutOfBoundsException=>println("IndexOutOfBoundsException") case f: FileNotFoundException => println("FileNotFoundException") case n: NullPointerException => println("NullPointerException") case _: Exception => println("Exception") }

Array匹配

def match5(arr: Array[String]): Unit = arr match { case Array("KB09") => println("hello KB09") //精确匹配，输入相同且只能有一个 case Array(a, b, c) => println("hello," + a + "and" + b + "and" + c) //任意输入三个就匹配上 case Array("KB09", _*) => println("hello KB09*") //输入以KB09开头，任意个 case _ => println("who are you") }

List匹配

object Test1 { def main(args: Array[String]): Unit = { for(list <- Array(List(0),List(1,0),List(0,0,0),List(1,0,0))){ val result=list match { case 0 :: Nil => "0" case x :: y :: Nil => x + " " + y case 0 :: tail => "0 ..." case _ => "something else" } println(result) } } } /* 0 1 0 0 ... something

元组匹配

object Test1 { def main(args: Array[String]): Unit = { for(pair<-Array((0,1),(0,1,9),(1,0),(2,1),(1,0,2))){ val result=pair match{ case(0,_)=>"0..." case(y,0)=>y case(a,b)=>(b,a) case _ =>"other" } println(result) } } }

case class与模式匹配

class Person //scala中定义一个类，只要class 类名 即可。 case class Teacher(name: String, subject: String) extends Person case class Student(name: String, classname: String) extends Person case class Worker(name: String, work: String) extends Person case class Stranger(name: String, age: Int) extends Person def match6(p: Person): Unit = p match{ //如果我们不确定输入参数的类型，那就把基类写上去。 case Teacher("zs","yuwen")=>println("zs教语文") case Teacher("zs",subject)=>println("zs老师的科目为"+subject) case Teacher(name,subject)=>println("只要是Teacher类型且不满足上面两个case就输出这个") case p1:Teacher=>println(p1.name+"老师您好"+p1.subject) case p2:Student =>println(p2.name+"学生您好"+p2.classname) case p3:Worker if p3.work=="repair"=>println(p3.work+"先生您好") case p4:Worker =>println(p4.work+"普通工人") case _=>println("陌生人") }

Option与模式匹配/Some()/None

val map=Map("zs"->"a","ls"->"b","ww"->"c") def match7(name:String):Unit={ var score=map.get(name) score match{ case Some(score)=>println(name+"的成绩为："+score) case None=>println("查询不到"+name+"对应的成绩") } }

调用代码

object Test1 { def main(args: Array[String]): Unit = { // match1("D") // match2("F",22) // match3("D","zhu") match4(new FileNotFoundException())//因为异常都是类， // 而我们调用一个函数要输入的是对象，是实例，是实际的值 //所以需要new一下创建一个对象。 // var arr1 = Array("KB09", "KB07", "KB05", "KB02") //hello KB09* // var arr2 = Array("KB09") //hello KB09 // var arr3 = Array("KB09", "KB07", "KB05") //hello,KB09andKB07andKB05 // var arr4 = Array("KB02", "KB07", "KB05", "KB09") //who are you // match5(arr4) match6(Teacher("zs","wen")) // match6(Stranger("zhu",14)) match7("zs") } }

隐式参数

含有隐式参数的函数可以不在object内，可以在一个类内，然后调用时创建类对象调用函数即可但是隐式参数的定义必须在object内在object内创建类对象时，会把这个类内函数，方法等都传进域内，从而起效果这个时候要满足同一个类型只能有一个隐式参数定义 class Person class Son extends Person{ def fun(a:Int,b:Int)(Implicit c:Int,msg:String="hello"):Int={ println(msg) a+b+c } } object Test1{ implicit val a:Int=10 implicit val str:String="welcome" def main(args:Array[String]):Unit={ val son=new Son //类Son中的方法，函数等都传进Test1域中 val sum=son.fun(10,20) println(sum) } }

隐式包

可以在另外一个object中定义隐式参数和隐式方法和隐式类隐式参数相同类型只能有一个隐式方法相同作用只能有一个隐式类内可以包含多个方法，但是它必须传入要调用它的类对象一个object也可以同时调用来自相同或者不同隐式包内的隐式参数，隐式函数，隐式类。

隐式参数在隐式包内

在另一个object内写入隐式参数定义 object impliciteg1{ implicit val num:Int=10 implicit val msg:String="hello" } 导入隐式包 //import implicitdemo.impliciteg1._ //放在这里作用域最大。 object Demo1{ //import implicitdemo.impliciteg1._ //放在这里在整个Demo1起效果 def sum(a:Int,b:Int)(implicit c:Int,d:String):Int={ println(d) a+b+c } def main(args:Array[String]):unit={ import implicitdemo.impliciteg1._ //导入隐式包，需要写上包名.类名._ //可以放在很多地方只不过所起的作用域不同 //放在这里说明只在main内起效果 val result=sum(10,10) println(result) //hello // 30

隐式函数在隐式包内

object impliciteg2{ implicit def doubleToInt(value:Double):Int=value.toInt //double转int implicit def stringToInt(value:String):Int=Integer.parseInt(value) //string转int //implicit def stringToInt(value:String):Int=Integer.parseInt(value) //Error，相同作用的隐式函数不能有多个 import implicitdemo.impliciteg2._ object Demo2{ def main(args:Array[String]):Unit={ import implicitdemo.impliciteg2._ val num1:Int=3.5 val num2:Int="1" //String是可以转Int类型的，前提是为"1","10"这种，不能是"haah"这样的。 println(num1) //3 println(num2) //1 } }

隐式类在隐式包内

隐式类所带的构造参数有且只能有一个，即只能传入一个对象隐式类必须被定义在“类”或“伴生对象”或包对象类，即隐式类不能是顶级的(top-level objects)隐式类不能是case class一个隐式包内可以有多个隐式类，他们可以被不同的对象调用，只要传入的对象对应即可不同的隐式类内如果传入的是相同的对象，就不能有相同的方法名作用域内不能有相同的隐式类名 object impliciteg3{ implicit class implicitClass1(x:Fun){ def ji(a:Int,b:Int):Int={ a*b } def shang(a:Int,b:Int):Int={ a/b } def add(a:Int,b:Int):Int={ a+b } } implicit class implicitClass2(x:Fun){ def aa(s:String):Unit={ println(s) } def bb(num:Int):String={ if(num%2==0) "偶数" else "奇数" } // def add(a:Int,b:Int):Int={ //因为传入的都是Demo3，如果调用时用到add方法时会编译报错 //没有用到add方法就不会有错误。 // a+b // } } implicit class implicitClass3(x:Fun){ def login(name:String,pwd:String):Boolean={ if(name.equals("hah")&&pwd=="123456") true else false } } } import implicitdemo.impliciteg3._ class Fun //如果需要导入隐式类，就必须创建class类，类名无所谓，但是要与隐式类传入的一致 //现在可能是个空类，但当隐式类传入Fun时，隐式类内的所有方法就传进Fun内了。 object Demo3{ def main(args:Array[String]):Unit={ val dm=new Fun //创建对象，有没有小括号都可 dm.aa("haha") //haha 调用隐式类implicitClass2内的aa函数 println(dm.ji(2,3)) //6 调用隐式类implicitClass1内的ji函数 println(dm.login("hah","1,2,3,4,5,6")) //true 调用隐式类implicitClass3内的login函数

功能增加

通过隐式函数 object Demo4{ def main(args:Array[String]):Unit={ implicit def transform(mysql:Mysql):Operater={ new OPerater } val mysql=new Mysql mysql.select() mysql.delete() } } class Operater{ def delete():Unit={ } } class Mysql{ def select():Unit={ } } 通过隐式类 object Demo4{ def main(args:Array[String]):Unit={ val mysql=new Mysql mysql.select() mysql.delete() } implicit class trans(x:Mysql){ def delete():Unit={ } } } class Mysql{ def select():Unit={ } }