//①简单表示：

    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表示没有值。

    trait ConsoleLogger{

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

    }

    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))

                //

            println(k2(5))

              //

        }

}

    注：编译器在调用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))

              //

        }

}

    注：可以发现隐式参数是分类型的

    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))

        }

}

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

    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），就进行转化，再调用方法