3scala高级

1、模式匹配

//①简单表示：
    sign = ch match { 
        case '+' => 1 
        case '-'  => -1 
        case '_' => 0 
    }

//②守卫：（case中加条件）
    grade match {
            case "A" => println(name + ", you are excellent")
            case "B" => println(name + ", you are good")
            case _ if name == "leo" => println(name + ", you are a good boy, come on")        //只有名字是leo，不管成绩是多少，打印
            case _ => println("you need to work harder")
      }

//③匹配类型：
    e match {
            case e1: IllegalArgumentException => println("you have illegal arguments! exception is: " + e1)
            case e2: FileNotFoundException => println("cannot find the file you need read or write!, exception is: " + e2)
            case e3: IOException => println("you got an error while you were doing IO operation! exception is: " + e3)
            case _: Exception => println("cannot know which exception you have!" )
      }
    注：对异常的类型进行匹配（也可以对int，string等类型进行匹配）

//④匹配集合：

      arr match {
            case Array("Leo") => println("Hi, Leo!")
            case Array(girl1, girl2, girl3) => println("Hi, girls, nice to meet you. " + girl1 + " and " + girl2 + " and " + girl3)
            case Array("Leo", _*) => println("Hi, Leo, please introduce your friends to me.")
            case _ => println("hey, who are you?")
      }
    注：匹配数组是集个参数，并且对值进行了匹配（集合也可以匹配）

//⑤样例类：

    case  class Student(id:Int,name:String)            //类似于类一样，只不过封装了get,set,hashcode等方法，很重要
        val  student1 = Student(1,"lihaozong")


//⑥Option：

    用来表示可能存在或也可能不存在的值(Option的子类有Some和None)。Some包装了某个值，None表示没有值。

2、特质（trait）

　　　　trait类似于java中的接口，不同的是trait中可以定义变量、定义函数及其实现

    trait ConsoleLogger{
        def log(msg:String){println(msg)}
    }

3、隐式转换

　　　　分为隐式转换和参数：可以在编写Scala程序时故意漏掉一些信息，让编译器去尝试在编译期间自动推导出这些信息来

　　　　关键字： implicit

　　1、隐式参数

　　　　当调用函数的时候，发现参数个数不会，编译器回去隐式参数里去找，看看有没有同一类型的隐式参数，如果有，则用此

    object Test{
  

        def k1(x:Int,y:Int):Int=x+y
  
        def k2(x:Int)(implicit y:Int=5):Int=x+y
  

        def main(args: Array[String]): Unit = {
    

            println(k1(2,3))
                //5
            println(k2(5))
              //10
        }
    
}

    注：编译器在调用k2的时候发现只穿了一个参数，这时就会在上下文中寻找有没有隐式参数，如果有，就调用隐式参数。

    object Test7 {
  
        implicit var b:Int=10
  
        def k2(x:Int, y:Int=5):Int=x+y
  
        def main(args: Array[String]): Unit = {
   
             println(k2(5))
              //0
        }
    
}
    注：可以发现隐式参数是分类型的

    object Test7 {
  
        implicit var b:Int=10
  
        implicit var c:Int=15
  
        def k2(x:Int)(implicit y:Int=5):Int=x+y
  
        def main(args: Array[String]): Unit = {
    
            println(k2(5))
  
        }
    
}

    注：这会报错，同一类型的隐式参数只有一个

        2、隐式转化：　

　　　　当一个对象想要调用一个方法，但是这个对象又没有该方法，这时会触发隐式转换。
　　　　编译器回去隐式方法里去找，看有没有这样一个隐式函数，把我这个对象转换为有这个方法的对象。
　　　　如果我变成了这个对象后，不就有这个方法了吗？

    class Man(val name:String){}
    class SuperMan(val name:String){
          def fly():Unit={
                println("超人会飞")
          }
    }

    object Test7 {
        implicit def man2SuperMan(man: Man):SuperMan=new SuperMan("")
        def main(args: Array[String]): Unit = {
            val man=new Man("abc")
            man.fly()
          }
    }

    注：开始定义了Man、SuperMan两个类，但是Man没有fly(),当使用这个方法，编译器会去寻找是否一个隐式转化使得Man-->SuperMan,
       如果找到（参数为Man类型，返回值为SuperMan），就进行转化，再调用方法