Scala函数代码整理：匿名函数、柯理化、模式匹配等

object Demon1 {
  def main(args: Array[String]): Unit = {
    //函数1
    def function1(x: Int, y: Int): Int = x + y

    println("函数1：" + function1(1, 2))
    println("=====================================")
    //函数2(匿名函数)
    val function2 = (x: Int, y: Int) => (x + y)
    println("匿名函数2：" + function2(1, 2))
    println("=====================================")
    //函数3
    val function3: (Int, Int) => Int = (_ + _)
    println("函数3：" + function3(1, 2))
    println("=====================================")

    //函数作为参数1
    def square(x: Int, y: Int) = x * y

    def function4(f: (Int, Int) => Int, name: String) = {
      //给作为参数的函数赋值
      val res = f(2, 3)
      //返回结果
      name + ":" + res
    }

    println("函数为参数的1：" + function4(square, "sam"))

    //函数作为参数2,在定义的函数参数列表中定义一个临时的函数
    def func(f: (Int, Int) => Int, name: String) = {
      //给作为参数的函数赋值
      val res = f(2, 3)
      //返回结果
      name + ":" + res
    }

    val res = func((x: Int, y: Int) => x + y, "sam")
    println("函数为参数的2：" + res)

    println("=====================================")

    //无返回值函数1
    def function5(name: String) = {
      name
      println("无返回值函数1.1") //因为只返回最后一个表达式的结果
    }

    println(function5("sam"))

    def function6(name: String) = {
      println("无返回值函数1.2")
      name
    }

    println(function6("sam"))
    println("=====================================")
    //无返回值函数2
    val function7 = (name: String) => {
      name
      println("无返回值函数2")
    }
    println(function7("sally"))
    println("=====================================")

    //函数作为返回值类型1
    def function8(): (Int, Int) => Int = {
      def demon(x: Int, y: Int) = {
        x + y
      }
      //返回demon
      demon
    }

    println("函数作为返回值类型1: " + function8()(1, 2))
    println("=====================================")

    //函数作为返回值类型2
    def function9(n: Int): (Int, Int) => Int = {
      if (n % 2 == 0) {
        def funAdd(x: Int, y: Int) = x + y

        funAdd
      } else {
        def funDelet(x: Int, y: Int) = x - y

        funDelet
      }
    }

    println("函数作为返回值类型2: " + function9(4)(5, 3))
    println("=====================================")

    //函数作为返回值，函数作为参数列表
    def leng(s: String) = {
      s.length
    }

    //输入一个姓名，返回姓名的长度，长度定义为一个函数，返回值类型的函数：输入今天是星期几，输出一段话
    def function10(f: (String) => Int, name: String): (Int) => Unit = {
      val l = f(name)
      if (l % 2 == 0) {
        def d1(x: Int) = {
          println("今天是你的幸运日")
        }

        d1
      } else {
        (x: Int) => {
          println("今天就不要出门了")
        }
      }
    }

    function10(leng, "saml")(6)
    println("=====================================")

    //柯理化
    def currying(a: Int, b: Int)(c: Int, d: Int) = {
      a + b + c + d
    }

    println("柯理化函数：" + currying(1, 2)(3, 4))
    println("=====================================")

    //模式匹配1
    def demon1(x: Int): String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "other"
    }

    println("模式匹配1：" + demon1(1))
    println("=====================================")

    //模式匹配2
    def demon2(x: Any): String = x match {
      case x: Int => "Int类型"
      case x: String => "String类型"
      case _ => "其他类型"
    }

    println("模式匹配2：" + demon2("sdas"))
    println("=====================================")

    //样例类
    case class Student(name: String, age: Int)
    def ex(student: Student) = student match {
      case Student("sam", 19) => println("My name is " + student.name + ",I'm " + student.age + " years old")
      case Student(name, age) => println("My name is " + student.name + ",I'm " + student.age + " years old")
    }

    val stu = Student("Dally", 19)
    ex(stu)
    println("=====================================")
    //隐式函数1(类型匹配，按类型匹配，即在一个类中只能有一个类型的隐式)
    implicit var a: Int = 10

    def demon3(a: Int, b: Int)(implicit c: Int) = {
      a + b + c
    }

    println(demon3(1, 2))
    println("=====================================")

    //隐式函数2
    def demon4(a: Int, b: Int)(implicit c: Int) = {
      a + b + c
    }
    println(demon4(1, 2)(5))
    println("=====================================")
    //隐式函数3
    def demon5(a: Int, b: Int)(implicit c: Int,d:Int) = {
      a + b + c+d
    }
    println(demon5(1,2)(3,4))
    //隐式函数4
    //implicit var s:String="John"
    def demon6(a:Int)(implicit b:Int,c:String)={
      a+b+c
    }
    println(demon6(1)(2,"John"))
    println("=====================================")
    //隐式方法
    implicit def DoubleToInt(a:Double)={a.toInt}
    val x:Int=3.5  //x的值自动转为整型
    println(x)
  }
}