＜Zhuuu_ZZ＞Scala(五)模式匹配&隐式参数、函数、类

模式匹配练习

• 模式匹配不关心泛型，即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={
  }
}